In diesem Tutorial lernst du, wie du einen Schrittmotor mit dem TB6560-Mikroschritt-Treiber und Arduino steuerst. Dieser Treiber ist einfach zu verwenden und kann große Schrittmotoren wie einen 3 A NEMA 23.
Ich habe ein Schaltbild und 2 Beispielcodes beigefügt. Im ersten Beispiel zeige ich dir, wie du diesen Schrittmotortreiber ohne Arduino-Bibliothek verwenden kannst. Im zweiten Beispiel schauen wir uns die AccelStepper-Bibliothek an. Diese Bibliothek ist recht einfach zu nutzen und ermöglicht es dir, Beschleunigung und Verzögerung zur Bewegung des Schrittmotors hinzuzufügen.
Nach jedem Beispiel erkläre ich den Code Schritt für Schritt, sodass du ihn problemlos an deine Bedürfnisse anpassen kannst.
Materialien
Hardware-Komponenten
| TB6560 stepper motor driver | × 1 | Amazon | |
 | NEMA 23 stepper motor | × 1 | Amazon |
 | Arduino Uno Rev3 | × 1 | Amazon |
| Power supply (24 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 TB6560 Mikroschritt-Treiber basiert auf dem Toshiba TB6560AHQ-Chip und kann verwendet werden, um zweiphasige bipolare Schrittmotoren anzusteuern.
Mit einem maximalen Dauerstrom von 3 A kann der TB6560-Treiber recht große Schrittmotoren wie einen NEMA 23 steuern. Achte darauf, keine Schrittmotoren mit einem Nennstrom von mehr als 3 A an den Treiber anzuschließen.
Der Chip verfügt über mehrere eingebaute Schutzfunktionen wie Überstrom-, Unterspannungsaus- und Überhitzungsschutz. Er hat jedoch keinen Verpolungsschutz, daher solltest du die Stromversorgung korrekt anschließen. Weitere Spezifikationen findest du in der Tabelle unten.
TB6560 Spezifikationen
| Betriebsspannung | 10 – 35 VDC, 24 VDC empfohlen |
| Maximaler Ausgangsstrom | 3 A pro Phase, 3,5 A Spitze |
| Mikroschrittauflösung | Voll, 1/2, 1/8 und 1/16 |
| Schutz | Unterspannungsaus, Überhitzungs- und Überstromschutz |
| Abmessungen | 75 x 50 x 35 mm |
| Bohrlochabstand | 69 x 43 mm, ⌀ 3,5 mm |
| Kosten | Check price |
Weitere Informationen findest du im untenstehenden Datenblatt/Handbuch:
Beachte, dass der TB6560 ein analoger Treiber ist. In den letzten Jahren sind digitale Treiber wie der DM556 oder DM542 deutlich 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 TB6560, sodass du dein System später problemlos aufrüsten kannst.
Ich habe die DM556-Treiber für meinen DIY-CNC-Fräser verwendet, und sie funktionieren seit mehreren Jahren einwandfrei.
TB6560 vs TB6600
Beim Kauf eines TB6560-Schrittmotortreibers wirst du wahrscheinlich auch auf den etwas teureren TB6600 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 |
Die Hauptunterschiede sind also die höhere maximale Spannung, der höhere maximale Strom und bis zu 1/32 Mikroschrittauflösung. Wenn du größere Schrittmotoren steuern oder eine höhere Auflösung benötigst, empfehle ich den TB6600.
Verdrahtung – Anschluss des TB6560 an Schrittmotor und Arduino
Das folgende Schaltbild zeigt, wie du den TB6560-Schrittmotortreiber mit dem Arduino und einem Schrittmotor verbinden kannst.
In diesem Tutorial schließen wir den Treiber in einer gemeinsamen Kathoden-Konfiguration an. Das bedeutet, dass wir alle negativen Seiten der Steuersignale zusammen auf Masse legen.
Die Anschlüsse sind auch in der folgenden Tabelle aufgeführt:
TB6560 Anschlüsse
| TB6560 | Anschluss |
|---|---|
| VCC | 10 – 35 VDC |
| GND | Masse der Stromversorgung |
| EN- | Nicht verbunden |
| EN+ | Nicht verbunden |
| CW- | Arduino GND |
| CW+ | Pin 2 Arduino |
| CLK- | Arduino GND |
| CLK+ | Pin 3 Arduino |
| A-, A+ | Spule 1 Schrittmotor |
| B-, B+ | Spule 2 Schrittmotor |
Beachte, dass die Enable-Pins (EN- und EN+) nicht verbunden sind. Das bedeutet, dass der Enable-Pin immer LOW ist und der Treiber immer aktiviert ist.
Wie bestimmt man die korrekte 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 getrennt 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 jetzt, während du die Enden zusammenhältst, die Welle des Schrittmotors erneut zu drehen.
Wenn du starken Widerstand spürst, hast du ein Drahtpaar gefunden, das mit derselben Spule verbunden ist. Das andere Drahtpaar gehört zur zweiten Spule.
Wenn sich die Welle noch frei drehen lässt, probiere ein anderes Drahtpaar. Verbinde dann die beiden Spulen mit den Pins, die im Verdrahtungsdiagramm oben gezeigt sind.
Wenn es immer noch unklar ist, hinterlasse bitte einen Kommentar unten, weitere Informationen findest du auch auf der RepRap.org wiki.
TB6560 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 TB6560 ermöglicht höhere Auflösungen durch Zwischenpositionen. Dies wird erreicht, indem die Spulen mit Zwischenstromstärken angesteuert werden.
Beispielsweise 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-Einstellung oder den Erregungsmodus des TB6560 ändern, indem du die DIP-Schalter am Treiber ein- oder ausschaltest. Siehe die Tabelle unten für Details. Achte darauf, dass der Treiber beim Einstellen der DIP-Schalter nicht mit Strom versorgt wird!
Mikroschritt-Tabelle
| S3 | S4 | Mikroschrittauflösung |
|---|---|---|
| AUS | AUS | Vollschritt |
| EIN | AUS | 1/2 Schritt |
| EIN | EIN | 1/8 Schritt |
| AUS | EIN | 1/16 Schritt |
Generell führt eine kleinere Mikroschritt-Einstellung zu einem ruhigeren und leiseren Betrieb. Allerdings begrenzt sie die maximale Geschwindigkeit, die du beim Steuern des Schrittmotortreibers mit einem Arduino erreichen kannst.
TB6560 Stromeinstellungen
Du kannst den Strom, der zum Motor fließt, während er läuft, einstellen, indem du die DIP-Schalter SW1, SW2, SW3 und S1 ein- oder ausschaltest. 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
| (A) | SW1 | SW2 | SW3 | S1 |
|---|---|---|---|---|
| 0,3 | AUS | AUS | EIN | EIN |
| 0,5 | AUS | AUS | EIN | AUS |
| 0,8 | AUS | EIN | AUS | EIN |
| 1 | AUS | EIN | AUS | AUS |
| 1,1 | AUS | EIN | EIN | EIN |
| 1,2 | EIN | AUS | AUS | EIN |
| 1,4 | AUS | EIN | EIN | AUS |
| 1,5 | EIN | AUS | EIN | EIN |
| 1,6 | EIN | AUS | AUS | AUS |
| 1,9 | EIN | EIN | AUS | EIN |
| 2 | EIN | AUS | EIN | AUS |
| 2,2 | EIN | EIN | EIN | EIN |
| 2,6 | EIN | EIN | AUS | AUS |
| 39 | EIN | EIN | EIN | AUS |
Der Haltestrom ist der Strom, der verwendet wird, um die Motorwelle in einer gestoppten Position zu halten. Du solltest diesen so niedrig wie möglich einstellen, um unnötige Erwärmung des Motors zu minimieren. Erhöhe diesen Wert, wenn dein Motor seine Position nicht halten kann.
Haltestrom-Tabelle
| Haltestrom | S2 |
|---|---|
| 20 % | EIN |
| 50 % | AUS |
Die Decay-Einstellung betrifft, wie der Treiberchip die Gegen-EMK des Motors behandelt. Das TB6560 Toshiba-Datenblatt bietet einige Erklärungen und Diagramme zu dieser Einstellung. Ich lasse den Decay-Modus normalerweise auf 0 %. Du kannst mit dieser Einstellung experimentieren, um die besten Ergebnisse für dein Setup zu erzielen.
Als Referenz hat der TB6600-Treiber eine feste Decay-Einstellung von 40 %.
Decay-Einstellungstabelle
| S5 | S6 | |
|---|---|---|
| 0 % Normal | AUS | AUS |
| 25 % | EIN | AUS |
| 50 % | AUS | EIN |
| 100 % Schnellmodus | EIN | EIN |
Im weiteren Verlauf dieses Tutorials verwende ich den Treiber im 1/8-Mikroschritt-Modus mit 1 A Laufstrom, 20 % Haltestrom und 0 % Decay-Einstellung.
TB6560 Arduino Beispielcode
Nachdem du den Treiber verdrahtet und die DIP-Schalter 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 die Schaltfläche oben rechts im Codefeld klickst.
/* Example sketch to control a stepper motor with TB6560 stepper motor driver and Arduino without a library.Homepage*/ // 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:
Der Sketch beginnt mit der Definition der Step- (CLK-) und Richtungs- (CW-) 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 1/8 Mikroschritt-Modus eingestellt habe, setze ich sie auf 1600 Schritte 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
Im setup() Abschnitt des Codes werden alle Motorsteuerungs-Pins mit der Funktion pinMode()als digitale OUTPUTs deklariert.
void setup() {
// Declare pins as output:
pinMode(stepPin, OUTPUT);
pinMode(dirPin, OUTPUT);
}
Im loop() Abschnitt des Codes lassen wir den Motor eine Umdrehung langsam in CW-Richtung und eine Umdrehung schnell in CCW-Richtung 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 (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 for-Schleife führt einen (Mikro-)Schritt des Schrittmotors aus. Da der Code in der Schleife 1600 Mal (stepsPerRevolution) ausgeführt wird, ergibt das eine 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 Impulsfrequenz steuern, indem du delayMicroseconds() im Code änderst. Je kürzer die Verzögerung, desto höher die Frequenz und 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 bietet auch viele andere nützliche Funktionen.
Du kannst die neueste Version dieser Bibliothek hier herunterladen:
Du kannst die Bibliothek installieren, indem du in der Arduino IDE zu Sketch > Include Library > Add .ZIP Library… 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.
AccelStepper Beispielcode
Mit dem folgenden Sketch kannst du Beschleunigung und Verzögerung zur Bewegung des Schrittmotors hinzufügen, ohne komplizierten Code. Im folgenden Beispiel läuft der Motor mit einer Geschwindigkeit von 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 TB6560 stepper motor driver, AccelStepper library and Arduino: acceleration and deceleration.Homepage*/ // 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 TB6560-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 erstellst du eine neue Instanz der AccelStepper-Klasse mit dem passenden Motor-Interface-Typ und den Verbindungen.
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() 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 zum A4988-Schrittmotortreiber an:
Fazit
In diesem Artikel habe ich dir gezeigt, wie du einen Schrittmotor mit dem TB6560-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:
- TB6600 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
Beachte, dass Kommentare zur Moderation zurückgehalten werden, um Spam zu verhindern.
