In diesem Tutorial lernst du, wie du einen Schrittmotor mit dem TB6600-Mikroschritt-Treiber und Arduino steuerst. Dieser Treiber ist einfach zu bedienen und kann große Schrittmotoren wie einen 3 A NEMA 23.
Ich habe ein Schaltbild und 3 Beispielcodes beigefügt. Im ersten Beispiel zeige ich dir, wie du diesen Schrittmotortreiber ohne Arduino-Bibliothek verwenden kannst.
Dieses Beispiel kann verwendet werden, um den Motor kontinuierlich drehen zu lassen. Im zweiten Beispiel schauen wir uns an, wie du die Geschwindigkeit, die Anzahl der Umdrehungen und die Drehrichtung des Schrittmotors steuern kannst.
Zum Schluss werfen wir einen Blick auf die AccelStepper library. Diese Bibliothek ist recht einfach zu verwenden und ermöglicht es dir, Beschleunigung und Verzögerung zur Bewegung des Schrittmotors hinzuzufügen.
Nach jedem Beispiel erkläre ich, wie der Code funktioniert, sodass du ihn problemlos an deine Bedürfnisse anpassen kannst.
Materialien
Hardware-Komponenten
| TB6600 stepper motor driver | × 1 | Amazon | |
 | NEMA 23 stepper motor | × 1 | Amazon |
 | Arduino Uno Rev3 | × 1 | Amazon |
| Power supply (24/36 V) | × 1 | Amazon | |
| Jumper wires | × 4 | Amazon | |
| USB cable type A/B | × 1 | Amazon |
Werkzeuge
| Wire stripper | Amazon | ||
| Small screwdriver | Amazon | ||
| Self-adjusting crimping pliers (empfohlen)* | Amazon | ||
| Wire ferrules assortment (empfohlen)* | Amazon |
*Hackaday hat einen großartigen Artikel über die Vorteile der Verwendung von Aderendhülsen (auch Endhülsen genannt) geschrieben.
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
Der TB6600 microstepping driver ist um den Toshiba TB6600HG IC aufgebaut und kann zum Ansteuern von zweiphasigen bipolaren Schrittmotoren verwendet werden.
Mit einem maximalen Dauerstrom von 3,5 A kann der TB6600-Treiber recht große Schrittmotoren wie einen NEMA 23 steuern. Achte darauf, keine Schrittmotoren mit einem Nennstrom von mehr als 3,5 A an den Treiber anzuschließen.
Der Treiber verfügt über mehrere eingebaute Sicherheitsfunktionen wie Überstrom-, Unterspannungsschutz und Überhitzungsschutz.
Weitere Spezifikationen findest du in der Tabelle unten. Beachte, dass die genauen Spezifikationen und Abmessungen je nach Hersteller leicht variieren können. Schau dir immer das Datenblatt deines speziellen Treibers an, bevor du ihn mit Strom versorgst.
TB6600 Spezifikationen
| Betriebsspannung | 9 – 42 V |
| Maximaler Ausgangsstrom | 4,5 A pro Phase, 5,0 A Spitze1 |
| Mikroschrittauflösung | voll, 1/2, 1/4, 1/8 und 1/162 |
| Schutz | Unterspannungsschutz, Überhitzungs- und Überstromschutz |
| Abmessungen | 96 x 72 x 28/36 mm |
| Bohrabstand | 88, ⌀ 5 mm |
| Kosten | Check price |
1 Dies sind die Spezifikationen für den TB6600HG IC, der Treiber selbst hat eine maximale Stromstärke von 3,5 A und 4,0 A Spitze.
2 Siehe Kommentar zu gefälschten/aufgerüsteten TB6600-Treibern weiter unten.
Für weitere Informationen kannst du das Datenblatt und Handbuch unten einsehen:
Gefälschte oder „aufgerüstete“ TB6600-Treiber
Ich habe kürzlich einen meiner bestellten TB6600-Treiber zerlegt und festgestellt, dass er tatsächlich keinen TB6600HG-Chip verwendet. Stattdessen wurde ein viel kleinerer TB67S109AFTG-Chip von Toshiba verbaut. Die Leistung und Spezifikationen dieser Chips sind ähnlich, aber der TB6600HG hat eine höhere Spitzenstromstärke (bis zu 5 A) und ist insgesamt ein viel größerer Chip mit besserer Kühlung.
Es gibt eine sehr einfache Möglichkeit zu überprüfen, ob dein Treiber einen TB6600HG- oder einen TB67S109AFTG-Chip verwendet, der TB6600HG unterstützt nur bis zu 1/16 Mikroschritte (siehe Datenblatt), während der TB67S109AFTG bis zu 1/32 geht. Der Hauptgrund, warum Hersteller auf diesen anderen Chip umgestiegen sind, ist wahrscheinlich der Preis. Unten findest du Links zu den Chips auf LCSC.com, die zeigen, dass der TB67S109AFTG etwa 1,50 $ günstiger ist.
TB6600HG: https://lcsc.com/product-detail/Motor-Drivers_TOSHIBA_TB6600HG_TB6600HG_C66042.html
TB67S109AFTG: https://lcsc.com/product-detail/Motor-Drivers_TOSHIBA_TB67S109AFTG_TB67S109AFTG_C92125.html
Du kannst originale TB6600-Treiber auf Amazon kaufen, like this 4-axis driver board aber die meisten verwenden den TB67S109AFTG-Chip. Du erkennst einen TB6600HG-Chip an den herausstehenden Pins auf der Platine und daran, dass er nur bis zu 1/16 Mikroschritte unterstützt.
Jim von embeddedtronicsblog did some testing on the TB67S109AFTG drivers und stellte fest, dass die Schrittmotoren damit besser liefen als mit den TB6600-Treibern. Solltest du also einen echten TB6600 oder das „Upgrade“ wählen? Ich würde sagen, es hängt davon ab, ob du wirklich den hohen Strombedarf brauchst oder lieber bis zu 1/32 Mikroschritte möchtest.
Das Datenblatt für den TB67S109AFTG findest du unten.
Alternativen
Beachte, dass der TB6600 ein analoger Treiber ist. In den letzten Jahren sind digitale Treiber wie der DM556 oder DM542 viel erschwinglicher geworden. Digitale Treiber bieten in der Regel eine bessere Leistung und einen leiseren Betrieb. Sie können genauso verdrahtet und gesteuert werden wie der TB6600, sodass du dein System später leicht aufrüsten kannst.
Ich habe die DM556-Treiber für meinen DIY-CNC-Fräser verwendet und sie funktionieren seit mehreren Jahren einwandfrei.
TB6600 vs TB6560
Beim Kauf eines TB6600-Schrittmotortreibers wirst du wahrscheinlich auch auf den etwas günstigeren TB6560 Treiber stoßen. Dieser Treiber kann mit dem gleichen Code/der gleichen Verdrahtung gesteuert werden, aber es gibt einige wichtige Unterschiede.
| TB6560 | TB6600 | |
|---|---|---|
| Betriebsspannung | 10 – 35 VDC, 24 VDC empfohlen | 9 – 42 VDC, 36 VDC empfohlen |
| Maximaler Ausgangsstrom | 3 A pro Phase, 3,5 A Spitze | 3,5 A pro Phase, 4 A Spitze |
| # Strom-Einstellungen | 14 | 8 |
| Mikroschrittauflösung | voll, 1/2, 1/8 und 1/16 | voll, 1/2, 1/4, 1/8, 1/16 und 1/32* |
| Taktfrequenz | 15 kHz | 200 kHz |
| Kosten | Check price | Check price |
*Treiber mit TB67S109AFTG-Chip.
Die Hauptunterschiede sind also die höhere maximale Spannung, der höhere maximale Strom und bis zu 1/32 Mikroschritte. Der TB6600 hat außerdem einen besseren Kühlkörper und ein schöneres Gesamtformat. Wenn du größere Schrittmotoren steuern oder eine höhere Auflösung brauchst, empfehle ich den TB6600.
Verdrahtung – Anschluss des TB6600 an Schrittmotor und Arduino
Den TB6600-Schrittmotortreiber an einen Arduino und Schrittmotor anzuschließen ist recht einfach. Das folgende Schaltbild zeigt dir, welche Verbindungen du herstellen musst.
In diesem Tutorial schließen wir den Treiber in einer gemeinsamen Kathoden-Konfiguration an. Das bedeutet, dass wir alle negativen Seiten der Steuersignale mit Masse verbinden.
Die Anschlüsse sind auch in der folgenden Tabelle aufgeführt:
TB6600 Anschlüsse
| TB6600 | Anschluss |
|---|---|
| VCC | 9 – 42 VDC |
| GND | Masse der Stromversorgung |
| ENA- | Nicht verbunden |
| ENA+ | Nicht verbunden |
| DIR- | Arduino GND |
| DIR+ | Pin 2 Arduino |
| PUL- | Arduino GND |
| PUL+ | Pin 3 Arduino |
| A-, A+ | Spule 1 Schrittmotor |
| B-, B+ | Spule 2 Schrittmotor |
Beachte, dass wir die Enable-Pins (ENA- und ENA+) nicht verbunden haben. Das bedeutet, dass der Enable-Pin immer LOW ist und der Treiber immer aktiviert ist.
Wie bestimmt man die richtige Schrittmotor-Verdrahtung?
Wenn du das Datenblatt deines Schrittmotors nicht findest, kann es schwierig sein herauszufinden, welcher Draht wo angeschlossen wird. Ich verwende folgenden Trick, um 4-adrige bipolare Schrittmotoren zu identifizieren:
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 A- und A+ angeschlossen, die andere an B- und B+, die Polarität spielt keine Rolle.
Um die zwei 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 halte die blanken Enden zusammen.
- Versuche dann, während du die Enden zusammenhältst, die Welle des Schrittmotors erneut zu drehen.
Wenn du starken Widerstand spürst, hast du ein Drahtpaar derselben Spule gefunden. Wenn sich die Welle noch frei drehen lässt, probiere ein anderes Drahtpaar. Verbinde nun die beiden Spulen mit den Pins, die im Schaltbild oben gezeigt sind.
Falls es noch unklar ist, hinterlasse bitte einen Kommentar unten, weitere Infos findest du auch auf der RepRap.org wiki.
TB6600 Mikroschritt-Einstellungen
Schrittmotoren haben typischerweise eine Schrittgröße von 1,8° oder 200 Schritte pro Umdrehung, dies bezieht sich auf Vollschritte. Ein Mikroschritt-Treiber wie der TB6600 ermöglicht höhere Auflösungen durch Zwischenpositionen. Dies wird erreicht, indem die Spulen mit Zwischenstromstärken angesteuert werden.
Zum Beispiel ergibt der Betrieb eines Motors im 1/2-Schritt-Modus bei einem 200-Schritte-pro-Umdrehung-Motor 400 Mikroschritte pro Umdrehung.
Du kannst die Mikroschritt-Einstellungen des TB6600 durch Ein- oder Ausschalten der DIP-Schalter am Treiber ändern. Siehe die Tabelle unten für Details. Achte darauf, dass der Treiber beim Einstellen der DIP-Schalter nicht mit Strom versorgt wird!
Bitte beachten , dass diese Einstellungen für die 1/32 Mikroschritt-Treiber mit dem TB67S109AFTG-Chip gelten. Fast alle TB6600-Treiber, die du heute kaufen kannst, verwenden diesen Chip. Normalerweise findest du auch eine Tabelle mit den Mikroschritt- und Stromeinstellungen auf dem Gehäuse des Treibers.
Mikroschritt-Tabelle
| S1 | S2 | S3 | Mikroschrittauflösung |
|---|---|---|---|
| EIN | EIN | EIN | NC |
| EIN | EIN | AUS | Vollschritt |
| EIN | AUS | EIN | 1/2 Schritt |
| AUS | EIN | EIN | 1/2 Schritt |
| EIN | AUS | AUS | 1/4 Schritt |
| AUS | EIN | AUS | 1/8 Schritt |
| AUS | AUS | EIN | 1/16 Schritt |
| AUS | AUS | AUS | 1/32 Schritt |
Generell führt eine kleinere Mikroschritt-Einstellung zu einem ruhigeren und leiseren Betrieb. Sie begrenzt jedoch die maximale Geschwindigkeit, die du beim Steuern des Schrittmotortreibers mit einem Arduino erreichen kannst.
TB6600 Stromeinstellungen
Du kannst den Strom, der zum Motor fließt, während er läuft, durch Einstellen der DIP-Schalter S4, S5 und S6 an- oder ausschalten. Ich empfehle, mit einem Strom von 1 A zu beginnen. Wenn dein Motor Schritte auslässt oder stehen bleibt, kannst du den Strom später erhöhen.
Strom-Tabelle
| Strom (A) | Spitzenstrom | S4 | S5 | S6 |
|---|---|---|---|---|
| 0,5 | 0,7 | EIN | EIN | EIN |
| 1,0 | 1,2 | EIN | AUS | EIN |
| 1,5 | 1,7 | EIN | EIN | AUS |
| 2,0 | 2,2 | EIN | AUS | AUS |
| 2,5 | 2,7 | AUS | EIN | EIN |
| 2,8 | 2,9 | AUS | AUS | EIN |
| 3,0 | 3,2 | AUS | EIN | AUS |
| 3,5 | 4,0 | AUS | AUS | AUS |
Einfacher TB6600 mit Arduino Beispielcode
Mit dem folgenden Sketch kannst du die Funktionalität des Schrittmotortreibers testen. Er lässt den Motor einfach mit einer festen Geschwindigkeit drehen.
Du kannst den Code mit dem Arduino IDE hochladen. Für dieses spezielle Beispiel musst du keine Bibliotheken installieren.
Im nächsten Beispiel schauen wir uns an, wie man die Geschwindigkeit, die Anzahl der Umdrehungen und die Drehrichtung des Schrittmotors steuert.
Du kannst den Code kopieren, indem du auf den Button oben rechts im Codefeld klickst.
/* Example sketch to control a stepper motor with TB6600 stepper motor driver
and Arduino without a library: continuous rotation.
More info: https://www.makerguides.com */
// Define stepper motor connections:
#define dirPin 2
#define stepPin 3
void setup() {
// Declare pins as output:
pinMode(stepPin, OUTPUT);
pinMode(dirPin, OUTPUT);
// Set the spinning direction CW/CCW:
digitalWrite(dirPin, HIGH);
}
void loop() {
// These four lines result in 1 step:
digitalWrite(stepPin, HIGH);
delayMicroseconds(500);
digitalWrite(stepPin, LOW);
delayMicroseconds(500);
}
Wie du siehst, ist der Code sehr kurz und einfach. Man braucht nicht viel, um einen Schrittmotor zum Drehen zu bringen!
Code-Erklärung
Der Sketch beginnt mit der Definition der Step- (PUL+) und Richtungs- (DIR+) 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.
// Define stepper motor connections: #define dirPin 2 #define stepPin 3
Im setup() Abschnitt des Codes werden alle Motorsteuerungs-Pins als digitale OUTPUTs mit der Funktion pinMode(pin, mode)deklariert. Ich habe auch die Drehrichtung des Schrittmotors eingestellt, indem ich den Richtungs-Pin auf HIGH gesetzt habe. Dafür verwenden wir die Funktion digitalWrite(pin, value).
void setup() {
// Declare pins as output:
pinMode(stepPin, OUTPUT);
pinMode(dirPin, OUTPUT);
// Set the spinning direction CW/CCW:
digitalWrite(dirPin, HIGH);
}
Im loop() Abschnitt des Codes lassen wir den Treiber einen Schritt ausführen, indem wir einen Impuls an den Step-Pin senden. Da der Code im Loop-Abschnitt kontinuierlich wiederholt wird, beginnt der Schrittmotor mit einer festen Geschwindigkeit zu drehen.
void loop() {
// These four lines result in 1 step:
digitalWrite(stepPin, HIGH);
delayMicroseconds(500);
digitalWrite(stepPin, LOW);
delayMicroseconds(500);
}
Im nächsten Beispiel siehst du, wie du die Geschwindigkeit des Motors ändern kannst.
2. Beispielcode zur Steuerung von Drehung, Geschwindigkeit und Richtung
Der folgende Sketch steuert sowohl die Geschwindigkeit, die Anzahl der Umdrehungen als auch die Drehrichtung des Schrittmotors.
/* Example sketch to control a stepper motor with TB6600 stepper motor driver
and Arduino without a library: number of revolutions, speed and direction.
More info: https://www.makerguides.com */
// Define stepper motor connections and steps per revolution:
#define dirPin 2
#define stepPin 3
#define stepsPerRevolution 1600
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);
}
Wie der Code funktioniert
Neben der Einstellung der Schrittmotoranschlüsse habe ich auch eine stepsPerRevolution Konstante definiert. Da ich den Treiber auf 1/8 Mikroschritt-Modus eingestellt habe, setze ich ihn auf 1600 Schritte pro Umdrehung (für einen Standard-Schrittmotor mit 200 Schritten pro Umdrehung). Ändere diesen Wert, wenn dein Setup anders ist.
// Define stepper motor connections and steps per revolution: #define dirPin 2 #define stepPin 3 #define stepsPerRevolution 1600
Der setup() Abschnitt ist wie zuvor, nur dass wir die Drehrichtung noch nicht definieren müssen.
Im loop() Abschnitt des Codes lassen wir den Motor eine Umdrehung langsam im Uhrzeigersinn (CW) und eine Umdrehung schnell gegen den Uhrzeigersinn (CCW) drehen. Danach lassen wir den Motor 5 Umdrehungen in jede Richtung mit hoher Geschwindigkeit drehen. 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 (Richtungs-) Pin entweder auf HIGH oder LOW. Dafür verwenden wir die Funktion digitalWrite(). Je nachdem, wie du den Schrittmotor angeschlossen hast, lässt das Setzen des DIR-Pins auf HIGH den Motor im Uhrzeigersinn oder gegen den Uhrzeigersinn drehen.
Anzahl der Schritte oder Umdrehungen steuern
In diesem Beispiel-Sketch steuern die for loops die Anzahl der Schritte, die der Schrittmotor ausführt. Der Code innerhalb der forLoop führt zu 1 (Mikro-)Schritt des Schrittmotors. Da der Code im Loop 1600 Mal ausgeführt wird (stepsPerRevolution), ergibt das 1 Umdrehung. In den letzten beiden Schleifen wird der Code innerhalb der for-Schleife 8000 Mal ausgeführt, was 8000 (Mikro-)Schritten oder 5 Umdrehungen entspricht.
Beachte, dass du den zweiten Wert in der for-Schleife auf jede gewünschte Schrittzahl ändern kannst. for(int i=0; i<800; i++) würde 800 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 steuern, indem du delayMicroseconds() im Code änderst. Je kürzer die Verzögerung, desto höher die Frequenz, desto schneller läuft der Motor.
Installation der AccelStepper-Bibliothek
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 hat auch viele andere nützliche Funktionen.
Du kannst die neueste Version dieser Bibliothek here herunterladen oder auf den Button unten klicken.
Du kannst die Bibliothek installieren, indem du zu Sketch > Include Library > Add .ZIP Library… im Arduino IDE gehst.
Eine andere 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.
Du kannst nach „accelstepper“ suchen und die Bibliothek von Mike McCauley auswählen. Wähle die neueste Version und klicke dann auf Installieren.
3. AccelStepper Beispielcode
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 1000 Schritten pro Sekunde und einer Beschleunigung von 500 Schritten pro Sekunde² hin und her.
Beachte, dass ich den Treiber weiterhin im 1/8 Mikroschritt-Modus verwende. Wenn du eine andere Einstellung nutzt, experimentiere mit den Geschwindigkeits- und Beschleunigungseinstellungen.
/* Example sketch to control a stepper motor with TB6600 stepper motor driver,
AccelStepper library and Arduino: acceleration and deceleration.
More info: https://www.makerguides.com */
// Include the AccelStepper library:
#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(1000);
stepper.setAcceleration(500);
}
void loop() {
// Set the target position:
stepper.moveTo(8000);
// 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
Der erste Schritt ist, die Bibliothek mit #include <AccelStepper.h>einzubinden.
// Include the AccelStepper library: #include "AccelStepper.h"
Als nächstes definierst du die TB6600-zu-Arduino-Verbindungen und den Motor-Interface-Typ. Der Motor-Interface-Typ muss auf 1 gesetzt werden, wenn du einen Step- und Direction-Treiber verwendest.
// 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
Dann musst du eine neue Instanz der AccelStepper-Klasse mit dem passenden Motor-Interface-Typ 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 verschiedenen 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() müssen wir neben der maximalen Geschwindigkeit auch die Beschleunigung/Verzögerung definieren. Dafür verwenden wir die Funktion setMaxSpeed() und setAcceleration().
void setup() {
// Set the maximum speed and acceleration:
stepper.setMaxSpeed(1000);
stepper.setAcceleration(500);
}
Im Loop-Abschnitt des Codes lassen wir den Motor eine vordefinierte Anzahl von Schritten drehen. Die Funktion stepper.moveTo() wird verwendet, um die Zielposition (in Schritten) 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(8000); // Run to target position with set speed and acceleration/deceleration: stepper.runToPosition();
Wenn du mehr Beispiele für die AccelStepper-Bibliothek sehen möchtest, schau dir mein Tutorial zu How to control a stepper motor with A4988 driver and Arduino an.
Fazit
In diesem Artikel habe ich dir gezeigt, wie du einen Schrittmotor mit dem TB6600-Schrittmotortreiber und Arduino steuerst. Ich hoffe, du fandest es nützlich und informativ.
Wenn du mehr über andere Schrittmotortreiber erfahren möchtest, könnten die folgenden Artikel hilfreich sein:
- TB6560 Stepper Motor Driver with Arduino Tutorial
- 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
- Control a Stepper Motor with an IR Remote
Wir haben auch einen Artikel über How To Use the TB6600 Stepper Motor Driver with ESP32 , falls du stattdessen mit einem ESP32-Mikrocontroller arbeiten möchtest.
Wenn du Fragen hast, hinterlasse bitte einen Kommentar unten.
