Dieser Artikel enthält alles, was Sie über die Steuerung eines 28BYJ-48 Schrittmotors mit dem ULN2003-Treiberboard und Arduino wissen müssen. Ich habe Datenblätter, einen Schaltplan und viele Beispielcodes beigefügt!
Zuerst werfen wir einen Blick auf die einfach zu verwendende Arduino Stepper-Bibliothek. Diese Bibliothek ist ideal für Einsteiger, bietet aber nicht viele Zusatzfunktionen.
Ich empfehle dringend, auch die Beispielcodes für die AccelStepper-Bibliothek am Ende dieses Tutorials anzuschauen. Diese Bibliothek ist recht einfach zu nutzen und kann die Leistung Ihrer Hardware deutlich verbessern.
Nach jedem Beispiel erkläre ich, wie der Code funktioniert, sodass Sie ihn problemlos an Ihre Bedürfnisse anpassen können.
Materialien
Hardware-Komponenten
 | 28BYJ-48 stepper motor | × 1 | Amazon |
| ULN2003 driver board | × 1 | Amazon | |
 | Arduino Uno Rev3 | × 1 | Amazon |
| Jumper wires | × 10 | Amazon | |
| Breadboard (optional, erleichtert die Verkabelung) | × 1 | Amazon | |
| USB cable type A/B | × 1 | Amazon | |
| 5V power supply (die direkte Stromversorgung des Schrittmotors über den Arduino kann diesen beschädigen!) | × 1 | Amazon |
Software
Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.
Informationen zum 28BYJ-48 Schrittmotor und ULN2003 Treiberboard
Der 28BYJ-48 ist einer der günstigsten Schrittmotoren auf dem Markt. Obwohl er nicht besonders genau oder leistungsstark ist, eignet er sich hervorragend für kleinere Projekte oder zum Lernen über Schrittmotoren.
Dieser Motor wird oft verwendet, um die Lamellen einer Klimaanlage automatisch zu verstellen. Er verfügt über ein eingebautes Getriebe, das ihm zusätzliches Drehmoment verleiht und die Geschwindigkeit stark reduziert.
Nachfolgend finden Sie die Spezifikationen sowohl für den Schrittmotor als auch für den Treiber, die in diesem Tutorial verwendet werden.
28BYJ-48 Schrittmotor Spezifikationen
| Nennspannung | 5 V |
| Spulenwiderstand | 50 Ohm |
| Spulentyp | Unipolar |
| Durchmesser – Welle | 0,197″ (5,00 mm) |
| Länge – Welle und Lager | 0,394″ (10 mm) |
| Eigenschaften | Abgeflachte Welle |
| Größe/Abmessungen | Rund – 1,100″ Durchmesser (28,00 mm) |
| Befestigungslochabstand | Abgeflachte Welle |
| Untersetzung | 1/64 (siehe Hinweis) |
| Schrittwinkel | Halbschrittmodus (empfohlen): 0,0879° Vollschrittmodus: 0,176° |
| Schritte pro Umdrehung | Halbschrittmodus: 4096 (siehe Hinweis) Vollschrittmodus: 2048 |
| Anschlussart | Drahtleitungen mit Stecker |
| Motortyp | Permanentmagnet-Getriebemotor |
| Anzahl der Phasen | 4 |
| Kosten | Check price |
Weitere Informationen finden Sie im Datenblatt hier.
Wichtiger Hinweis: Hersteller geben meist eine Untersetzung von 64:1 an. Einige Mitglieder der Arduino Forums haben festgestellt, dass dies nicht korrekt ist und haben einige Motoren zerlegt, um das tatsächliche Übersetzungsverhältnis zu prüfen. Sie ermittelten, dass das genaue Übersetzungsverhältnis tatsächlich 63,68395:1 beträgt, was ungefähr 4076 Schritte pro vollständiger Umdrehung (im Halbschrittmodus) ergibt.
Ich bin mir nicht sicher, ob alle Hersteller dasselbe Getriebe verwenden, aber Sie können die Schritte pro Umdrehung im Code einfach an Ihr Modell anpassen.
Der Adafruit Industries Small Reduction Stepper Motor verwendet denselben Formfaktor wie der 28BYJ-48, hat aber ein anderes Übersetzungsverhältnis. Er besitzt ein etwa 1/16 Untersetzungsgetriebe, was 513 Schritte pro Umdrehung (im Vollschrittmodus) ergibt. Das Datenblatt können Sie hier herunterladen:
Verdrahtung – Anschluss des 28BYJ-48 Schrittmotors und ULN2003 Treiberboards an Arduino UNO
Das untenstehende Schaltbild zeigt, wie das ULN2003 Treiberboard mit dem 28BYJ-48 Schrittmotor und dem Arduino verbunden wird. Die Anschlüsse sind auch in der Tabelle unten aufgeführt.
Ich habe ein Steckbrett und einige Jumper-Kabel verwendet, um das Treiberboard mit einer externen Stromversorgung zu verbinden.
ULN2003 und 28BYJ-48 zu Arduino Anschlüsse
| ULN2003 Treiberboard | Anschluss |
|---|---|
| IN1 | Pin 8 Arduino |
| IN2 | Pin 9 Arduino |
| IN3 | Pin 10 Arduino |
| IN4 | Pin 11 Arduino |
| – | Logic GND Arduino |
| – | GND Stromversorgung |
| + | 5 V Stromversorgung |
Bitte beachten: Es ist möglich, den Schrittmotor direkt über den 5 V Ausgang des Arduino zu versorgen. Dies wird jedoch nicht empfohlen. Wenn der Schrittmotor zu viel Strom zieht, kann dies den Arduino beschädigen. Ich habe auch festgestellt, dass bei Stromversorgung des Arduino nur über USB inkonsistentes Verhalten und schlechte Leistung des Schrittmotors auftreten kann.
Ich empfehle, das Treiberboard/den Schrittmotor mit einer externen Stromquelle zu versorgen. Es sollte mit einem weiblichen DC-Stecker geliefert werden, sodass Sie es einfach mit (Jumper-)Kabeln verbinden können. Beachten Sie, dass Sie auch den GND des Arduino mit dem – Anschluss am ULN2003 Treiberboard verbinden müssen.
Nach dem Hochladen des Codes müssen Sie den Arduino auch mit Strom versorgen, entweder über ein USB Typ-B Kabel oder über die 5,5 mm Strombuchse.
Der Jumper neben den Stromanschlüssen auf dem Treiberboard kann verwendet werden, um die Stromversorgung des Schrittmotors zu trennen.
Einfacher Arduino Beispielcode zur Steuerung eines 28BYJ-48 Schrittmotors
Sie können den folgenden Beispielcode mit dem Arduino IDE hochladen.
Dieses Beispiel verwendet die Stepper.h Bibliothek, die standardmäßig mit der Arduino IDE installiert sein sollte. Dieser Sketch dreht den Schrittmotor eine Umdrehung in eine Richtung, pausiert und dreht dann eine Umdrehung in die andere Richtung.
/*
Example sketch to control a 28BYJ-48 stepper motor
with ULN2003 driver board and Arduino UNO.
More info: https://www.makerguides.com
*/
// Include the Arduino Stepper.h library:
#include "Stepper.h"
// Define number of steps per rotation:
const int stepsPerRevolution = 2048;
// Wiring:
// Pin 8 to IN1 on the ULN2003 driver
// Pin 9 to IN2 on the ULN2003 driver
// Pin 10 to IN3 on the ULN2003 driver
// Pin 11 to IN4 on the ULN2003 driver
// Create stepper object called 'myStepper', note the pin order:
Stepper myStepper = Stepper(stepsPerRevolution, 8, 10, 9, 11);
void setup() {
// Set the speed to 5 rpm:
myStepper.setSpeed(5);
// Begin Serial communication at a baud rate of 9600:
Serial.begin(9600);
}
void loop() {
// Step one revolution in one direction:
Serial.println("clockwise");
myStepper.step(stepsPerRevolution);
delay(500);
// Step one revolution in the other direction:
Serial.println("counterclockwise");
myStepper.step(-stepsPerRevolution);
delay(500);
}
Code-Erklärung:
Der Sketch beginnt mit dem Einbinden der Stepper.h Arduino-Bibliothek. Weitere Informationen zu dieser Bibliothek finden Sie auf der Arduino website.
// Include the Arduino Stepper.h library: #include "Stepper.h"
Als nächstes definiere ich, wie viele Schritte der Motor für eine Umdrehung benötigt. In diesem Beispiel verwenden wir den Motor im Vollschrittmodus. Das bedeutet, dass 2048 Schritte für eine 360-Grad-Drehung nötig sind (siehe Motorspezifikationen oben).
// Define number of steps per rotation: const int stepsPerRevolution = 2048;
Danach müssen Sie eine neue Instanz der Stepper-Klasse erstellen, die einen bestimmten Schrittmotor repräsentiert, der mit dem Arduino verbunden ist. Dafür verwenden wir die Funktion Stepper(steps, pin1, pin2, pin3, pin4) wobei steps die Anzahl der Schritte pro Umdrehung ist und pin1 bis pin4 die Pins sind, an die der Motor angeschlossen ist. Um die korrekte Schrittfolge zu erhalten, müssen die Pins in folgender Reihenfolge gesetzt werden: 8, 10, 9, 11.
// Create stepper object called 'myStepper', note the pin order: Stepper myStepper = Stepper(stepsPerRevolution, 8, 10, 9, 11);
In diesem Fall habe ich den Schrittmotor ‘myStepper’ genannt, aber Sie können auch andere Namen verwenden, wie ‘z_motor’ oder ‘liftmotor’ usw. Stepper liftmotor = Stepper(stepsPerRevolution, 8, 10, 9, 11);. Sie können mehrere Schrittmotor-Objekte mit unterschiedlichen Namen und Pins erstellen. So können Sie problemlos 2 oder mehr Schrittmotoren gleichzeitig steuern.
Im Setup können Sie die Geschwindigkeit in U/min mit der Funktion setSpeed(rpm)einstellen. Die maximale Geschwindigkeit für einen 28BYJ-48 Schrittmotor liegt ungefähr bei10-15 U/min bei 5 V.
void setup() {
// Set the speed to 5 rpm:
myStepper.setSpeed(5);
// Begin Serial communication at a baud rate of 9600:
Serial.begin(9600);
}
Im Loop-Teil des Codes rufen wir einfach die step(steps) Funktion auf, die den Motor eine bestimmte Anzahl von Schritten mit einer durch die setSpeed(rpm) Funktion bestimmten Geschwindigkeit dreht. Wenn Sie eine negative Zahl übergeben, dreht sich der Motor in die entgegengesetzte Richtung.
void loop() {
// Step one revolution in one direction:
Serial.println("clockwise");
myStepper.step(stepsPerRevolution);
delay(500);
// Step one revolution in the other direction:
Serial.println("counterclockwise");
myStepper.step(-stepsPerRevolution);
delay(500);
}
Beispielcodes für 28BYJ-48 Schrittmotor mit Arduino und AccelStepper-Bibliothek
In den folgenden drei Beispielen zeige ich Ihnen, wie Sie sowohl die Geschwindigkeit, die Drehrichtung als auch die Anzahl der Schritte, die der Schrittmotor ausführen soll, steuern können. In diesen Beispielen verwende ich die AccelStepper-Bibliothek.
Die AccelStepper-Bibliothek von Mike McCauley ist eine großartige Bibliothek für Ihr Projekt. Ein Vorteil ist, dass sie Beschleunigung und Verzögerung unterstützt, aber sie bietet noch viele weitere nützliche Funktionen.
Sie können die neueste Version dieser Bibliothek über den folgende Link herunterladen.
Sie können die Bibliothek installieren, indem Sie in der Arduino IDE zu Sketch > Include Library > Add .ZIP Library… gehen.
Eine weitere Möglichkeit ist, zu Tools > Manage Libraries… zu navigieren oder unter Windows Strg + Shift + I zu drücken. Der Library Manager öffnet sich und aktualisiert die Liste der installierten Bibliotheken.
Sie können nach ‘accelstepper‘ suchen und die Bibliothek von Mike McCauley auswählen. Wählen Sie die neueste Version und klicken Sie dann auf Installieren.
1. Beispielcode für kontinuierliche Rotation
Der folgende Sketch kann verwendet werden, um einen oder mehrere Schrittmotoren kontinuierlich mit konstanter Geschwindigkeit laufen zu lassen. (Keine Beschleunigung oder Verzögerung wird verwendet).
Sie können den Code kopieren, indem Sie auf den Button oben rechts im Codefeld klicken.
/*
Example sketch to control a 28BYJ-48 stepper motor
with ULN2003 driver board, AccelStepper and Arduino UNO:
continuous rotation. More info: https://www.makerguides.com
*/
// Include the AccelStepper library:
#include "AccelStepper.h"
// Motor pin definitions:
#define motorPin1 8 // IN1 on the ULN2003 driver
#define motorPin2 9 // IN2 on the ULN2003 driver
#define motorPin3 10 // IN3 on the ULN2003 driver
#define motorPin4 11 // IN4 on the ULN2003 driver
// Define the AccelStepper interface type: 4 wire motor in half step mode:
#define MotorInterfaceType 8
// Initialize with pin sequence IN1-IN3-IN2-IN4
AccelStepper stepper = AccelStepper(MotorInterfaceType, motorPin1, motorPin3, motorPin2, motorPin4);
void setup() {
// Set the maximum steps per second:
stepper.setMaxSpeed(1000);
}
void loop() {
// Set the speed of the motor in steps per second:
stepper.setSpeed(500);
// Step the motor with constant speed as set by setSpeed():
stepper.runSpeed();
}
Wie der Code funktioniert:
Der erste Schritt ist wieder das Einbinden der Bibliothek mit #include "AccelStepper.h„.
// Include the AccelStepper library: #include "AccelStepper.h"
Als nächstes definieren wir die ULN2003 zu Arduino Verbindungen.
Die Anweisung #define wird verwendet, um einem konstanten Wert einen Namen zu geben. Der Compiler ersetzt alle Verweise auf diese Konstante durch den definierten Wert, wenn das Programm kompiliert wird. Also überall, wo Sie motorPin1erwähnen, ersetzt der Compiler dies beim Kompilieren durch den Wert 8.
// Motor pin definitions: #define motorPin1 8 // IN1 on the ULN2003 driver #define motorPin2 9 // IN2 on the ULN2003 driver #define motorPin3 10 // IN3 on the ULN2003 driver #define motorPin4 11 // IN4 on the ULN2003 driver
Als nächstes geben wir den Motortyp für die AccelStepper-Bibliothek an. In diesem Fall steuern wir einen 4-Draht-Schrittmotor im Halbschrittmodus, daher setzen wir den Schnittstellentyp auf ‘8’. Wenn Sie den Motor im Vollschrittmodus betreiben möchten (weniger Schritte pro Umdrehung), ändern Sie einfach die 8 auf 4.
// Define the AccelStepper interface type: 4 wire motor in half step mode: #define MotorInterfaceType 8
Danach erstellen Sie eine neue Instanz der AccelStepper-Klasse mit dem passenden Schnittstellentyp und den Verbindungen. Um die korrekte Schrittfolge zu erhalten, müssen die Pins in folgender Reihenfolge gesetzt werden: motorPin1, motorPin3, motorPin2, motorPin4.
In diesem Fall habe ich den Schrittmotor ‘stepper’ genannt, aber Sie können auch andere Namen verwenden, wie ‘z_motor’ oder ‘liftmotor’ usw. AccelStepper liftmotor = AccelStepper(MotorInterfaceType, motorPin1, motorPin3, motorPin2, motorPin4);. Sie können mehrere Schrittmotor-Objekte mit unterschiedlichen Namen und Pins erstellen. So können Sie problemlos 2 oder mehr Schrittmotoren gleichzeitig steuern.
// Initialize with pin sequence IN1-IN3-IN2-IN4 AccelStepper stepper = AccelStepper(MotorInterfaceType, motorPin1, motorPin3, motorPin2, motorPin4);
Im Setup-Teil des Codes definieren wir die maximale Geschwindigkeit in Schritten pro Sekunde mit der Funktion setMaxSpeed(). Geschwindigkeiten über 1000 Schritte pro Sekunde können unzuverlässig sein, daher habe ich dies als Maximum gesetzt. Beachten Sie, dass ich den Namen des Schrittmotors (‘stepper’) angebe, für den ich die maximale Geschwindigkeit definieren möchte. Wenn Sie mehrere Schrittmotoren angeschlossen haben, können Sie für jeden Motor eine andere Geschwindigkeit festlegen: stepper2.setMaxSpeed(500);.
void setup() {
// Set the maximum steps per second:
stepper.setMaxSpeed(1000);
}
Im Loop setzen wir zuerst die Geschwindigkeit, mit der der Motor laufen soll, mit der Funktion setSpeed(). (Sie können dies auch im Setup-Teil des Codes platzieren).
stepper.runSpeed() fragt den Motor ab und wenn ein Schritt fällig ist, führt er diesen aus. Das hängt von der eingestellten Geschwindigkeit und der Zeit seit dem letzten Schritt ab. Wenn Sie die Drehrichtung ändern möchten, können Sie eine negative Geschwindigkeit setzen: stepper.setSpeed(-400); dreht den Motor in die andere Richtung.
void loop() {
// Set the speed of the motor in steps per second:
stepper.setSpeed(500);
// Step the motor with constant speed as set by setSpeed():
stepper.runSpeed();
}
Im Halbschrittmodus dauert eine Umdrehung 4096 Schritte, daher entsprechen 500 Schritte/Sekunde ungefähr 7 U/min.
2. Sketch zur Steuerung der Schritt- oder Umdrehungsanzahl
Mit dem folgenden Sketch können Sie sowohl die Geschwindigkeit, die Drehrichtung als auch die Anzahl der Schritte/Umdrehungen steuern.
In diesem Fall dreht der Schrittmotor 1 Umdrehung im Uhrzeigersinn mit 500 Schritte/Sekunde, dann 1 Umdrehung gegen den Uhrzeigersinn mit 1000 Schritte/Sekunde und zuletzt 2 Umdrehungen im Uhrzeigersinn mit 1000 Schritte/Sekunde.
/* Example sketch to control a 28BYJ-48 stepper motor with
ULN2003 driver board, AccelStepper and Arduino UNO
More info: https://www.makerguides.com */
#include "AccelStepper.h"
// Motor pin definitions:
#define motorPin1 8 // IN1 on the ULN2003 driver
#define motorPin2 9 // IN2 on the ULN2003 driver
#define motorPin3 10 // IN3 on the ULN2003 driver
#define motorPin4 11 // IN4 on the ULN2003 driver
// Define the AccelStepper interface type; 4 wire motor in half step mode:
#define MotorInterfaceType 8
// Initialize with pin sequence IN1-IN3-IN2-IN4 for using the AccelStepper library with 28BYJ-48 stepper motor:
AccelStepper stepper = AccelStepper(MotorInterfaceType, motorPin1, motorPin3, motorPin2, motorPin4);
void setup() {
// Set the maximum steps per second:
stepper.setMaxSpeed(1000);
}
void loop() {
// Set the current position to 0:
stepper.setCurrentPosition(0);
// Run the motor forward at 500 steps/second until the motor reaches 4096 steps (1 revolution):
while (stepper.currentPosition() != 4096) {
stepper.setSpeed(500);
stepper.runSpeed();
}
delay(1000);
// Reset the position to 0:
stepper.setCurrentPosition(0);
// Run the motor backwards at 1000 steps/second until the motor reaches -4096 steps (1 revolution):
while (stepper.currentPosition() != -4096) {
stepper.setSpeed(-1000);
stepper.runSpeed();
}
delay(1000);
// Reset the position to 0:
stepper.setCurrentPosition(0);
// Run the motor forward at 1000 steps/second until the motor reaches 8192 steps (2 revolutions):
while (stepper.currentPosition() != 8192) {
stepper.setSpeed(1000);
stepper.runSpeed();
}
delay(3000);
}
Code-Erklärung:
Der erste Teil des Codes bis zur loop()-Funktion ist identisch mit dem vorherigen Beispiel.
Im Loop verwende ich eine while loop in Kombination mit der currentPosition() Funktion. Zuerst setze ich die aktuelle Position des Schrittmotors mit stepper.setCurrentPosition(0)auf Null.
// Set the current position to 0: stepper.setCurrentPosition(0);
Als nächstes verwenden wir die while-Schleife. Eine while-Schleife läuft kontinuierlich und unendlich, bis der Ausdruck in den Klammern () falsch wird. In diesem Fall prüfe ich, ob die aktuelle Position des Schrittmotors nicht gleich 4096 Schritte ist (!= bedeutet: ist nicht gleich). Solange dies nicht der Fall ist, läuft der Schrittmotor mit der konstanten Geschwindigkeit, die mit setSpeed()eingestellt wurde.
// Run the motor forward at 500 steps/second until the motor reaches 4096 steps (1 revolution):
while (stepper.currentPosition() != 4096) {
stepper.setSpeed(500);
stepper.runSpeed();
}
Im restlichen Loop machen wir genau dasselbe, nur mit anderer Geschwindigkeit und Zielposition.
3. Beispielcode für Beschleunigung und Verzögerung
Mit dem folgenden Sketch können Sie Beschleunigung und Verzögerung zu den Bewegungen des Schrittmotors hinzufügen, ohne komplizierten Code. Der erste Abschnitt dieses Sketches ist wie in Beispiel 1, aber Setup und Loop sind anders.
Der Motor dreht zwei Umdrehungen hin und her mit einer Geschwindigkeit von 1000 Schritte pro Sekunde und einer Beschleunigung von 200 Schritte/Sekunde².
/*
Example sketch to control a 28BYJ-48 stepper motor with ULN2003 driver board,
AccelStepper and Arduino UNO: acceleration and deceleration.
More info: https://www.makerguides.com
*/
#include "AccelStepper.h"
// Motor pin definitions:
#define motorPin1 8 // IN1 on the ULN2003 driver
#define motorPin2 9 // IN2 on the ULN2003 driver
#define motorPin3 10 // IN3 on the ULN2003 driver
#define motorPin4 11 // IN4 on the ULN2003 driver
// Define the AccelStepper interface type; 4 wire motor in half step mode:
#define MotorInterfaceType 8
// Initialize with pin sequence IN1-IN3-IN2-IN4
AccelStepper stepper = AccelStepper(MotorInterfaceType, motorPin1, motorPin3, motorPin2, motorPin4);
void setup() {
// Set the maximum steps per second:
stepper.setMaxSpeed(1000);
// Set the maximum acceleration in steps per second^2:
stepper.setAcceleration(200);
}
void loop() {
// Set target position:
stepper.moveTo(8192);
// Run to position with set speed and acceleration:
stepper.runToPosition();
delay(1000);
// Move back to original position:
stepper.moveTo(0);
// Run to position with set speed and acceleration:
stepper.runToPosition();
delay(1000);
}
Wie der Code funktioniert:
Im Setup müssen wir neben der maximalen Geschwindigkeit auch die Beschleunigung/Verzögerung definieren. Dafür verwenden wir die Funktion setAcceleration().
void setup() {
// Set the maximum steps per second:
stepper.setMaxSpeed(1000);
// Set the maximum acceleration in steps per second^2:
stepper.setAcceleration(200);
}
Im Loop-Teil des Codes habe ich eine andere Methode verwendet, um den Motor eine vorgegebene Anzahl von Schritten drehen zu lassen. Zuerst setze ich die Zielposition mit der Funktion moveTo(). Danach verwenden wir einfach die Funktion runToPosition() , damit der Motor mit der eingestellten Geschwindigkeit und Beschleunigung zur Zielposition läuft. Der Motor wird vor Erreichen der Zielposition abbremsen.
void loop() {
// Set target position:
stepper.moveTo(8192);
// Run to position with set speed and acceleration:
stepper.runToPosition();
delay(1000);
// Move back to original position:
stepper.moveTo(0);
// Run to position with set speed and acceleration:
stepper.runToPosition();
delay(1000);
}
Zum Schluss setzen wir die neue Zielposition wieder auf 0, damit wir zum Ursprung zurückkehren.
Fazit
In diesem Artikel habe ich gezeigt, wie Sie einen 28BYJ-48 Schrittmotor mit einem ULN2003 Treiber und Arduino steuern können. Wir haben 4 Beispiele betrachtet, die sowohl die Stepper- als auch die AccelStepper-Bibliothek verwenden. Ich hoffe, Sie fanden es nützlich und informativ.
Wenn Sie mehr über die Steuerung größerer Schrittmotoren mit mehr Drehmoment und höherer Geschwindigkeit erfahren möchten, schauen Sie sich die untenstehenden Artikel an. Dort zeige ich, wie man NEMA 17 Schrittmotoren mit Treibern wie dem A4988 steuert.
Weitere Schrittmotor-Tutorials:
- Control a stepper motor with L298N motor driver and Arduino
- How to control a Stepper Motor with Arduino Motor Shield Rev3
- How to control a stepper motor with A4988 driver and Arduino
- How to control a stepper motor with DRV8825 driver and Arduino
Wenn Sie Fragen haben, hinterlassen Sie bitte einen Kommentar unten.
