Componenten · 12 min leestijd

TT-motor met Arduino: snelheid, koppel, PWM en encoder

Wat is een DC-motor met tandwielkast (gele TT-motor)? Overbrenging 1:48, snelheid en koppel, 3–6 V, stroom meten, snelheden gelijktrekken met PWM, ruisdempende condensatoren, encoder, N20 vs TT.

Een DC-motor met tandwielkast is een kleine, snelle gelijkstroommotor met een tandwielkast (reductor) op de as, die het toerental verlaagt en het koppel verhoogt. De gele plastic TT-motor die je op Arduino-robotauto's ziet, is het bekendste lid van deze familie: de motor binnenin draait duizenden keren per minuut, maar dankzij de tandwielen draait het wiel slechts 100–250 keer per minuut en krijgt het genoeg kracht om moeiteloos een auto aan te drijven. Hij wordt meestal verkocht als set met een rubberen wiel van 65 mm en werkt op 3–6 V.

In deze gids leer je hoe de overbrengingsverhouding (1:48) snelheid en koppel verandert, wat de spanning, stroom en snelheid van de TT-motor zijn, hoe je de stroom meet die de motor opneemt en hoe je de juiste motordriver kiest. Daarna zie je waarom twee motoren bij dezelfde PWM-waarde met verschillende snelheden draaien, en trek je ze eerst met software en daarna met metingen via een encoderschijf gelijk. Je vindt ook ruisdempende condensatoren, code voor ESP32 en Raspberry Pi Pico en een vergelijking met de N20-micromotor.

Gele TT DC-motor met tandwielkast en wielenset
Gele TT-motor en wielenset van 65 mm: tandwielkast 1:48, werkspanning 3–6 V en een as die aan beide kanten uitsteekt.

Wat is een DC-motor met tandwielkast en hoe werkt hij?

Een gewone kleine DC-motor draait onbelast met 8.000–10.000 rpm, maar zijn koppel is erg laag; zet je hem direct op een wiel, dan beweegt de auto niet. De reductor gebruikt in elkaar grijpende tandwielen om dit hoge toerental te verlagen en het koppel met dezelfde verhouding te verhogen. Bij een verhouding van 1:48 draait de uitgaande as één keer per 48 omwentelingen van de motoras: de snelheid wordt door 48 gedeeld en het koppel ongeveer met 48 vermenigvuldigd (min de wrijvingsverliezen in de tandwielen). Het vermogen (koppel × snelheid) blijft gelijk; de reductor ruilt simpelweg snelheid in voor kracht. Daarom zijn tandwielmotoren ideaal voor taken die langzame maar krachtige beweging vragen, zoals wielen, lieren, deuren of transportbanden.

EigenschapGele TT-motor (1:48, typische waarden)
Werkspanning3–6 V DC
Overbrengingsverhouding1:48 (versies met 1:120 en 1:220 bestaan ook)
Uitgaand toerental onbelastOngeveer 90–120 rpm bij 3 V, ongeveer 200–250 rpm bij 6 V
Stroom onbelastOngeveer 150 mA
BlokkeerstroomOngeveer 1,2 A bij 4,5 V, ongeveer 1,5 A bij 6 V
BlokkeermomentOngeveer 0,4 kg·cm bij 3 V, ongeveer 0,8 kg·cm bij 6 V
AsDubbelzijdige plastic as met twee afgeplatte kanten
Behuizing en tandwielenPlastic; ongeveer 70 × 22 × 18 mm, 30 g
WielOngeveer 65 mm doorsnede, rubber

Berekeningen voor overbrengingsverhouding, snelheid en koppel

Een paar eenvoudige berekeningen volstaan om een motor te kiezen of in te schatten hoe snel een robot gaat. De omtrek van een wiel is π × diameter: voor een wiel van 65 mm is dat 3,14 × 6,5 ≈ 20,4 cm. Een wiel dat onbelast op 6 V met 200 rpm draait, legt 200 × 20,4 = 4080 cm per minuut af, ongeveer 0,68 m/s; onder belasting daalt dit met 20–30%. Aan de koppelkant is 0,8 kg·cm bij de straal van 3,25 cm van het wiel gelijk aan een duwkracht van 0,8 / 3,25 ≈ 0,25 kg; dat is het maximum dat de motor kan leveren voordat hij vastloopt. Motoren moeten langdurig niet met meer dan ongeveer een derde van hun blokkeermoment worden belast.

OverbrengingsverhoudingUitgaand toerental (6 V, onbelast)KoppelGeschikt voor
1:48Ongeveer 200–250 rpmGemiddeldRobotauto, lijnvolger, robot die obstakels ontwijkt
1:120Ongeveer 80–100 rpmHoogAuto die zware lasten draagt, langzame en gecontroleerde beweging
1:220Ongeveer 45–55 rpmZeer hoogDeur, gordijn, draaitafel, zonnevolger
Snel maar zwak of langzaam maar sterk: je kunt met de overbrengingsverhouding niet allebei winnen. 1:48 is genoeg voor een racewagen; voor een robot die een helling op moet of een zware lading batterijen, sensoren en een display draagt, is 1:120 veiliger. Bij het kiezen van batterijen kun je de totale capaciteit controleren met de batterijduurcalculator.

Op welke spanning werkt een TT-motor?

De nominale spanning van de TT-motor is 3–6 V en binnen dit bereik verandert zijn snelheid vrijwel evenredig met de spanning. De meest gebruikte voeding is 4 AA-batterijen: nieuwe alkalinecellen geven 6,0–6,4 V, oplaadbare Ni-MH-cellen 4,8–5,2 V. Twee 18650 Li-ioncellen geven vol 8,4 V, wat te veel is voor een motor van 6 V; maar drivers zoals de L298N laten ongeveer 2 V vallen, dus er komt zo'n 6 V bij de motor aan. Gebruik je een efficiëntere driver, dan kun je de maximale PWM-waarde begrenzen: om uit 8,4 V gemiddeld 6 V te halen, gebruik je hoogstens 255 × 6 / 8,4 ≈ 182. Details over batterijen vind je in de artikelen een Arduino op batterijen laten werken en mAh-batterijcapaciteit.

Voed de motor nooit rechtstreeks vanaf de 5V van de Arduino of een digitale pin. Een pin kan hooguit 20–40 mA leveren; de TT-motor neemt zelfs onbelast 150 mA op en 1,5 A als hij vastloopt. De motor wekt bij het stoppen ook een tegenspanning op (back-EMF). Voed de motor altijd via een driver (L298N, L9110S, TB6612FNG) of een MOSFET met diode, vanuit een aparte batterij, met de min van de batterij verbonden met de GND van de Arduino.

De stroom meten die de motor opneemt

Als je de stroom kent, kun je de juiste driver kiezen en berekenen hoe lang de batterij meegaat. De makkelijkste manier is een multimeter op stroom zetten en in serie met de motor aansluiten: steek de rode meetpen in de 10A-aansluiting, haal de draad van de plus van de batterij los en zet de multimeter ertussen. Meet eerst met de motor in de lucht (onbelast), daarna met de robot op de vloer en tot slot door het wiel heel even met je hand vast te houden. Hoe je een multimeter gebruikt, lees je in hoe gebruik je een multimeter; om de stroom continu met een Arduino te bewaken, zie het artikel over de ACS712-stroomsensor.

SituatieTypische stroom (6 V)Wat betekent het?
Wiel in de lucht, onbelast150–170 mAWrijving van tandwielen en borstels; de motor is gezond
Robot rijdt over een vlakke vloer200–350 mANormaal bedrijf; gebruik deze waarde voor batterijberekeningen
Helling of tapijt400–700 mADe motor heeft het zwaar; overweeg een verhouding van 1:120 of een lichter chassis
Wiel geblokkeerd (vastgelopen)1,2–1,5 ASlechtste geval voor driver en batterij; de motor wordt warm als het blijft duren
Moment van opstartenKortstondig tot 1 AKan de batterijspanning laten zakken en de Arduino resetten

De batterijduur volgt eenvoudig uit deze waarden: een robot waarvan de twee motoren samen 0,6 A opnemen op een vlakke vloer, rijdt ongeveer 2000 / 600 ≈ 3,3 uur op Ni-MH AA-cellen van 2000 mAh. Kijk bij het kiezen van een driver naar de blokkeerstroom: de L9110S levert ongeveer 800 mA per kanaal, wat voor TT-motoren op het randje is; de TB6612FNG, met 1,2 A continu en 3,2 A piek per kanaal, heeft meer marge. Om snel het verband tussen stroom, spanning en weerstand uit te rekenen, kun je de wet van Ohm-calculator gebruiken.

Een motordriver kiezen en bedraden

L298N dubbele motordrivermodule
De L298N-module kan twee TT-motoren tegelijk aansturen; maar omdat hij ongeveer 2 V laat vallen, krijgen de motoren minder dan de batterijspanning.
DriverStroom per kanaalSpanningsvalOpmerking
L298N2 AOngeveer 1,5–2,5 VRobuust en veelgebruikt; met 4×AA blijft er ongeveer 4–4,5 V over voor de motor
L293D (shield)0,6 A (piek 1,2 A)Ongeveer 1,5–2,5 VPast op de Uno, stuurt vier motoren aan; voor TT op het randje
L9110S0,8 ALaagKlein en goedkoop; heeft moeite met de blokkeerstroom
TB6612FNG1,2 A (piek 3,2 A)Zeer laag (MOSFET)Gebruikt de batterijspanning efficiënt, een van de beste keuzes voor TT
AansluitingArduino UnoESP32Raspberry Pi Pico
L298N ENA (snelheid linkermotor, PWM)D5GPIO 25GP15
L298N IN1 / IN2D7 / D8GPIO 27 / GPIO 33GP14 / GP13
L298N ENB (snelheid rechtermotor, PWM)D6GPIO 26GP10
L298N IN3 / IN4D9 / D4GPIO 32 / GPIO 4GP12 / GP11
Uitgang linker-/rechterencoder (LM393)D2 / D3GPIO 34 / GPIO 35GP16 / GP17
VCC van de encodermodule5V3V33V3(OUT)
GNDMin van de batterij, GND van L298N en Arduino gedeeldGedeeldGedeeld

Vergeet de jumpers op ENA en ENB niet te verwijderen; blijven ze zitten, dan negeert de motor PWM en draait hij altijd op volle snelheid. Alle pinnen van de L298N en zijn rem- en uitloopgedrag worden uitgebreid uitgelegd in het artikel DC-motor en L298N. Als een motor de verkeerde kant op draait, is het verwisselen van de twee draden van die motor op de driver de nettere oplossing in plaats van de code aan te passen.

Arduino-code: vooruit, achteruit, bochten en snelheidscorrectie

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 in de code is de kleinste PWM-waarde waarbij de motor de statische wrijving overwint en begint te draaien. De pinnen 5 en 6 van de Uno geven PWM van ongeveer 980 Hz; TT-motoren zoemen onder een waarde ergens tussen 60 en 90 meestal alleen zonder te draaien. Deze waarde voor je eigen motor vinden is makkelijk: begin de PWM op 0, verhoog in stappen van vijf en noteer de waarde waarbij het wiel voor het eerst draait. Hoe PWM werkt en details over de frequentie lees je in Wat is PWM?.

Waarom draaien twee motoren met verschillende snelheden?

Als je twee TT-motoren uit dezelfde doos dezelfde PWM geeft, verwacht je dat de robot rechtdoor rijdt, maar vaker wel dan niet drijft de auto naar één kant af. De reden is productieverschil bij goedkope motoren: de tolerantie van borstels en magneten, tandwielwrijving, smering en de uitlijning van de plastic assen verschillen bij elke motor een beetje. De tolerantie van ±10% die verkopers noemen, kan een snelheidsverschil van wel 20% tussen twee motoren betekenen. Bovendien is het verschil niet constant: het verandert naarmate de batterijspanning daalt, de motor warm wordt of de vloer verandert. En doordat de motoren gespiegeld gemonteerd zijn, draait de ene vanuit het oogpunt van de motor vooruit terwijl de andere achteruit draait, en sommige motoren draaien in de twee richtingen met verschillende snelheden.

  1. Laat de robot op een vlakke vloer 2–3 meter vooruit rijden met dezelfde PWM en noteer naar welke kant hij afdrijft.
  2. Drijft de auto naar rechts af, dan is de linkermotor sneller; verlaag SOL_KATSAYI naar 0.95 en probeer opnieuw.
  3. Verander de factor in stappen van 0,01–0,02 tot de auto rechtdoor rijdt; dit kost meestal 3–5 pogingen.
  4. Voer dezelfde test achteruit uit; is het verschil groot, gebruik dan aparte factoren voor vooruit en achteruit.
  5. De instelling kan verlopen als de batterijspanning verandert; ga voor een blijvende, zichzelf corrigerende oplossing verder met de encodermethode hieronder.

Ruis onderdrukken: condensatoren op de motor

Terwijl DC-motoren met borstels draaien, ontstaan er kleine vonkjes tussen de borstels en de commutator. Deze vonken veroorzaken spanningspieken op de voedingslijn en elektrische ruis die de lucht in wordt gestraald. De symptomen ken je: de Arduino reset zichzelf als de motor draait, er verschijnt rommel in de Serial Monitor, de ultrasone sensor meet onzinnige afstanden of de Bluetooth-verbinding valt weg. De oplossing is de ruis bij de bron te onderdrukken, direct op de motor.

  • 100 nF over de motorklemmen: Soldeer een keramische condensator van 100 nF met opdruk 104 tussen de twee klemmen van elke motor. Houd de pootjes zo kort mogelijk.
  • Nog twee naar de behuizing: Bij motoren met een metalen behuizing vermindert een extra 100 nF van elke klem naar de behuizing de ruis verder. De behuizing van de TT-motor is van plastic, dus de enkele condensator over de klemmen is meestal genoeg.
  • Elco op de driververvoeding: Plaats een elco van 470–1000 µF op de voedingsingang van de L298N; hij dempt de dip in de batterijspanning bij het opstarten.
  • Draai de draden in elkaar: Draai de twee draden van de motor om elkaar heen; de ruis die de draden uitstralen, neemt af.
  • Scheid de voedingen: Voed de Arduino en de motoren zo mogelijk met aparte batterijen en verbind de GND's op één punt.

Hoe condensatoren werken en hoe je hun codes leest, vind je in Wat is een condensator?, en andere oorzaken van resets als de motor draait in Arduino blijft resetten.

Snelheid meten met een encoderschijf

De as van de TT-motor steekt aan beide kanten uit; op het uiteinde zonder wiel plaats je meestal de plastic encoderschijf met 20 sleuven die bij de set zit. De sleuven van de schijf passeren tussen de armen van een U-vormige infraroodsleufsensor (een optische module met een LM393-comparator) en elke sleuf geeft een puls. Omdat de schijf even snel draait als het wiel, betekenen 20 pulsen één wielomwenteling. Worden er in een halve seconde 30 pulsen geteld, dan is het wiel 30 / 20 = 1,5 keer gedraaid, wat neerkomt op 1,5 × 120 = 180 rpm. Vermenigvuldig je het aantal omwentelingen met de wielomtrek, dan krijg je ook de afgelegde afstand: elke puls is ongeveer 20,4 / 20 ≈ 1 cm.

De onderstaande code meet de snelheid van beide wielen en past de PWM van de rechtermotor automatisch aan tot beide kanten hetzelfde aantal pulsen tellen. Dit is een eenvoudige proportionele (P-)regelaar: hoe groter het verschil, hoe groter de correctie. Omdat sleufsensoren bij het passeren van een flank meerdere pulsen kunnen geven, negeert de interruptfunctie pulsen die dichter dan 2 ms bij elkaar liggen. Voor details over interrupts zie het artikel Arduino-interrupt.

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}

Als je de code uitvoert, zie je in de Serial Monitor dat de rechter PWM-waarde de eerste paar seconden verandert en dat de twee wielsnelheden daarna naar elkaar toe groeien. Is KP te groot, dan slingert de rechtermotor heen en weer, versnellend en vertragend; is hij te klein, dan verloopt de correctie traag; waarden tussen 2 en 6 uitproberen is een goed begin. Voor nauwkeuriger rijden kun je ook de totale afgelegde afstand gelijktrekken of een volledige PID-regelaar schrijven. De encodersensor werkt vrijwel zoals de infraroodsensoren in lijnvolgrobots; details in het artikel over de TCRT5000-infraroodsensor.

Een TT-motor aansturen met een ESP32

De 3,3 V-pinnen van de ESP32 sturen de ingangen van de L298N en TB6612FNG zonder problemen aan, omdat deze drivers alles boven 2,3 V als HIGH zien. De ESP32 Arduino-core ondersteunt analogWrite; de standaard PWM-frequentie is ongeveer 1 kHz. Voed de encodersensoren vanaf 3V3 zodat hun uitgangen ook 3,3 V zijn; GPIO 34 en 35 zijn pinnen die alleen als ingang werken en ideaal voor de encoders. Dankzij de Wi-Fi en Bluetooth van de ESP32 kun je de robot met je telefoon bedienen en de snelheid op een webpagina tonen.

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 met de Raspberry Pi Pico en MicroPython

Elke GPIO van de Pico kan PWM genereren. In MicroPython stel je de frequentie van het PWM-object in op 1 kHz en geef je de snelheid met duty_u16() in het bereik 0–65535; 65535 betekent volle snelheid. De onderstaande code laat de linkermotor op verschillende snelheden draaien en meet zijn snelheid met de encoder. Wil je de Pico met dezelfde batterij voeden als de motoren, dan kun je de 5V-uitgang van de L298N verbinden met de VSYS-pin.

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 of N20-micromotor?

N20 DC-micromotor met tandwielkast
N20-micromotor met tandwielkast: metalen tandwielen, een 3 mm D-as en ongeveer een vijfde van het volume van de TT-motor.
EigenschapTT-motor (geel)N20-micromotor
AfmetingenOngeveer 70 × 22 × 18 mmOngeveer 12 × 10 mm doorsnede, 25–35 mm lang
TandwielenPlasticMetal
Spanningsopties3–6 VVersies voor 3 V, 6 V en 12 V
OverbrengingsverhoudingMeestal 1:48 (1:120, 1:220)Ruime keuze van 1:10 tot 1:1000
AsPlastic, met twee afgeplatte kantenMetalen D-as van 3 mm
EncoderAparte schijf en sleufsensorVersies met een magnetische hall-encoder achterop zijn gebruikelijk
Prijs en duurzaamheidZeer goedkoop, tandwielen slijten na verloop van tijdDuurder, nauwkeuriger en langer houdbaar
Geschikte projectenEducatieve robots, robotautosetsMinisumo, snelle lijnvolgers, kleine mechanismen

Kortom, de TT-motor is de beste start voor een eerste robotauto en schoolprojecten omdat hij goedkoop en makkelijk te monteren is. Heb je een kleiner, nauwkeuriger en duurzamer mechanisme nodig, of bouw je een wedstrijdrobot, dan heeft de N20 de voorkeur; N20's met encoders meten op de motoras, wat honderden pulsen per wielomwenteling en een veel nauwkeurigere snelheidsmeting geeft. Voor een overzicht van welk motortype bij welke klus past, zie het artikel over de verschillen tussen DC-, servo- en stappenmotoren.

Projectideeën met een tandwielmotor

  • Robotauto: Bouw een met Bluetooth bestuurde auto met twee TT-motoren, een zwenkwiel en een L298N; elke stap staat in het artikel Arduino-robotauto.
  • Lijnvolgrobot: Volg een zwarte lijn met infraroodsensoren; het snelheidsevenwicht van de motoren is hier erg belangrijk. Zie lijnvolgrobot.
  • Robot die obstakels ontwijkt: Detecteer obstakels voor je met een HC-SR04 en verander van richting; de opbouw staat in het artikel robot die obstakels ontwijkt.
  • Meetwiel: Rol een encoderwiel over de vloer om een digitale rolmaat voor kamers te maken; elke puls is ongeveer 1 cm.
  • Automatisch gordijn: Open het gordijn 's ochtends en sluit het 's avonds met een TT-motor van 1:220; laat het door licht activeren met een LDR.
  • Draaiende displaystandaard: Bouw een standaard die met een langzame motor een klein product of model langzaam laat draaien.

Veelgemaakte fouten en hoe je ze oplost

SymptoomWaarschijnlijke oorzaakOplossing
Motor zoemt maar draait nietPWM onder de dode zone of een zwakke batterijVerhoog MIN_PWM, meet de batterijspanning
Motor altijd op volle snelheidENA/ENB-jumper geplaatst of een pin zonder PWMVerwijder de jumper; gebruik pinnen 3, 5, 6, 9, 10, 11 op de Uno
Auto rijdt niet rechtdoorProductieverschil tussen de motorenBalanceer met een factor of bouw een gesloten lus met encoders
Arduino reset als de motor draaitAanloopstroom trekt de batterijspanning omlaag, borstelruisVoeg 100 nF over de motorklemmen en 470 µF op de driveringang toe; voed de Arduino apart
Eén wiel draait achteruitMotordraden verkeerd om aangeslotenVerwissel de twee draden van die motor op de driver
Snelheid lager dan verwacht2 V verloren over de L298NGebruik een batterij met hogere spanning of een MOSFET-driver zoals de TB6612FNG
Encoder telt te veel pulsenSensorgeklapper aan de sleufrandGebruik een dode-tijdfilter van 2 ms in de interrupt, centreer de schijf in de sensor
Test na het bouwen van je robot elke motor afzonderlijk met het wiel in de lucht: controleer of vooruit, achteruit en stop goed werken en of beide motoren ongeveer hetzelfde klinken. Klinkt er een duidelijk anders, dan kunnen zijn tandwielen wrijving hebben of is er een tand gebroken; het probleem oplossen voordat je de robot op de vloer zet, scheelt uren.

De TT-motor is een goedkoop maar zeer leerzaam onderdeel om de afweging tussen snelheid en koppel bij een overbrengingsverhouding, snelheidsregeling met PWM en terugkoppeling met een encoder te leren. Met de juiste driver, een paar condensatoren en eenvoudige balanceercode rijdt je robot rechtdoor en betrouwbaar. In de BlueGrays-app vind je de met Bluetooth bestuurde auto, de robot die obstakels ontwijkt en infraroodsensorprojecten met stapsgewijze schakelschema's en code, zodat je deze motoren meteen in een project kunt gebruiken.

Veelgestelde vragen

Wat is een DC-motor met tandwielkast?

Een DC-motor met tandwielkast is een kleine, snelle gelijkstroommotor met een tandwielkast op de as. De tandwielen verlagen het toerental en verhogen het koppel met dezelfde verhouding; bij 1:48 draait de uitgaande as één keer per 48 omwentelingen van de motoras. Zo kan een kleine motor moeiteloos een robotauto of mechanisme bewegen.

Op welke spanning werkt een TT-motor?

Gele TT-motoren werken op 3–6 V en de meestgebruikte voeding is 4 AA-batterijen. Ze draaien met ongeveer 90–120 rpm bij 3 V en ongeveer 200–250 rpm bij 6 V. Een spanning boven 6 V maakt de motor sneller, maar zorgt ervoor dat hij warm wordt en zijn tandwielen snel slijten.

Hoeveel stroom neemt een TT-motor op?

Ongeveer 150 mA onbelast en 200–350 mA in een robot die over een vlakke vloer rijdt. Als het wiel geblokkeerd is, kan de stroom bij 6 V oplopen tot 1,5 A. Daarom moeten motordriver en batterij worden gekozen op de blokkeerstroom en mag de motor nooit rechtstreeks vanaf een Arduino-pin worden gevoed.

Waarom draaien twee DC-motoren niet even snel?

Goedkope motoren verschillen in borstels, magneten, tandwielwrijving en smering; zelfs bij dezelfde PWM kunnen hun snelheden 10–20% uiteenlopen. Ook batterijspanning en temperatuur veranderen het verschil. Het probleem los je op door in software een factor toe te passen op de snellere motor, of door beide wielsnelheden met encoders te meten en de PWM automatisch bij te stellen.

Waarom plaats je een condensator op een DC-motor?

Terwijl motoren met borstels draaien, veroorzaken kleine vonken bij de borstels elektrische ruis. Deze ruis kan de Arduino resetten, sensoren verkeerd laten meten en draadloze verbindingen laten wegvallen. Een keramische condensator van 100 nF die over de motorklemmen is gesoldeerd, onderdrukt de ruis bij de bron.

Hoe meet je de motorsnelheid met een encoderschijf?

Een sleufschijf op de motoras passeert een optische sleufsensor en elke sleuf geeft een puls. De Arduino telt deze pulsen met een interrupt; bij een schijf met 20 sleuven zijn 20 pulsen één wielomwenteling. Deel het aantal pulsen in één seconde door 20 en vermenigvuldig met 60 om het aantal omwentelingen per minuut te krijgen.

Alle projecten bekijken
Auto met Bluetooth-besturing en L298N
AR-80Gevorderd
Premium

Auto met Bluetooth-besturing en L298N

Verander je telefoon in een afstandsbediening en bestuur je eigen robotauto. De Arduino ontvangt via een Bluetooth-module commando's van een afstandsbedieningsapp op je telefoon en laat de wielen…

5.0(39)
66
Obstakelvermijdende robot
AR-81Gevorderd
Premium

Obstakelvermijdende robot

Zin om een slim voertuig te bouwen dat zelf zijn weg vindt? De obstakelvermijdende robot scant voortdurend zijn omgeving dankzij de ultrasone sensor voorop.

5.0(38)
49
Zwart-wit ondergrond herkennen met TCRT5000
AR-78Gemiddeld
Premium

Zwart-wit ondergrond herkennen met TCRT5000

Met de kleine sensor die de ogen van lijnvolgrobots vormt, merk je of de ondergrond zwart of wit is.

4.7(40)
49
Reflectie (nabijheid) meten met de TCRT5000
AR-77Gemiddeld
Premium

Reflectie (nabijheid) meten met de TCRT5000

Met een kleine sensor die onzichtbaar licht uitzendt en meet hoeveel er terugkaatst, detecteer je het oppervlak ervoor.

4.6(33)
43
Servo's bedienen met joystick
AR-60Gemiddeld
Premium

Servo's bedienen met joystick

Stuur twee motoren aan met een joystick, net als bij het draaien van een bewakingscamera.

4.7(42)
58
ESP32 ledhelderheid regelen met een potmeter (analoog → PWM)
ES-13Gemiddeld
Premium

ESP32 ledhelderheid regelen met een potmeter (analoog → PWM)

In dit project regel je de helderheid van een led analoog met een potmeter. De ADC-pin van de ESP32 leest de spanning van 0–3,3 V van de potmeter; die waarde wordt omgezet in een PWM-signaal (pulsbreedtemodulatie) en naar de led gestuurd. Als je aan de potmeter draait, wordt de led dus geleidelijk helderder en zwakker. Met Arduino Core 3.0+ kun je analogWrite() direct gebruiken; op de ESP32-S2/S3 ligt de ADC-resolutie vast op 12 bit.

4.5(19)
32
ESP32-led dimmen met PWM
ES-8Beginner

ESP32-led dimmen met PWM

De helderheid van de led soepel veranderen van 0 naar max en van max naar 0. We sturen PWM aan met analogWrite() zoals bij Arduino; dezelfde syntaxis werkt zonder problemen met ESP32 Arduino Core 3.0+. Een pindefinitie, pinMode en analogWrite zijn genoeg.

4.8(36)
55
Raspberry Pi Pico PWM-led-fade (ademeffect)
PI-14Beginner

Raspberry Pi Pico PWM-led-fade (ademeffect)

De led knippert niet meer alleen, hij ademt! Met de PWM (Pulse Width Modulation) van de Raspberry Pi Pico wordt de helderheid van de led langzaam hoger en dan langzaam weer lager: een rustig "ademeffect" zoals het lampje van een slapende laptop. Je leert de klasse machine.PWM, de 16-bits helderheidswaarde van 0–65535 met duty_u16() en de PWM-frequentie.

4