Schrittmotor 28BYJ-48 mit Arduino ansteuern – Präzise Bewegungen für deine Projekte

Warum der 28BYJ-48?

Wenn du schon einmal einen normalen Gleichstrommotor verwendet hast, kennst du das Problem: Er dreht sich einfach, sobald Spannung anliegt. Willst du eine exakte Position anfahren – etwa bei einem Kamera-Slider, einem kleinen Plotter oder einer automatischen Pflanzenbewässerung – bist du mit einem DC-Motor schnell am Limit. Genau hier kommt der Schrittmotor ins Spiel.

Der 28BYJ-48 ist ein Unipolarschrittmotor mit 5 Volt Betriebsspannung und einem integrierten Getriebe, das die Schrittzahl pro Umdrehung auf 2048 Schritte (im Vollschrittmodus) erhöht. Das entspricht einer Winkelauflösung von etwa 0,18° pro Schritt – eine Genauigkeit, die für die allermeisten Hobby-Projekte mehr als ausreicht.

So funktioniert ein Schrittmotor

Bevor wir löten und programmieren, lohnt sich ein kurzer Blick unter die Haube. Das Verständnis der Funktionsweise hilft dir später enorm beim Debuggen und Optimieren.

Elektromagnetisches Grundprinzip

Ein Schrittmotor besteht aus einem Rotor (dem drehenden Teil mit Permanentmagneten oder gezahntem Eisenkern) und einem Stator (dem feststehenden Teil mit mehreren Spulen). Werden die Spulen in einer bestimmten Reihenfolge bestromt, erzeugen sie ein magnetisches Drehfeld, das den Rotor schrittweise mitzieht.

Der 28BYJ-48 besitzt vier Spulen, die als zwei Wicklungspaare mit Mittelabgriff ausgeführt sind – daher die Bezeichnung Unipolar. Das bedeutet: Der Strom fließt immer nur in eine Richtung durch jede Spule, und die Ansteuerung ist dadurch besonders einfach, weil du keine H-Brücke brauchst. Der ULN2003-Treiber schaltet die Spulen lediglich gegen Masse durch.

Vollschritt vs. Halbschritt

Bei der Vollschritt-Ansteuerung sind immer zwei Spulen gleichzeitig aktiv. Der Motor macht pro Schritt eine volle Bewegung von einem Spulenpaar zum nächsten. Die Drehmoment-Ausbeute ist hier am höchsten, dafür ist die Bewegung etwas ruckartiger.

Bei der Halbschritt-Ansteuerung wechseln sich Phasen ab, in denen mal zwei, mal nur eine Spule bestromt wird. Der Rotor hält auf halbem Weg zwischen zwei Vollschritt-Positionen, wodurch sich die Auflösung verdoppelt – beim 28BYJ-48 mit ULN2003 sind das dann 4096 Schritte pro Umdrehung. Die Bewegung wird sanfter, allerdings sinkt das Drehmoment in den Einzelspulen-Phasen um etwa 30 %.

Das eingebaute Getriebe

Der Motor selbst macht pro Umdrehung 32 Vollschritte (64 mit Halbschritt). Das integrierte Getriebe untersetzt mit einem Verhältnis von ≈1:64 – genau genommen 63,68395:1, was in der Praxis zu den bekannten 2048 Vollschritten (bzw. 4096 Halbschritten) pro Umdrehung der Abtriebswelle führt. Dieses Getriebe ist der Grund, warum der 28BYJ-48 trotz seiner geringen Leistungsaufnahme von etwa 1–2 Watt ein überraschend hohes Drehmoment liefert.

Drehmoment-Kurve und Geschwindigkeit

Ein wichtiger Punkt: Das Drehmoment eines Schrittmotors sinkt mit steigender Drehzahl. Beim 28BYJ-48 liegt das praktische Maximum bei etwa 10–15 U/min. Darüber verliert der Motor rapide an Kraft und beginnt, Schritte zu überspringen – der gefürchtete „Step Loss". Für Positionierungsaufgaben, bei denen es mehr auf Präzision als auf Geschwindigkeit ankommt, ist das kein Problem. Für schnelle Fahrten oder Antriebe von kleinen Robotern solltest du eher einen NEMA17-Motor in Betracht ziehen.

Der ULN2003-Treiber – das Darlington-Array

Das mitgelieferte kleine blaue Board ist mehr als nur eine Adapterplatine. Der darauf verbaute ULN2003A-Chip enthält sieben Darlington-Transistorpaare, von denen wir vier für die Motorsteuerung nutzen. Ein Darlington-Paar besteht aus zwei hintereinander geschalteten Bipolartransistoren – dadurch erreicht der ULN2003 eine Stromverstärkung, die den Arduino vor den induktiven Lasten der Motorspulen schützt.

Der Arduino-Pin muss nur wenige Milliampere liefern, während der ULN2003 die Motorspulen mit bis zu 500 mA pro Kanal (theoretisch) versorgt. In der Praxis zieht der 28BYJ-48 pro Spule etwa 150–200 mA. Die Freilaufdioden sind bereits im Chip integriert und schützen vor Spannungsspitzen, die beim Abschalten der Spulen entstehen.

Schaltplan – Schritt für Schritt

Die Verkabelung ist denkbar einfach. Du brauchst keinen externen Treiber, keine H-Brücke und keine zusätzliche Spannungsversorgung – der Motor läuft direkt am 5V-Pin des Arduino.

1Motor mit ULN2003-Treiber verbinden

Der 28BYJ-48 hat einen 5-poligen JST-XH-Stecker, der direkt auf die Stiftleiste des ULN2003-Treiberboards passt. Einfach aufstecken – die Kodierung verhindert Verpolung. Falls du eigene Kabel verwenden möchtest, findest du in unserem Shop ein praktisches JST-XH Stecker Set zum Selbstkonfektionieren.

2ULN2003 mit dem Arduino verbinden

Nutze vier Jumper-Wires (Female-to-Male) und ein Breadboard mit 400 Kontakten für einen sauberen Aufbau:

• IN1 → Pin 8 (Arduino)
• IN2 → Pin 9 (Arduino)
• IN3 → Pin 10 (Arduino)
• IN4 → Pin 11 (Arduino)
• GND → GND (Arduino)
• VCC → 5V (Arduino)

3Arduino mit dem Computer verbinden

Schließe deinen Arduino UNO R3 per USB an und wähle in der Arduino IDE das richtige Board und den richtigen Port aus. Keine externe Stromversorgung nötig – der 28BYJ-48 ist mit 5V und ~200 mA pro Spule so genügsam, dass der USB-Port des Rechners locker ausreicht.

Drei lauffähige Code-Beispiele

Jetzt der spannende Teil: Programmierung. Ich zeige dir drei Stufen, die aufeinander aufbauen – vom einfachen Drehen bis zur interaktiven Positionssteuerung.

Stufe 1: Einfaches Drehen mit der Stepper-Bibliothek

Die Arduino-IDE bringt von Haus aus die Stepper-Bibliothek mit. Sie ist simpel, aber für die ersten Schritte perfekt geeignet. Der folgende Code lässt den Motor eine Umdrehung im Uhrzeigersinn und anschließend eine Umdrehung gegen den Uhrzeigersinn fahren – mit einer kurzen Pause dazwischen.

/*
 * 28BYJ-48 Schrittmotor – Stufe 1: Einfaches Drehen
 * Benötigt: Stepper.h (in Arduino IDE enthalten)
 * Verdrahtung: IN1→D8, IN2→D9, IN3→D10, IN4→D11
 */

#include <Stepper.h>

const int stepsPerRevolution = 2048;  // 28BYJ-48 Vollschritt (32 * 63.684)

// Motor initialisieren: Schritte/Umdrehung, Pins 8-11
Stepper myStepper(stepsPerRevolution, 8, 10, 9, 11);

void setup() {
  myStepper.setSpeed(10);  // 10 U/min – sicherer Bereich für den 28BYJ-48
  Serial.begin(9600);
  Serial.println("28BYJ-48 Schrittmotor – Einfaches Drehen");
}

void loop() {
  Serial.println("Drehe im Uhrzeigersinn...");
  myStepper.step(stepsPerRevolution);
  delay(1000);

  Serial.println("Drehe gegen den Uhrzeigersinn...");
  myStepper.step(-stepsPerRevolution);
  delay(1000);
}

Stufe 2: Beschleunigte Bewegung mit AccelStepper

Die Standard-Bibliothek hat einen Nachteil: Sie blockiert. Während myStepper.step() läuft, kann dein Arduino nichts anderes tun. Das ist für einfache Anwendungen okay, aber sobald du mehrere Motoren gleichzeitig bewegen oder während der Fahrt Sensorwerte auslesen willst, wird es eng.

Abhilfe schafft die AccelStepper-Bibliothek von Mike McCauley. Sie bringt echte Beschleunigungsrampen, nicht-blockierenden Betrieb und absolute Positionierung mit. Perfekt für Projekte, bei denen es auf sanfte Bewegungen ankommt.

/*
 * 28BYJ-48 Schrittmotor – Stufe 2: AccelStepper
 * Bibliothek installieren: Werkzeuge → Bibliotheken verwalten → "AccelStepper"
 * Verdrahtung: IN1→D8, IN2→D9, IN3→D10, IN4→D11
 */

#include <AccelStepper.h>

// AccelStepper mit HALF4WIRE-Modus (4-Draht Unipolar über ULN2003)
AccelStepper stepper(AccelStepper::HALF4WIRE, 8, 10, 9, 11);

void setup() {
  Serial.begin(9600);
  Serial.println("28BYJ-48 Schrittmotor – AccelStepper Demo");

  // Maximale Geschwindigkeit und Beschleunigung
  stepper.setMaxSpeed(1000.0);      // Schritte/Sekunde (~30 U/min im Vollschritt)
  stepper.setAcceleration(500.0);   // Sanftes Anfahren
}

void loop() {
  // 2048 Schritte (1 Umdrehung) nach vorne fahren
  Serial.println("Fahre 1 Umdrehung vorwärts...");
  stepper.move(2048);

  // Während der Motor läuft, run() regelmäßig aufrufen
  while (stepper.distanceToGo() != 0) {
    stepper.run();
  }

  delay(1500);

  // Zurück auf Position 0 (1 Umdrehung rückwärts)
  Serial.println("Fahre zurück auf Position 0...");
  stepper.move(-2048);

  while (stepper.distanceToGo() != 0) {
    stepper.run();
  }

  delay(1500);

  // Absolute Positionierung: Zielposition = 1024 (halbe Umdrehung)
  Serial.println("Absolute Position: 1024 (halbe Umdrehung)...");
  stepper.moveTo(1024);

  while (stepper.distanceToGo() != 0) {
    stepper.run();
  }

  Serial.print("Aktuelle Position: ");
  Serial.println(stepper.currentPosition());

  delay(3000);
}

Stufe 3: Positionssteuerung mit Potentiometer

In der dritten Stufe wird es interaktiv: Ein Potentiometer dient als Drehgeber, mit dem du die Zielposition des Motors direkt steuern kannst. Zusätzlich nutzen wir einen Taster zum Setzen einer Nullposition („Homing"). Das ist die Basis für Projekte wie einen Kamera-Slider, bei dem der Benutzer die Position frei wählen kann.

/*
 * 28BYJ-48 Schrittmotor – Stufe 3: Potentiometer-Steuerung mit Homing
 * Potentiometer: Mitte an A0, Außen an 5V und GND
 * Taster: Pin 2 gegen GND (INPUT_PULLUP)
 * Verdrahtung Motor: IN1→D8, IN2→D9, IN3→D10, IN4→D11
 */

#include <AccelStepper.h>

AccelStepper stepper(AccelStepper::HALF4WIRE, 8, 10, 9, 11);

const int potPin = A0;
const int buttonPin = 2;
const int maxSteps = 2048;         // 1 volle Umdrehung
const int deadZone = 15;           // Totzone gegen Zittern

int targetPosition = 0;
bool homed = false;

void setup() {
  Serial.begin(9600);
  pinMode(buttonPin, INPUT_PULLUP);

  stepper.setMaxSpeed(800.0);
  stepper.setAcceleration(400.0);

  Serial.println("28BYJ-48 – Potentiometer-Steuerung");
  Serial.println("Drehe Poti zum Positionieren, drücke Taster für Nullposition.");
}

void loop() {
  // === Taster-Abfrage: Nullposition setzen ===
  if (digitalRead(buttonPin) == LOW) {
    delay(50);  // Entprellen
    if (digitalRead(buttonPin) == LOW) {
      stepper.setCurrentPosition(0);
      targetPosition = 0;
      homed = true;
      Serial.println("✔ Nullposition gesetzt (Home).");
      while (digitalRead(buttonPin) == LOW);  // Warten auf Loslassen
      delay(50);
    }
  }

  // === Potentiometer lesen und auf Zielposition mappen ===
  int potValue = analogRead(potPin);
  int newTarget = map(potValue, 0, 1023, 0, maxSteps);

  // Totzone: Nur reagieren, wenn sich die Position deutlich ändert
  if (abs(newTarget - targetPosition) > deadZone) {
    targetPosition = newTarget;
    stepper.moveTo(targetPosition);

    Serial.print("Ziel: ");
    Serial.print(targetPosition);
    Serial.print(" / ");
    Serial.print(maxSteps);
    Serial.print("  (Poti-Rohwert: ");
    Serial.print(potValue);
    Serial.println(")");
  }

  // === Motor bewegen (nicht-blockierend) ===
  stepper.run();

  // Status-LED oder Homescreen? Hier später erweiterbar.
  // Tipp: MPU-6050 Gyro anschließen für Closed-Loop-Positionierung!
}

Projektideen für deinen 28BYJ-48

Der 28BYJ-48 ist so vielseitig, dass er in unzähligen Projekten zum Einsatz kommen kann. Hier sind drei bewährte Anwendungen, bei denen der Motor seine Stärken voll ausspielt:

Häufige Fehler und Troubleshooting

🚫 Motor zuckt nur, dreht sich aber nicht

Ursache: Meistens eine falsche Pin-Reihenfolge im Code. Prüfe die Reihenfolge: (8, 10, 9, 11) – nicht (8, 9, 10, 11). Alternativ kann eine Spule nicht durchgesteuert sein – die vier Status-LEDs auf dem ULN2003-Board zeigen dir die aktive Phase an. Leuchten sie in der richtigen Sequenz auf?

⚡ Motor verliert Schritte unter Last

Ursache: Das Drehmoment reicht nicht, oder die Geschwindigkeit ist zu hoch. Reduziere die Geschwindigkeit (setMaxSpeed) und erhöhe die Beschleunigung moderat. Bei AccelStepper kann ein zu aggressiver Beschleunigungswert dafür sorgen, dass der Motor beim Anfahren Schritte springt.

🔌 ULN2003-Treiber wird heiß

Ursache: Eine moderate Erwärmung ist normal. Wird der Chip aber zu heiß zum Anfassen (>60 °C), prüfe die Spannungsversorgung. Der 28BYJ-48 sollte an 5V betrieben werden, nicht an 12V. Und trenne die Motor-Stromversorgung (VCC am ULN2003) von der Arduino-Logikversorgung, wenn du eine externe Quelle nutzt.

📏 Position driftet mit der Zeit

Ursache: Schrittmotoren sind Open-Loop – jeder verlorene Schritt summiert sich. Abhilfe: Ein Endschalter (Limit Switch) oder eine Lichtschranke als Referenzpunkt definieren, den der Motor regelmäßig anfährt („Auto-Home"). Oder wie in Stufe 3 den Taster zum manuellen Nullen nutzen.