Schrittmotoren mit Arduino beherrschen:Der umfassende Leitfaden

In diesem Tutorial erfahren wir alles, was wir über die Steuerung von Schrittmotoren mit Arduino wissen müssen. Wir behandeln die Steuerung eines NEMA17-Schrittmotors in Kombination mit einem A4988, einem DRV8825 und einem TMC2208-Schritttreiber.

Diese Kombination aus Schrittmotoren und Treibern wird in unzähligen Anwendungen eingesetzt, bei denen eine Positionskontrolle erforderlich ist, wie zum Beispiel 3D-Drucker, CNC-Maschinen, Robotik, Automatisierungsmaschinen und so weiter.

Ich habe es selbst bereits in vielen meiner Arduino-Projekte verwendet, wie zum Beispiel im Folgenden:

• DIY-Kamera-Slider
• 3D-Drahtbiegemaschine
• DIY-Schaumstoffschneidemaschine
• DIY-Lasergravierer
• Stiftplotter mit automatischem Stiftwechsler
• SCARA-Roboterarm

Ich werde im Detail erklären, wie sie funktionieren, wie man Schrittmotoren mit Arduino verbindet, wie man die Strombegrenzung der Treiber einstellt und wie man sie mit oder ohne Arduino-Bibliothek programmiert. Außerdem zeige ich Ihnen, wie wir mit einem Arduino-CNC-Shield für jede Art von Arduino-Projekt ganz einfach mehrere Schrittmotoren steuern können. 

In diesem Tutorial gibt es also einiges zu besprechen. Sie können sich das folgende Video ansehen oder das schriftliche Tutorial unten lesen, das auch alle Beispielcodes und Schaltpläne enthält.

Was ist ein Schrittmotor und wie funktioniert er?

Ich beginne damit, kurz zu erklären, was ein Schrittmotor ist und wie er funktioniert, da dies uns hilft, alles andere in diesem Tutorial besser zu verstehen. 

Ein Schrittmotor ist ein einzigartiger Typ eines bürstenlosen Gleichstrommotors, dessen Position auch ohne Rückmeldung präzise gesteuert werden kann.

Das Funktionsprinzip eines Schrittmotors basiert auf Magnetfeldern. Es besteht aus zwei Hauptkomponenten, einem Stator und einem Rotor. Der Rotor ist normalerweise ein Permanentmagnet und ist von einigen Spulen auf dem Stator umgeben.

Wenn wir die Spulen bestromen oder Strom durch sie fließen lassen, werden im Stator bestimmte Magnetfelder erzeugt, die den Rotor entweder anziehen oder abstoßen. Indem wir die Spulen Schritt für Schritt, eine nach der anderen, in einer bestimmten Reihenfolge aktivieren, können wir eine kontinuierliche Bewegung des Rotors erreichen, ihn aber auch an jeder Position stoppen lassen.

Deshalb werden diese Motoren auch Schrittmotoren genannt, sie bewegen sich in diskreten Schritten. 

Durch die Erhöhung der Anzahl der Magnetpole am Rotor können wir die Anzahl der möglichen Stopppositionen erhöhen und somit die Auflösung bzw. die Präzision des Motors erhöhen. Bitte beachten Sie, dass dies nur eine grundlegende Erklärung ist. Weitere Einzelheiten finden Sie in meinem Tutorial zur Funktionsweise von Schrittmotoren. 

Ein typischer Schrittmotor, beispielsweise ein NEMA17, verfügt über 50 Stopppunkte oder Schritte auf dem Rotor. Andererseits kann der Stator über mehrere Spulen verfügen, die in zwei Phasen angeordnet sind und vier verschiedene Ausrichtungen oder Positionen des Magnetfelds bereitstellen.

Die 50 Schritte des Rotors multipliziert mit den 4 verschiedenen Ausrichtungen des Magnetfelds ergeben also insgesamt 200 Schritte für eine vollständige Drehung. Oder wenn wir 360 Grad durch 200 Schritte teilen, ist das eine Auflösung von 1,8 Grad pro Schritt.

Ich habe erwähnt, dass die Statorspulen in zwei Phasen organisiert sind, und das können wir auch erkennen, wenn wir uns die Anzahl der Drähte eines Schrittmotors ansehen. Es verfügt über vier Drähte, zwei für jede Phase. Die vier verschiedenen Ausrichtungen des Magnetfelds sind möglich, da wir den Strom in beide Richtungen durch die Phasen fließen lassen können.

Es gibt auch Schrittmotoren mit 5, 6 oder sogar 8 Drähten, aber sie arbeiten immer noch auf zwei Phasen oder wir steuern sie mit nur vier Anschlüssen.

Die Sache mit ihnen ist, dass sie unterschiedliche Leistungsmerkmale bieten können, wie z. B. mehr Drehmoment oder mehr Geschwindigkeit, je nachdem, wie wir diese Drähte an die vier Steuerklemmen anschließen.

Mit dieser kurzen Erklärung verstehen wir jedoch, dass wir zum Antrieb eines Schrittmotors nicht einfach Strom anschließen können, da sonst nichts passieren wird. Stattdessen müssen wir die beiden Motorphasen in beide Richtungen mit Strom versorgen und sie in einer bestimmten Reihenfolge und in einer zeitlichen Abfolge aktivieren oder ihnen Impulse senden. Deshalb brauchen wir Treiber zur Steuerung von Schrittmotoren. 

Es gibt viele Arten und Größen von Treibern, entsprechend den vielen Arten und Größen von Schrittmotoren. Das grundlegende Funktionsprinzip aller Modelle besteht jedoch darin, dass sie über zwei H-Brücken verfügen, die eine Bestromung der Motorphasen in beide Richtungen ermöglichen.

Natürlich verfügen sie über viele weitere Funktionen wie Mikroschritte, Strombegrenzung usw., die es uns ermöglichen, die Schrittmotoren einfach zu steuern, was der eigentliche Zweck dieser Motoren ist.

So steuern Sie den NEMA17-Schrittmotor mit Arduino und dem A4988-Schritttreiber

Okay, jetzt können wir uns das erste Beispiel für dieses Tutorial ansehen, wie man einen NEMA 17-Schrittmotor mit einem A4988-Schritttreiber steuert. 

Okay, jetzt können wir uns das erste Beispiel für dieses Tutorial ansehen, wie man einen NEMA 17-Schrittmotor mit einem A4988-Schrittantrieb steuert.

Der NEMA17 ist unter Herstellern der beliebteste Schrittmotor, da er eine hervorragende Leistung bietet und gleichzeitig erschwinglich ist. Es ist auch in fast jedem Desktop-3D-Drucker und Lasergravierer zu finden. 

Im Allgemeinen hat der NEMA17-Schrittmotor 200 Schritte oder eine Auflösung von 1,8 Grad pro Schritt, es gibt jedoch auch Modelle mit 400 Schritten und einer Auflösung von 0,9 Grad pro Schritt. Wir sollten hier beachten, dass die Bezeichnung NEMA17 eigentlich nur die Größe des Motors in Bezug auf die Größe der Frontplatte beschreibt.

Die Zahl gibt die Größe der Frontplatte in Zoll an, wenn sie durch 10 geteilt wird. In diesem Fall wäre das 17 geteilt durch 10, was einer Frontplatte von 1,7 Zoll oder einer Frontplatte von 2,3 Zoll im Fall von NEMA23 entspricht.

Die Größe der Frontplatte ist also festgelegt, aber die Länge der NEMA17-Schrittmotoren kann zwischen 20 mm und 60 mm variieren, und damit variiert auch der Leistungsbedarf des Motors. Der Leistungsbedarf wird normalerweise dadurch definiert, wie viel Strom der Motor aufnehmen darf. Der Bereich für diese NEMA17-Schrittmotoren liegt zwischen 0,3 A und 2,5 A.

Nun müssen wir entsprechend der Nennstromstärke des Schrittmotors einen geeigneten Treiber auswählen, der diese Strommenge verarbeiten kann. Der beliebteste Treiber zur Steuerung von NEMA17-Schrittmotoren ist der Schrittmotortreiber A4988.

Der A4988 hat einen maximalen Nennstrom von 2 A pro Spule, aber das ist eigentlich ein Spitzenwert. Es wird empfohlen, die Stromstärke auf etwa 1 A zu begrenzen, es ist aber natürlich auch möglich, die Stromstärke auf bis zu 2 A zu erhöhen, damit der IC gut gekühlt wird. 

Eine tolle Funktion des A4988-Schrittmotortreibers, die eigentlich alle anderen Antriebe haben, ist die Strombegrenzung. Damit können wir ganz einfach einstellen, wie viel Strom der Motor unabhängig von der Motorleistung aufnehmen soll. Beispielsweise können wir sogar einen Schrittmotor mit einer Nennleistung von 2,5 A anschließen, beschränken den Strom des Treibers jedoch auf 1,5 A. Auch wenn der Motor also nicht seine maximale Leistung erbringt, können wir ihn trotzdem nutzen.

Wenn andererseits der Nennstrom des Motors unter der am Treiber eingestellten Stromgrenze liegt, würde der Motor überhitzen. Natürlich wird immer empfohlen, den Nennstrom des Motors an den Nennstrom des Treibers anzupassen.

A4988 und Arduino-Verbindung

Also gut, jetzt sehen wir uns an, wie man den A4988-Treiber mit dem Schrittmotor und dem Arduino-Controller verbindet.

Sie können die für dieses Arduino-Tutorial benötigten Komponenten über die folgenden Links erhalten:

• Schrittmotor NEMA 17………………… Amazon / Banggood / AliExpress
• A4988 Schrittmotortreiber…………………..… Amazon / Banggood / AliExpress
• DRV8825 Schrittmotortreiber……….……..… Amazon / Banggood / AliExpress
• TMC2208 Schrittmotortreiber ………………… Amazon / Banggood / AliExpress
• Arduino CNC Shield ………………………. Amazon  / Banggood  / AliExpress
• Arduino Uno………………………………..… Amazon / Banggood / AliExpress

Offenlegung:Dies sind Affiliate-Links. Als Amazon-Partner verdiene ich an qualifizierten Käufen.

In der oberen rechten Ecke des Treibers befinden sich die VMOT- und GND-Pins und hier schließen wir die Stromversorgung für den Motor an, die zwischen 8 und 36 V liegen kann. Auch hier empfiehlt sich die Verwendung eines Entkopplungskondensators zwischen diesen beiden Pins, um die Platine vor Spannungsspitzen zu schützen. Wir sollten einen großen Elektrolytkondensator mit einer Kapazität von mindestens 47 uF verwenden. 

Als nächstes kommen die vier Pins, an denen wir den Schrittmotor anschließen. Eine Phase des Motors geht an die Pins 1A und 1B und die andere Phase an die Pins 2A und 2B. 

Manchmal kann es etwas schwierig sein zu erkennen, welche zwei Drähte des Motors eine Phase bilden, es gibt jedoch mehrere Möglichkeiten, sie zu identifizieren. Der einfachste Weg besteht darin, die Welle des Schrittmotors von Hand zu drehen und dann zwei Drähte miteinander zu verbinden. Wenn Sie zwei Drähte verbinden, die eine Phase bilden, wäre die Drehung der Welle etwas schwieriger.

Eine andere Möglichkeit besteht darin, ein Multimeter zu verwenden und den Durchgang zwischen den beiden Drähten zu prüfen. Wenn Sie zwei Drähte verbinden, die eine Phase bilden, liegt ein Kurzschluss vor und das Multimeter beginnt zu piepen.

Sobald wir eine Phase gefunden haben, können wir sie mit jeder der beiden Positionen auf dem Treiber verbinden, die Reihenfolge spielt keine Rolle. 

Als nächstes haben wir den IC oder die Logik-Stromversorgungspins VDD und GND, die zwischen 3 V und 5 V liegen können. Auf der anderen Seite haben wir die Step- und Direction-Pins, die mit jedem Pin des Arduino-Boards verbunden werden können. Mit dem Direction-Pin wählen wir die Drehrichtung des Motors aus und mit dem Step-Pin steuern wir die Schritte des Motors. Mit jedem Impuls, den wir an den Step-Pin senden, bewegt sich der Motor einen Schritt in die ausgewählte Richtung. 

Direkt über diesen Pins befinden sich die Sleep- und Reset-Pins, die, wie der Name schon sagt, dazu dienen, den Treiber in den Ruhemodus zu versetzen oder ihn zurückzusetzen. Wir sollten beachten, dass beide Pins aktiv niedrig sind. Der Sleep-Pin befindet sich standardmäßig im HIGH-Zustand, der RST-Pin ist jedoch schwebend. Das heißt, um den Treiber zu aktivieren, ist es am einfachsten, diese beiden Pins einfach miteinander zu verbinden, vorausgesetzt, wir nutzen die Funktionen dieser Pins nicht. 

Der Enable-Pin ist ebenfalls aktiv niedrig. Wenn wir ihn also nicht auf HIGH ziehen, wird der Treiber aktiviert. 

Die nächsten drei Pins, MS1, MS2 und MS3, dienen der Auswahl der Schrittauflösung des Motors. Wir haben bereits gesagt, dass die Schrittauflösung von der Konstruktion des Motors abhängt und bei einem NEMA 17-Schrittmotor normalerweise 200 Schritte pro Umdrehung beträgt. Allerdings verfügen alle Schrittmotortreiber über diese Funktion namens Mikroschritt, die den Antrieb des Motors mit höheren Auflösungen ermöglicht. Dies wird erreicht, indem die Spulen mit einem mittleren Stromniveau erregt werden, wodurch Zwischenstufenpositionen erzeugt werden.

Wenn wir beispielsweise eine Viertelschrittauflösung wählen, ergeben die 200 Schritte des Motors 200 multipliziert mit 4, was 800 Mikroschritten pro Umdrehung entspricht. Um dies zu erreichen, verwendet der Treiber vier verschiedene Stromstärken an den Spulen. 

Der A4988-Treiber hat eine maximale Auflösung von 16 Mikroschritten, was bedeutet, dass ein NEMA17-Motor mit 200 Schritten 3200 Schritte pro Umdrehung hat, also 0,1125 Grad pro Schritt. Das ist eine wirklich beeindruckende Präzision und deshalb werden diese Arten von Schrittmotoren und Treibern in so vielen Anwendungen eingesetzt. Tatsächlich gibt es Schrittmotortreiber mit bis zu 256 Mikroschritten, das sind satte 51.200 Schritte pro Umdrehung oder 0,007 Grad pro Schritt.

Allerdings verfügen diese drei Pins über Pulldown-Widerstände. Wenn wir sie also nicht angeschlossen lassen, arbeitet der Treiber im Vollschrittmodus. Um eine andere Mikroschrittauflösung auszuwählen, müssen wir gemäß dieser Tabelle 5 V an die entsprechenden Pins anschließen. 

A4988 Strombegrenzung

Nun gut, da wir nun wissen, wie man den Schrittmotor und den Treiber an die Arduino-Platine anschließt, können wir mit der Erklärung fortfahren, wie man den Arduino zur Steuerung des Schrittmotors programmiert oder codiert. Bevor wir das jedoch tun oder bevor wir den Motor antreiben, müssen wir noch eine weitere sehr wichtige Sache tun, und zwar die Strombegrenzung des Treibers anpassen.

Wie wir bereits erklärt haben, müssen wir die Stromgrenze des Treibers so anpassen, dass sie niedriger ist als die Stromnennleistung des Motors, sonst würde der Motor überhitzen.

Am A4988-Treiber gibt es jedoch ein kleines Trimmpotentiometer, mit dem wir die Strombegrenzung anpassen können. Durch Drehen des Potentiometers im Uhrzeigersinn erhöht sich die Strombegrenzung und umgekehrt. Es gibt zwei Methoden, mit denen der tatsächliche Wert der Strombegrenzung ermittelt werden kann. 

Die erste Methode besteht darin, die Referenzspannung zwischen dem Potentiometer selbst und GND zu messen. Wir können die Referenzspannung mit einem Multimeter messen und diesen Wert in der folgenden Formel verwenden, um die Stromgrenze des Treibers zu berechnen:

Strombegrenzung =Vref / (8 x Rcs)

Der Rcs ist der Strommesswiderstand oder die Werte der Strommesswiderstände direkt neben dem Chip. Je nach Hersteller liegen diese Werte meist bei 0,05, 0,1 oder 0,2 Ohm. Daher müssen wir uns den Wert dieser Widerstände genauer ansehen, um die Stromgrenze mit dieser Methode genau berechnen zu können. In meinem Fall waren diese Widerstände mit R100 gekennzeichnet, was 0,1 Ohm bedeutete.

Wenn wir beispielsweise eine Referenzspannung von 0,7 V messen und Widerstände mit 0,1 Ohm haben, liegt die Strombegrenzung bei 0,875 A. Oder wenn wir den Strom beispielsweise auf 1 A begrenzen möchten, sollten wir die Referenzspannung auf 0,8 V einstellen. 

Die zweite Methode zum Festlegen der Strombegrenzung besteht darin, den Strom durch die Spulen direkt zu messen. Zu diesem Zweck müssen wir den Schrittmotor und den Treiber wie zuvor erläutert verbinden. Wir können den Controller-Anschluss überspringen, sondern stattdessen 5 V an die Direction- und Step-Pins anschließen, damit der Motor aktiv bleibt und eine Position hält. Die MS-Pins sollten nicht verbunden bleiben, damit der Treiber im Vollschrittmodus arbeitet. Dann können wir eine Leitung oder Spule vom Motor trennen und sie mit einem Amperemeter in Reihe schalten. Auf diese Weise können wir ablesen, wie viel Strom durch die Spule fließt, sobald wir den Treiber sowohl mit der Logikspannung (5 V) als auch mit der Spannung für den Motor (in meinem Fall 12 V) versorgen.

Hierbei ist jedoch zu beachten, dass bei Betrieb des Treibers im Vollschrittmodus der Strom in den Spulen nur 70 % der eigentlichen Stromgrenze erreichen kann. Wenn Sie den Treiber also in den anderen Mikroschrittmodi verwenden, sollte der Messwert vom Amperemeter mit 1,3 multipliziert werden, um den tatsächlichen Wert der Strombegrenzung des Treibers zu erhalten. 

Ich habe beide Methoden zum Einrichten des aktuellen Limits des Treibers ausprobiert und sie haben ungefähr die gleichen Ergebnisse geliefert.

Schrittmotoren und Arduino – Beispielcodes

Jetzt können wir jedoch mit der Programmierung des Arduino fortfahren oder uns einige Beispielcodes zur Steuerung eines Schrittmotors mit einem Arduino-Board ansehen.

Beginnen wir mit einem sehr einfachen Beispielcode, der zeigt, wie man einen Schrittmotor ohne Verwendung einer Bibliothek steuert.

Beispielcode 1

/* 
 * Basic example code for controlling a stepper without library
 * 
 * by Dejan, https://howtomechatronics.com
 */
// defines pins
#define stepPin 2
#define dirPin 5 
 
void setup() {
 // Sets the two pins as Outputs
 pinMode(stepPin,OUTPUT); 
 pinMode(dirPin,OUTPUT);
}
void loop() {
 digitalWrite(dirPin,HIGH); // Enables the motor to move in a particular direction
 // Makes 200 pulses for making one full cycle rotation
 for(int x = 0; x < 800; x++) {
 digitalWrite(stepPin,HIGH); 
 delayMicroseconds(700); // by changing this time delay between the steps we can change the rotation speed
 digitalWrite(stepPin,LOW); 
 delayMicroseconds(700); 
 }
 delay(1000); // One second delay
 
 digitalWrite(dirPin,LOW); //Changes the rotations direction
 // Makes 400 pulses for making two full cycle rotation
 for(int x = 0; x < 1600; x++) {
 digitalWrite(stepPin,HIGH);
 delayMicroseconds(500);
 digitalWrite(stepPin,LOW);
 delayMicroseconds(500);
 }
 delay(1000);
}Code language: PHP (php)

Codebeschreibung:

Hier müssen wir lediglich festlegen, mit welcher Pin-Nummer die STEP- und DIR-Pins verbunden sind, und diese als Ausgänge definieren. In der Schleife legen wir zunächst die Drehrichtung des Motors fest, indem wir den Direction-Pin auf HIGH setzen. Dann senden wir mithilfe einer „for“-Schleife 200 Impulse an den STEP-Pin, wodurch der Motor einen vollen Zyklus lang dreht, wenn man davon ausgeht, dass er im Vollschrittmodus arbeitet. Die Impulse werden einfach durch Umschalten des Zustands des STEP-Pins von HIGH auf LOW mit einer gewissen Zeitverzögerung dazwischen erzeugt. Diese Zeitverzögerung definiert tatsächlich die Rotationsgeschwindigkeit. Wenn wir ihn verringern, erhöht sich die Rotationsgeschwindigkeit, da die Schritte schneller ausgeführt werden, und umgekehrt. 

Dann ändern wir die Drehrichtung und senden mithilfe einer weiteren „for“-Schleife 400 Impulse, die den Motor um zwei volle Zyklen drehen lassen würden. Wenn wir jedoch den Mikroschrittmodus des Treibers ändern, beispielsweise um einen Viertelschritt, wodurch der Motor jetzt 800 Schritte hätte, dreht sich der Motor in der ersten Schleife nur um 90 Grad und in der zweiten Schleife nur um eine halbe Drehung.

Beispielcode 2

Hier ist ein weiteres einfaches Beispiel, die Steuerung der Schrittmotorgeschwindigkeit mithilfe eines Potentiometers.

Zu diesem Zweck müssen Sie lediglich das Potentiometer an den Arduino anschließen und seinen Wert mit der Funktion analogRead() ablesen.

/*
 Basic example code for controlling a stepper without library
 by Dejan, https://howtomechatronics.com
*/
// defines pins
#define stepPin 2
#define dirPin 5
int customDelay, customDelayMapped;
void setup() {
 // Sets the two pins as Outputs
 pinMode(stepPin, OUTPUT);
 pinMode(dirPin, OUTPUT);
}
void loop() {
 speedControl();
 // Makes pules with custom delay, depending on the Potentiometer, from which the speed of the motor depends
 digitalWrite(stepPin, HIGH);
 delayMicroseconds(customDelayMapped);
 digitalWrite(stepPin, LOW);
 delayMicroseconds(customDelayMapped);
}
// Custom function for reading the potentiometer and mapping its value from 300 to 3000, suitable for the custom delay value in microseconds
void speedControl() {
 customDelay = analogRead(A0); // Read the potentiometer value
 customDelayMapped = map(customDelay, 0, 1023, 300, 3000); // Convert the analog input from 0 to 1024, to 300 to 3000
}Code language: PHP (php)

Codebeschreibung:

Anschließend können wir die Potentiometerwerte, die zwischen 0 und 1023 liegen, auf Werte abbilden oder umwandeln, die als Verzögerungszeit in Mikrosekunden für die Schrittimpulse geeignet sind. Ich habe festgestellt, dass der Mindestwert für die Verzögerung zwischen den Schritten etwa 300 Mikrosekunden beträgt. Durch die Unterschreitung begann der Schrittmotor, Schritte zu überspringen. 

Insgesamt ist die Steuerung von Schrittmotoren mit dieser Methode einfach und funktioniert, allerdings nur, wenn die erforderliche Steuerung einfach ist, wie in den Beispielen gezeigt. Falls wir eine komplexere Steuerung benötigen, verwenden wir am besten eine Arduino-Bibliothek.

Schrittmotoren mit Arduino und der AccelStepper-Bibliothek steuern – Beispiele

Die beliebteste Bibliothek zur Steuerung von Schrittmotoren mit Arduino ist die AccelStepper-Bibliothek von Mike McCauley. Es handelt sich um eine äußerst vielseitige Bibliothek mit Geschwindigkeits-, Beschleunigungs- und Verzögerungssteuerung, Einstellung von Zielpositionen, gleichzeitiger Steuerung mehrerer Schrittmotoren usw.

Die Bibliothek verfügt über eine großartige Dokumentation, die erklärt, wie die einzelnen Funktionen funktionieren. Ich habe diese Bibliothek bereits für mehrere meiner Arduino-Projekte verwendet, um die Bewegung meines DIY-Kameraschiebers, der 3D-Drahtbiegemaschine, des SCARA-Roboterarms und einiger anderer zu steuern. Bei Interesse finden Sie auf der Website zu jedem Projekt Details und Code-Erklärungen. 

Schauen wir uns nun einige Codebeispiele an, die diese Bibliothek verwenden.

Beispielcode – Schrittmotor-Geschwindigkeitssteuerung mit einem Potentiometer

Das erste Beispiel wird die Steuerung der Motorgeschwindigkeit mithilfe des Potentiometers sein.

/* 
 * Basic example code for controlling a stepper with the AccelStepper library
 * 
 * by Dejan, https://howtomechatronics.com
 */
#include <AccelStepper.h>
// Define the stepper motor and the pins that is connected to
AccelStepper stepper1(1, 2, 5); // (Type of driver: with 2 pins, STEP, DIR)
void setup() {
 // Set maximum speed value for the stepper
 stepper1.setMaxSpeed(1000);
}
void loop() {
 stepper1.setSpeed((analogRead(A0));
 // Step the motor with a constant speed previously set by setSpeed();
 stepper1.runSpeed();
}Code language: PHP (php)

Codebeschreibung:

Hier müssen wir also zunächst die AccelStepper-Bibliothek einbinden. Bevor wir das tun, müssen wir natürlich die Bibliothek installieren und das können wir über den Arduino IDE-Bibliotheksmanager tun. Wir müssen nur nach „AccelStepper“ suchen und die Bibliothek wird angezeigt und wir können sie installieren. 

Dann müssen wir eine Instanz der AccelStepper-Klasse für unseren Motor erstellen. Der erste Parameter hier ist der Treibertyp, in diesem Fall ist dieser Wert für einen Treiber mit zwei Steuerpins 1, und die anderen beiden Parameter sind die Pinnummern, mit denen unser Treiber mit dem Arduino verbunden ist. Wenn wir mehrere Schrittmotoren haben, müssen wir jeden von ihnen so definieren und können sie nach Belieben benennen. In diesem Fall habe ich meinen Motor Stepper1 genannt. 

Im Setup-Bereich müssen wir lediglich die maximale Geschwindigkeit des Motors einstellen, die in Schritten pro Sekunde definiert ist. Dieser Wert kann bis zu 4000 betragen, in der Dokumentation der Bibliothek heißt es jedoch, dass Geschwindigkeitswerte von mehr als 1000 Schritten pro Sekunde möglicherweise unzuverlässig sind. 

Im Schleifenabschnitt stellen wir mit der Funktion setSpeed() die aktuelle Geschwindigkeit des Motors ein. In diesem Fall ist das der analoge Eingang des Potentiometers, der zwischen 0 und 1023 liegt.

Damit sich der Motor bewegen und diese konstante Geschwindigkeit umsetzen kann, müssen wir in jedem Intervall die Funktion runSpeed() aufrufen. Ein negativer Wert hier oder einfach das Einfügen eines Minuszeichens vor dem Wert würde dazu führen, dass sich der Schrittmotor in die entgegengesetzte Richtung dreht.

Beispielcode – Steuerung von zwei Schrittmotoren mit Beschleunigung und Verzögerung

Hier ist ein weiteres Beispiel für die Steuerung von zwei Schrittmotoren mit Implementierung von Beschleunigung und Verzögerung mithilfe der AccelStepper-Bibliothek.

/*
 Controlling two stepper with the AccelStepper library
 by Dejan, https://howtomechatronics.com
*/
#include <AccelStepper.h>
// Define the stepper motor and the pins that is connected to
AccelStepper stepper1(1, 2, 5); // (Typeof driver: with 2 pins, STEP, DIR)
AccelStepper stepper2(1, 3, 6);
void setup() {
 stepper1.setMaxSpeed(1000); // Set maximum speed value for the stepper
 stepper1.setAcceleration(500); // Set acceleration value for the stepper
 stepper1.setCurrentPosition(0); // Set the current position to 0 steps
 stepper2.setMaxSpeed(1000);
 stepper2.setAcceleration(500);
 stepper2.setCurrentPosition(0);
}
void loop() {
 stepper1.moveTo(800); // Set desired move: 800 steps (in quater-step resolution that's one rotation)
 stepper1.runToPosition(); // Moves the motor to target position w/ acceleration/ deceleration and it blocks until is in position
 stepper2.moveTo(1600);
 stepper2.runToPosition();
 // Move back to position 0, using run() which is non-blocking - both motors will move at the same time
 stepper1.moveTo(0);
 stepper2.moveTo(0);
 while (stepper1.currentPosition() != 0 || stepper2.currentPosition() != 0) {
 stepper1.run(); // Move or step the motor implementing accelerations and decelerations to achieve the target position. Non-blocking function
 stepper2.run();
 //
 //
 }
}Code language: PHP (php)

Codebeschreibung:

Wir müssen also die beiden Schrittmotoren definieren und im Setup mit der Funktion setAcceleration() den Beschleunigungswert für die Motoren festlegen. Mit der Funktion setCurrentPosition() stellen wir die Position der Motoren auf 0 Schritte ein. 

Im Schleifenabschnitt beginnen wir mit der Funktion moveTo(), mit der wir dem Motor mitteilen, in welche Position er gehen soll oder wie viele Schritte er bewegen soll. Bei einer Viertelschrittauflösung würden 800 Schritte eine volle Umdrehung bedeuten. Anschließend bewegt die Funktion runToPosition() den Motor an diese Position und implementiert dabei Beschleunigung und Verzögerung. Allerdings handelt es sich hierbei um eine Blockierfunktion, sodass die Codeausführung dort bleibt, bis der Schrittmotor diese Position erreicht. 

Mit der gleichen Methode bewegen wir den zweiten Motor um 1600 Schritte oder zwei volle Umdrehungen mit Viertelschrittauflösung. 

Wenn wir nicht möchten, dass unser Code blockiert wird, bis der Motor die Zielposition erreicht, sollten wir anstelle der Funktion runToPosition() die Funktion run() verwenden. run() implementiert auch Beschleunigung und Verzögerung, um die Zielposition zu erreichen, führt jedoch nur einen Schritt pro Aufruf aus. Deshalb müssen wir es so oft wie möglich aufrufen. Aus diesem Grund fügen wir hier die run()-Funktionen für beide Motoren in diese while-Schleife ein, die so lange ausgeführt wird, bis beide Schrittmotoren die Position 0 erreichen. Zuvor haben wir die beiden Motoren mit den moveTo()-Funktionen so eingestellt, dass sie auf Position 0 fahren. 

Wir könnten dieser „while“-Schleife auch mehr Code hinzufügen und neben dem Betrieb des Motors auch andere Dinge tun. Tatsächlich gibt es viele Methoden, die Motoren anzutreiben und auch andere Dinge zu tun. Ich empfehle, die gut beschriebene Dokumentation der Bibliothek durchzugehen, damit Sie verstehen, wie die einzelnen Funktionen funktionieren, und sie entsprechend Ihren Anforderungen implementieren können.

Beispielcode – Steuerung mehrerer Schrittmotoren mit der AccelStepper-Bibliothek

Ich möchte Ihnen noch ein Beispiel mit der AccelStepper-Bibliothek zeigen, bei dem es um die koordinierte Steuerung mehrerer Schrittmotoren geht. Das bedeutet, dass wir für jeden Stepper Zielpositionen festlegen können und sie ihre Positionen alle gleichzeitig erreichen können, unabhängig von der unterschiedlichen Distanz, die sie zurücklegen müssen.

Dies kann einfach mit der MultiStepper-Klasse erfolgen, die in der AccelStepper-Bibliothek enthalten ist.

/*
 Controlling multiple steppers with the AccelStepper and MultiStepper library
 by Dejan, https://howtomechatronics.com
*/
#include <AccelStepper.h>
#include <MultiStepper.h>
// Define the stepper motor and the pins that is connected to
AccelStepper stepper1(1, 2, 5); // (Typeof driver: with 2 pins, STEP, DIR)
AccelStepper stepper2(1, 3, 6);
AccelStepper stepper3(1, 4, 7);
MultiStepper steppersControl; // Create instance of MultiStepper
long gotoposition[3]; // An array to store the target positions for each stepper motor
void setup() {
 stepper1.setMaxSpeed(1000); // Set maximum speed value for the stepper
 stepper2.setMaxSpeed(1000);
 stepper3.setMaxSpeed(1000);
 // Adding the 3 steppers to the steppersControl instance for multi stepper control
 steppersControl.addStepper(stepper1);
 steppersControl.addStepper(stepper2);
 steppersControl.addStepper(stepper3);
}
void loop() {
 // Store the target positions in the "gotopostion" array
 gotoposition[0] = 800; // 800 steps - full rotation with quater-step resolution
 gotoposition[1] = 1600;
 gotoposition[2] = 3200;
 steppersControl.moveTo(gotoposition); // Calculates the required speed for all motors
 steppersControl.runSpeedToPosition(); // Blocks until all steppers are in position
 delay(1000);
 gotoposition[0] = 0;
 gotoposition[1] = 0;
 gotoposition[2] = 0;
 steppersControl.moveTo(gotoposition);
 steppersControl.runSpeedToPosition();
 delay(1000);
}Code language: PHP (php)

Codebeschreibung:

Hier müssen wir auch die MultiStepper-Klasse einbinden und eine Instanz davon erstellen. Dann müssen wir ein Array vom Typ „long“ definieren, das zum Speichern der Zielpositionen für unsere Motoren verwendet wird. Im Setup-Abschnitt müssen wir die maximalen Geschwindigkeitswerte der Stepper definieren und die Stepper zur zuvor erstellten MultiStepper-Instanz hinzufügen, die ich in meinem Fall „steppersControl“ genannt habe. 

Im Schleifenabschnitt beginnen wir mit dem Speichern der Zielpositionswerte in dem zuvor erstellten Array. Ich habe den ersten Stepper so eingestellt, dass er sich um eine Umdrehung bewegt, den zweiten auf zwei Umdrehungen und den dritten auf drei Umdrehungen. Dann können wir dieses Array der Funktion moveTo() zuweisen, die die erforderlichen Geschwindigkeiten berechnet, damit alle Motoren gleichzeitig an diesen Positionen ankommen. Dann müssen wir nur noch die Funktion runSpeedToPosition() aufrufen, die die Motoren in ihre Position bewegt. Wir sollten jedoch beachten, dass diese Funktion den Code blockiert, bis die Stepper ihre Zielposition erreichen. Wir könnten stattdessen die Funktion run() verwenden, wenn wir den Code nicht blockieren möchten. Wir sollten auch beachten, dass die MultiStepper-Klasse keine Beschleunigung und Verzögerung unterstützt. 

Wenn Sie jedoch anhand fortgeschrittenerer Beispiele mehr erfahren möchten, können Sie sich meine bereits erwähnten Arduino-Projekte ansehen. Alle Details und Codes dafür finden Sie auf der Website.

CNC-Shield zur Steuerung mehrerer Schrittmotoren für jedes Arduino-Projekt

Da wir uns immer noch mit der Steuerung mehrerer Schrittmotoren befassen, lohnt es sich, einen Blick auf das Arduino-CNC-Shield zu werfen.

Der Hauptzweck des Arduino CNC-Shields ist die Steuerung von 2- oder 3-Achsen-CNC-Maschinen. Tatsächlich ist es jedoch eine großartige Option für die Steuerung aller Arten von Projekten, bei denen wir mehrere Schrittmotoren steuern müssen, da es kompakt ist und einfache Anschlüsse für die Treiber und Motoren bietet. 

Dieses Schild wird auf eine Arduino-UNO-Platine montiert und kann bis zu vier einzelne Schrittmotoren steuern. Alle übrigen Arduino-Pins stehen zur Verfügung. Ich habe diese Kombination aus einem Arduino UNO-Board und dem CNC-Shield zur Steuerung meines 4-Achsen-SCARA-Roboterarms verwendet.

Ich werde diesen Abschnitt des Artikels, wie man das CNC-Shield mit Arduino verwendet, bald mit weiteren Details aktualisieren.

DRV8825 vs. A4988

Also gut, jetzt machen wir weiter und sehen, wie wir Schrittmotoren mit dem anderen Treiber steuern können, den ich eingangs erwähnt habe, dem DRV8825.

Tatsächlich gilt alles, was wir bisher über die Steuerung von Schrittmotoren mit dem Schritttreiber A4988 erklärt haben, auch für den DRV8825. Das Funktionsprinzip, die Anschlüsse und die Codierung sind bei beiden Treibern nahezu gleich. Der Unterschied zwischen ihnen liegt in ihren technischen Eigenschaften und jetzt werden wir sie uns ansehen und vergleichen.

Der DRV8825 ist ein Schrittmotortreiber von Texas Instruments, der aufgrund der gleichen Anschlüsse als direkter Ersatz für den Allegro A4988-Treiber verwendet werden kann. Die drei Hauptunterschiede zwischen ihnen bestehen darin, dass der DR8825 ohne zusätzliche Kühlung mehr Strom liefern kann als der A4988 (1,5 A gegenüber 1 A), eine höhere maximale Versorgungsspannung hat (45 V gegenüber 35 V) und eine höhere Mikroschrittauflösung (32 gegenüber 16 Mikroschritten) bietet. 

Natürlich gibt es auch noch andere kleinere Unterschiede. Beispielsweise befindet sich das Strombegrenzungspotentiometer an einer anderen Position und die Beziehung zwischen der Strombegrenzungseinstellung und der Referenzpinspannung ist unterschiedlich. Der DRV8825 benötigt keine Logikstromversorgung und die Position dieses Pins wird als FAULT-Ausgang verwendet.

Es ist jedoch sicher, den FAULT-Pin direkt an 5 V anzuschließen, sodass der DRV8825 als direkter Ersatz in Systemen verwendet werden kann, die für den A4988-Treiber entwickelt wurden. 

Es ist jedoch zu beachten, dass es beim Ersetzen eines A4988-Treibers durch einen DRV8825 sehr wichtig ist, sicherzustellen, dass die Ausrichtung des Treibers korrekt ist. Ich habe bereits erwähnt, dass sich ihre Potentiometer an verschiedenen Stellen befinden, beim A4988 unter dem Chip und beim DRV8825 oberhalb des Chips, und das kann manchmal zu Verwirrung führen und der Treiber kann leicht auf der falschen Seite platziert werden. 

Um die Stromgrenze einzustellen, können wir die Referenzspannung mit einer Sonde an GND und der anderen am Potentiometer selbst messen.

Die Berechnungsformel für den Schrittantrieb DRV8825 lautet wie folgt:

Aktuelle Grenze =Vref x 2

Zur Auswahl der Mikroschrittauflösung können wir die folgende Tabelle verwenden.

Insgesamt ist der DRV8825 ein besserer Schrittmotortreiber als der A4988, da er höhere Strom- und Spannungswerte sowie eine höhere Mikroschrittauflösung bietet, was zu einem gleichmäßigeren und leiseren Betrieb des Schrittmotors führt.

TMC2208 Schrittmotortreiber

Apropos reibungsloserer und leiserer Betrieb:Schauen wir uns den Schritttreiber TMC2208 an. Der TMC2208-Chip wird von Trinamic hergestellt, einem in Deutschland ansässigen Unternehmen, das auf Bewegungssteuerungselektronik spezialisiert ist. Der TMC2208 ist ein leiser Schrittmotortreiber, der auch als direkter Ersatz in Systemen verwendet werden kann, die für die A4988- oder DRV8825-Treiber entwickelt wurden. Es wird häufig in Desktop-3D-Druckern, Lasergravierern, Scannern usw. verwendet.

Was diesen Treiber von den beiden anderen unterscheidet, ist seine integrierte Interpolationseinheit, die 256 Unterteilungen oder Mikroschritte bietet. Dies ermöglicht eine perfekte Sinussteuerung, die intern im Chip erzeugt wird. Das bedeutet, dass der Treiber 256 Mikroschritte an den Schrittmotor ausgibt, unabhängig davon, welche Mikroschrittauflösung wir über die beiden MS-Pins ausgewählt haben, 2, 4, 8 oder 16 Mikroschritte. Dies sorgt für einen reibungsloseren Betrieb und reduziert die Belastung des Mikrocontrollers erheblich.

Diese Funktion des Treibers sorgt in Kombination mit der geräuschlosen Stromsteuerung der StealthChop2-Technologie für eine äußerst geräuschlose Steuerung der Schrittmotoren. Hier ist ein Vergleich der Geräuschpegel zwischen den drei Fahrern.

Geräuschpegel des Schritttreibers: A4988 etwa 65 dB, DRV8825 etwa 67 dB und TMC2208 etwa 41 dB.

Der TMC2208 treibt die Schrittmotoren völlig geräuschlos an, was wirklich beeindruckend ist.

Der Nennstrom des TMC2208 ist etwas höher als der des A4988-Treibers oder beträgt 1,2 A bei 2 A Spitzenstrom. Zum Festlegen des aktuellen Limits des Treibers können wir wiederum dieselbe Methode verwenden, die für die anderen Treiber erläutert wurde. Wir müssen die Referenzspannung mit einer Sonde auf GND und der anderen insgesamt direkt neben dem Enable-Pin messen.

Die Formel zur Berechnung des aktuellen Grenzwerts lautet wie folgt:

Aktuelle Grenze =Vref x 0,71

Obwohl er als direkter Ersatz verwendet werden kann, hat der TMC2208-Treiber eine etwas andere Pinbelegung als der A4988-Treiber. Hier haben wir nur zwei Pins zur Auswahl der Mikroschrittauflösung und zum Aktivieren des Treibers müssen wir den Enable-Pin mit GND verbinden.

In Bezug auf die Codierung ist es dasselbe wie bei den anderen beiden Treibern. 

Der TMC2208-Treiber verfügt im Vergleich zu den beiden anderen Treibern auch über einige andere, erweiterte Funktionen, wie zum Beispiel eine einfach zu verwendende UART-Schnittstelle, die die Steuerung des Treibers über nur eine einzige Leitung anstelle der beiden Step- und Dir-Pins ermöglicht. Darüber hinaus biete ich weitere Tuning- und Steuerungsmöglichkeiten. 

Insgesamt ist der TMC2208 ein besserer Treiber als der A4988 und der DRV8825, aber das ist normal, da er mit einem höheren Preis verbunden ist. Wenn Sie diese zusätzlichen Funktionen jedoch nicht benötigen und der Geräuschpegel Sie nicht stört, sind die beiden anderen Treiber eine gute Wahl.

Schlussfolgerung

Damit haben wir so ziemlich alles abgedeckt, was wir über die Steuerung von Schrittmotoren mit Arduino wissen müssen. Der NEMA17 und die drei Treiber A4988, DRV8825 und TMC2208 sind einfach unglaublich vielseitig und können in so vielen Anwendungen eingesetzt werden, bei denen eine Positionskontrolle erforderlich ist. Sie können jederzeit mehr erfahren, indem Sie einige meiner Arduino-Projekte erkunden.

Wenn Sie lernen möchten, wie man größere Schrittmotoren wie NEMA23 oder NEMA34 steuert, habe ich auch dafür ein spezielles Tutorial. 

Ich hoffe, Ihnen hat dieses Tutorial gefallen und Sie haben etwas Neues gelernt. Vergessen Sie nicht, sich anzumelden, und stellen Sie im Kommentarbereich unten Ihre Fragen.