A4988-stappenmotordriver met NEMA 17: Vref, microstepping, code
Zo stuur je een NEMA 17 aan met de A4988: STEP/DIR-bedrading, de Vref-formule, de stroom instellen met een multimeter, MS1–MS3-microstepping, AccelStepper en CNC Shield.
Een NEMA 17 aansturen met de A4988 is de goedkoopste manier om de nauwkeurige beweging van 3D-printers, CNC-machines en lasergraveerders in je eigen project te brengen. De A4988 is een bipolaire stappenmotordriver van Allegro, verkocht op een module ter grootte van een vingertop: elke STEP-puls van de Arduino zet de motor één stap vooruit, de DIR-pin bepaalt de richting en de driver houdt de stroom door de motorspoelen op de waarde die jij instelt. Kortom: om de motor te laten draaien heb je maar twee pins en een voeding tussen 8 en 35 V nodig.
In deze gids leer je hoe de A4988 werkt, hoe je met een multimeter de spoelen van een NEMA 17 vindt, hoe je hem aansluit en waarom je een condensator van 100 µF op de voeding nodig hebt. Daarna volgt de belangrijkste stap, de stroom instellen met Vref, waarbij we de formule en de multimetermeting stap voor stap doorlopen. Ook vind je hier microstepping met de MS1–MS3-pins, een eerste sketch zonder bibliotheek, soepel optrekken met AccelStepper, de CNC Shield, code voor ESP32 en Raspberry Pi Pico, warmte en koelplaten, een vergelijking tussen DRV8825 en TMC2208 en oplossingen voor het klassieke probleem "de motor trilt maar draait niet".

Wat is de A4988 en hoe werkt hij?
In de A4988 zitten twee volledige H-bruggen (één per spoel), een translator en een stroomregelcircuit. De translator maakt van elke LOW→HIGH-overgang op de STEP-pin de juiste stroomvolgorde voor de spoelen, dus je hoeft de spoelvolgorde niet zelf in je code uit te werken. De stroomregeling werkt met een chopper: de driver bewaakt voortdurend de stroom door elke spoel via een kleine meetweerstand (Rs) en schakelt de uitgang kort uit zodra de stroom de ingestelde limiet bereikt. Daarom blijft de spoelstroom op een veilige waarde, ook als je de motor ruim boven de nominale spanning voedt, bijvoorbeeld met 12 of 24 V. De chip heeft ook beveiliging tegen oververhitting, onderspanning, kortgesloten belasting en kortsluiting naar massa.
| Eigenschap | Waarde |
|---|---|
| Motorvoeding (VMOT) | 8–35 V |
| Logicavoeding (VDD) | 3–5,5 V (5 V op Arduino, 3,3 V op ESP32 en Pico) |
| Stroom per spoel | Ongeveer 1 A zonder koelplaat, tot 2 A met goede koeling |
| Microstepping | Volledig, 1/2, 1/4, 1/8, 1/16 |
| Stuurpins | STEP, DIR, ENABLE, MS1–MS3, RESET, SLEEP |
| STEP-puls | HIGH- en LOW-deel elk minstens 1 µs |
| Beveiliging | Thermische uitschakeling (165 °C), onderspanningsblokkering, kortsluitbeveiliging |
| Geschikte motoren | Bipolaire stappenmotoren met 4 draden (NEMA 17, NEMA 14, enz.) |
NEMA 17-stappenmotor: specificaties en de spoelen vinden
NEMA 17 is geen motormodel maar een maatstandaard voor motoren met een voorplaat van 42 × 42 mm; wat erin zit hangt af van de lengte van de behuizing en de fabrikant. De 17HS4401, het meest gebruikte model in hobbyprojecten, maakt 200 stappen per omwenteling (1,8°), heeft een nominale stroom van 1,7 A per fase, een spoelweerstand van ongeveer 1,5 Ω en ongeveer 40 N·cm houdkoppel. De spanning op het label is slechts 1,7 A × 1,5 Ω ≈ 2,6 V, maar laat je daardoor niet misleiden: omdat de A4988 de stroom zelf begrenst, voed je de motor met 12–24 V. Een hogere spanning laat de spoelstroom bij elke stap sneller oplopen, waardoor de motor bij hoge snelheid minder koppel verliest. Wil je weten hoe hij verschilt van kleine unipolaire motoren zoals de 28BYJ-48, lees dan 28BYJ-48 en ULN2003.
De 4 draden van de motor horen bij twee onafhankelijke spoelen. Voordat je hem op de A4988 aansluit, moet je weten welke twee draden dezelfde spoel vormen. Bij veel modellen is zwart-groen de ene spoel en rood-blauw de andere, maar de kleuren verschillen per fabrikant, dus meten is het betrouwbaarst:
- Zet je multimeter op weerstand (Ω); weet je niet hoe, bekijk dan de multimetergids.
- Houd één draad vast en meet hem tegen elk van de andere drie. De draad met een waarde van 1–4 Ω is het andere uiteinde van dezelfde spoel; de andere twee tonen een open circuit (OL).
- De overige twee draden vormen de tweede spoel en moeten dezelfde weerstand tonen. Met de gemeten weerstand en de nominale stroom kun je de labelspanning van de motor controleren met de rekenmachine voor de wet van Ohm.
- Geen multimeter? Houd de uiteinden van twee draden tegen elkaar en draai de as met de hand: wordt hij merkbaar zwaarder om te draaien, dan horen die twee draden bij dezelfde spoel.
- Sluit de ene spoel aan op de pins 1A–1B van de A4988 en de andere op 2A–2B. Draait de motor de andere kant op dan je wilt, wissel dan gewoon de twee draden van één spoel om.
A4988-pinout en bedradingsschema
| A4988-pin | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| VMOT | Plus van de adapter van 12–24 V (+ 100 µF) | Plus van de adapter van 12–24 V (+ 100 µF) | Plus van de adapter van 12–24 V (+ 100 µF) |
| GND (naast VMOT) | Min van de adapter | Min van de adapter | Min van de adapter |
| 1A, 1B | Motorspoel 1 | Motorspoel 1 | Motorspoel 1 |
| 2A, 2B | Motorspoel 2 | Motorspoel 2 | Motorspoel 2 |
| VDD | 5V | 3V3 | 3V3 (OUT) |
| GND (naast VDD) | GND | GND | GND |
| STEP | D2 | GPIO 25 | GP2 |
| DIR | D5 | GPIO 26 | GP3 |
| ENABLE | D8 | GPIO 27 | GP4 |
| MS1, MS2, MS3 | 5V (1/16-stap) | 3V3 (1/16-stap) | 3V3 (1/16-stap) |
| RESET, SLEEP | Verbind ze met elkaar | Verbind ze met elkaar | Verbind ze met elkaar |
Waarom is een condensator van 100 µF een must?
A4988-boards hebben alleen kleine keramische condensatoren. In combinatie met de inductie van de voedingskabels veroorzaken deze condensatoren met lage ESR spanningspieken wanneer je de voeding inschakelt of de motor plotseling stroom trekt. Zulke pieken kunnen de limiet van 35 V van de chip overschrijden, zelfs met een voeding van 12 V, en de driver blijvend beschadigen. De oplossing is simpel: plaats een elco van minstens 47 µF, bij voorkeur 100 µF, tussen VMOT en GND, zo dicht mogelijk bij het board. De spanningsklasse moet ruim boven de voedingsspanning liggen: kies 25 V voor een voeding van 12 V en 35 V of 50 V voor 24 V. Elco's zijn gepolariseerd; het lange pootje (+) gaat naar VMOT en het korte pootje (–), gemarkeerd met de streep op de behuizing, naar GND. Over condensatortypes lees je meer in Wat is een condensator?, en voor de keuze van de juiste adapter zie een Arduino van stroom voorzien.
De stroom instellen met Vref: de formule
Met de kleine potentiometer op de A4988 stel je Vref (de referentiespanning) in, die de maximale motorstroom bepaalt. De driver vergelijkt deze spanning met de spanning over de twee meetweerstanden (Rs) op het board, en de piekspoelstroom is: I = Vref / (8 × Rs). Om de benodigde Vref te vinden, herschik je de formule: Vref = I × 8 × Rs. Om Rs te vinden, lees je de opdruk van de twee kleine SMD-weerstanden naast de chip: R100 betekent 0,1 Ω, R068 betekent 0,068 Ω en R050 betekent 0,05 Ω. Heb je moeite met de codes, gebruik dan de rekenmachine voor SMD-weerstandscodes of het artikel over SMD-weerstandscodes.
| Rs-opdruk | Rs-waarde | Formule | Vref voor 0,8 A | Vref voor 1 A | Vref voor 1,2 A |
|---|---|---|---|---|---|
| R050 | 0,05 Ω | Vref = I × 0,4 | 0,32 V | 0,40 V | 0,48 V |
| R068 | 0,068 Ω | Vref = I × 0,544 | 0,44 V | 0,54 V | 0,65 V |
| R100 | 0,1 Ω | Vref = I × 0,8 | 0,64 V | 0,80 V | 0,96 V |
Welke stroom kies je? De stroom op het label van de motor (1,7 A bij de 17HS4401) is een plafond dat je nooit mag overschrijden. Zonder koelplaat kan de A4988 comfortabel ongeveer 1 A aan, dus 0,8–1 A is een goed startpunt. Op gangbare boards met R100-weerstanden betekent dat een Vref van 0,64–0,80 V. Slaat de motor onder belasting stappen over, verhoog de stroom dan in stappen van 0,1 A; ga je boven 1,2 A, monteer dan een koelplaat en een ventilator op de chip. Meer stroom dan nodig verwarmt de driver en de motor veel meer dan dat de motor merkbaar sterker wordt.
Vref meten met een multimeter: stap voor stap
- Koppel de motor los van de driver terwijl alle spanning uit staat. Je hebt de motor niet nodig om Vref te meten.
- Voed de pins VDD en GND van de A4988 met de logicavoeding (de 5V van de Arduino is genoeg). Vref wordt van deze spanning afgeleid, dus zonder VDD kun je hem niet meten; VMOT aangesloten laten kan geen kwaad.
- Zet de multimeter op gelijkspanning (bereik 2 V of 20 V). Raak met de zwarte meetpen GND aan en met de rode meetpen de metalen bovenkant van de potentiometer; sommige boards hebben in plaats daarvan een klein testpunt met het label VREF.
- Draai de potentiometer heel licht met een kleine plastic of keramische schroevendraaier en let op de aflezing. Op de meeste boards verhoogt rechtsom Vref, maar dat kan verschillen; sommige potentiometers draaien na een volledige slag door, dus ga in kleine stapjes.
- Zodra je de berekende waarde bereikt, schakel je de voeding uit, sluit je de motor aan en zet je pas dan weer spanning erop.
- Laat de motor een paar minuten draaien en controleer de temperatuur van de chip. Kun je je vinger er zelfs niet een paar seconden op houden, verlaag dan Vref een beetje of monteer een koelplaat.
Microstepping met MS1, MS2 en MS3
Microstepping betekent dat de driver de stroom in de twee spoelen geleidelijk verandert, waardoor elke hele stap in kleinere delen wordt opgedeeld. De A4988 kiest een van vijf modi op basis van de logische niveaus op de pins MS1–MS3. Deze pins hebben interne pull-downweerstanden, dus als je alle drie onaangesloten laat, draait de motor in volledige-stapmodus.
| MS1 | MS2 | MS3 | Modus | Stappen per omwenteling | Staphoek |
|---|---|---|---|---|---|
| LOW | LOW | LOW | Volledige stap | 200 | 1,8° |
| HIGH | LOW | LOW | Halve stap | 400 | 0,9° |
| LOW | HIGH | LOW | 1/4-stap | 800 | 0,45° |
| HIGH | HIGH | LOW | 1/8-stap | 1600 | 0,225° |
| HIGH | HIGH | HIGH | 1/16-stap | 3200 | 0,1125° |
Het echte voordeel van microstepping is een soepele, stille draaiing: in volledige-stapmodus schokt de motor bij elke stap en resoneert en trilt hij bij bepaalde snelheden, terwijl de beweging bij 1/16 bijna continu is. Verwacht echter niet dat de nauwkeurigheid echt 16 keer beter wordt. Het koppel dat één microstap vooruit duwt is slechts sin(90° / 16) ≈ 10% van het houdkoppel; als wrijving of belasting die kleine kracht overwint, loopt de motor een paar microstappen achter. Om de snelheid te berekenen gebruik je: stappen/s = RPM × 200 × microstappen / 60. Bijvoorbeeld: 60 RPM bij 1/16 vraagt 3200 STEP-pulsen per seconde. Wil je de modus in software wijzigen, dan kun je de MS-pins ook op de Arduino aansluiten; in de meeste projecten is een vaste modus kiezen met draden echter genoeg.
Eerste sketch: de motor laten draaien met STEP en DIR, zonder bibliotheek
De onderstaande sketch laat de motor één omwenteling vooruit en één terug draaien zonder bibliotheek, puur door pulsen naar de STEP-pin te sturen. We nemen aan dat je MS1–MS3 met 5V hebt verbonden, zodat de motor op 1/16 draait en één omwenteling 3200 stappen is.
1// A4988 + NEMA 17, kütüphanesiz / without a library
2const int STEP_PIN = 2; // CNC Shield X ekseniyle aynı / same as CNC Shield X axis
3const int DIR_PIN = 5;
4const int EN_PIN = 8; // aktif LOW / active LOW
5
6const long STEPS_PER_REV = 200L * 16; // 1,8° motor, 1/16 mikro adım = 3200 / 1.8° motor, 1/16 microstep
7
8void setup() {
9 pinMode(STEP_PIN, OUTPUT);
10 pinMode(DIR_PIN, OUTPUT);
11 pinMode(EN_PIN, OUTPUT);
12 digitalWrite(EN_PIN, LOW); // sürücüyü aç / enable the driver
13}
14
15void rotate(long steps, unsigned int pauseUs) {
16 digitalWrite(DIR_PIN, steps > 0 ? HIGH : LOW); // yön / direction
17 delayMicroseconds(5); // DIR, STEP'ten önce otursun / let DIR settle before STEP
18 for (long i = 0; i < labs(steps); i++) {
19 digitalWrite(STEP_PIN, HIGH);
20 delayMicroseconds(5); // darbe en az 1 µs / pulse at least 1 µs
21 digitalWrite(STEP_PIN, LOW);
22 delayMicroseconds(pauseUs); // küçüldükçe hız artar / smaller = faster
23 }
24}
25
26void loop() {
27 rotate(STEPS_PER_REV, 500); // 1 tur ileri, ~1,6 sn / one turn forward, ~1.6 s
28 delay(1000);
29 rotate(-STEPS_PER_REV, 500); // 1 tur geri / one turn back
30 delay(1000);
31}In deze code zijn er drie timings om op te letten. De A4988 heeft nodig dat het HIGH- en het LOW-deel van de STEP-puls minstens 1 µs duren; 5 µs is een veilige waarde. Nadat DIR verandert, moet je minstens 200 ns wachten voor de eerste STEP-puls; de code wacht hiervoor 5 µs. De snelheid wordt bepaald door de pauze tussen de pulsen: met een pauze van 500 µs duurt één stap ongeveer 0,51 ms, dus een omwenteling (3200 stappen) duurt ongeveer 1,6 seconden, ruwweg 36 RPM. Deze code heeft twee zwakke punten: de motor start abrupt op volle snelheid en de Arduino kan niets anders doen terwijl de lus draait. Als je de pauze meteen naar 100 µs verlaagt, start de motor hoogstwaarschijnlijk niet en zoemt hij alleen.
Optrekken en afremmen met AccelStepper
Een stappenmotor kun je niet in een oogwenk van stilstand naar hoge snelheid brengen; de rotor en de belasting kunnen zo'n plotselinge verandering niet bijhouden, de motor raakt uit de pas en slaat stappen over. De oplossing is de snelheid geleidelijk op te voeren en af te bouwen als je het doel nadert. AccelStepper, die je installeert via de Library Manager, doet dit zonder te blokkeren: je roept run() constant aan binnen loop() en de bibliotheek zet een stap zodra die aan de beurt is. Zo kun je knoppen lezen, een display bijwerken of sensoren uitlezen terwijl de motor draait; deze aanpak vind je uitgebreid in millis() vs delay(). Op een Uno kan AccelStepper betrouwbaar een paar duizend stappen per seconde halen (de documentatie noemt ongeveer 4000 stappen/s bij 16 MHz), dus het voorbeeld gebruikt 2000 stappen/s, wat bij 1/16 ongeveer 37 RPM is.
1#include <AccelStepper.h>
2
3const int STEP_PIN = 2;
4const int DIR_PIN = 5;
5const int EN_PIN = 8;
6const long STEPS_PER_REV = 200L * 16; // 1/16 mikro adımda 1 tur / one turn at 1/16 microstep
7
8AccelStepper stepper(AccelStepper::DRIVER, STEP_PIN, DIR_PIN);
9
10void setup() {
11 stepper.setEnablePin(EN_PIN);
12 stepper.setPinsInverted(false, false, true); // EN aktif LOW / EN is active LOW
13 stepper.enableOutputs();
14 stepper.setMaxSpeed(2000); // adım/sn, Uno için güvenli / steps per second, safe on Uno
15 stepper.setAcceleration(1500); // adım/sn² / steps per second²
16 stepper.moveTo(STEPS_PER_REV * 3); // 3 tur ileri / three turns forward
17}
18
19void loop() {
20 if (stepper.distanceToGo() == 0) { // hedefe varıldı / target reached
21 delay(500);
22 stepper.moveTo(stepper.currentPosition() == 0 ? STEPS_PER_REV * 3 : 0); // git-gel / back and forth
23 }
24 stepper.run(); // her döngüde çağır, bekletmez / call every loop, non-blocking
25}| Functie | Wat het doet |
|---|---|
| AccelStepper(AccelStepper::DRIVER, STEP, DIR) | Maakt een object aan voor een driver met STEP/DIR-ingangen |
| setMaxSpeed(stappen/s) | De topsnelheid die bereikt wordt |
| setAcceleration(stappen/s²) | De snelheid van optrekken en afremmen |
| moveTo(positie) / move(stappen) | Ga naar een absolute positie, of relatief ten opzichte van waar de motor nu is |
| run() | Zet een stap als die aan de beurt is; moet constant worden aangeroepen binnen loop() |
| runToPosition() | Blokkeert het programma tot het doel is bereikt |
| distanceToGo() / currentPosition() | Resterende stappen en de huidige positie |
| setCurrentPosition(0) | Behandelt het huidige punt als nul (na homing met een eindschakelaar) |
| setEnablePin() / setPinsInverted() | Definieert de EN-pin; geïnverteerd omdat EN bij de A4988 actief-LOW is |
| enableOutputs() / disableOutputs() | Zet de spoelen onder stroom of laat ze los |
Meerdere motoren met de CNC Shield V3
Stuur je meer dan één NEMA 17 aan, dan voorkom je een wirwar van draden het makkelijkst met de Arduino CNC Shield V3. Dit board past op de Uno en heeft vier A4988-voetjes (X, Y, Z en A), microstepping-jumpers onder elke driver, motoraansluitingen, eindschakelaaringangen en een voedingsklem; met alle drie de jumpers geplaatst draait de A4988 op 1/16. In de bedradingstabel hebben we bewust D2, D5 en D8 gekozen voor STEP, DIR en EN: dit zijn de pins van de X-as van de shield, dus de sketches hierboven werken ongewijzigd op de shield. Flash je GRBL op de Uno, dan wordt de shield een CNC- of lasercontroller die G-code van je computer ontvangt. In GRBL voer je in de instellingen $100, $101 en $102 in hoeveel stappen elke as per millimeter nodig heeft: met een GT2-tandwiel van 20 tanden en 1/16-microstepping is dat 200 × 16 / (20 × 2) = 80 stappen/mm, en op een T8-spindel met een spoed van 8 mm is het 200 × 16 / 8 = 400 stappen/mm.
| As | STEP | DIR | Opmerking |
|---|---|---|---|
| X | D2 | D5 | Eindschakelaar D9 |
| Y | D3 | D6 | Eindschakelaar D10 |
| Z | D4 | D7 | Eindschakelaar D12 (GRBL 1.1) |
| A | Via jumpers | Via jumpers | Kloon van X, Y of Z (bijv. een Y-as met twee motoren) |
| Alle drivers | – | – | Gedeelde EN-pin D8: LOW = drivers aan |
De A4988 gebruiken met de ESP32
De pins van de ESP32 geven 3,3 V af. De A4988 leest een ingang alleen betrouwbaar als HIGH wanneer die boven 70% van VDD ligt; bij een VDD van 5 V is die drempel 3,5 V, dus een signaal van 3,3 V komt tekort. Daarom sluit je bij de ESP32 of Pico de VDD-pin van de A4988 aan op 3V3: de driver werkt prima op 3–5,5 V en je hebt geen niveauconverter nodig. Omdat VDD is veranderd, moet je Vref opnieuw meten. De onderstaande sketch beweegt de motor, met optrekken, naar de hoek die je in de Serial Monitor typt (bijvoorbeeld 90 of -45). Doordat de ESP32 veel sneller is, haalt AccelStepper hier makkelijk 6000 stappen per seconde; voor hogere snelheden kun je de bibliotheek FastAccelStepper bekijken, die hardwaretimers gebruikt. Ben je nieuw met de ESP32, begin dan met Wat is de ESP32?.
1#include <AccelStepper.h>
2
3// ESP32: STEP=25, DIR=26, EN=27, A4988 VDD → 3V3
4const int STEP_PIN = 25;
5const int DIR_PIN = 26;
6const int EN_PIN = 27;
7const float STEPS_PER_DEG = 200.0 * 16 / 360.0; // 1/16'da derece başına 8,89 adım / 8.89 steps per degree at 1/16
8
9AccelStepper stepper(AccelStepper::DRIVER, STEP_PIN, DIR_PIN);
10
11void setup() {
12 Serial.begin(115200);
13 stepper.setEnablePin(EN_PIN);
14 stepper.setPinsInverted(false, false, true); // EN aktif LOW / EN is active LOW
15 stepper.enableOutputs();
16 stepper.setMaxSpeed(6000); // adım/sn / steps per second
17 stepper.setAcceleration(4000); // adım/sn² / steps per second²
18 Serial.println("Aci yaz, ornek 90 / type an angle, e.g. 90");
19}
20
21void loop() {
22 if (Serial.available()) {
23 float angle = Serial.parseFloat(); // Seri Monitör'den açı / angle from the Serial Monitor
24 while (Serial.available()) Serial.read(); // satır sonunu at / drop the line ending
25 stepper.moveTo(lround(angle * STEPS_PER_DEG));
26 Serial.printf("Hedef / target: %.1f\n", angle);
27 }
28 stepper.run(); // bekletmeden adım at / step without blocking
29}A4988 met de Raspberry Pi Pico en MicroPython
Ook bij de Pico sluit je de VDD-pin van de A4988 aan op de 3V3 (OUT)-pin. In plaats van een optrekbibliotheek kun je in MicroPython een eenvoudige lineaire helling schrijven zoals hieronder: de functie move() verandert de pauze tussen pulsen geleidelijk van 2000 µs naar 400 µs over de eerste en laatste 600 stappen en draait daartussen op volle snelheid. De MicroPython-lus voegt aan elke stap enkele tientallen microseconden toe, dus de echte snelheid is iets lager dan berekend. Heb je tienduizenden stappen per seconde of meerdere motoren tegelijk nodig, dan kunnen de PIO-blokken van de Pico de pulsen genereren zonder de CPU te belasten. Om MicroPython op de Pico te installeren, zie Wat is de Raspberry Pi Pico?.
1from machine import Pin
2import time
3
4step = Pin(2, Pin.OUT) # STEP → GP2
5direction = Pin(3, Pin.OUT) # DIR → GP3
6enable = Pin(4, Pin.OUT, value=0) # EN → GP4, 0 = sürücü açık / 0 = driver enabled
7
8STEPS_PER_REV = 200 * 16 # 1/16 mikro adım / 1/16 microstep
9
10def move(steps, max_sps=2500, ramp_steps=600):
11 direction.value(1 if steps > 0 else 0) # yön / direction
12 time.sleep_us(5)
13 n = abs(steps)
14 ramp = min(ramp_steps, n // 2) # hızlanma ve yavaşlama adımı / accel and decel steps
15 fast = 1000000 // max_sps # en kısa bekleme, µs / shortest pause, µs
16 slow = 2000 # 500 adım/sn ile başla / start at 500 steps/s
17 for i in range(n):
18 k = min(i, n - 1 - i) # başa ya da sona uzaklık / distance to start or end
19 pause = slow - (slow - fast) * k // ramp if k < ramp else fast
20 step.value(1)
21 time.sleep_us(3) # STEP darbesi / STEP pulse
22 step.value(0)
23 time.sleep_us(pause)
24
25while True:
26 move(STEPS_PER_REV) # 1 tur ileri / one turn forward
27 time.sleep(1)
28 move(-STEPS_PER_REV // 2) # yarım tur geri / half a turn back
29 time.sleep(1)Warmte, koelplaten en thermische beveiliging
Het is normaal dat de A4988 warm wordt, want de spoelstroom loopt door de MOSFET's in de chip. Het stroompad van elke spoel heeft doorgaans een totale weerstand van 0,64 Ω, en het gedissipeerde vermogen groeit met het kwadraat van de stroom: ongeveer P ≈ I² × 0,64 Ω. Bij een instelling van 1 A is dat ongeveer 0,65 W en bij 1,5 A ongeveer 1,45 W; naarmate de chip warmer wordt stijgt ook zijn weerstand, dus de werkelijke waarde ligt nog hoger. Dat is veel warmte voor een board ter grootte van een vingertop. Wanneer de chip 165 °C bereikt, schakelt de thermische beveiliging de uitgangen uit en weer in zodra hij ongeveer 15 °C is afgekoeld. Een motor die een paar seconden draait, stopt en daarna uit zichzelf doorgaat, is het klassieke teken van deze beveiliging.
- Monteer een koelplaat: Plak een kleine aluminium koelplaat met thermische tape op de chip; zorg dat hij de pins en de potentiometer niet raakt.
- Zorg voor luchtstroom: Boven 1,2 A, of in een gesloten behuizing, vermenigvuldigt een kleine ventilator het effect van de koelplaat.
- Stel de stroom in op wat je nodig hebt: Slaat de motor onder belasting geen stappen over, verlaag dan Vref een beetje; 20% minder stroom geeft ongeveer 36% minder warmte.
- Schakel de spoelen uit bij stilstand: Heb je geen houdkoppel nodig, zet dan de EN-pin HIGH of roep disableOutputs() aan als de beweging klaar is; zowel de driver als de motor koelen af.
- Controleer ook de temperatuur van de motor: Stappenmotoren trekken ook bij stilstand stroom, dus ze worden warm of zelfs heet. Komt de behuizing boven 60 °C, verlaag dan de stroom; bij die temperatuur beginnen PLA-onderdelen in een 3D-printer te verweken.
- Stap over op een sterkere driver: Heeft je motor meer dan 1,5 A nodig, dan past een driver zoals de DRV8825 of TMC2209 beter.
A4988 vs DRV8825 vs TMC2208
| Eigenschap | A4988 | DRV8825 | TMC2208 |
|---|---|---|---|
| Motorspanning | 8–35 V | 8,2–45 V | 4,75–36 V |
| Comfortabele continue stroom | Ongeveer 1 A (zonder koelplaat) | Ongeveer 1,5 A (zonder koelplaat) | Ongeveer 0,85 A RMS (kleine koelplaat) |
| Maximale stroom | 2 A (goede koeling) | 2,2 A (goede koeling) | Ongeveer 1,4 A RMS (2 A piek) |
| Fijnste microstap | 1/16 | 1/32 | 1/16 (geïnterpoleerd naar 1/256) |
| Stroom uit Vref | I = Vref / (8 × Rs) | I = Vref × 2 | Hangt van het board af, gebruik de formule van de fabrikant |
| Pin voor logicavoeding | VDD vereist | Niet nodig (die pin is de FAULT-uitgang) | VIO vereist |
| Geluid | Merkbaar gejank | Gejank vergelijkbaar met de A4988 | Bijna geluidloos (StealthChop) |
| Kortste STEP-puls | 1 µs | 1,9 µs | Zeer kort, geen probleem |
| Wanneer kiezen | Beginners, goedkoop en gangbaar | Hogere stroom en spanning | Stille 3D-printers en desktopmachines |
Alle drie de drivers hebben dezelfde "StepStick"-footprint van 16 pins en kunnen op een CNC Shield vaak worden verwisseld, maar er zijn verschillen om op te letten. De potentiometer van de DRV8825 zit op een andere plek en zijn formule is anders; de pin die bij de A4988 VDD is, is bij de DRV8825 de FAULT-uitgang. Met dezelfde code draait de TMC2208 de motor in de tegenovergestelde richting van de A4988, dus je moet DIR in software inverteren of de motorconnector 180° draaien. De geavanceerde instellingen doe je via UART, en wil je sensorloze homing (StallGuard), kijk dan naar de TMC2209. Kortom: de A4988 blijft de verstandigste plek om te beginnen voor leren en goedkope projecten; kies de TMC2208 als geluid telt en de DRV8825 als je meer stroom nodig hebt. Voor een algemene vergelijking van motortypes lees je DC-, servo- en stappenmotoren vergeleken.
Motor trilt maar draait niet: veelgemaakte fouten en oplossingen
| Symptoom | Waarschijnlijke oorzaak | Oplossing |
|---|---|---|
| Motor trilt en zoemt maar draait niet | Spoelparen kloppen niet: 1A–1B zitten niet op dezelfde spoel | Zoek de spoelen met een multimeter; sluit de ene spoel aan op 1A–1B en de andere op 2A–2B |
| As wiebelt heen en weer | Een spoeldraad is gebroken of een breadboardcontact zit los | Verbind de motordraden met schroefklemmen of soldeer, en meet elke draad door |
| Draait op lage snelheid, loopt vast en jankt bij het versnellen | Snelheid te hoog, geen optrekken of voedingsspanning te laag | Voeg optrekken toe met AccelStepper, verlaag de topsnelheid, probeer 24 V in plaats van 12 V |
| Zwak, met de hand makkelijk te stoppen, slaat stappen over | Vref (stroomlimiet) te laag | Verhoog Vref in stappen van 0,1 A |
| Draait een paar seconden, stopt en gaat daarna door | Oververhitting, thermische beveiliging grijpt in | Monteer een koelplaat en ventilator, verlaag de stroom |
| Helemaal geen koppel, as draait vrij | EN is HIGH, RESET zweeft of er is geen VMOT of VDD | Verbind RESET met SLEEP, zet EN op LOW, meet de voedingen met een multimeter |
| Draait altijd dezelfde kant op | DIR-pin niet aangesloten of verkeerde pin in de code | Controleer de DIR-draad en het pinnummer in de code |
| Arduino herstart wanneer de motor start | Motor en Arduino worden gevoed door dezelfde zwakke voeding | Gebruik een aparte adapter voor de motor en verbind de GND's |
| Driver is plotseling kapot | Motor losgekoppeld onder spanning, geen condensator of driver achterstevoren geplaatst | Maak verbindingen met de voeding uit, voeg 100 µF toe, lijn de driver uit op zijn EN-pin |
Projectideeën met de A4988 en NEMA 17
- Camera-slider: Beweeg een camera millimeter voor millimeter langs een rail met een GT2-riem en tandwiel om time-lapsevideo's te maken.
- Pennenplotter: Beweeg een pen over twee assen met een CNC Shield en GRBL om tekeningen van je computer op papier te zetten; een servomotor is alles wat je nodig hebt om de pen op te tillen en neer te laten.
- Draaitafel: Draai een voorwerp in gelijke hoeken voor productfoto's of 3D-scannen; omdat één omwenteling bij 1/16 uit 3200 stappen bestaat, zet je ongeveer 89 stappen tussen elk van 36 foto's.
- Zonnevolger: Bouw een opstelling die een paneel de hele dag naar de zon draait; het volledige idee staat in het artikel over de zonnevolger.
- Basis van een robotarm: Draai de basis van een zware arm met een NEMA 17 en tandwielen in plaats van een servo; voor de andere gewrichten zie het artikel over de robotarm.
- Handmatige positionering: Beweeg de motor snel met een joystick en nauwkeurig, stap voor stap, met een rotary encoder.
- Automatisch gordijn of schuifafdekking: Zoek bij het opstarten het nulpunt met een eindschakelaar, sla het op met setCurrentPosition(0) en verplaats het gordijn naar elke gewenste positie.
Dit is een NEMA 17 aansturen met de A4988 in een notendop: koppel de spoelen goed, zet 100 µF op de voeding, bereken Vref met de formule en stel hem in met een multimeter, kies je microstepping en laat de motor met optrekken draaien. Als je deze basis eenmaal kent, wordt ook duidelijk hoe machines als 3D-printers en CNC's werken. In de BlueGrays-app vind je bewegingsprojecten zoals een stappenmotor gebruiken en een stappenmotor ombouwen tot een servo van 360 graden, stap voor stap met schakelschema's en code.
Veelgestelde vragen
Wat moet de Vref van de A4988 zijn?
Vref bereken je met Vref = I × 8 × Rs. Op gangbare boards met R100-weerstanden (0,1 Ω) wordt dat Vref = I × 0,8, dus voor 1 A stel je 0,8 V in. Voor een NEMA 17 van 1,7 A zoals de 17HS4401 is 0,64–0,8 V (0,8–1 A) zonder koelplaat een goed begin; met een koelplaat kun je tot 0,96 V (1,2 A) gaan.
Kan de A4988 een NEMA 17 aansturen en hoeveel ampère kan hij leveren?
Ja, de A4988 is de meest gebruikte driver voor de NEMA 17. Zonder koelplaat levert hij comfortabel ongeveer 1 A per spoel, en met een goede koelplaat en ventilator kan hij 2 A halen. In de praktijk heeft een DRV8825 of TMC2209 het makkelijker als je continu meer dan 1,2–1,5 A nodig hebt.
Welke spanning heeft een NEMA 17-stappenmotor nodig?
De spanning op het label (ongeveer 2,6 V bij de 17HS4401) is gewoon de spoelweerstand maal de nominale stroom, niet de spanning die je rechtstreeks op de motor zet. Omdat de A4988 de stroom zelf begrenst, voed je de motor met 12–24 V; een hogere spanning geeft meer koppel bij hoge snelheid. Het maximum van de A4988 is 35 V.
Waarom trilt mijn stappenmotor maar draait hij niet?
De meest voorkomende oorzaak zijn verkeerd gekoppelde spoelen: de twee draden van de ene spoel moeten naar 1A–1B en die van de andere spoel naar 2A–2B. Andere oorzaken zijn een te hoge snelheid zonder optrekken, een lage Vref, een gebroken draad of een ontoereikende voeding. Probeer de motor eerst op een heel lage snelheid; draait hij dan soepel, dan is snelheid het probleem.
Waarom wordt de A4988 zo heet?
De spoelstroom loopt door de MOSFET's in de chip en de warmte stijgt met het kwadraat van de stroom; van 1 A naar 1,5 A meer dan verdubbelt hij. Boven 1 A heb je een koelplaat en luchtstroom nodig. De chip schakelt zichzelf uit bij 165 °C; een motor die af en toe stopt en weer start is het teken.
A4988, DRV8825 of TMC2208: welke kies ik?
De A4988 is de goedkoopste en het makkelijkst te leren, met microstepping tot 1/16. De DRV8825 kan tot 45 V en 1/32-microstepping aan en levert meer stroom zonder koelplaat. De TMC2208 is populair in 3D-printers omdat hij bijna geluidloos is, maar hij verwerkt minder stroom en draait de motor de andere kant op dan de A4988.
Projecten om hierna te bouwen
Alle projecten bekijken
Een stappenmotor gebruiken
Een motor die stap voor stap draait, precies zo ver als jij wilt, zoals de wijzer van een klok.

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

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.

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.

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

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.

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…

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.
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

