A4988 Schrittmotortreiber mit NEMA 17: Vref einstellen und Code

Einen NEMA 17 mit dem A4988 anzusteuern ist der günstigste Weg, die präzise Bewegung von 3D-Druckern, CNC-Fräsen und Lasergravierern in dein eigenes Projekt zu holen. Der A4988 ist ein bipolarer Schrittmotortreiber von Allegro, der auf einem fingerkuppengroßen Modul verkauft wird: Jeder STEP-Impuls vom Arduino bewegt den Motor um einen Schritt, der DIR-Pin wählt die Richtung, und der Treiber hält den Strom durch die Motorspulen auf dem Wert, den du einstellst. Zum Drehen des Motors brauchst du also nur zwei Pins und ein Netzteil zwischen 8 und 35 V.

In dieser Anleitung lernst du, wie der A4988 funktioniert, wie du die Spulen eines NEMA 17 mit dem Multimeter findest, wie du alles verkabelst und warum ein 100-µF-Kondensator an die Versorgung gehört. Danach kommt der wichtigste Schritt, die Strombegrenzung über Vref: Formel und Messung mit dem Multimeter Schritt für Schritt. Außerdem: Microstepping mit MS1–MS3, ein erster Sketch ohne Bibliothek, sanftes Beschleunigen mit AccelStepper, das CNC Shield, Code für ESP32 und Raspberry Pi Pico, Wärme und Kühlkörper, ein Vergleich mit DRV8825 und TMC2208 sowie Lösungen für das typische Problem "Motor vibriert, dreht sich aber nicht".

Was ist der A4988 und wie funktioniert er?

Im A4988 stecken zwei vollständige H-Brücken (eine pro Spule), ein Translator und eine Stromregelung. Der Translator wandelt jeden LOW→HIGH-Wechsel am STEP-Pin in die richtige Stromfolge für die Spulen um, sodass du die Spulenreihenfolge nicht selbst im Code berechnen musst. Die Stromregelung arbeitet als Chopper: Der Treiber misst den Strom jeder Spule ständig über einen kleinen Messwiderstand (Rs) und schaltet den Ausgang kurz ab, sobald der Strom die eingestellte Grenze erreicht. Deshalb bleibt der Spulenstrom auch dann sicher, wenn du den Motor weit über seiner Nennspannung betreibst, zum Beispiel mit 12 oder 24 V. Außerdem ist der Chip gegen Übertemperatur, Unterspannung, Kurzschluss der Last und Kurzschluss gegen Masse geschützt.

NEMA 17 Schrittmotor: Daten und Spulen finden

NEMA 17 ist kein Motormodell, sondern ein Baugrößenstandard für Motoren mit einem Flansch von 42 × 42 mm; das Innenleben hängt von der Baulänge und vom Hersteller ab. Der in Hobbyprojekten verbreitetste 17HS4401 macht 200 Schritte pro Umdrehung (1,8°), hat einen Nennstrom von 1,7 A pro Phase, einen Spulenwiderstand von etwa 1,5 Ω und rund 40 Ncm Haltemoment. Die Spannung auf dem Typenschild beträgt nur 1,7 A × 1,5 Ω ≈ 2,6 V, aber lass dich davon nicht täuschen: Weil der A4988 den Strom selbst begrenzt, wird der Motor mit 12–24 V versorgt. Eine höhere Spannung lässt den Spulenstrom bei jedem Schritt schneller ansteigen, sodass der Motor bei hohen Drehzahlen weniger Drehmoment verliert. Wenn dich der Unterschied zu kleinen unipolaren Motoren wie dem 28BYJ-48 interessiert, lies 28BYJ-48 und ULN2003.

Die 4 Adern des Motors gehören zu zwei unabhängigen Spulen, und bevor du ihn an den A4988 anschließt, musst du wissen, welche zwei Adern zur selben Spule gehören. Bei vielen Modellen bilden Schwarz-Grün die eine und Rot-Blau die andere Spule, aber die Farben unterscheiden sich je nach Hersteller, deshalb ist Messen am zuverlässigsten:

1. Stell dein Multimeter auf Widerstandsmessung (Ω); falls du unsicher bist, wirf einen Blick in die Multimeter-Anleitung.
2. Halte eine Ader fest und miss sie nacheinander gegen die anderen drei. Die Ader mit 1–4 Ω ist das andere Ende derselben Spule; bei den anderen beiden zeigt das Display einen offenen Kreis (OL).
3. Die übrigen zwei Adern sind die zweite Spule und sollten denselben Widerstand zeigen. Mit dem gemessenen Widerstand und dem Nennstrom kannst du die Spannung auf dem Typenschild mit dem Rechner für das ohmsche Gesetz prüfen.
4. Kein Multimeter zur Hand? Halte die Enden von zwei Adern aneinander und dreh die Welle von Hand: Lässt sie sich deutlich schwerer drehen, gehören die beiden Adern zur selben Spule.
5. Schließ eine Spule an die Pins 1A–1B des A4988 an und die andere an 2A–2B. Dreht der Motor in die falsche Richtung, tausch einfach die beiden Adern einer Spule.

A4988 Pinbelegung und Schaltplan

Warum ist ein 100-µF-Kondensator Pflicht?

Auf A4988-Platinen sitzen nur kleine Keramikkondensatoren. Zusammen mit der Induktivität der Netzteilkabel erzeugen diese Kondensatoren mit niedrigem ESR beim Einschalten oder bei plötzlichen Stromspitzen des Motors Spannungsspitzen. Diese können selbst bei nur 12 V Versorgung die 35-V-Grenze des Chips überschreiten und den Treiber dauerhaft beschädigen. Die Lösung ist einfach: Setz einen Elektrolytkondensator (Elko) mit mindestens 47 µF, besser 100 µF, zwischen VMOT und GND, so nah wie möglich an der Platine. Seine Spannungsfestigkeit sollte deutlich über der Versorgungsspannung liegen: bei 12 V ein 25-V-Typ, bei 24 V einer mit 35 V oder 50 V. Elkos sind gepolt; das lange Bein (+) kommt an VMOT, das kurze Bein (–), gekennzeichnet durch den Streifen auf dem Gehäuse, an GND. Mehr zu Kondensatortypen findest du in Was ist ein Kondensator?, und wie du das richtige Netzteil wählst, in Arduino-Stromversorgung.

Strom einstellen mit Vref: die Formel

Das kleine Potentiometer auf dem A4988 stellt Vref (die Referenzspannung) ein, die den maximalen Motorstrom bestimmt. Der Treiber vergleicht diese Spannung mit der Spannung an den beiden Messwiderständen (Rs) auf der Platine, und der maximale Spulenstrom ergibt sich aus: I = Vref / (8 × Rs). Um die nötige Vref zu finden, stellst du die Formel um: Vref = I × 8 × Rs. Rs erkennst du an der Beschriftung der beiden kleinen SMD-Widerstände neben dem Chip: R100 bedeutet 0,1 Ω, R068 0,068 Ω und R050 0,05 Ω. Wenn du mit den Codes Schwierigkeiten hast, nutze den SMD-Widerstandscode-Rechner oder den Artikel zu SMD-Widerstandscodes.

Welchen Strom solltest du wählen? Der Strom auf dem Typenschild (1,7 A beim 17HS4401) ist eine Obergrenze, die du nie überschreiten solltest. Ohne Kühlkörper verkraftet der A4988 etwa 1 A problemlos, daher sind 0,8–1 A ein guter Startwert. Auf verbreiteten Platinen mit R100-Widerständen entspricht das einer Vref von 0,64–0,80 V. Verliert der Motor unter Last Schritte, erhöhe den Strom in Schritten von 0,1 A; über 1,2 A gehören Kühlkörper und Lüfter auf den Chip. Mehr Strom als nötig erwärmt Treiber und Motor deutlich stärker, als er den Motor spürbar kräftiger macht.

Vref mit dem Multimeter messen: Schritt für Schritt

1. Trenne bei ausgeschalteter Versorgung den Motor vom Treiber. Für die Vref-Messung brauchst du den Motor nicht.
2. Versorge VDD und GND des A4988 mit der Logikspannung (die 5V des Arduino reichen). Vref wird aus dieser Spannung erzeugt, ohne VDD kannst du sie also nicht messen; VMOT darf ruhig angeschlossen bleiben.
3. Stell das Multimeter auf Gleichspannung (Bereich 2 V oder 20 V). Halte die schwarze Messspitze an GND und die rote an die Metalloberseite des Potentiometers; manche Platinen haben stattdessen einen kleinen Messpunkt mit der Aufschrift VREF.
4. Dreh das Potentiometer mit einem kleinen Kunststoff- oder Keramikschraubendreher ganz leicht und beobachte den Wert. Bei den meisten Platinen erhöht Drehen im Uhrzeigersinn die Vref, das kann aber variieren; manche Potis springen nach einer vollen Umdrehung wieder auf den Anfang, also geh in kleinen Schritten vor.
5. Hast du den berechneten Wert erreicht, schalte die Versorgung ab, schließ den Motor an und schalte erst dann wieder ein.
6. Lass den Motor ein paar Minuten laufen und prüf die Temperatur des Chips. Kannst du den Finger nicht einmal ein paar Sekunden darauf halten, senke Vref etwas oder setz einen Kühlkörper auf.

Microstepping mit MS1, MS2 und MS3

Beim Microstepping (Mikroschrittbetrieb) ändert der Treiber den Strom in den beiden Spulen stufenweise und teilt so jeden Vollschritt in kleinere Teile. Der A4988 wählt anhand der Logikpegel an MS1–MS3 einen von fünf Modi. Diese Pins haben interne Pull-down-Widerstände; lässt du alle drei offen, läuft der Motor im Vollschritt.

Der eigentliche Vorteil von Microstepping ist eine ruhige, leise Drehung: Im Vollschritt ruckt der Motor bei jedem Schritt und gerät bei bestimmten Drehzahlen in Resonanz, bei 1/16 ist die Bewegung dagegen fast stufenlos. Erwarte aber nicht, dass die Genauigkeit wirklich um das 16-Fache steigt. Das Drehmoment, das einen einzelnen Mikroschritt weiterbewegt, beträgt nur sin(90° / 16) ≈ 10 % des Haltemoments; überwinden Reibung oder Last diese kleine Kraft, hinkt der Motor ein paar Mikroschritte hinterher. Für die Geschwindigkeit gilt: Schritte/s = U/min × 200 × Mikroschritte / 60. Für 60 U/min bei 1/16 brauchst du zum Beispiel 3200 STEP-Impulse pro Sekunde. Willst du den Modus per Software umschalten, kannst du auch die MS-Pins mit dem Arduino verbinden; in den meisten Projekten reicht es aber, einen festen Modus per Drahtbrücke zu wählen.

Erster Sketch: Drehen mit STEP und DIR ohne Bibliothek

Der folgende Sketch dreht den Motor ohne Bibliothek, nur durch Impulse am STEP-Pin, eine Umdrehung vor und eine zurück. Wir gehen davon aus, dass MS1–MS3 an 5V liegen, der Motor also im 1/16-Modus läuft und eine Umdrehung 3200 Schritte hat.

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}

Drei Zeiten sind in diesem Code wichtig. Der A4988 verlangt, dass HIGH- und LOW-Phase des STEP-Impulses mindestens 1 µs dauern; 5 µs sind ein sicherer Wert. Nach einem Wechsel von DIR musst du vor dem ersten STEP-Impuls mindestens 200 ns warten; der Code wartet dafür 5 µs. Die Geschwindigkeit bestimmt die Pause zwischen den Impulsen: Mit 500 µs Pause dauert ein Schritt etwa 0,51 ms, eine Umdrehung (3200 Schritte) also rund 1,6 Sekunden, das sind etwa 36 U/min. Der Code hat zwei Schwächen: Der Motor startet abrupt mit voller Geschwindigkeit, und der Arduino kann während der Schleife nichts anderes tun. Senkst du die Pause direkt auf 100 µs, läuft der Motor höchstwahrscheinlich gar nicht erst an und brummt nur.

Beschleunigen und Abbremsen mit AccelStepper

Einen Schrittmotor kannst du nicht schlagartig aus dem Stand auf hohe Drehzahl bringen; Rotor und Last kommen dieser plötzlichen Änderung nicht hinterher, der Motor verliert den Takt und überspringt Schritte. Die Lösung ist, die Geschwindigkeit rampenförmig zu erhöhen und vor dem Ziel wieder zu senken. AccelStepper, das du über den Bibliotheksverwalter installierst, erledigt das ohne zu blockieren: Du rufst run() ständig in loop() auf, und die Bibliothek macht einen Schritt, sobald einer fällig ist. So kannst du Taster abfragen, ein Display aktualisieren oder Sensoren auslesen, während sich der Motor dreht; dieses Prinzip erklärt der Artikel millis() statt delay() ausführlich. Auf einem Uno schafft AccelStepper zuverlässig einige tausend Schritte pro Sekunde (die Dokumentation nennt etwa 4000 Schritte/s bei 16 MHz); deshalb nutzt das Beispiel 2000 Schritte/s, das sind bei 1/16 etwa 37 U/min.

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}

Mehrere Motoren mit dem CNC Shield V3

Wenn du mehr als einen NEMA 17 ansteuerst, ist das Arduino CNC Shield V3 der einfachste Weg, Kabelsalat zu vermeiden. Die Platine wird auf den Uno gesteckt und hat vier A4988-Steckplätze (X, Y, Z und A), Microstepping-Jumper unter jedem Treiber, Motoranschlüsse, Endschaltereingänge und eine Schraubklemme für die Versorgung; mit allen drei Jumpern läuft der A4988 im 1/16-Modus. In der Anschlusstabelle haben wir D2, D5 und D8 bewusst für STEP, DIR und EN gewählt: Das sind die X-Achsen-Pins des Shields, die Sketches oben laufen darauf also unverändert. Spielst du GRBL auf den Uno, wird das Shield zu einer CNC- oder Lasersteuerung, die G-Code vom Computer annimmt. In GRBL trägst du in $100, $101 und $102 ein, wie viele Schritte jede Achse pro Millimeter braucht: Mit einer GT2-Riemenscheibe mit 20 Zähnen und 1/16-Microstepping sind das 200 × 16 / (20 × 2) = 80 Schritte/mm, bei einer T8-Trapezgewindespindel mit 8 mm Steigung 200 × 16 / 8 = 400 Schritte/mm.

A4988 mit dem ESP32 verwenden

Die Pins des ESP32 liefern 3,3 V. Der A4988 erkennt einen Eingang nur sicher als HIGH, wenn er über 70 % von VDD liegt; bei VDD = 5 V liegt diese Schwelle bei 3,5 V, ein 3,3-V-Signal reicht also nicht. Verbinde deshalb beim ESP32 und Pico den VDD-Pin des A4988 mit 3V3: Der Treiber arbeitet zwischen 3 und 5,5 V problemlos, und du brauchst keinen Pegelwandler. Da sich VDD geändert hat, miss Vref neu. Der folgende Sketch fährt den Motor mit Beschleunigung auf den Winkel, den du in den seriellen Monitor tippst (zum Beispiel 90 oder -45). Weil der ESP32 viel schneller ist, schafft AccelStepper hier problemlos 6000 Schritte pro Sekunde; für noch höhere Geschwindigkeiten lohnt sich die Bibliothek FastAccelStepper, die Hardware-Timer nutzt. Wenn der ESP32 neu für dich ist, beginne mit Was ist der 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 mit dem Raspberry Pi Pico und MicroPython

Auch am Pico verbindest du VDD des A4988 mit dem Pin 3V3 (OUT). Statt einer Beschleunigungsbibliothek kannst du in MicroPython eine einfache lineare Rampe wie unten schreiben: Die Funktion move() ändert die Pause zwischen den Impulsen während der ersten und letzten 600 Schritte schrittweise zwischen 2000 µs und 400 µs und fährt dazwischen mit voller Geschwindigkeit. Die MicroPython-Schleife fügt jedem Schritt einige zehn Mikrosekunden hinzu, daher ist die echte Geschwindigkeit etwas geringer als berechnet. Brauchst du zehntausende Schritte pro Sekunde oder mehrere Motoren gleichzeitig, können die PIO-Blöcke des Pico die Impulse erzeugen, ohne die CPU zu belasten. Wie du MicroPython auf den Pico bringst, steht in Was ist der 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)

Wärme, Kühlkörper und Übertemperaturschutz

Dass der A4988 heiß wird, ist normal, denn der Spulenstrom fließt durch die MOSFETs im Chip. Im Strompfad jeder Spule liegen typischerweise insgesamt 0,64 Ω, und die Verlustleistung wächst mit dem Quadrat des Stroms: grob P ≈ I² × 0,64 Ω. Bei 1 A sind das etwa 0,65 W, bei 1,5 A etwa 1,45 W; wird der Chip warm, steigt auch der Widerstand, und der echte Wert liegt noch höher. Für eine fingerkuppengroße Platine ist das viel Wärme. Erreicht der Chip 165 °C, schaltet der Übertemperaturschutz die Ausgänge ab und nach etwa 15 °C Abkühlung wieder ein. Ein Motor, der ein paar Sekunden läuft, stoppt und dann von selbst weitermacht, ist das typische Zeichen dafür.

• Kühlkörper aufsetzen: Kleb einen kleinen Aluminium-Kühlkörper mit Wärmeleitklebeband auf den Chip; achte darauf, dass er weder Pins noch Potentiometer berührt.
• Für Luftstrom sorgen: Über 1,2 A oder in einem geschlossenen Gehäuse vervielfacht ein kleiner Lüfter die Wirkung des Kühlkörpers.
• Strom nach Bedarf einstellen: Verliert der Motor unter Last keine Schritte, senke Vref etwas; 20 % weniger Strom bedeuten etwa 36 % weniger Wärme.
• Spulen im Stillstand abschalten: Brauchst du kein Haltemoment, setz den EN-Pin nach der Bewegung auf HIGH oder ruf disableOutputs() auf; Treiber und Motor kühlen dann ab.
• Auch die Motortemperatur prüfen: Schrittmotoren ziehen auch im Stillstand Strom und werden deshalb warm oder sogar heiß. Liegt das Gehäuse über 60 °C, senke den Strom; bei dieser Temperatur werden PLA-Teile am 3D-Drucker weich.
• Auf einen stärkeren Treiber umsteigen: Braucht dein Motor mehr als 1,5 A, passt ein Treiber wie der DRV8825 oder TMC2209 besser.

A4988, DRV8825 und TMC2208 im Vergleich

Alle drei Treiber nutzen dasselbe 16-polige "StepStick"-Format und lassen sich auf einem CNC Shield oft gegeneinander tauschen, es gibt aber Unterschiede. Das Potentiometer des DRV8825 sitzt an einer anderen Stelle, und die Formel ist eine andere; der Pin, der beim A4988 VDD ist, ist beim DRV8825 der FAULT-Ausgang. Mit demselben Code dreht der TMC2208 den Motor in die Gegenrichtung zum A4988; du musst DIR im Code invertieren oder den Motorstecker um 180° drehen. Seine erweiterten Einstellungen erfolgen über UART, und wenn du eine sensorlose Referenzfahrt (StallGuard) willst, schau dir den TMC2209 an. Kurz gesagt: Zum Lernen und für günstige Projekte ist der A4988 nach wie vor der sinnvollste Einstieg; ist Lautstärke wichtig, nimm den TMC2208, brauchst du mehr Strom, den DRV8825. Einen allgemeinen Vergleich der Motortypen findest du in Unterschied zwischen DC-Motor, Servo und Schrittmotor.

Motor vibriert, dreht sich aber nicht: häufige Fehler und Lösungen

Projektideen mit A4988 und NEMA 17

• Kameraslider: Fahr eine Kamera mit GT2-Riemen und Riemenscheibe millimeterweise über eine Schiene und nimm Zeitraffervideos auf.
• Stiftplotter: Bewege mit CNC Shield und GRBL einen Stift auf zwei Achsen und bring Zeichnungen vom Computer aufs Papier; zum Heben und Senken des Stifts genügt ein Servomotor.
• Drehteller: Dreh ein Objekt für Produktfotos oder 3D-Scans in gleichen Winkeln weiter; da eine Umdrehung bei 1/16 aus 3200 Schritten besteht, fährst du bei 36 Fotos jeweils etwa 89 Schritte.
• Solartracker: Bau eine Vorrichtung, die ein Panel den ganzen Tag zur Sonne ausrichtet; die ganze Idee steht im Artikel Sonnenstandsnachführung.
• Roboterarm-Basis: Dreh die Basis eines schweren Arms mit einem NEMA 17 und Zahnrädern statt mit einem Servo; für die übrigen Gelenke lies den Artikel Roboterarm.
• Manuelles Positionieren: Bewege den Motor mit einem Joystick schnell und mit einem Drehgeber präzise Schritt für Schritt.
• Automatischer Vorhang oder Schiebedeckel: Finde beim Start mit einem Endschalter den Nullpunkt, speichere ihn mit setCurrentPosition(0) und fahr den Vorhang in jede gewünschte Position.

Kurz zusammengefasst heißt NEMA 17 mit dem A4988 ansteuern: Spulen richtig zuordnen, 100 µF an die Versorgung, Vref mit der Formel berechnen und mit dem Multimeter einstellen, Microstepping wählen und den Motor mit Beschleunigung fahren. Wenn du diese Grundlagen beherrschst, verstehst du auch, wie Maschinen wie 3D-Drucker und CNC-Fräsen arbeiten. In der BlueGrays App findest du Bewegungsprojekte wie die Verwendung eines Schrittmotors und den Umbau eines Schrittmotors zu einem 360-Grad-Servo, Schritt für Schritt mit Schaltplänen und Code.