Schrittmotoren mit Arduino meistern: Der umfassende Leitfaden

In diesem Tutorial lernen Sie alles, was Sie über die Steuerung von Schrittmotoren mit Arduino wissen müssen. Wir behandeln die Ansteuerung eines NEMA17-Schrittmotors in Kombination mit den Treibern A4988, DRV8825 und TMC2208.

Diese Kombination aus Schrittmotoren und Treibern findet sich in unzähligen Anwendungen, wo Positionssteuerung gefragt ist: 3D-Drucker, CNC-Maschinen, Robotik, Automatisierungsmaschinen u. v. m.

Ich habe sie selbst in vielen Arduino-Projekten eingesetzt, z. B.:

DIY-Kameraslider
3D-Drahtbiegemaschine
DIY-Schaumschneidemaschine
DIY-Lasergravur
Pen-Plotter mit automatischem Stiftwechsler
SCARA-Roboterarm

Ich erkläre detailliert: Funktionsweise, Anschluss an Arduino, Strombegrenzung der Treiber einstellen, Programmierung mit und ohne Arduino-Bibliothek. Zudem zeige ich, wie man mehrere Schrittmotoren mittels Arduino-CNC-Shield für beliebige Projekte einfach steuert.

Wir haben viel vor. Sie können das folgende Video ansehen oder das schriftliche Tutorial unten mit allen Beispielcodes und Schaltplänen lesen.

Was ist ein Schrittmotor und wie funktioniert er?

Kurze Einführung in Schrittmotoren und ihre Funktionsweise – das hilft beim Verständnis des gesamten Tutorials.

Ein Schrittmotor ist ein bürstenloser DC-Motor, dessen Position präzise gesteuert werden kann – sogar ohne Rückführung (Feedback).

Das Funktionsprinzip basiert auf Magnetfeldern. Zwei Hauptkomponenten: Stator und Rotor. Der Rotor ist meist ein Permanentmagnet, umgeben von Spulen am Stator.

Wenn wir Strom durch die Spulen leiten, entstehen im Stator Magnetfelder, die den Rotor anziehen oder abstoßen. Durch schrittweises Aktivieren der Spulen in einer bestimmten Reihenfolge erreichen wir kontinuierliche Rotation, können den Rotor aber auch an jeder Position anhalten.

Daher der Name: Sie bewegen sich in diskreten Schritten.

Erhöht man die Anzahl der Magnetpole am Rotor, steigt die Zahl der möglichen Rastpositionen – Auflösung und Präzision nehmen zu. (Dies ist nur eine Grundlagen-Erklärung; Details in meinem Tutorial How Stepper Motors Work.)

Ein typischer NEMA17-Schrittmotor hat 50 Rastpunkte (Schritte) am Rotor. Der Stator besitzt mehrere Spulen, organisiert in zwei Phasen, die vier verschiedene Magnetfeldorientierungen erzeugen.

50 Rotorschritte × 4 Orientierungen = 200 Schritte pro Umdrehung. 360° / 200 = 1,8° pro Schritt.

Die Statorspulen sind in zwei Phasen organisiert – erkennbar an den 4 Drähten des Motors (je 2 pro Phase). Die vier Orientierungen entstehen, da Strom in beide Richtungen durch die Phasen fließen kann.

Es gibt auch Motoren mit 5, 6 oder 8 Drähten – sie arbeiten aber weiterhin mit zwei Phasen / vier Steueranschlüssen. Unterschiedliche Verdrahtung ermöglicht andere Leistungsmerkmale (mehr Drehmoment oder Geschwindigkeit).

Kurz: Ein Schrittmotor lässt sich nicht einfach mit Spannung versorgen – nichts passiert. Wir müssen die beiden Phasen in beide Richtungen energisieren und in zeitlicher Sequenz Pulsen. Deshalb brauchen wir Treiber.

Es gibt viele Treiber-Typen und -Größen passend zu den Motoren. Das Grundprinzip aller: zwei H-Brücken, die Phasen in beide Richtungen energisieren. Dazu Funktionen wie Microstepping, Strombegrenzung – genau dafür sind sie da.

NEMA17-Schrittmotor mit Arduino und A4988-Treiber steuern

Schauen wir uns das erste Beispiel an: NEMA17 mit A4988-Treiber.

Der NEMA17 ist der beliebteste Schrittmotor unter Maker – gute Leistung, günstig. In fast jedem Desktop-3D-Drucker und Lasergravur verbaut.

Typischer NEMA17: 200 Schritte, 1,8°/Schritt; es gibt auch 400-Schritt-/0,9°-Modelle. Wichtig: Die Bezeichnung NEMA17 beschreibt nur die Baugröße (Frontplattenmaß). Die Zahl = Frontplattengröße in Zoll geteilt durch 10 → 17/10 = 1,7 Zoll (NEMA23 = 2,3 Zoll). Frontplatte fix, aber Länge variiert 20–60 mm → Leistungsaufnahme (Strom) variiert: 0,3 A bis 2,5 A.

Passend zum Motornennstrom muss ein geeigneter Treiber gewählt werden. Beliebtester Treiber für NEMA17: A4988.

A4988: max. 2 A pro Spule (Peak), empfohlen ~1 A (bis 2 A mit guter Kühlung). Tolles Feature: Strombegrenzung per Potentiometer – unabhängig vom Motornennstrom einstellbar. Beispiel: 2,5-A-Motor, Treiber auf 1,5 A begrenzt → Motor läuft nicht am Maximum, aber nutzbar. Ist Motorstrom niedriger als eingestellter Grenzwert → Überhitzung. Empfehlung: Motornennstrom und Treibergrenzwert angleichen.

A4988 und Arduino verbinden

Schritt für Schritt Anschluss:

Rechts oben: VMOT und GND → Motorstromversorgung 8–36 V. Entkopplungskondensator (≥ 47 µF Elektrolyt) empfohlen gegen Spannungsspitzen.
4 Pins für Schrittmotor: 1A/1B = Phase 1, 2A/2B = Phase 2. Phasenidentifikation: Welle per Hand drehen, zwei Drähte verbinden → schwerer drehen = Phase. Oder Multimeter Durchgangsprüfung → Piepen = Phase. Reihenfolge auf Treiber egal.
Logikversorgung: VDD und GND (3–5 V).
STEP und DIR Pins → beliebige Arduino-Pins. DIR = Drehrichtung, STEP = Schrittsteuerung. Jeder Puls an STEP = ein Schritt in gewählter Richtung.
SLP (Sleep) und RST (Reset) – beide active low. SLP default HIGH, RST floating. Einfachste Aktivierung: SLP und RST verbinden (wenn Funktionen nicht genutzt).
EN (Enable) – active low. Solange nicht auf HIGH gezogen, ist Treiber aktiviert.
MS1, MS2, MS3 – Microstepping-Auflösung wählen. Basisauflösung motorabhängig (NEMA17 typ. 200 Schritte). Microstepping: Zwischenströme erzeugen Zwischenpositionen. Viertel-Schritt → 200 × 4 = 800 Mikroschritte/Umdrehung (4 Strompegel). A4988 max. 1/16 → 3200 Schritte/Umdrehung (0,1125°). Es gibt Treiber bis 1/256 → 51.200 Schritte (0,007°). Pins haben Pull-Down → offen = Vollschritt. Für andere Auflösung 5 V auf entsprechende Pins legen (Tabelle beachten).

A4988 Strombegrenzung einstellen

Bevor Motor Strom bekommt: Stromgrenze des Treibers einstellen – niedriger als Motornennstrom, sonst Überhitzung.

Kleines Trimm-Poti auf A4988: im Uhrzeigersinn = Stromgrenze steigt, gegen Uhrzeigersinn = fällt. Zwei Methoden zur Ermittlung des tatsächlichen Grenzwerts:

Referenzspannung messen: Spannung am Poti gegen GND messen. Formel: Stromgrenze = Vref / (8 × Rcs). Rcs = Strommesswiderstand (neben Chip, meist 0,05 / 0,1 / 0,2 Ω). Beispiel: R100 = 0,1 Ω. Vref = 0,7 V → 0,875 A. Für 1 A → Vref auf 0,8 V einstellen.
Spulenstrom direkt messen: Motor + Treider anschließen (wie oben). Controller weglassen, aber 5 V an DIR und STEP → Motor hält Position. MS-Pins offen (Vollschritt). Eine Spule trennen, Ammeter in Reihe schalten. Beide Spannungen anlegen (Logik 5 V, Motor 12 V) → Spulenstrom ablesen. Wichtig: Im Vollschritt erreichen Spulen nur 70 % der tatsächlichen Stromgrenze. Für andere Microstepping-Modi: Ammeterwert × 1,3 = tatsächliche Stromgrenze.

Beide Methoden lieferten bei mir annähernd gleiche Ergebnisse.

Schrittmotoren & Arduino – Beispielcodes

Jetzt programmieren wir den Arduino – mehrere Beispielcodes zur Schrittmotorsteuerung.

Beispielcode 1: Basis-Steuerung ohne Bibliothek

/* Basic example code for controlling a stepper without library
 * by Dejan, https://howtomechatronics.com */
#define stepPin 2
#define dirPin 5

void setup() {
  pinMode(stepPin, OUTPUT);
  pinMode(dirPin, OUTPUT);
}

void loop() {
  digitalWrite(dirPin, HIGH); // Richtung festlegen
  // 200 Pulse für eine volle Umdrehung (Vollschritt)
  for (int x = 0; x < 800; x++) {
    digitalWrite(stepPin, HIGH);
    delayMicroseconds(700); // Geschwindigkeitssteuerung über Delay
    digitalWrite(stepPin, LOW);
    delayMicroseconds(700);
  }
  delay(1000);
  digitalWrite(dirPin, LOW); // Richtung ändern
  // 400 Pulse für zwei Umdrehungen
  for (int x = 0; x < 1600; x++) {
    digitalWrite(stepPin, HIGH);
    delayMicroseconds(500);
    digitalWrite(stepPin, LOW);
    delayMicroseconds(500);
  }
  delay(1000);
}

Code-Erklärung: STEP- und DIR-Pin definieren, als Output setzen. Im Loop: Richtung auf HIGH, per for-Schleife 200 Pulse (eine Umdrehung im Vollschritt) senden. Pulserzeugung durch Toggeln von STEP mit Delay – Delay bestimmt Geschwindigkeit (kleiner = schneller). Dann Richtung ändern, 400 Pulse (zwei Umdrehungen). Hinweis: Bei geändertem Microstepping (z. B. 1/4 → 800 Schritte/Umdrehung) entspricht erste Schleife nur 90°, zweite nur halbe Umdrehung.

Beispielcode 2: Geschwindigkeit per Potentiometer steuern

Potentiometer an Arduino anschließen, Wert per analogRead() einlesen.

/* Basic example code for controlling a stepper without library
 * by Dejan, https://howtomechatronics.com */
#define stepPin 2
#define dirPin 5
int customDelay, customDelayMapped;

void setup() {
  pinMode(stepPin, OUTPUT);
  pinMode(dirPin, OUTPUT);
}

void loop() {
  speedControl();
  digitalWrite(stepPin, HIGH);
  delayMicroseconds(customDelayMapped);
  digitalWrite(stepPin, LOW);
  delayMicroseconds(customDelayMapped);
}

void speedControl() {
  customDelay = analogRead(A0); // Potentiometer 0–1023
  customDelayMapped = map(customDelay, 0, 1023, 300, 3000); // auf 300–3000 µs mappen
}

Code-Erklärung: Potentiometerwert (0–1023) auf Delay-Bereich (300–3000 µs) mappen. Minimum ~300 µs – darunter verliert Motor Schritte. Diese Methode ist einfach, funktioniert aber nur für simple Steuerungen. Für komplexere Steuerung: Arduino-Bibliothek nutzen.

Schrittmotoren mit Arduino und AccelStepper-Bibliothek steuern – Beispiele

Beliebteste Bibliothek: AccelStepper von Mike McCauley. Extrem vielseitig: Geschwindigkeits-, Beschleunigungs-/Verzögerungssteuerung, Zielpositionen, gleichzeitige Steuerung mehrerer Motoren u. v. m. Gute Dokumentation. Ich nutze sie in meinen Projekten (Kameraslider, Drahtbiegemaschine, SCARA-Arm…). Details und Codes auf der Website.

Beispiel: Geschwindigkeitssteuerung per Potentiometer mit AccelStepper

/* Basic example code for controlling a stepper with the AccelStepper library
 * by Dejan, https://howtomechatronics.com */
#include 
AccelStepper stepper1(1, 2, 5); // Treiber-Typ 1 (2 Pins: STEP, DIR)

void setup() {
  stepper1.setMaxSpeed(1000); // Max. Schritte/Sekunde
}

void loop() {
  stepper1.setSpeed(analogRead(A0)); // Aktuelle Geschwindigkeit setzen
  stepper1.runSpeed(); // Motor mit konstanter Geschwindigkeit laufen lassen
}

Erklärung: AccelStepper includieren (vorher über Library Manager installieren). Instanz erstellen: Parameter 1 = Treibertyp (1 = 2 Pins), dann STEP-Pin, DIR-Pin. Bei mehreren Motoren je Instanz. setup(): setMaxSpeed() (Schritte/Sekunde, max. 4000, >1000 laut Doku evtl. unzuverlässig). loop(): setSpeed() mit Potentiometerwert (0–1023), runSpeed() pro Zyklus aufrufen. Negativer Wert = umgekehrte Drehrichtung.

Beispiel: Zwei Schrittmotoren mit Beschleunigung/Verzögerung steuern

/* Controlling two steppers with the AccelStepper library
 * by Dejan, https://howtomechatronics.com */
#include 
AccelStepper stepper1(1, 2, 5);
AccelStepper stepper2(1, 3, 6);

void setup() {
  stepper1.setMaxSpeed(1000);
  stepper1.setAcceleration(500);
  stepper1.setCurrentPosition(0);
  stepper2.setMaxSpeed(1000);
  stepper2.setAcceleration(500);
  stepper2.setCurrentPosition(0);
}

void loop() {
  stepper1.moveTo(800); // Ziel: 800 Schritte (bei 1/4-Schritt = 1 Umdrehung)
  stepper1.runToPosition(); // Blockierend bis Position erreicht
  stepper2.moveTo(1600);
  stepper2.runToPosition();
  // Zurück zu 0, nicht-blockierend – beide gleichzeitig
  stepper1.moveTo(0);
  stepper2.moveTo(0);
  while (stepper1.currentPosition() != 0 || stepper2.currentPosition() != 0) {
    stepper1.run(); // Nicht-blockierend, implementiert Beschl./Verzögerung
    stepper2.run();
  }
}

Erklärung: Zwei Motoren definieren. setup(): Beschleunigung (setAcceleration), Startposition 0 (setCurrentPosition). loop(): moveTo() setzt Zielposition (Schritte). runToPosition() fährt hin mit Beschl./Verz. – blockiert bis Ankunft. Zweiter Motor analog. Für gleichzeitige Bewegung: moveTo(0) für beide, dann while-Schleife mit run() (nicht-blockierend, ein Schritt pro Aufruf) für beide Motoren, bis beide bei 0 sind. In while-Schleife kann weiterer Code stehen. Doku der Bibliothek lohnt sich für tiefes Verständnis.

Beispiel: Mehrere Schrittmotoren koordiniert mit AccelStepper & MultiStepper

MultiStepper-Klasse (gehört zu AccelStepper) ermöglicht koordinierte Bewegung: Zielpositionen für jeden Motor setzen, alle erreichen Ziel gleichzeitig – egal wie weit.

/* Controlling multiple steppers with AccelStepper and MultiStepper
 * by Dejan, https://howtomechatronics.com */
#include 
#include 
AccelStepper stepper1(1, 2, 5);
AccelStepper stepper2(1, 3, 6);
AccelStepper stepper3(1, 4, 7);
MultiStepper steppersControl;
long gotoposition[3]; // Zielpositions-Array

void setup() {
  stepper1.setMaxSpeed(1000);
  stepper2.setMaxSpeed(1000);
  stepper3.setMaxSpeed(1000);
  steppersControl.addStepper(stepper1);
  steppersControl.addStepper(stepper2);
  steppersControl.addStepper(stepper3);
}

void loop() {
  gotoposition[0] = 800;  // 1 Umdrehung (1/4-Schritt)
  gotoposition[1] = 1600; // 2 Umdrehungen
  gotoposition[2] = 3200; // 3 Umdrehungen
  steppersControl.moveTo(gotoposition); // Berechnet nötige Geschwindigkeiten
  steppersControl.runSpeedToPosition(); // Blockiert bis alle da sind
  delay(1000);
  gotoposition[0] = 0;
  gotoposition[1] = 0;
  gotoposition[2] = 0;
  steppersControl.moveTo(gotoposition);
  steppersControl.runSpeedToPosition();
  delay(1000);
}

Erklärung: MultiStepper includieren, Instanz erstellen, long-Array für Zielpositionen. setup(): MaxSpeed setzen, Motoren zu steppersControl hinzufügen. loop(): Zielpositionen in Array speichern, moveTo(Array) berechnet Geschwindigkeiten für gleichzeitiges Erreichen, runSpeedToPosition() fährt hin (blockierend). Für nicht-blockierend: run() nutzen. Hinweis: MultiStepper unterstützt keine Beschleunigung/Verzögerung. Für fortgeschrittene Beispiele: meine Arduino-Projekte auf der Website.

CNC-Shield für mehrere Schrittmotoren in jedem Arduino-Projekt

Hauptzweck: 2- oder 3-Achs-CNC-Maschinen steuern. Aber auch hervorragend für jedes Projekt mit mehreren Schrittmotoren – kompakt, einfache Treiber-/Motoranschlüsse. Shield auf Arduino UNO, steuert bis zu 4 Motoren einzeln, alle restlichen Arduino-Pins frei. Ich nutzte UNO + CNC-Shield für meinen 4-Achs-SCARA-Roboterarm. Details zur CNC-Shield-Nutzung folgen bald.

DRV8825 vs. A4988

Alles Gesagte über A4988 gilt weitgehend auch für DRV8825 – Funktionsweise, Anschluss, Code fast identisch. Unterschiede in technischen Daten:

Höherer Strom ohne Zusatzkühlung: 1,5 A vs. 1 A (A4988)
Höhere max. Versorgungsspannung: 45 V vs. 35 V
Höhere Microstepping-Auflösung: 1/32 vs. 1/16

Kleinere Unterschiede: Poti an anderer Stelle, anderes Vref-Strom-Verhältnis. DRV8825 braucht keine Logikversorgung (Pin wird zu FAULT-Ausgang). FAULT-Pin kann bedenkenlos auf 5 V gelegt werden → direkter Ersatz in A4988-Systemen möglich. Wichtig: Beim Austausch auf korrekte Orientierung achten! Poti-Position unterscheidet sich (A4988 unter Chip, DRV8825 über Chip) – leicht falsch herum einzusetzen.

Stromgrenze einstellen: Vref an Poti gegen GND messen. Formel: Stromgrenze = Vref × 2. Microstepping per Tabelle wählen.

Fazit: DRV8825 ist besser als A4988 – höherer Strom/Spannung, feineres Microstepping → ruhigerer, leiserer Motorlauf.

TMC2208-Schrittmotortreiber

Noch leiser und smoother: TMC2208 von Trinamic (Deutschland, Motion-Control-Spezialist). Leiser Treiber, direkter Ersatz für A4988/DRV8825. Weit verbreitet in Desktop-3D-Druckern, Lasergravuren, Scannern.

Besonderheit: Integrierte Interpolationseinheit mit 256 Unterteilungen (Microsteps). Erzeugt perfekte Sinussteuerung intern im Chip. Output: 256 Mikroschritte an Motor, egal welche MS-Pin-Einstellung (2, 4, 8, 16). → Sanfterer Lauf, Entlastung des Mikrocontrollers. Kombiniert mit StealthChop2-Technologie (lautlose Stromregelung) = ultra-leise Steuerung.

Lautstärkevergleich: A4988 ~65 dB, DRV8825 ~67 dB, TMC2208 ~41 dB. TMC2208 treibt Motoren vollständig lautlos – beeindruckend.

Strom: 1,2 A (2 A Peak) – leicht über A4988. Stromgrenze einstellen: Vref an Pin neben EN-Pin gegen GND messen. Formel: Stromgrenze = Vref × 0,71.

Pinout leicht abweichend: nur 2 MS-Pins, EN auf GND ziehen zum Aktivieren. Code identisch zu anderen Treibern.

Zusatzfeatures: UART-Interface (einzelne Leitung statt STEP/DIR), mehr Tuning-Optionen.

Fazit: TMC2208 ist besser als A4988/DRV8825 – aber teurer. Wenn Sie Extras und Lautlosigkeit nicht brauchen, sind die anderen beiden hervorragende Wahl.

Fazit

Wir haben alles Wichtige zur Steuerung von Schrittmotoren mit Arduino abgedeckt. NEMA17 und die drei Treiber (A4988, DRV8825, TMC2208) sind extrem vielseitig für alle Anwendungen mit Positionssteuerung. Vertiefen Sie Ihr Wissen durch meine Arduino-Projekte.

Interesse an größeren Motoren (NEMA23, NEMA34)? Demnächst eigenes Tutorial.

Hoffe, Ihnen hat das Tutorial gefallen und Sie haben Neues gelernt. Abonnieren Sie gerne und stellen Sie Fragen in den Kommentaren.

Schritt-für-Schritt-Anleitung zur Karton- & Wellpappenverpackungsproduktion Die besten Arduino-Starterkits für Elektronik-Einsteiger: Vertrauenswürdiger Ratgeber

Herstellungsprozess

3d Drucken

Automatisierungssteuerung System

Industrietechnik