Dieser Artikel enthält alles, was du über die Steuerung eines Schrittmotors mit dem DRV8825 stepper motor driver und Arduino wissen musst. Ich habe ein Schaltbild, eine Anleitung zum Einstellen der Strombegrenzung und viele Beispielcodes beigefügt.
Obwohl du diesen Treiber ohne Arduino-Bibliothek verwenden kannst, empfehle ich dir dringend, dir auch den Beispielcode für die AccelStepper-Bibliothek am Ende dieses Tutorials anzusehen. Diese Bibliothek ist recht einfach zu verwenden und kann die Leistung deiner Hardware deutlich verbessern.
Materialien
Hardware-Komponenten
 | DRV8825 stepper motor driver | × 1 | Amazon |
 | NEMA 17 stepper motor | × 1 | Amazon |
 | Arduino Uno Rev3 | × 1 | Amazon |
| Power supply (8,2-45 V) | × 1 | Amazon | |
| Breadboard | × 1 | Amazon | |
 | Capacitor (100 µF) | × 1 | Amazon |
| Jumper wires | ~ 10 | Amazon | |
| USB cable type A/B | × 1 | Amazon |
Ich verwende diesen Treiber gerne in Kombination mit einem CNC-shield oder expansion board. Ein solches Shield enthält bereits Kondensatoren und bietet eine einfache Möglichkeit, die Mikroschrittauflösung einzustellen. Es erleichtert die Verkabelung erheblich und ist eine tolle Option, wenn du eine dauerhaftere Lösung als ein Steckbrett benötigst.
Werkzeuge
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.
Über den Treiber
Im Herzen des DRV8825-Treibers befindet sich ein Chip von Texas Instruments: der DRV8825 Stepper Motor Controller IC. Dieser integrierte Motortreiber macht die Ansteuerung mit einem Mikrocontroller sehr einfach, da du nur zwei Pins benötigst, um sowohl die Geschwindigkeit als auch die Drehrichtung des Schrittmotors zu steuern.
Der Treiber hat eine maximale Ausgangskapazität von 45 V und ± 2 A, was ideal ist, um kleine bis mittelgroße Schrittmotoren wie einen NEMA 17 bipolaren Schrittmotor anzutreiben.
Wenn du größere Schrittmotoren wie einen NEMA 23 steuern möchtest, schau dir den TB6600 Schrittmotortreiber an. Dieser Treiber kann mit dem gleichen Code wie der A4988 verwendet werden und hat eine Stromstärke von 3,5 A.
Der DRV8825-Treiberchip verfügt über mehrere integrierte Schutzfunktionen wie Überstrom-, Kurzschluss-, Unterspannungssperre und Übertemperaturschutz. Weitere Spezifikationen findest du in der folgenden Tabelle.
DRV8825 Spezifikationen
| Minimale Betriebsspannung | 8,2 V |
| Maximale Betriebsspannung | 45 V |
| Dauerstrom pro Phase | 1,5 A |
| Maximalstrom pro Phase | 2,2 A |
| Minimale Logikspannung | 2,5 V |
| Maximale Logikspannung | 5,25 V |
| Mikroschrittauflösung | Voll, 1/2, 1/4, 1/8, 1/16 und 1/32 |
| Verpolungsschutz? | Nein |
| Abmessungen | 15,5 × 20,5 mm (0,6″ × 0,8″) |
| Kosten | Check price |
Weitere Informationen findest du im Datenblatt hier.
Unterschiede zwischen DRV8825 und A4988
Der DRV8825 ist dem A4988 sehr ähnlich, aber es gibt einige wichtige Unterschiede:
- Der DRV8825 bietet 1/32 Mikroschritte, während der A4988 nur bis 1/16-Schritt geht. Höhere Mikroschrittauflösungen sorgen für einen ruhigeren und leiseren Betrieb, sind aber nicht immer notwendig.
- Das Potentiometer zur Strombegrenzung befindet sich an einer anderen Stelle.
- Das Verhältnis zwischen Referenzspannung und Strombegrenzung ist unterschiedlich.
- Der DRV8825 benötigt eine minimale STEP-Pulsdauer von 1,9 µs, der A4988 benötigt mindestens 1 µs.
- Der DRV8825 kann mit einer höheren Motorspannung betrieben werden (45 V vs. 35 V). Das macht ihn weniger anfällig für Schäden durch LC-Spannungsspitzen.
- Der DRV8825 kann etwas mehr Strom liefern als der A4988, ohne zusätzliche Kühlung.
Beachte, dass das Pinout des DRV8825 genau das gleiche ist wie beim A4988, sodass er als direkter Ersatz verwendet werden kann!
Mikroschritteinstellungen
Schrittmotoren haben typischerweise eine Schrittgröße von 1,8° oder 200 Schritte pro Umdrehung, dies bezieht sich auf Vollschritte. Ein Mikroschritt-Treiber wie der DRV8825 ermöglicht höhere Auflösungen, indem Zwischenpositionen angesteuert werden. Dies wird erreicht, indem die Spulen mit Zwischenstromstärken versorgt werden.
Zum Beispiel liefert der Viertelschrittmodus bei einem 200-Schritte-pro-Umdrehung-Motor 800 Mikroschritte pro Umdrehung, indem vier verschiedene Stromstufen verwendet werden.
Die Auflösungsauswahl-Pins (M0, M1 und M2) ermöglichen die Auswahl einer von sechs Schrittauflösungen gemäß der folgenden Tabelle.
| M0 | M1 | M2 | Mikroschrittauflösung |
|---|---|---|---|
| Low | Low | Low | Vollschritt |
| High | Low | Low | 1/2 Schritt |
| Low | High | Low | 1/4 Schritt |
| High | High | Low | 1/8 Schritt |
| Low | Low | High | 1/16 Schritt |
| High | Low | High | 1/32 Schritt |
| Low | High | High | 1/32 Schritt |
| High | High | High | 1/32 Schritt |
Alle drei Eingänge haben interne 100 kΩ Pull-Down-Widerstände, sodass das Nichtanschließen der drei Mikroschrittauswahl-Pins zum Vollschrittmodus führt.
Ich verwende oft ein CNC-shield oder Erweiterungsboard in Kombination mit diesen Treibern. Das Erweiterungsboard hat 3 DIP-Schalter, um M0 – M2 auf High oder Low zu setzen, und auf dem CNC-Shield kannst du Jumper installieren. Wenn du den Treiber mit einem Steckbrett verwendest, kannst du einfach Jumperkabel verwenden, um die Auswahlpins mit 5 V zu verbinden (also auf HIGH zu setzen).
Verkabelung – Anschluss des DRV8825 an Arduino und Schrittmotor
Das obige Schaltbild zeigt, wie du den DRV8825-Treiber mit einem Schrittmotor und dem Arduino verbindest.
Die Anschlüsse sind auch in der folgenden Tabelle aufgeführt:
DRV8825 Anschlüsse
| DRV8825 | Anschluss |
|---|---|
| VMOT | 8,2-45 V |
| GND | Motormasse |
| SLP | 5 V |
| RST | 5 V |
| GND | Logikmasse |
| STP | Pin 3 |
| DIR | Pin 2 |
| A1, A2, B1, B2 | Schrittmotor |
- Die Motorversorgung wird an GND und VMOT (oben rechts) angeschlossen.
- Die beiden Spulen des Schrittmotors werden an A1, A2 und B1, B2 angeschlossen (siehe unten).
- Der GND-Pin (unten rechts) ist mit dem Masse-Pin des Mikrocontrollers verbunden und VDD ist mit 5 V verbunden.
- Die STP (Step) und DIR (Direction) Pins sind mit den digitalen Pins 3 bzw. 2 verbunden. Du kannst auch andere digitale Pins wählen, aber das sind die, die ich für dieses Tutorial und den Beispielcode verwendet habe.
- Du musst RST (Reset) und SLP (Sleep) mit 5 V verbinden, sonst schaltet sich der Treiber nicht ein.
- Der EN (Enable) Pin kann unverbunden bleiben, er ist standardmäßig auf Low gezogen. Wenn dieser Pin auf High gesetzt wird, ist der Treiber deaktiviert.
- Der DRV8825 verfügt außerdem über einen FAULT-Ausgang, der auf Low geht, wenn die H-Brücken-FETs aufgrund von Überstromschutz oder thermischem Abschalten deaktiviert werden. Dieser Pin bleibt in diesem Tutorial unverbunden.
Im weiteren Verlauf dieses Tutorials habe ich M0, M1 und M3 unverbunden gelassen, sodass der Treiber im Vollschrittmodus arbeitet. Das erleichtert das Erklären des Codes. Normalerweise würde ich 1/16 oder 1/32 Mikroschritte verwenden und die entsprechenden Pins mit 5 V verbinden (siehe Tabelle in der Einleitung).
Warnung
Das DRV8825-Trägerboard verwendet Keramikkondensatoren mit niedrigem ESR, was es anfällig für zerstörerische LC-Spannungsspitzen macht, besonders bei Verwendung von längeren Stromkabeln als ein paar Zentimeter.
Um den Treiber zu schützen, kannst du einen Elektrolytkondensator zwischen VMOT und GND anschließen. Pololu empfiehlt einen Kondensator von 47 µF oder mehr (ich habe einen 100 µF Kondensator verwendet).
Wie finde ich die richtige Verkabelung für meinen Schrittmotor?
Wenn du kein Datenblatt für deinen Schrittmotor findest, kann es schwierig sein, die richtige Verkabelung herauszufinden. Ich verwende folgenden Trick, um 4-adrige bipolare Schrittmotoren richtig anzuschließen:
Das Einzige, was du identifizieren musst, sind die zwei Drahtpaare, die mit den beiden Spulen des Motors verbunden sind. Die Drähte einer Spule werden an A1 und A2 angeschlossen, die andere an B1 und B2, die Polung spielt keine Rolle.
Um die beiden Drähte einer Spule zu finden, gehe wie folgt vor, während der Motor nicht angeschlossen ist:
- Versuche, die Welle des Schrittmotors von Hand zu drehen und achte darauf, wie schwer sie sich dreht.
- Nimm nun ein beliebiges Drahtpaar vom Motor und berühre die blanken Enden zusammen.
- Versuche erneut, die Welle des Schrittmotors zu drehen.
Wenn du starken Widerstand spürst, hast du ein Drahtpaar derselben Spule gefunden. Wenn sich die Welle frei drehen lässt, probiere ein anderes Drahtpaar. Verbinde nun die beiden Spulen mit den Pins, die im Schaltplan oben gezeigt sind.
Wie stelle ich die Strombegrenzung ein?
Bevor du mit dem Programmieren deines Arduino beginnst und den Treiber verwendest, gibt es eine sehr wichtige Sache, die viele vergessen: die Strombegrenzung einstellen!
Dieser Schritt ist nicht kompliziert, aber absolut notwendig, um deinen Schrittmotor und den Treiber zu schützen. Wenn du keine passende Strombegrenzung einstellst, kann dein Motor mehr Strom ziehen, als er oder dein Treiber verträgt, was wahrscheinlich zu Schäden an einem oder beiden führt.
Um die Strombegrenzung einzustellen, musst du eine Referenzspannung messen und das Potentiometer auf der Platine entsprechend anpassen. Du benötigst ein small screwdriver, ein multimeter zum Messen der Referenzspannung und Krokodilklemmen (optional, aber sehr praktisch).
Um die Referenzspannung zu messen, muss der Treiber mit Strom versorgt werden. Der DRV8825 benötigt nur Strom über VMOT (8,2-45 V) und du musst 5 V an RST und SLP anlegen, sonst schaltet sich der Treiber nicht ein. Es ist am besten, den Schrittmotor währenddessen zu trennen.
Wenn du den Treiber bereits wie oben gezeigt verkabelt hast, kannst du den Arduino angeschlossen lassen, um die RST- und SLP-Pins mit Strom zu versorgen.
| DRV8825 | Anschluss |
|---|---|
| VMOT | 8,2-45 V |
| GND | Motormasse |
| SLP | 5 V |
| RST | 5 V |
| GND | Logikmasse |
Formel zur Strombegrenzung
Der nächste Schritt ist, die Strombegrenzung mit folgender Formel zu berechnen:
Strombegrenzung = Vref × 2
Das bedeutet, dass für eine Strombegrenzung von 1 A der Vref 0,5 V betragen sollte.
Um die richtige Strombegrenzung auszuwählen, schaue im Datenblatt deines Schrittmotors nach. Wenn du die Stromaufnahme deines Motors nicht findest, empfehle ich, mit 1 A zu beginnen. Du kannst sie später immer erhöhen, wenn dein Motor/Treiber Schritte verliert.
Bonusinfo: Im Vollschrittmodus ist der Strom durch jede Spule auf etwa 70 % der eingestellten Strombegrenzung begrenzt. Das bedeutet, du müsstest die Strombegrenzung um 40 % höher einstellen, also 1,4 A im Vollschrittmodus. Bei Mikroschritten gilt die obige Formel.
Wenn dein Motor viel Lärm macht, versuche, die Strombegrenzung zu senken. Es ist am besten, die Strombegrenzung gerade so hoch einzustellen, dass der Motor keine Schritte verliert.
Vref messen
Jetzt musst du die Referenzspannung (Vref) zwischen den zwei auf dem Bild markierten Punkten (GND und Potentiometer) messen und auf den berechneten Wert einstellen.
Ich empfehle, Krokodilklemmen an den Schraubendreher zu klemmen, um die Strombegrenzung einzustellen. So kannst du das Potentiometer drehen und gleichzeitig die Referenzspannung messen.
Hinweis: Es gibt eine andere Methode, die Strombegrenzung zu messen, indem man direkt den Stromverbrauch des Schrittmotors misst. Persönlich finde ich die oben beschriebene Methode viel einfacher.
Pololu erwähnt auf seiner Webseite Folgendes:
Hinweis: Der Spulenstrom kann sich stark vom Strom der Stromversorgung unterscheiden, daher solltest du den Strom an der Stromversorgung nicht zur Einstellung der Strombegrenzung verwenden. Der geeignete Ort für dein Amperemeter ist in Reihe mit einer der Spulen deines Schrittmotors.
Pololu
FAQ zur Strombegrenzung
Muss der Schrittmotor angeschlossen sein oder nicht?
Nein, du musst den Schrittmotor beim Einstellen der Strombegrenzung nicht anschließen. Um auf Nummer sicher zu gehen, trenne deinen Motor, da er manchmal die Vref-Messung stört.
Muss ich den Motor durch Ausführen des Arduino-Motorsketches drehen?
Nein, siehe Frage oben.
Muss ich das Potentiometer im Uhrzeigersinn oder gegen den Uhrzeigersinn drehen, um Vref zu erhöhen?
Das hängt vom Hersteller des Treibers ab. Wenn du ein originales Pololu Breakout-Board des DRV8825 oder A4988 hast, drehst du das Potentiometer im Uhrzeigersinn, um Vref zu erhöhen, und gegen den Uhrzeigersinn, um es zu verringern.
Kühlung des Treibers
Der DRV8825-Treiber-IC hat eine maximale Stromstärke von 2,5 A pro Spule, aber ohne Kühlkörper kann er nur etwa 1,5 A pro Spule liefern, bevor er überhitzt.
Der Treiber wird normalerweise mit einem kleinen, selbstklebenden Kühlkörper geliefert, den ich dir empfehle sofort zu montieren. Du kannst auch viele kleine Kühlkörper günstig bei Amazon kaufen.
Grundlegender Arduino-Beispielcode zur Steuerung eines Schrittmotors
Nachdem du den Treiber verkabelt und die Strombegrenzung eingestellt hast, ist es Zeit, den Arduino mit dem Computer zu verbinden und Code hochzuladen. Du kannst den folgenden Beispielcode mit dem Arduino IDE hochladen. Für dieses spezielle Beispiel musst du keine Bibliotheken installieren.
Dieser Sketch steuert sowohl die Geschwindigkeit, die Anzahl der Umdrehungen als auch die Drehrichtung des Schrittmotors.
Du kannst den Code kopieren, indem du auf den Button oben rechts im Codefeld klickst.
/* Example sketch to control a stepper motor with
A4988/DRV8825 stepper motor driver and
Arduino without a library.
More info: https://www.makerguides.com */
// Define stepper motor connections and steps per revolution:
#define dirPin 2
#define stepPin 3
#define stepsPerRevolution 200
void setup() {
// Declare pins as output:
pinMode(stepPin, OUTPUT);
pinMode(dirPin, OUTPUT);
}
void loop() {
// Set the spinning direction clockwise:
digitalWrite(dirPin, HIGH);
// Spin the stepper motor 1 revolution slowly:
for (int i = 0; i < stepsPerRevolution; i++) {
// These four lines result in 1 step:
digitalWrite(stepPin, HIGH);
delayMicroseconds(2000);
digitalWrite(stepPin, LOW);
delayMicroseconds(2000);
}
delay(1000);
// Set the spinning direction counterclockwise:
digitalWrite(dirPin, LOW);
// Spin the stepper motor 1 revolution quickly:
for (int i = 0; i < stepsPerRevolution; i++) {
// These four lines result in 1 step:
digitalWrite(stepPin, HIGH);
delayMicroseconds(1000);
digitalWrite(stepPin, LOW);
delayMicroseconds(1000);
}
delay(1000);
// Set the spinning direction clockwise:
digitalWrite(dirPin, HIGH);
// Spin the stepper motor 5 revolutions fast:
for (int i = 0; i < 5 * stepsPerRevolution; i++) {
// These four lines result in 1 step:
digitalWrite(stepPin, HIGH);
delayMicroseconds(500);
digitalWrite(stepPin, LOW);
delayMicroseconds(500);
}
delay(1000);
// Set the spinning direction counterclockwise:
digitalWrite(dirPin, LOW);
//Spin the stepper motor 5 revolutions fast:
for (int i = 0; i < 5 * stepsPerRevolution; i++) {
// These four lines result in 1 step:
digitalWrite(stepPin, HIGH);
delayMicroseconds(500);
digitalWrite(stepPin, LOW);
delayMicroseconds(500);
}
delay(1000);
}
So funktioniert der Code:
Der Sketch beginnt mit der Definition der Step- und Direction-Pins. Ich habe sie an Arduino Pin 3 und 2 angeschlossen.
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 du dirPinerwähnst, ersetzt der Compiler es beim Kompilieren durch den Wert 2.
Ich habe auch eine stepsPerRevolution Konstante definiert. Da ich den Treiber auf Vollschrittmodus eingestellt habe, habe ich ihn auf 200 Schritte pro Umdrehung gesetzt. Ändere diesen Wert, wenn dein Setup anders ist.
// Define stepper motor connections and steps per revolution: #define dirPin 2 #define stepPin 3 #define stepsPerRevolution 200
Im setup() Abschnitt des Codes werden alle Motorsteuerungs-Pins als digitale OUTPUTs mit der Funktion pinMode()deklariert.
void setup() {
// Declare pins as output:
pinMode(stepPin, OUTPUT);
pinMode(dirPin, OUTPUT);
}
Im loop() Abschnitt lassen wir den Motor eine Umdrehung langsam im Uhrzeigersinn und eine Umdrehung schnell gegen den Uhrzeigersinn drehen. Danach dreht der Motor 5 Umdrehungen in jede Richtung mit hoher Geschwindigkeit. Wie steuerst du also Geschwindigkeit, Drehrichtung und Anzahl der Umdrehungen?
// Set the spinning direction clockwise:
digitalWrite(dirPin, HIGH);
// Spin the stepper motor 1 revolution slowly:
for(int i = 0; i < stepsPerRevolution; i++)
{
// These four lines result in 1 step:
digitalWrite(stepPin, HIGH);
delayMicroseconds(2000);
digitalWrite(stepPin, LOW);
delayMicroseconds(2000);
}
Drehrichtung steuern:
Um die Drehrichtung des Schrittmotors zu steuern, setzen wir den DIR (Direction) Pin entweder auf HIGH oder LOW. Dafür verwenden wir die Funktion digitalWrite(). Je nachdem, wie du den Schrittmotor angeschlossen hast, bewirkt das Setzen des DIR-Pins auf HIGH, dass sich der Motor im Uhrzeigersinn oder gegen den Uhrzeigersinn dreht.
Anzahl der Schritte oder Umdrehungen steuern:
In diesem Beispielsketch steuern die for loops die Anzahl der Schritte, die der Schrittmotor ausführt. Der Code innerhalb der for-Schleife bewirkt einen Schritt des Motors. Da der Code in der Schleife 200-mal ausgeführt wird (stepsPerRevolution), ergibt das eine Umdrehung. In den letzten zwei Schleifen wird der Code innerhalb der for-Schleife 1000-mal ausgeführt, was 1000 Schritten oder 5 Umdrehungen entspricht.
Beachte, dass du den zweiten Term in der for-Schleife auf jede gewünschte Schrittzahl ändern kannst. for(int i = 0; i < 100; i++) würde 100 Schritte oder eine halbe Umdrehung ergeben.
Geschwindigkeit steuern:
Die Geschwindigkeit des Schrittmotors wird durch die Frequenz der Impulse bestimmt, die wir an den STEP-Pin senden. Je höher die Frequenz, desto schneller läuft der Motor. Du kannst die Frequenz der Impulse ändern, indem du delayMicroseconds() im Code änderst. Je kürzer die Verzögerung, desto höher die Frequenz und desto schneller läuft der Motor.
AccelStepper Bibliothek Tutorial
Die von Mike McCauley geschriebene AccelStepper-Bibliothek ist eine großartige Bibliothek für dein Projekt. Ein Vorteil ist, dass sie Beschleunigung und Verzögerung unterstützt, aber sie bietet noch viele weitere nützliche Funktionen.
Du kannst die Bibliothek installieren, indem du zu Tools > Manage Libraries… gehst oder Strg + Shift + I unter Windows zu drückst. Der Library Manager öffnet sich und aktualisiert die Liste der installierten Bibliotheken.
Du kannst nach ‘accelstepper’ suchen und die Bibliothek von Mike McCauley auswählen. Wähle die neueste Version und klicke 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).
/* Example sketch to control a stepper motor with
DRV8825 stepper motor driver, AccelStepper library
and Arduino: continuous rotation.
More info: https://www.makerguides.com */
#include "AccelStepper.h"
// Define stepper motor connections and motor interface type. Motor interface type must be set to 1 when using a driver:
#define dirPin 2
#define stepPin 3
#define motorInterfaceType 1
// Create a new instance of the AccelStepper class:
AccelStepper stepper = AccelStepper(motorInterfaceType, stepPin, dirPin);
void setup() {
// Set the maximum speed in steps per second:
stepper.setMaxSpeed(1000);
}
void loop() {
// Set the speed in steps per second:
stepper.setSpeed(400);
// Step the motor with a constant speed as set by setSpeed():
stepper.runSpeed();
}
So funktioniert der Code:
Der erste Schritt ist, die Bibliothek mit #include "AccelStepper.h"einzubinden.
#include "AccelStepper.h"
Der nächste Schritt ist, die DRV8825-zu-Arduino-Verbindungen und den Motortyp zu definieren. Der Motortyp muss auf 1 gesetzt werden, wenn ein Step- und Direction-Treiber verwendet wird.
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 du dirPinerwähnst, ersetzt der Compiler es beim Kompilieren durch den Wert 2.
// Define stepper motor connections and motor interface type. Motor interface type must be set to 1 when using a driver: #define dirPin 2 #define stepPin 3 #define motorInterfaceType 1
Als nächstes musst du eine neue Instanz der AccelStepper-Klasse mit dem passenden Motortyp und den Verbindungen erstellen.
In diesem Fall habe ich den Schrittmotor ‘stepper’ genannt, aber du kannst auch andere Namen verwenden, wie ‘z_motor’ oder ‘liftmotor’ usw. AccelStepper liftmotor = AccelStepper(motorInterfaceType, stepPin, dirPin);. Der Name, den du dem Schrittmotor gibst, wird später verwendet, um Geschwindigkeit, Position und Beschleunigung für diesen Motor einzustellen. Du kannst mehrere Instanzen der AccelStepper-Klasse mit unterschiedlichen Namen und Pins erstellen. So kannst du problemlos 2 oder mehr Schrittmotoren gleichzeitig steuern.
// Create a new instance of the AccelStepper class: AccelStepper stepper = AccelStepper(motorInterfaceType, stepPin, dirPin);
Im setup() Abschnitt des Codes definieren wir die maximale Geschwindigkeit in Schritten pro Sekunde. Geschwindigkeiten über 1000 Schritte pro Sekunde können unzuverlässig sein, daher habe ich das als Maximum gesetzt. Beachte, dass ich den Namen des Schrittmotors (‘stepper’) angebe, für den ich die maximale Geschwindigkeit festlegen möchte. Wenn du mehrere Schrittmotoren angeschlossen hast, kannst du für jeden Motor eine andere Geschwindigkeit angeben:
void setup() {
// Set the maximum speed in steps per second:
stepper.setMaxSpeed(1000);
stepper2.setMaxSpeed(500);
}
Im loop() setzen wir zuerst die Geschwindigkeit, mit der der Motor laufen soll. Dafür verwenden wir die Funktion setSpeed(). (Du kannst das auch im Setup-Abschnitt des Codes platzieren).
stepper.runSpeed() fragt den Motor ab und wenn ein Schritt fällig ist, führt er einen Schritt aus. Das hängt von der eingestellten Geschwindigkeit und der Zeit seit dem letzten Schritt ab. Wenn du die Drehrichtung ändern möchtest, kannst du eine negative Geschwindigkeit setzen: stepper.setSpeed(-400); dreht den Motor in die andere Richtung.
void loop() {
// Set the speed in steps per second:
stepper.setSpeed(400);
// Step the motor with a constant speed as set by setSpeed():
stepper.runSpeed();
}
2. Beispielcode zur Steuerung der Schrittzahl oder Umdrehungen
Um den Motor eine bestimmte Anzahl von Schritten drehen zu lassen, verwende ich gerne eine while loop in Kombination mit stepper.currentPosition(). Du kannst den folgenden Beispielcode verwenden, um den Motor hin und her laufen zu lassen.
/*Example sketch to control a stepper motor
with DRV8825 stepper motor driver, AccelStepper library
and Arduino: number of steps or revolutions.
More info: https://www.makerguides.com */
#include "AccelStepper.h"
// Define stepper motor connections and motor interface type. Motor interface type must be set to 1 when using a driver:
#define dirPin 2
#define stepPin 3
#define motorInterfaceType 1
// Create a new instance of the AccelStepper class:
AccelStepper stepper = AccelStepper(motorInterfaceType, stepPin, dirPin);
void setup() {
// Set the maximum speed in steps per second:
stepper.setMaxSpeed(1000);
}
void loop() {
// Set the current position to 0:
stepper.setCurrentPosition(0);
// Run the motor forward at 200 steps/second until the motor reaches 400 steps (2 revolutions):
while(stepper.currentPosition() != 400)
{
stepper.setSpeed(200);
stepper.runSpeed();
}
delay(1000);
// Reset the position to 0:
stepper.setCurrentPosition(0);
// Run the motor backwards at 600 steps/second until the motor reaches -200 steps (1 revolution):
while(stepper.currentPosition() != -200)
{
stepper.setSpeed(-600);
stepper.runSpeed();
}
delay(1000);
// Reset the position to 0:
stepper.setCurrentPosition(0);
// Run the motor forward at 400 steps/second until the motor reaches 600 steps (3 revolutions):
while(stepper.currentPosition() != 600)
{
stepper.setSpeed(400);
stepper.runSpeed();
}
delay(3000);
}
Code-Erklärung:
Der erste Teil des Codes bis zum loop()-Abschnitt ist genau derselbe wie im vorherigen Beispiel.
Im loop verwende ich eine while-Schleife 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);
Dann 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 400 Schritte ist (!= bedeutet: ist nicht gleich). Solange das zutrifft, läuft der Schrittmotor mit der konstanten Geschwindigkeit, die mit setSpeed()gesetzt wurde.
// Run the motor forward at 200 steps/second until the motor reaches 400 steps (2 revolutions):
while(stepper.currentPosition() != 400)
{
stepper.setSpeed(200);
stepper.runSpeed();
}
Im Rest der Schleife machen wir genau dasselbe, nur mit anderer Geschwindigkeit und Zielposition.
3. Beispielcode für Beschleunigung und Verzögerung
Mit dem folgenden Sketch kannst du Beschleunigung und Verzögerung zu den Bewegungen des Schrittmotors hinzufügen, ohne komplizierten Code. Im folgenden Beispiel läuft der Motor mit 200 Schritten pro Sekunde und einer Beschleunigung von 30 Schritten pro Sekunde² hin und her.
/* Example sketch to control a stepper motor
with DRV8825 stepper motor driver, AccelStepper library
and Arduino: acceleration and deceleration.
More info: https://www.makerguides.com */
#include "AccelStepper.h"
// Define stepper motor connections and motor interface type. Motor interface type must be set to 1 when using a driver:
#define dirPin 2
#define stepPin 3
#define motorInterfaceType 1
// Create a new instance of the AccelStepper class:
AccelStepper stepper = AccelStepper(motorInterfaceType, stepPin, dirPin);
void setup() {
// Set the maximum speed and acceleration:
stepper.setMaxSpeed(200);
stepper.setAcceleration(30);
}
void loop() {
// Set the target position:
stepper.moveTo(600);
// Run to target position with set speed and acceleration/deceleration:
stepper.runToPosition();
delay(1000);
// Move back to zero:
stepper.moveTo(0);
stepper.runToPosition();
delay(1000);
}
Code-Erklärung:
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 speed and acceleration:
stepper.setMaxSpeed(200);
stepper.setAcceleration(30);
}
Im loop-Abschnitt habe ich eine andere Methode verwendet, um den Motor eine vorgegebene Schrittzahl drehen zu lassen. Die Funktion stepper.moveTo() wird verwendet, um die Zielposition einzustellen. Die Funktion stepper.runToPostion() bewegt den Motor (mit Beschleunigung/Verzögerung) zur Zielposition und blockiert, bis diese erreicht ist. Da diese Funktion blockierend ist, solltest du sie nicht verwenden, wenn du gleichzeitig andere Dinge steuern musst.
// Set the target position: stepper.moveTo(600); // Run to target position with set speed and acceleration/deceleration: stepper.runToPosition();
Fazit
In diesem Artikel habe ich dir gezeigt, wie du einen Schrittmotor mit dem DRV8825 Schrittmotortreiber und Arduino steuerst. Wenn du mehr über andere Schrittmotortreiber erfahren möchtest, könnten die untenstehenden Artikel hilfreich sein:
- How to control a stepper motor with A4988 driver and Arduino
- 28BYJ-48 Stepper Motor with ULN2003 Driver and Arduino Tutorial
- How to control a Stepper Motor with Arduino Motor Shield Rev3
- TB6600 Stepper Motor Driver with Arduino Tutorial
Und wenn du Kommentare hast, kannst du sie gerne im Kommentarbereich hinterlassen.
