DC-gelijkstroommotor (TT Motor)

Wat het is

De TT-tandwielmotor is de geel-blauwe motor onderaan vrijwel elke robotauto voor beginners. Het is een kleine gelijkstroommotor met borstels die aan een kunststof reductietandwielbak is gemonteerd, met een dubbel-D-uitgaande as die rechtstreeks in een passend wiel wordt gedrukt. Koop er twee, voeg een chassis en een zwenkwiel toe en je hebt een robot die kan rijden en draaien. Daarom is dit de aandrijfmotor achter de eerste lijnvolger of robot met obstakelvermijding die de meeste mensen bouwen.

Een kale gelijkstroommotor draait op zichzelf veel te snel en veel te zwak om iets te verplaatsen. De versnellingsbak maakt hem bruikbaar: die verandert de snelle, zwakke draai in de langzame, krachtige draai met veel koppel.

Hoe het werkt

In de gele behuizing gebeuren twee dingen:

1. De motor zet elektrische energie om in draaiing. Leg spanning over de twee aansluitingen en hij draait; keer de polariteit om en hij draait de andere kant op. Meer spanning betekent meer snelheid.
2. De versnellingsbak verlaagt die snelheid. Een tandwielstelsel van ongeveer 1:48 betekent dat het wiel één keer draait voor elke ongeveer 48 motoromwentelingen. Je verliest evenveel snelheid als je koppel wint, en dat is de ruilhandel die je wilt: een wiel heeft koppel nodig, geen waas. Of deze verhouding geschikt is voor jouw robot kun je vóór aankoop berekenen; zie een gelijkstroom-tandwielmotor kiezen.

Om de motor te besturen doe je twee dingen tegelijk: stel de richting in door te kiezen welke aansluiting positief is, wat de H-brug doet, en stel de snelheid in met PWM door de voeding snel aan en uit te schakelen, zodat de motor een gemiddelde spanning ziet. Leer die combinatie in gelijkstroommotoren besturen met PWM en een H-brug.

Wanneer je hem gebruikt

Kies een TT-motor voor elke lichte robot met wielen en lage snelheid: lijnvolgers, robots met obstakelvermijding, doolhofrobots en een eerste basis met differentiaalaandrijving. Hij is goedkoop, vergevingsgezind en het onderwerp van vrijwel elke tutorial voor beginners.

Ga een stap verder wanneer je meer nodig hebt: voeg wielencoders toe als je afstand en snelheid wilt meten voor odometrie, of stap over op motoren met metalen tandwielen wanneer de robot zwaarder wordt of moet klimmen. Kunststof tandwielen raken bij mishandeling uitgesleten.

Bedrading en valkuilen

• Sluit hem nooit rechtstreeks aan op een logicapin. De aanloopstroom is ongeveer 1 A. Bestuur hem via een L298N of een vergelijkbare H-brug, gevoed vanaf de accu en niet vanaf de 5V-pin van de Arduino.
• Twee motoren passen niet perfect bij elkaar. Identieke PWM rijdt zelden volmaakt recht; stel één motor in software af of sluit een snelheidsregellus met encoders.
• Let op inschakelstroom en teruggeïnduceerde spanning. Motoren laten de voeding inzakken bij het starten en slaan spanning terug bij het stoppen. Houd motorvoeding en logicavoeding op gescheiden rails met een gemeenschappelijke massa; zie een robot van stroom voorzien.
• Match het wiel op de as. De dubbel-D-as past alleen goed in een passende dubbel-D-boring van een wiel; in een rond gat slipt hij.

De vier getallen op de datasheet van een motor

Elke gelijkstroommotor met borstels wordt door vier waarden gekenmerkt, en ze zijn niet onafhankelijk; de hele curve volgt uit twee ervan.

Het koppel van een gelijkstroommotor met borstels daalt lineair met de snelheid, van het aanloopkoppel bij nul RPM tot nul koppel bij de snelheid zonder belasting. De stroom doet het omgekeerde. Dat levert drie belangrijke gevolgen op:

Het maximale vermogen ligt bij de helft van het toerentalbereik. Vermogen is koppel × snelheid en het product van twee rechte lijnen bereikt zijn maximum in het midden. Een TT-motor bij 6 V levert zijn grootste vermogen rond 100 RPM.

Het maximumrendement ligt rond een kwart van het aanloopkoppel, ver boven het vermogensmaximum. Dat is het punt waarop je een robot wilt laten werken, niet het vermogensmaximum en uiteraard niet dicht bij het aanlooppunt.

De aanloopstroom is de ontwerpbeperking, niet de draaistroom. Een motor die blijft verbruiken van 150 mA, trekt direct 1 A zodra een wiel tegen een muur loopt; twee motoren die tegelijk vastlopen vragen samen 2 A. Je driver en accu moeten dat beide overleven, want op een robot gebeurt het voortdurend.

Een motor voor je robot dimensioneren

De rekensom duurt vijf minuten en lost de meeste “mijn robot is te traag”-vragen op voordat ze ontstaan.

Snelheid. Wielomtrek × RPM ÷ 60 levert meters per seconde:

65 mm wheel -> circumference = pi x 0.065 = 0.204 m
200 RPM     -> 200 / 60 = 3.33 rev/s
speed       = 0.204 x 3.33 = 0.68 m/s

Dat is loopsnelheid, ongeveer goed voor een lijnvolger en behoorlijk snel voor een doolhofrobot die bij kruisingen moet stoppen.

Koppel. Om een robot met massa m te versnellen met versnelling a heeft elk van de n aangedreven wielen nodig:

torque per wheel = m x a x r / n

Voor een robot van 500 g die met 0,5 m/s² versnelt op wielen van 65 mm (r = 0,0325 m) met twee aangedreven wielen:

= 0.5 x 0.5 x 0.0325 / 2 = 0.004 N.m = 0.041 kg.cm

Tegenover een aanloopkoppel van 0,8 kg·cm is dat bijna een factor twintig in reserve. Daarom werken TT-motoren prima in lichte robots en hoef je deze berekening meestal niet te maken. Doe dat wel wanneer de robot zwaar wordt of moet klimmen.

Controleer daarna de vloer. Het motorkoppel is slechts één grens; wrijving is de andere. Een lichte robot op een gladde vloer bereikt zijn gripgrens doorgaans rond een kwart van het aanloopkoppel, waardoor het grootste deel van het motorvermogen de vloer niet eens bereikt. De tutorial over duwkracht en grip werkt uit welke grens je werkelijk raakt.

Waarom je robot niet recht rijdt

Twee TT-motoren met identieke PWM rijden niet recht, en dat verrast mensen meer dan het zou moeten. De oorzaken zijn ongeveer gerangschikt van groot naar klein:

De laatste regel vangt mensen, omdat dit effect alleen bij lage snelheid optreedt. Een robot die bij volle snelheid goed recht rijdt maar tijdens kruipen sterk uitwijkt, laat twee verschillende wrijvingsdrempels zien, geen besturingsfout.

Er zijn twee echte oplossingen. De softwarecorrectie is een vermenigvuldigingsfactor per motor die je empirisch bepaalt: rij vooruit, meet de drift over 2 m, stel bij en herhaal. Het is snel en geldt alleen voor de accuspanning en het oppervlak waarbij je hebt afgesteld. De juiste oplossing zijn encoders en een snelheidsregellus, die continu corrigeren en niet om de accu geven.

De dode zone en waarom die belangrijk is

Onder een bepaald duty cycle draait de motor helemaal niet; eerst moet de statische wrijving in de borstels en het tandwielstelsel worden overwonnen. Bij een TT-motor is dat doorgaans 20–35% duty en het verschilt tussen twee motoren uit dezelfde verpakking.

Meet de drempel van jouw motor:

// Ramp up slowly and note where each wheel starts.
for (int duty = 0; duty <= 255; duty += 5) {
  analogWrite(ENA, duty);
  Serial.println(duty);
  delay(500);                 // long enough to see it start
}

Compenseer daarna, zodat een klein commando een kleine beweging veroorzaakt in plaats van niets:

const int DEADBAND_A = 65;    // measured, out of 255

int applyDeadband(int speed) {
  if (speed == 0) return 0;
  int sign = (speed > 0) ? 1 : -1;
  return sign * map(abs(speed), 1, 255, DEADBAND_A, 255);
}

Zonder deze correctie doet het onderste kwart van je regelbereik helemaal niets. Daardoor gedraagt een PID-regellus zich zeer vreemd in de buurt van de streefwaarde, want kleine correcties hebben letterlijk geen effect totdat de opgebouwde integrale term de drempel passeert en de robot plots opzij schiet.

Problemen oplossen

TT-motor of iets anders?

Het belangrijkste inkoopadvies: als je denkt ooit encoders te willen, koop dan nu motoren met encoders. Achteraf inbouwen betekent de aandrijving uit elkaar halen, en het prijsverschil bedraagt een paar dollar per motor. Vrijwel elk project dat begint als lijnvolger en uitgroeit tot een doolhofoplosser loopt tegen deze beperking aan.