DC-motor vs servo vs stappenmotor: verschillen en welke je kiest
DC-motor vs servo vs stappenmotor: snelheid, koppel en precisie vergeleken, drivers L298N, ULN2003 en A4988, stroomverbruik, BLDC en ESC, en wat je waar gebruikt.
Het verschil tussen een DC-motor, een servomotor en een stappenmotor past in één zin: een DC-motor draait continu en snel zolang je hem voedt, een servo beweegt naar de hoek die je vraagt en houdt die vast, en een stappenmotor draait in kleine, telbare stappen. Wil je dus een wiel laten draaien, dan kies je een DC-motor; om een deksel 90 graden te openen een servo; om een onderdeel met een tiende millimeter nauwkeurigheid te verplaatsen een stappenmotor. Zodra er in een project met Arduino, ESP32 of Raspberry Pi Pico iets moet bewegen, kom je een van deze drie tegen.
In deze gids vergelijken we wat er in elke motor zit, echte cijfers voor snelheid, koppel en positienauwkeurigheid van populaire modellen (TT-motor, SG90, MG996R, 28BYJ-48, NEMA 17), welke driver elk nodig heeft (L298N, een PWM-signaal, ULN2003, A4988), hoeveel stroom ze verbruiken en welke in welk project wordt gebruikt. Aan het eind vind je Arduino-, ESP32- en Pico-code die alle drie tegelijk aanstuurt, een korte introductie tot borstelloze motoren (BLDC) en ESC's, en de meest gemaakte fouten.




Kort antwoord: de drie motoren vergeleken in één tabel
| Eigenschap | DC motor | Servo motor | Stappenmotor |
|---|---|---|---|
| Beweging | Draait continu | Beweegt naar een ingestelde hoek en houdt die vast (meestal 0–180°) | Draait stap voor stap, zonder draaibegrenzing |
| Wat je bestuurt | Snelheid en richting | Hoek (positie) | Aantal stappen en stapsnelheid |
| Terugkoppeling | Geen (toe te voegen met een encoder) | Ja: de ingebouwde potentiometer | Geen (open lus) |
| Snelheid | Zeer hoog (duizenden RPM zonder tandwielkast) | Gemiddeld (SG90: 0,1 s/60°) | Laag tot gemiddeld, koppel daalt bij hogere snelheid |
| Koppel | Hangt af van de tandwielkast | Hoog voor zijn formaat (dankzij de tandwielkast) | Hoog bij lage snelheid, houdt ook vast in stilstand |
| Positienauwkeurigheid | Geen | Ongeveer 1° | 1,8° (veel fijner met microstappen) |
| In stilstand | Draait vrij | Houdt actief zijn positie vast | Vergrendeld zolang de spoelen onder stroom staan |
| Driver | H-brug (L298N, L9110S) of MOSFET | Niet nodig, signaal rechtstreeks van een pin | ULN2003 of A4988, DRV8825 |
| Draden | 2 | 3 (GND, +, signaal) | 4 of 5 (soms 6) |
| Typisch gebruik | Wielen, ventilatoren, pompen | Robotarmen, deurgrendels, radar | 3D-printers, CNC, camerasliders |
De belangrijkste rij in de tabel is terugkoppeling. Een servo weet waar hij is dankzij zijn interne potentiometer, en als iets hem wegduwt, keert hij terug naar zijn positie. Een stappenmotor weet niet waar hij is; je telt gewoon hoeveel stappen hij heeft gezet, en die telling klopt zolang de motor niet overbelast is en geen stappen overslaat. Een DC-motor heeft geen idee hoever hij gedraaid heeft; heb je positie nodig, dan moet je een encoder op de as zetten. Welke motor je kiest, hangt grotendeels af van of je project deze informatie nodig heeft.
Hoe werkt een DC-motor?
Bijna elke DC-motor in hobbyprojecten is een DC-motor met koolborstels. Binnenin zitten vaste magneten en een draaiende spoel (de rotor); koolborstels en een koperen commutator keren de stroomrichting om terwijl de rotor draait, zodat hij blijft draaien. Hij heeft twee draden: zet er spanning op en hij draait, wissel de draden om en hij draait de andere kant op. De spanning bepaalt de snelheid en de stroom die hij opneemt bepaalt het koppel. Terwijl de motor draait, wekken de spoelen een tegenspanning op, de back-EMF, die de stroom beperkt; als de as geblokkeerd is, verdwijnt die back-EMF en schiet de stroom omhoog naar de blokkeerstroom.

Een kleine DC-motor zonder tandwielkast draait duizenden RPM maar heeft heel weinig koppel, daarom gebruiken robots altijd motoren met tandwielkast. De 1:48-kast in een TT-motor brengt ruwweg 12.000 RPM op de motoras terug naar 250 RPM aan het wiel en vermenigvuldigt het koppel met ongeveer 48 (min de verliezen in de tandwielen). Je verandert de snelheid met PWM en de richting met een H-brug; de details staan in DC-motor aansturen met de L298N. Het zwakke punt van een DC-motor is positie: dezelfde PWM-waarde geeft een andere snelheid afhankelijk van de batterijspanning en de belasting, dus een opdracht "2 seconden vooruit rijden" legt elke keer een andere afstand af. Heb je een exacte afstand nodig, dan voeg je een encoder toe aan het wiel.
Hoe werkt een servomotor?
Een servomotor is eigenlijk een compleet systeem in een klein doosje: een DC-motor, een tandwielstelsel dat het toerental verlaagt en het koppel verhoogt, een potentiometer op de uitgaande as en een printplaat voor de besturing. De Arduino stuurt de servo niet rechtstreeks een hoek, maar een puls met 50 Hz (eens per 20 ms); de breedte van de puls geeft de gewenste positie aan. De besturing vergelijkt dat doel met de werkelijke positie die de potentiometer meet en stuurt de motor in die richting tot het verschil nul is. Dit heet geregelde besturing met terugkoppeling (closed loop), en daarom biedt een servo weerstand als je hem met de hand probeert te draaien.

| Apparaat | Wat de pulsbreedte betekent | Voorbeeld |
|---|---|---|
| Standaardservo (180°) | Hoek: ongeveer 1 ms aan het ene uiteinde, 1,5 ms midden, 2 ms aan het andere uiteinde | SG90, MG90S, MG996R |
| Servo met continue rotatie (360°) | Snelheid en richting: 1,5 ms stop, korter de ene kant op, langer de andere kant op | FS90R |
| ESC + borstelloze motor | Gas: 1 ms stop, 2 ms vol gas | ESC's voor drones en RC-modellen |
Het standaard RC-bereik is 1–2 ms, maar de meeste goedkope servo's zoals de SG90 hebben ruwweg 0,5–2,4 ms nodig voor de volle 180°, en de Arduino Servo-bibliotheek gebruikt standaard 544–2400 µs. De dode zone van de SG90, de kleinste verandering waarop hij reageert, is ongeveer 10 µs, wat neerkomt op ruwweg 1°; daarom ligt de praktische precisie van een servo rond één graad. Een servo met continue rotatie (FS90R) is een servo met uitgeschakelde terugkoppeling: je bestuurt snelheid en richting in plaats van hoek, en de positie-informatie gaat verloren. Heb je meer kracht nodig, dan is de MG996R met metalen tandwielen de standaardkeuze; voor de basis, zie Wat is een servomotor?
Hoe werkt een stappenmotor?
Een stappenmotor heeft geen borstels. De spoelen in de behuizing worden in een vaste volgorde bekrachtigd en de magnetische rotor zet telkens één stap naar de volgende spoel. De meest gebruikte hybride stappenmotoren hebben 200 stappen per omwenteling, oftewel 1,8° per stap. Stuur een aantal pulsen en hij zet evenveel stappen; stuur ze sneller en hij draait sneller. Zolang de spoelen onder stroom staan, blijft de motor vergrendeld op zijn plaats; dit heet houdmoment. Het cruciale verschil: een stappenmotor werkt zonder terugkoppeling (open lus). Als de belasting zijn koppel overschrijdt, slaat hij stappen over, en de Arduino merkt dat nooit. Daarom laten 3D-printers bij het opstarten elke as tot een eindschakelaar lopen (homing).

Je komt twee typen stappenmotoren tegen. Unipolaire motoren (28BYJ-48, 5 draden) hebben een gemeenschappelijke draad voor de spoelen en worden aangestuurd door een eenvoudige transistorarray zoals de ULN2003. Bipolaire motoren (NEMA 17, 4 draden) vragen dat de spoelstroom omgekeerd wordt, wat gebeurt met stroombegrenzende drivers zoals de A4988, DRV8825 of TMC2209. Deze drivers doen ook aan microstappen: de A4988 verdeelt elke hele stap in 16, waardoor het aantal stappen per omwenteling oploopt naar 3200 en de beweging veel stiller en vloeiender wordt. Zie voor details 28BYJ-48 en ULN2003 en A4988-stappenmotordriver.
Snelheid, koppel en positienauwkeurigheid: de cijfers
| Model | Voeding | Snelheid | Koppel | Precisie | Stroom |
|---|---|---|---|---|---|
| TT DC motor (1:48) | 3–6 V | ≈ 200–250 RPM (6 V, onbelast) | 0,8 kg·cm (6 V, geblokkeerd) | Geen (heeft een encoder nodig) | 150 mA onbelast, 1,5 A geblokkeerd |
| SG90 servo | 4,8–6 V | 0,1 s / 60° | 1,8 kg·cm | ≈ 1° | Zeer weinig in rust, kan boven 0,5 A komen tijdens bewegen |
| MG996R servo | 4,8–7,2 V | 0,17 s / 60° (4,8 V) | 9,4–11 kg·cm | ≈ 1° | 0,5–0,9 A tijdens bewegen, 2,5 A geblokkeerd |
| 28BYJ-48-stappenmotor | 5 V | ≈ 10–15 RPM | ≈ 0,3 kg·cm | ≈ 0,18° (2048 stappen/omwenteling) | 150–200 mA, ook in stilstand |
| NEMA 17-stappenmotor (17HS4401) | 12–24 V (met A4988) | Enkele honderden RPM | ≈ 4 kg·cm (0,4 N·m) houdmoment | 1,8°; 0,1125° bij 1/16 microstap | Tot 1,7 A per fase, instelbaar met Vref |
Koppel wordt meestal opgegeven in kg·cm: een motor van 1 kg·cm kan een last van 1 kg op 1 cm van de as dragen, maar slechts 0,5 kg op 2 cm (1 kg·cm ≈ 0,098 N·m). Een MG996R levert bij 6 V bijvoorbeeld 11 kg·cm; aan het eind van een arm van 15 cm kan hij theoretisch 11 / 15 ≈ 0,73 kg vasthouden. Maar dat is het piekkoppel op het moment dat de motor blokkeert, en het gewicht van de arm zelf telt mee in de belasting. Een goede vuistregel voor een lange levensduur is onder de helft van die waarde te blijven, dus in de praktijk kun je aan het eind van die arm een paar honderd gram dragen.
Bij snelheid draait de rangorde om. De DC-motor is veruit de snelste. Een SG90-servo voltooit een beweging van 180° in ongeveer 0,3 seconde en kan niet sneller. Het koppel van een stappenmotor daalt bij hogere snelheid, omdat de spoelstroom bij elke stap niet de tijd krijgt om volledig op te bouwen; een 28BYJ-48 begint stappen over te slaan boven ongeveer 15 RPM. Een NEMA 17 op een A4988 voeden met 24 V in plaats van 12 V geeft meer koppel bij hoge snelheid, omdat de driver de stroom toch al begrenst. Qua precisie wint de stappenmotor echter: een NEMA 17 geeft 1,8° in hele-stapmodus en op papier 0,1125° bij 1/16 microstappen. Een kleine kanttekening: de interne overbrengingsverhouding van de 28BYJ-48 is niet precies 1:64 maar ongeveer 1:63,68, dus een echte omwenteling is ongeveer 2038 stappen in plaats van 2048; in projecten die continu draaien, zoals klokken, loopt dat verschil op.
Welke driver heeft elke motor nodig?
Een Arduino-pin kan hooguit 40 mA leveren, en de veilige grens ligt rond 20 mA; zelfs een kleine TT-motor neemt in onbelaste toestand ongeveer 7 keer zoveel op en geblokkeerd meer dan 70 keer zoveel. Bovendien veroorzaakt een motorspoel op het moment dat de stroom wordt onderbroken een hoge spanningspiek in tegengestelde richting, die een onbeschermde pin kan vernietigen. Daarom zit er altijd een driver tussen motor en board: het board stuurt alleen kleine stuursignalen, terwijl de motorstroom rechtstreeks van de voeding door de driver loopt. Drivers bevatten transistors en diodes die de tegenspanning opvangen. Voor een ventilator of pomp die maar één kant op draait, is een enkele MOSFET genoeg.
| Motor | Driver | Arduino-kant | Opmerking |
|---|---|---|---|
| DC-motor, één richting | MOSFET (bijv. IRLZ44N) + diode | 1 PWM-pin | Ventilatoren, pompen, trilmotoren |
| DC-motor, beide richtingen | L298N, L9110S, TB6612FNG | 2 richtingspins + 1 PWM-pin | De H-brug keert de richting om, PWM bepaalt de snelheid |
| Servo motor | Niet nodig (ingebouwd) | 1 pin, 50 Hz-signaal | Voor veel servo's een PCA9685-board (16 kanalen, I2C) |
| Unipolaire stappenmotor (28BYJ-48) | ULN2003 | 4 pins | Schakelt de spoelen in volgorde, 500 mA per kanaal |
| Bipolaire stappenmotor (NEMA 17) | A4988, DRV8825, TMC2209 | 2 pins (STEP, DIR) | Stroomlimiet instelbaar met Vref, doet microstappen |
| Borstelloze motor (BLDC) | ESC | 1 pin, servosignaal | De stroomwaarde moet bij de motor passen (bijv. 30 A) |

Stroomverbruik: hoeveel stroom neemt elke motor op?
De drie motoren gedragen zich heel verschillend als het om stroom gaat, en je moet je voeding daarop afstemmen. Een DC-motor neemt meer stroom op naarmate de belasting toeneemt; bij het starten en als een wiel vastloopt, komt hij in de buurt van zijn blokkeerstroom. Dimensioneer je voeding op die piek, niet op de stroom in onbelaste toestand. Een servo neemt heel weinig op terwijl hij wacht, maar veroorzaakt bij elke beweging korte, scherpe stroompieken: zelfs één SG90 kan kortstondig boven 0,5 A komen, en een MG996R haalt 2,5 A als hij wordt belast. Deze pieken trekken de spanning omlaag en resetten de Arduino, of veroorzaken een brownout-fout op de ESP32. Bij een stappenmotor loopt daarentegen zelfs stroom door de spoelen als hij helemaal niet beweegt: een 28BYJ-48 neemt 150–200 mA op in stilstand en wordt warm. Als je in projecten op batterijen geen houdmoment nodig hebt, verlengt het uitschakelen van de spoelen (de EN-pin van een A4988 HIGH zetten) de batterijduur aanzienlijk.
- Gebruik een aparte voeding: Voed motoren niet via de 5V-pin van de Arduino. Een USB-poort levert ongeveer 500 mA en het board gebruikt daar al een deel van; behalve één kleine servo heeft elke motor een eigen voeding nodig.
- Verbind de massa's: De min van de motorvoeding moet verbonden zijn met de GND van het board; anders heeft het stuursignaal geen referentie (zie gemeenschappelijke massa).
- Voeg condensatoren toe: Plaats een elco van 470–1000 µF op de voedingslijn van de servo, minstens 47 µF op de VMOT-ingang van de A4988 en een keramische condensator van 100 nF over de aansluitingen van een DC-motor met borstels. De eerste vermindert spanningsdips, de laatste vermindert borstelruis.
- Dimensioneer de voeding op de piekstroom: Een robotarm met 4 servo's heeft bijvoorbeeld een voeding van 5–6 V nodig die minstens 3 A kan leveren, en een auto met twee TT-motoren heeft een accupakket nodig dat 2 × 1,5 A aankan. Hoe lang de batterij meegaat, reken je uit met de batterijduurcalculator.
- Verlaag de spanning op de juiste manier: Heb je 5–6 V voor servo's nodig uit een pakket van 7,4 V, gebruik dan een schakelende regelaar zoals de LM2596; lineaire regelaars zoals de 7805 worden bij stromen in het ampèrebereik erg heet.
Alle drie de motoren aansturen met één Arduino: stap voor stap
Het verschil zie je het best door alle drie naast elkaar te laten draaien. In de onderstaande schakeling wordt een TT-motor aangestuurd door een L298N, een SG90 rechtstreeks vanaf een pin en een 28BYJ-48 door een ULN2003-board. De pintabel werkt met alle drie de codevoorbeelden: Arduino Uno, ESP32 en Raspberry Pi Pico.
| Aansluiting | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| L298N ENA (snelheid, PWM) | D5 | GPIO 25 | GP15 |
| L298N IN1 | D7 | GPIO 26 | GP14 |
| L298N IN2 | D8 | GPIO 27 | GP13 |
| Servosignaal (oranje) | D9 | GPIO 18 | GP16 |
| ULN2003 IN1 | D10 | GPIO 19 | GP2 |
| ULN2003 IN2 | D11 | GPIO 21 | GP3 |
| ULN2003 IN3 | D12 | GPIO 22 | GP4 |
| ULN2003 IN4 | D13 | GPIO 23 | GP5 |
| GND (alle voedingen) | GND | GND | GND |
- Verwijder de ENA-jumper op de L298N; sluit ENA, IN1 en IN2 aan op de pins in de tabel en de DC-motor op de klemmen OUT1 en OUT2. Sluit de motorvoeding (bijvoorbeeld twee 18650-cellen in serie, 7,4 V) aan op de 12V-klem.
- Sluit de bruine draad van de servo aan op GND, de rode op een aparte voeding van 5–6 V en de oranje signaaldraad op D9.
- Steek de witte connector van de 28BYJ-48 in het ULN2003-board, verbind IN1–IN4 met D10–D13 en voed de +-klem van het board vanaf een voeding van 5 V.
- Verbind de min van alle voedingen en de GND van de Arduino met elkaar.
- Upload de code met de Arduino IDE; de bibliotheken Servo en Stepper worden met de IDE meegeleverd, dus je hoeft ze niet te installeren.
- Schakel de motorvoedingen in en bekijk hoe de drie motoren zich na elkaar gedragen.
1#include <Servo.h>
2#include <Stepper.h>
3
4// DC motor (L298N): ENA=5, IN1=7, IN2=8
5const int ENA = 5; // PWM; Servo kütüphanesi 9 ve 10'un PWM'ini kapatır / Servo library disables PWM on 9 and 10
6const int IN1 = 7;
7const int IN2 = 8;
8
9const int SERVO_PIN = 9; // servo sinyali / servo signal
10Servo servo;
11
12const int STEPS_PER_REV = 2048; // 28BYJ-48 tam tur / full revolution
13Stepper stepper(STEPS_PER_REV, 10, 12, 11, 13); // sıra: IN1, IN3, IN2, IN4 / order: IN1, IN3, IN2, IN4
14
15void releaseStepper() { // bobinleri bırak, boşta akım çekmesin / release coils, no idle current
16 for (int pin = 10; pin <= 13; pin++) {
17 digitalWrite(pin, LOW);
18 }
19}
20
21void setup() {
22 pinMode(ENA, OUTPUT);
23 pinMode(IN1, OUTPUT);
24 pinMode(IN2, OUTPUT);
25 servo.attach(SERVO_PIN);
26 stepper.setSpeed(10); // devir/dakika, 28BYJ-48 için en fazla ~15 / RPM, max ~15 for 28BYJ-48
27}
28
29void loop() {
30 // 1) DC motor: hız ve yön, konum yok / speed and direction, no position
31 digitalWrite(IN1, HIGH);
32 digitalWrite(IN2, LOW);
33 analogWrite(ENA, 180); // yaklaşık %70 güç / about 70% power
34 delay(2000);
35 analogWrite(ENA, 0); // motoru serbest bırak / let the motor coast
36 delay(500);
37
38 // 2) Servo: açı ver, gidip orada kalsın / give an angle, it goes there and holds
39 servo.write(0);
40 delay(600);
41 servo.write(180);
42 delay(600);
43 servo.write(90);
44 delay(600);
45
46 // 3) Step motor: tam çeyrek tur ileri ve geri / exactly a quarter turn forward and back
47 stepper.step(STEPS_PER_REV / 4); // 512 adım = 90° / 512 steps = 90°
48 delay(500);
49 stepper.step(-STEPS_PER_REV / 4);
50 releaseStepper();
51 delay(1000);
52}| Regel | Motor | Wat het doet |
|---|---|---|
| digitalWrite(IN1/IN2) | DC | Stelt de richting in: HIGH-LOW vooruit, LOW-HIGH achteruit |
| analogWrite(ENA, 180) | DC | Stelt de snelheid in: 180 / 255 ≈ 70% vermogen; waar de motor stopt is onbekend |
| servo.write(90) | Servo | Beweegt de servo naar 90° en houdt hem daar zolang het signaal blijft komen |
| stepper.setSpeed(10) | Stepper | Stelt de tijd tussen stappen in voor 10 omwentelingen per minuut |
| stepper.step(512) | Stepper | Zet precies 512 stappen (90°); blokkeert de code tot het klaar is |
| releaseStepper() | Stepper | Schakelt alle vier de spoelen uit; de motor draait vrij en neemt geen stroom op |
Als je de code uitvoert, is het verschil duidelijk: de DC-motor draait twee seconden, maar zijn as stopt elke keer op een ander punt. De servo schiet naar 0°, 180° en 90°, en biedt weerstand als je hem met de hand probeert te draaien. De stappenmotor draait langzaam precies een kwartslag en keert terug naar hetzelfde punt; nadat releaseStepper() is aangeroepen, kun je zijn as vrij met de hand draaien. De functie step() van de Stepper-bibliotheek blokkeert de code tot de beweging klaar is; wil je meerdere motoren tegelijk aansturen met vloeiende acceleratie, schakel dan over op de AccelStepper-bibliotheek.
DC-motor, servo en stappenmotor met de ESP32
De pins van de ESP32 geven 3,3 V af; de ingangen van de L298N en ULN2003 lezen dit niveau als HIGH, en servo's werken ook met een signaal van 3,3 V. De motoren hebben nog steeds een eigen voeding nodig. Het verschil zit in de servo: de standaard Servo-bibliotheek van Arduino ondersteunt de ESP32 niet. Installeer de ESP32Servo-bibliotheek of, zoals hieronder, genereer het 50 Hz-signaal zelf met de hardware-PWM-eenheid van de ESP32, LEDC. Omdat we twee verschillende frequenties gebruiken, 1 kHz voor de DC-motor en 50 Hz voor de servo, wijzen we de kanalen met ledcAttachChannel aan aparte timers toe (kanalen 0 en 2); in sommige core-versies delen naburige kanalen dezelfde timer. De code is voor ESP32 Arduino core 3.x; in 2.x-versies gebruik je in plaats daarvan ledcSetup en ledcAttachPin. De Stepper-bibliotheek werkt ongewijzigd op de ESP32; ben je nieuw met dit board, kijk dan eens naar Wat is de ESP32?
1#include <Stepper.h>
2
3// ESP32 Arduino çekirdeği 3.x / ESP32 Arduino core 3.x
4const int ENA = 25; // L298N hız (PWM) / L298N speed (PWM)
5const int IN1 = 26;
6const int IN2 = 27;
7const int SERVO_PIN = 18; // servo sinyali / servo signal
8
9const int STEPS_PER_REV = 2048;
10Stepper stepper(STEPS_PER_REV, 19, 22, 21, 23); // sıra: IN1, IN3, IN2, IN4 / order: IN1, IN3, IN2, IN4
11
12void motor(int speed) { // -255 … 255
13 digitalWrite(IN1, speed > 0);
14 digitalWrite(IN2, speed < 0);
15 ledcWrite(ENA, abs(speed));
16}
17
18void servoWrite(int angle) { // 0 … 180
19 int us = map(angle, 0, 180, 500, 2400); // açı → darbe (µs) / angle → pulse (µs)
20 ledcWrite(SERVO_PIN, (uint32_t)us * 65535 / 20000); // 20 ms içindeki pay / share of the 20 ms period
21}
22
23void setup() {
24 pinMode(IN1, OUTPUT);
25 pinMode(IN2, OUTPUT);
26 ledcAttachChannel(ENA, 1000, 8, 0); // kanal 0: 1 kHz, 8 bit (0–255) / channel 0: 1 kHz, 8-bit
27 ledcAttachChannel(SERVO_PIN, 50, 16, 2); // kanal 2, ayrı zamanlayıcı: 50 Hz, 16 bit / channel 2, separate timer: 50 Hz, 16-bit
28 stepper.setSpeed(10); // devir/dakika / RPM
29}
30
31void loop() {
32 motor(200); delay(2000); // DC: ileri / forward
33 motor(0); delay(500); // DC: dur / stop
34 servoWrite(0); delay(600); // servo: 0°
35 servoWrite(180); delay(600); // servo: 180°
36 servoWrite(90); delay(600); // servo: 90°
37 stepper.step(512); delay(500); // step: çeyrek tur / quarter turn
38 stepper.step(-512); delay(1000);
39}MicroPython-code voor de Raspberry Pi Pico
Op de Pico kan elke GP-pin PWM leveren. In MicroPython stel je de snelheid van de DC-motor in van 0 tot 65535 met duty_u16() en de pulsbreedte van de servo in nanoseconden met duty_ns(). De stappenmotor draai je door de halve-stapreeks na elkaar naar vier pins te schrijven; in halve-stapmodus is één omwenteling van de 28BYJ-48 4096 stappen. Ben je nieuw met de Pico, begin dan met Wat is de Raspberry Pi Pico?
1from machine import Pin, PWM
2import time
3
4# DC motor (L298N): ENA=GP15, IN1=GP14, IN2=GP13
5ena = PWM(Pin(15))
6ena.freq(1000)
7in1 = Pin(14, Pin.OUT)
8in2 = Pin(13, Pin.OUT)
9
10# Servo: GP16, 50 Hz
11servo = PWM(Pin(16))
12servo.freq(50)
13
14# Step motor (ULN2003): IN1–IN4 = GP2–GP5
15coils = [Pin(n, Pin.OUT) for n in (2, 3, 4, 5)]
16SEQ = [(1,0,0,0), (1,1,0,0), (0,1,0,0), (0,1,1,0),
17 (0,0,1,0), (0,0,1,1), (0,0,0,1), (1,0,0,1)] # yarım adım dizisi / half-step sequence
18
19def motor(speed): # -100 … 100
20 in1.value(speed > 0)
21 in2.value(speed < 0)
22 ena.duty_u16(int(abs(speed) * 655.35))
23
24def servo_angle(angle): # 0 … 180
25 us = 500 + angle * 1900 // 180 # 500–2400 µs
26 servo.duty_ns(us * 1000)
27
28phase = 0 # dizideki konum, çağrılar arasında korunur / position in the sequence, kept between calls
29
30def step(steps, delay_ms=2): # yarım adımda 4096 adım = 1 tur / 4096 half-steps = 1 turn
31 global phase
32 d = 1 if steps > 0 else -1
33 for _ in range(abs(steps)):
34 phase = (phase + d) % 8
35 for pin, v in zip(coils, SEQ[phase]):
36 pin.value(v)
37 time.sleep_ms(delay_ms)
38 for pin in coils:
39 pin.value(0) # bobinleri bırak / release coils
40
41while True:
42 motor(70) # DC: %70 ileri / 70% forward
43 time.sleep(2)
44 motor(0) # DC: dur / stop
45 time.sleep(0.5)
46 for a in (0, 180, 90): # servo: üç açı / three angles
47 servo_angle(a)
48 time.sleep(0.6)
49 step(1024) # step: çeyrek tur / quarter turn
50 time.sleep(0.5)
51 step(-1024)
52 time.sleep(1)Welke motor voor welk project?
| Project | Geschikte motor | Waarom? |
|---|---|---|
| Robotauto, lijnvolgrobot | DC-motor met tandwielkast (TT, N20) | Draait continu, goedkoop, snelheidsregeling met PWM is genoeg |
| Parkeerbarrière, deurgrendel, slot | Servo (SG90; MG996R voor zware deksels) | Beweegt tussen twee posities en blijft daar |
| Automatische schuifdeur, garagedeur | DC-motor met tandwielkast + eindschakelaar | Lange slag en veel kracht; de eindpunten worden met schakelaars gedetecteerd |
| 3D-printer, CNC, lasergraveerder | NEMA 17-stappenmotor + A4988 of TMC2209 | Herhaalbare positie fijner dan een tiende millimeter |
| Robotarm | Servo (MG996R aan de basis, SG90 in de grijper) | Elk gewricht moet op een bepaalde hoek stoppen |
| Camera-slider, draaitafel, slim gordijn | Stappenmotor | Langzame, vloeiende en herhaalbare beweging |
| Radar, pan-tilt-camera, zonnevolger | Servo | Een zwaai van 0–180° is genoeg en de code is heel eenvoudig |
| Ventilator, waterpomp | DC motor + MOSFET | Eén richting is genoeg; alleen snelheid of aan/uit |
| Drone, RC-vliegtuig, elektrisch skateboard | Borstelloze motor (BLDC) + ESC | Zeer hoge snelheid, rendement en vermogen |
In sommige projecten kan elke motor het, en komt de keuze neer op details. In een robotauto zijn DC-motoren prima voor de wielen, maar wil je dat de auto precies 50 cm rijdt, dan voeg je encoders toe of stuur je de wielen aan met stappenmotoren. In een robotarm zijn servo's de makkelijkste route; zware, precieze armen gebruiken stappenmotoren met overbrenging in de gewrichten. Bij een 3D-printer is het eenvoudig uit te rekenen hoeveel stappen een as per millimeter nodig heeft: met een motor van 200 stappen, 1/16 microstappen en een GT2-poelie met 20 tanden (tandsteek 2 mm) krijg je 200 × 16 / (20 × 2) = 80 stappen/mm; met een T8-leidspindel met een spoed van 8 mm wordt het 200 × 16 / 8 = 400 stappen/mm. Voor projecten die 0–180° zwaaien, zoals een radar of een zonnevolger, is een servo zowel de goedkoopste als de eenvoudigste oplossing.
Een korte introductie tot borstelloze motoren (BLDC) en ESC's
Een borstelloze DC-motor (BLDC) is omgekeerd gebouwd: de magneten zitten op het draaiende deel en de spoelen in de vaste behuizing. Zonder borstels of commutator is er geen wrijving, vonkvorming of slijtage; de motor is efficiënter, stiller en gaat veel langer mee. De prijs is dat de stroomrichting nu door een elektronische schakeling moet worden omgeschakeld in plaats van door borstels. Daarom hebben BLDC-motoren 3 draden en draaien ze niet als je ze rechtstreeks op een batterij aansluit. Bij modelmotoren wordt de snelheid opgegeven met de KV-waarde, de RPM zonder belasting per volt. Een motor van 1000 KV (bijv. de A2212) op een 3-cels LiPo (11,1 V) draait onbelast ongeveer 11.100 RPM. Drones, RC-vliegtuigen, elektrische skateboards en steps, computerventilatoren en harde schijven gebruiken allemaal borstelloze motoren.
Om een BLDC-motor op een Arduino aan te sluiten heb je een ESC (electronic speed controller) nodig. De ESC zet de gelijkspanning van de batterij om in driefasige pulsen voor de motor; sensorloze ESC's schatten de rotorpositie op basis van de back-EMF in de spoel die geen stroom krijgt. Het mooie is dat de stuuringang van de ESC hetzelfde is als die van een servo: met pulsen van 50 Hz betekent 1000 µs stop en 2000 µs vol gas. De stroomwaarde van de ESC (bijv. 30 A) moet hoger zijn dan de maximale stroom die de motor kan opnemen, en de meeste ESC's hebben een BEC-uitgang die 5 V levert. Uit veiligheid wil een ESC bij het opstarten eerst minimaal gas zien; dit heet armeren, en de motor draait pas als dat signaal binnenkomt. In de onderstaande code gaat de signaaldraad van de ESC naar D9 en de loper van de potentiometer voor het gas naar A0.
1#include <Servo.h>
2
3Servo esc; // ESC bir servo gibi sürülür / an ESC is driven like a servo
4const int POT_PIN = A0; // gaz potansiyometresi / throttle potentiometer
5
6void setup() {
7 esc.attach(9, 1000, 2000); // 1000–2000 µs aralığı / 1000–2000 µs range
8 esc.writeMicroseconds(1000); // en düşük gaz: ESC'yi kur (arming) / minimum throttle: arm the ESC
9 delay(3000); // bip seslerini bekle / wait for the beeps
10}
11
12void loop() {
13 int throttle = map(analogRead(POT_PIN), 0, 1023, 1000, 2000); // pot → gaz / pot → throttle
14 esc.writeMicroseconds(throttle);
15 delay(20); // bir servo periyodu / one servo period
16}Veelgemaakte fouten en hoe je ze oplost
- De Arduino reset als de motor draait: De motor of servo wordt gevoed via de 5V-pin van het board. Gebruik een aparte voeding, verbind de massa's en voeg een grote condensator toe aan de voeding.
- De servo trilt of springt rond: De voeding is te zwak, de draden zijn dun en lang, of de massa wordt niet gedeeld. Sluit de servo aan op een voeding van 5–6 V die minstens 1 A kan leveren.
- De snelheid van de DC-motor verandert niet als er een servo wordt gebruikt: Op de Uno zit ENA op pin 9 of 10, en de Servo-bibliotheek schakelt PWM op die pins uit. Verplaats ENA naar 3, 5, 6 of 11.
- De DC-motor draait niet bij lage PWM-waarden, hij zoemt alleen: Er is te weinig kracht om de statische wrijving te overwinnen. Start de motor even met een hoge waarde en verlaag dan de snelheid, of houd de minimumwaarde rond 80–100. Houd ook rekening met de spanningsval van de L298N van ongeveer 2 V.
- De stappenmotor trilt maar draait niet: De spoelvolgorde klopt niet of de snelheid is te hoog. Gebruik voor de 28BYJ-48 de volgorde Stepper(2048, IN1, IN3, IN2, IN4) en houd de snelheid onder 15 RPM.
- De stappenmotor slaat stappen over: De belasting is te zwaar, de acceleratie te fel of de stroomlimiet van de A4988 te laag. Stel Vref in met de formule I = Vref / (8 × Rcs), waarbij Rcs de stroommeetweerstand op het board is, en gebruik rustige acceleratie met AccelStepper.
- De A4988 is doorgebrand: De motorkabel is aangesloten of losgehaald terwijl de driver onder spanning stond, Vref was te hoog of er zat geen condensator op VMOT. Sluit de motor altijd aan terwijl de voeding uit staat.
- De ESC laat de motor niet draaien en blijft piepen: Hij kreeg bij het inschakelen geen signaal voor minimaal gas. Zorg dat setup() writeMicroseconds(1000) stuurt en een paar seconden wacht; kalibreer de ESC indien nodig zoals beschreven in de handleiding.
Kortom: een DC-motor staat voor snelheid, een servo voor hoek en een stappenmotor voor positie; combineer de juiste motor met de juiste driver en de helft van je project is opgelost. Beginnen met een SG90 en een TT-motor en daarna doorstappen naar een stappenmotor is de makkelijkste manier om alle drie te leren. In de BlueGrays-app vind je de basis van servomotoren, servobesturing met een potentiometer, de basis van stappenmotoren, een stappenmotor omzetten in een servo van 360 graden, een auto met Bluetooth-besturing met de L298N en een robot die obstakels ontwijkt, elk stap voor stap met schakelschema's en code.
Veelgestelde vragen
Wat is het verschil tussen een servo en een stappenmotor?
Een servo kent zijn positie dankzij zijn interne potentiometer en beweegt meestal naar de gevraagde hoek tussen 0 en 180° en blijft daar. Een stappenmotor kan onbeperkt draaien en kent zijn positie door stappen te tellen, maar als hij overbelast raakt en stappen overslaat, merkt hij dat niet. Kies een servo voor korte, snelle hoekbewegingen en een stappenmotor voor nauwkeurig positioneren over veel omwentelingen.
Kan ik een DC-motor rechtstreeks op een Arduino aansluiten?
Nee. Een Arduino-pin kan hooguit 40 mA leveren, terwijl een kleine DC-motor honderden milliampères opneemt en een spanningspiek in tegengestelde richting veroorzaakt die de pin kan vernietigen als de stroom wordt onderbroken. Gebruik een MOSFET en een diode voor besturing in één richting, of een H-brugdriver zoals de L298N of L9110S voor vooruit en achteruit.
Waarom wordt mijn stappenmotor heet?
Er loopt voortdurend stroom door de spoelen van een stappenmotor om houdmoment te leveren, ook als de motor stilstaat, dus het is normaal dat de behuizing warm of zelfs heet wordt. Als hij te heet is om je hand er langer dan een paar seconden op te houden, staat de stroomlimiet (Vref) van de A4988 te hoog. Als je de positie niet hoeft vast te houden, kun je warmte en verbruik verminderen door de EN-pin HIGH te zetten of de spoelen uit te schakelen.
Kan een servomotor 360 graden draaien?
Standaardservo's draaien meestal alleen tussen 0 en 180° vanwege een mechanische aanslag binnenin. Servo's met continue rotatie (360°) zoals de FS90R maken hele omwentelingen, maar dan bestuur je snelheid en richting in plaats van hoek en verlies je de positie-informatie. Heb je zowel hele omwentelingen als een nauwkeurige positie nodig, dan is een stappenmotor de betere keuze.
Waarom gebruiken 3D-printers stappenmotoren?
Een stappenmotor draait bij elke ontvangen puls een vaste hoek, dus hij geeft herhaalbare, nauwkeurige positionering zonder extra sensor. Een NEMA 17-motor met 1/16 microstappen en een GT2-riem zet 80 stappen per millimeter, ongeveer 0,0125 mm per stap. Omdat ze goedkoop, robuust en eenvoudig aan te sturen zijn, zijn stappenmotoren de standaard in hobby-3D-printers en CNC-machines.
Hoe stuur je een borstelloze (BLDC) motor aan met een Arduino?
Een borstelloze motor kun je niet rechtstreeks vanaf een pin of met een L298N aansturen; je hebt een ESC ertussen nodig. De signaaldraad van de ESC gaat naar een Arduino-pin, en met de Servo-bibliotheek betekent writeMicroseconds(1000) stop en writeMicroseconds(2000) vol gas. Bij het inschakelen moet je een paar seconden minimaal gas sturen om de ESC te armeren.
Projecten om hierna te bouwen
Alle projecten bekijken
Een servomotor gebruiken
De arm van een kleine servomotor draait na elkaar naar drie standen: helemaal naar het begin, precies naar het midden en helemaal naar het einde, en wacht bij elke stop twee seconden.

Een stappenmotor gebruiken
Een motor die stap voor stap draait, precies zo ver als jij wilt, zoals de wijzer van een klok.

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…

Servomotor aansturen met een potentiometer
Als je aan de knop van de potentiometer draait, draait de arm van de servomotor mee: het ene uiteinde van de knop staat voor nul graden, het andere voor een halve slag.

360-gradenservo van een stappenmotor
Leer een gewone stappenmotor naar elke gewenste hoek te gaan, helemaal rond de cirkel.

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.

ESP32-servomotor (bediening met potentiometer)
In dit project bedien je een SG90-servomotor met een potentiometer. De analoge waarde van de potentiometer zet je om naar het bereik van 0–180 graden en zo stel je de servohoek in. De ESP32Servo-bibliotheek maakt het servosignaal op geschikte GPIO-pinnen van de ESP32 die als uitgang kunnen dienen; dit project gebruikt GPIO 18. Dit is een basismethode voor robotarmen, cameragimbals en automatische deurmechanismen.

ESP32 RFID-deurslot (RC522 + servo + OLED + buzzer + LED)
We bouwen een slim deurslot met een ESP32, een RC522 RFID-module, een SG90-servo, een SSD1306 OLED-display, een actieve buzzer en 2 leds. Bij het scannen van een kaart wordt de UID vergeleken met de geautoriseerde kaarten in de code; bij een match ontgrendelt de servo (groene led + 2 korte piepjes) en vergrendelt na 5 seconden weer. Een onbekende kaart laat de rode led branden, geeft 3 snelle piepjes en toont de UID op de OLED.
Meer artikelen
BlueGrays-app
Bouw deze schakeling stap voor stap op je telefoon
Schakelschema, code en onderdelenlijst op één scherm. Meer dan 500 Arduino-, ESP32- en Pico-projecten om te bouwen.
Scan met je telefoon
Richt je camera op de code en de appstore van je telefoon opent.
of open de store

