Was ist ein Schrittmotor? Präzise Drehung mit 28BYJ-48 und ULN2003 am Arduino

Ein Schrittmotor teilt seine Drehung in kleine, gleich große Schritte. Bei jedem Befehl dreht er um einen festen Winkel weiter, daher weißt du ohne zusätzlichen Sensor genau, wo der Motor steht. 3D-Drucker, CNC-Maschinen, Kameraslider und automatische Vorhänge nutzen Schrittmotoren wegen dieser Präzision. Der günstigste Einstieg mit dem Arduino ist der Motor 28BYJ-48 mit der dazu verkauften Treiberplatine ULN2003.

Wie funktioniert ein Schrittmotor?

Im Schrittmotor sind mehrere Spulen um einen gezahnten Magnetrotor angeordnet. Werden die Spulen in einer bestimmten Reihenfolge bestromt, zieht es den Rotor jedes Mal zur nächsten Spule und er rückt einen Schritt weiter. Läuft die Reihenfolge schnell ab, dreht der Motor schnell, läuft sie langsam ab, dreht er langsam; kehrst du sie um, dreht er andersherum. Weil der Motor jeden Schritt zählt, ist seine Position bekannt – bei Überlastung kann er aber Schritte verlieren, ohne es zu merken.

Schrittmotor, Servo oder Gleichstrommotor?

Reicht es, einen Winkel anzufahren und zu halten, ist ein Servo einfacher; Details in Was ist ein Servomotor? Brauchst du schnelle, dauerhafte Drehung, passen ein Gleichstrommotor und ein L298N-Motortreiber besser. Für Aufgaben, bei denen der Motor mehrere Umdrehungen machen und trotzdem seine Position kennen muss, ist der Schrittmotor unschlagbar.

Technische Daten des 28BYJ-48

Anschluss des ULN2003-Treibers

Der 5-polige Stecker des Motors passt nur in einer Richtung in die Buchse der ULN2003-Platine, falsch einstecken geht nicht. Verbinde die Pins IN1–IN4 der Platine mit den Arduino-Pins 8–11 und die Anschlüsse + und – mit einer 5-V-Versorgung. Der ULN2003 ist ein Darlington-Transistorarray, das das kleine Signal des Arduino-Pins auf den Strom verstärkt, den die Spule braucht; die vier LEDs zeigen, wie die Spulen nacheinander schalten.

Erste Drehung mit der Stepper-Bibliothek

Die Stepper-Bibliothek ist in der Arduino IDE schon enthalten. Achten musst du nur auf die Pinreihenfolge: Für den 28BYJ-48 wird das Objekt in der Reihenfolge 8, 10, 9, 11 (IN1, IN3, IN2, IN4) angelegt. Schreibst du 8, 9, 10, 11, zittert der Motor auf der Stelle statt zu drehen – der häufigste Fehler.

1#include <Stepper.h>
2
3const int STEPS_PER_REV = 2048;                  // 28BYJ-48 tam tur / full revolution
4Stepper motor(STEPS_PER_REV, 8, 10, 9, 11);      // sıra: IN1, IN3, IN2, IN4 / order: IN1, IN3, IN2, IN4
5
6void setup() {
7  motor.setSpeed(10);                            // devir/dakika, en fazla ~15 / RPM, max ~15
8}
9
10void loop() {
11  motor.step(STEPS_PER_REV);        // bir yönde tam tur / one full turn
12  delay(1000);
13  motor.step(-STEPS_PER_REV / 2);   // ters yönde yarım tur / half a turn back
14  delay(1000);
15}

Positionssteuerung mit einem Potentiometer

Speicherst du die aktuelle Position des Motors in einer Variablen, kannst du ihn an jeden beliebigen Punkt fahren. Der folgende Code rechnet die Stellung des Potentiometers in 0–2048 Schritte um, und der Motor folgt dem Drehknopf an dieselbe Stelle. Eine Toleranz von 10 Schritten ignoriert kleines Zittern. Den Anschluss des Potentiometers erklärt Was ist ein Potentiometer?

1#include <Stepper.h>
2
3Stepper motor(2048, 8, 10, 9, 11);
4int position = 0;                                    // şu anki adım / current step
5
6void setup() {
7  motor.setSpeed(12);
8}
9
10void loop() {
11  int target = map(analogRead(A0), 0, 1023, 0, 2048);  // potansiyometre → hedef / pot → target
12  if (abs(target - position) > 10) {                 // küçük titreşimleri yok say / ignore jitter
13    motor.step(target - position);
14    position = target;
15  }
16}

AccelStepper: sanftes Beschleunigen ohne Blockieren

Der Befehl step() der Stepper-Bibliothek hält dein Programm an, bis die Bewegung fertig ist; so lange kannst du weder Taster lesen noch ein Display aktualisieren. AccelStepper, das du im Bibliotheksverwalter installierst, bewegt den Motor im Hintergrund Schritt für Schritt und ergänzt Beschleunigung und Abbremsen, um ruckartige Starts zu vermeiden. Für den 28BYJ-48 nutzt man den Halbschrittmodus (HALF4WIRE), in dem eine Umdrehung 4096 Schritte hat:

1#include <AccelStepper.h>
2
3// 28BYJ-48 + ULN2003, yarım adım: tur başına 4096 / half-step: 4096 per turn
4AccelStepper motor(AccelStepper::HALF4WIRE, 8, 10, 9, 11);
5
6void setup() {
7  motor.setMaxSpeed(1000);      // adım/saniye / steps per second
8  motor.setAcceleration(400);   // adım/saniye² / steps per second²
9  motor.moveTo(4096);           // bir tur ileri / one turn forward
10}
11
12void loop() {
13  if (motor.distanceToGo() == 0) {
14    motor.moveTo(-motor.currentPosition());   // geri dön / go back
15  }
16  motor.run();                  // her döngüde çağır, bekletmez / call every loop, non-blocking
17}

Stärkere Motoren: NEMA 17 und A4988

Für kraftintensive Aufgaben wie 3D-Drucker und CNC-Maschinen nutzt man bipolare Schrittmotoren wie den NEMA 17. Sie machen 200 Schritte pro Umdrehung (1,8°) und sind viel stärker als der 28BYJ-48. Angesteuert werden sie mit Treibern wie dem A4988 oder DRV8825: Bei jedem STEP-Puls macht der Motor einen Schritt, der Pin DIR legt die Richtung fest. Der Treiber läuft mit 8–35 V und teilt per Mikroschritt jeden Schritt bis zu 16-fach für eine weichere Bewegung.

1const int STEP_PIN = 3;
2const int DIR_PIN = 4;
3
4void setup() {
5  pinMode(STEP_PIN, OUTPUT);
6  pinMode(DIR_PIN, OUTPUT);
7}
8
9void loop() {
10  digitalWrite(DIR_PIN, HIGH);          // yön / direction
11  for (int i = 0; i < 200; i++) {       // NEMA 17'de 200 adım = 1 tur / 200 steps = 1 turn
12    digitalWrite(STEP_PIN, HIGH);
13    delayMicroseconds(800);             // küçüldükçe hız artar / smaller = faster
14    digitalWrite(STEP_PIN, LOW);
15    delayMicroseconds(800);
16  }
17  delay(1000);
18}

Schrittmotor mit ESP32 und Raspberry Pi Pico

Die Eingänge des ULN2003 arbeiten problemlos mit 3,3-V-Signalen; den Motor versorgst du trotzdem separat mit 5 V. Am ESP32 funktioniert AccelStepper unverändert; nutze Pins außerhalb von 6–11 und 34–39, zum Beispiel GPIO 19, 18, 5 und 17. Am Pico drehst du den Motor mit MicroPython, indem du die Halbschrittfolge nacheinander auf die vier Pins schreibst:

1from machine import Pin
2import time
3
4pins = [Pin(n, Pin.OUT) for n in (2, 3, 4, 5)]      # IN1–IN4 → GP2–GP5
5SEQ = [[1,0,0,0],[1,1,0,0],[0,1,0,0],[0,1,1,0],
6       [0,0,1,0],[0,0,1,1],[0,0,0,1],[1,0,0,1]]    # yarım adım dizisi / half-step sequence
7
8def rotate(steps, delay_ms=2):
9    direction = 1 if steps > 0 else -1
10    for i in range(abs(steps)):
11        for pin, value in zip(pins, SEQ[(i * direction) % 8]):
12            pin.value(value)
13        time.sleep_ms(delay_ms)
14    for pin in pins:
15        pin.value(0)                                   # bobinleri bırak / release coils
16
17rotate(4096)        # bir tur / one turn (half-step)
18rotate(-1024)       # çeyrek tur geri / quarter turn back

Projektideen mit Schrittmotoren

• Analoguhr: eine Tischuhr, deren Stunden- und Minutenzeiger von Schrittmotoren gedreht werden.
• Kameraslider: eine Schiene, die die Kamera für Zeitraffer sehr langsam bewegt.
• Automatischer Fischfutterautomat: ein Mechanismus, der zweimal am Tag seinen Behälter dreht und Futter ausgibt.
• Sonnennachführung: ein Panel mit zwei Lichtsensoren zur hellsten Richtung drehen; zum Licht siehe LDR-Lichtsensor.
• Drehteller: ein Teller, der ein Objekt für Produktfotos oder 3D-Scans in gleichen Winkeln dreht.
• Automatischer Vorhang: ein Motor, der die Vorhangschnur aufwickelt und sich seine Position merkt.

Typische Fehler und ihre Lösungen

• Der Motor zittert, dreht aber nicht: Die Pinreihenfolge in der Stepper-Bibliothek stimmt nicht; schreib 8, 10, 9, 11 statt 8, 9, 10, 11.
• Der Motor verliert Schritte: Zu hohe Drehzahl oder zu schwere Last; halte den 28BYJ-48 unter 15 U/min und ergänze Beschleunigung mit AccelStepper.
• Der Arduino startet neu: Die Versorgung reicht nicht; versorge den Motor aus einer externen 5-V-Quelle und verbinde die Massen.
• Der Motor wird im Stillstand heiß: Die Spulen bleiben bestromt; setze nach der Bewegung alle vier Pins auf LOW.
• Die Umdrehungen stimmen nicht: Im Vollschritt sind es 2048 Schritte, im Halbschritt 4096, beim NEMA 17 dagegen 200. Verwechsle Modus und Motor nicht.
• Mit dem A4988 dreht der Motor nicht: Die Strombegrenzung ist zu niedrig, die Motorversorgung fehlt oder RESET und SLEEP sind nicht miteinander verbunden.

Ein Schrittmotor ist der einfachste Weg zu sagen "dreh genau so weit", und er ist die Grundlage von Maschinen wie CNC-Fräsen und 3D-Druckern. In der BlueGrays-App findest du Projekte zur Nutzung des 28BYJ-48 und zum Bau eines 360-Grad-Servos aus einem Schrittmotor Schritt für Schritt mit Schaltplänen und Code.