In diesem Artikel lernst du, wie du einen Schrittmotor mit dem L298N Motor-Treiber steuerst. Dieses Treiber-Board wird normalerweise zur Steuerung von Gleichstrommotoren verwendet, ist aber auch eine kostengünstige Alternative zur Steuerung von Schrittmotoren! Es kann sowohl die Geschwindigkeit als auch die Drehrichtung der meisten Schrittmotoren wie einem NEMA 17 steuern.
Ich habe ein Schaltbild und viele Beispielcodes beigefügt. Im ersten Beispiel schauen wir uns die Stepper.h Arduino-Bibliothek an. Ich empfehle dir auch, am Ende dieses Tutorials einen Blick auf die Beispielcodes für die AccelStepper Bibliothek zu werfen. Diese Bibliothek ist recht einfach zu verwenden und kann die Leistung deiner Hardware deutlich verbessern.
Nach jedem Beispiel erkläre ich, wie der Code funktioniert, sodass du ihn problemlos an deine Bedürfnisse anpassen kannst.
Materialien
Hardware-Komponenten
 | L298N motor driver board | × 1 | Amazon |
 | NEMA 17 stepper motor | × 1 | Amazon |
 | Arduino Uno Rev3 | × 1 | Amazon |
| 12V power supply | × 1 | Amazon | |
| Jumper wires | × 10 | Amazon | |
| USB cable type A/B | × 1 | Amazon |
Software
Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.
Informationen zum L298N Motor-Treiber
Das L298N Motor-Treiber-Board ist um den L298 Dual-Full-Bridge-Treiber von STMicroelectronics aufgebaut. Mit diesem Motor-Treiber kannst du Gleichstrommotoren, Schrittmotoren, Relais und Magnetventile steuern. Es verfügt über zwei separate Kanäle, genannt A und B, mit denen du 2 Gleichstrommotoren oder 1 Schrittmotor steuern kannst, wenn sie kombiniert werden.
Der L298N ist normalerweise auf einer (roten) Breakout-Platine montiert, was das Verdrahten erheblich erleichtert. Die Breakout-Platine enthält außerdem einen 78M05 5 V Spannungsregler.
Warum wird mein Schrittmotor HEISS?
Wichtig zu wissen ist, dass der L298 keine einfache Möglichkeit zur Strombegrenzung hat im Gegensatz zu anderen Schrittmotortreibern wie dem A4988. Das bedeutet, dass der Stromverbrauch von der Beziehung zwischen Induktivität und Widerstand (L/R) des angeschlossenen Schrittmotors abhängt. Wenn der Motor zu viel Strom zieht, kannst du den Treiber beschädigen und der Motor wird heiß!
Das bedeutet für dich, dass du bei der Auswahl des Schrittmotors und der Stromversorgung für diesen Motor-Treiber vorsichtig sein musst. Nicht alle Schrittmotoren funktionieren! Die Betriebsspannung des L298N liegt zwischen 4,8 und 46 Volt (maximal 35 V, wenn er auf der Breakout-Platine montiert ist). Da der Treiber einen maximalen Strom von 2 Ampere pro Kanalliefern kann, musst du einen Schrittmotor finden, der in diesem Spannungsbereich betrieben werden kann und die maximale Stromstärke nicht überschreitet.
Überprüfe das Datenblatt deines Schrittmotors und suche nach der Spannung bzw. dem Stromverbrauch des Motors. Wenn du kein Datenblatt findest, kannst du den Widerstand einer Wicklung messen und mit folgender Formel den Stromverbrauch schätzen:
I = U ÷ R oder Stromverbrauch (A) = Versorgungsspannung (V) ÷ Wicklungswiderstand (Ω)
Ich würde versuchen, einen Motor zu finden, der bei der gewünschten Spannung weniger als 2 A zieht.
Der Motor, den ich für dieses Tutorial verwendet habe, zieht bei 5 V etwa 1 A. Ich habe auch diesen Schrittmotor von Adafruit gefunden, der bei 12 V gut funktioniert und nur 350 mA zieht.
Wenn der Motor, den du antreiben möchtest, nicht mit dem L298N Motor-Treiber funktioniert, ist es besser, einen Chopper-Treiber zu verwenden. Ich habe Tutorials für die A4988 und DRV8825 Treiber geschrieben, die mit vielen Schrittmotoren hervorragend funktionieren.
L298N Motor-Treiber Spezifikationen
| Betriebsspannung | 5 – 35 V |
| Logikspannung | 4,5 – 7 V |
| Maximaler Strom | 2 A pro Kanal oder 4 A max |
| Motorsteuerung | L298N, steuert 2 Gleichstrommotoren oder 1 Schrittmotor |
| Spannungsregler | 78M05 |
| Modulabmessungen | 43 x 43 x 28 mm |
| Bohrungsabmessungen | 3,2 mm, 37 mm Abstand |
| Kosten | Check price |
Weitere Informationen findest du im folgenden Datenblatt:
L298N Pinbelegung
Der L298 ist in verschiedenen Gehäusen erhältlich, die Pinbelegung für den L298N (Multiwatt15) ist unten angegeben:
| Pin Nr. | Name | Funktion |
|---|---|---|
| 1, 15 | Sense A, Sense B | Der Sense-Widerstand muss zwischen diesem Pin und GND angeschlossen werden (auf der Breakout-Platine nicht verwendet). |
| 2, 3 | Out 1, Out 2 | Ausgänge der Brücke A; der Strom, der durch die Last zwischen diesen beiden Pins fließt, wird an Pin 1 überwacht. |
| 4 | Vs | Versorgungsspannung für die Leistungsausgänge |
| 5, 7 | Input 1, Input 2 | TTL-kompatible Eingänge der Brücke A |
| 6, 11 | Enable A, Enable B | TTL-kompatibler Enable-Eingang: Der LOW-Zustand deaktiviert die Brücke A (Enable A) und/oder die Brücke B (Enable B). |
| 8 | GND | Masse |
| 9 | VSS | Versorgungsspannung für die Logikblöcke. |
| 10, 12 | Input 3, Input 4 | TTL-kompatible Eingänge der Brücke B. |
| 13, 14 | Out 3, Out 4 | Ausgänge der Brücke B; der Strom, der durch die Last zwischen diesen beiden Pins fließt, wird an Pin 15 überwacht. |
Verdrahtung – Anschluss des L298N an Schrittmotor und Arduino
Das folgende Schaltbild zeigt, wie du einen Schrittmotor, die Stromversorgung und den Arduino mit der L298N Breakout-Platine verbindest.
Die Anschlüsse sind auch in der folgenden Tabelle aufgeführt:
L298N Anschlüsse
| L298N | Anschluss |
|---|---|
| +12V | 5 – 35 V Stromversorgung |
| GND | Masse der Stromversorgung und Arduino |
| 12 V Jumper | Entfernen, wenn Motorstrom > 12 V! |
| 5V+ (optional) | 5 V Arduino, wenn der 12 V Jumper entfernt ist |
| IN1 | Pin 8 Arduino |
| IN2 | Pin 9 Arduino |
| IN3 | Pin 10 Arduino |
| IN4 | Pin 11 Arduino |
| ENA und ENB Jumper | Eingebaut lassen |
| OUT1 + OUT2 | Schrittmotor-Spule A |
| OUT3 + OUT4 | Schrittmotor-Spule B |
Wichtiger Hinweis: Entferne den +12V Jumper, wenn du eine Stromversorgung mit mehr als 12 V verwendest.
Wenn der +12V Jumper gesetzt ist, ist der onboard Spannungsregler aktiviert und erzeugt die 5 V Logikspannung. Wenn du den Jumper entfernst, musst du der Platine 5 V vom Arduino bereitstellen.
Du musst außerdem die ENA- und ENB-Jumper an ihrem Platz lassen, damit der Motor immer aktiviert ist.
Wie bestimme ich die Verkabelung des Schrittmotors?
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 zu identifizieren:
Das Einzige, was du herausfinden musst, sind die zwei Drahtpaare, die jeweils mit einer der beiden Spulen verbunden sind. Eine Spule wird an OUT1 und OUT2 angeschlossen, die andere an OUT3 und OUT4, 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 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.
Schließe nun die beiden Spulen an die Pins an, die im obigen Verdrahtungsdiagramm gezeigt sind.
Beispielcode für die Stepper.h Bibliothek mit L298N Treiber, Schrittmotor und Arduino
Du kannst den folgenden Beispielcode mit dem Arduino IDE hochladen.
Dieses Beispiel verwendet die Stepper.h Bibliothek, die standardmäßig mit der Arduino IDE installiert sein sollte. Du findest sie unter Sketch > Include Library > Stepper.
Dieses Sketch dreht den Schrittmotor 1 Umdrehung in eine Richtung, pausiert und dreht dann 1 Umdrehung in die andere Richtung.
/* Example sketch to control a stepper motor with
L298N motor driver, Arduino UNO and Stepper.h library.
More info: https://www.makerguides.com */
// Include the Stepper library:
#include "Stepper.h"
// Define number of steps per revolution:
const int stepsPerRevolution = 200;
// Initialize the stepper library on pins 8 through 11:
Stepper myStepper = Stepper(stepsPerRevolution, 8, 9, 10, 11);
void setup() {
// Set the motor speed (RPMs):
myStepper.setSpeed(100);
}
void loop() {
// Step one revolution in one direction:
myStepper.step(200);
delay(2000);
// Step on revolution in the other direction:
myStepper.step(-200);
delay(2000);
}
Wie der Code funktioniert:
Das Sketch beginnt mit dem Einbinden der Stepper.h Arduino-Bibliothek. Mehr Informationen zu dieser Bibliothek findest du auf der Arduino website.
// Include the Stepper library: #include "Stepper.h"
Als Nächstes definieren wir, wie viele Schritte der Motor für eine Umdrehung benötigt. In diesem Beispiel verwenden wir den Motor im Vollschrittmodus. Das bedeutet, dass 200 Schritte für 360 Grad benötigt werden. Du kannst diesen Wert ändern, wenn du einen anderen Schrittmotortyp oder eine andere Konfiguration verwendest.
// Define number of steps per revolution: const int stepsPerRevolution = 200;
Danach erstellst du eine neue Instanz der Stepper-Klasse, die einen bestimmten Schrittmotor repräsentiert, der an den Arduino angeschlossen ist. Dafür verwenden wir die Funktion Stepper(steps, pin1, pin2, pin3, pin4) wobei steps die Anzahl der Schritte pro Umdrehung ist und pin1 bis pin4 die Pins sind, die den Schrittmotor antreiben. In unserem Fall sind das die Pins 8, 9, 10 und 11.
// Initialize the stepper library on pins 8 through 11: Stepper myStepper = Stepper(stepsPerRevolution, 8, 9, 10, 11);
Ich habe den Schrittmotor ‘myStepper’ genannt, aber du kannst auch andere Namen verwenden, wie ‘z_motor’ oder ‘liftmotor’ usw. Stepper liftmotor = Stepper(stepsPerRevolution, 8, 9, 10, 11);. Der Name ‘myStepper’ wird verwendet, um die Geschwindigkeit und die Anzahl der Schritte für diesen speziellen Motor einzustellen. Du kannst mehrere Stepper-Objekte mit unterschiedlichen Namen erstellen, wenn du mehr als einen Motor steuern möchtest.
Im setup() definieren wir die Geschwindigkeit des Motors. Du kannst die Geschwindigkeit in U/min mit der Funktion setSpeed(rpm)einstellen. Ich habe sie auf 100 gesetzt, sodass wir etwa 1,6 Umdrehungen pro Sekunde sehen sollten.
// Set the motor speed (RPMs): myStepper.setSpeed(100);
Im loop-Teil des Codes rufen wir einfach die step(steps) Funktion auf, die den Motor eine bestimmte Anzahl von Schritten mit der durch die setSpeed(rpm) Funktion festgelegten Geschwindigkeit dreht. Wenn du eine negative Zahl übergibst, dreht sich der Motor in die entgegengesetzte Richtung.
void loop() {
// Step one revolution in one direction:
myStepper.step(200);
delay(2000);
// Step on revolution in the other direction:
myStepper.step(-200);
delay(2000);
}
Beachte, dass die step(steps) Funktion blockierendist, das heißt, sie wartet, bis der Motor die Bewegung abgeschlossen hat, bevor sie die Kontrolle an die nächste Zeile im Sketch übergibt.
Installation der AccelStepper Bibliothek
In den folgenden drei Beispielen zeige ich dir, wie du sowohl die Geschwindigkeit, die Richtung als auch die Anzahl der Schritte des Schrittmotors steuern kannst. In diesem Beispiel verwende ich die AccelStepper Bibliothek.
Die AccelStepper Bibliothek von Mike McCauley 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 Bibliothek installieren, indem du zu Tools > Manage Libraries…gehst oder auf Windows Strg + Shift + I drückst. Der Library Manager öffnet sich und aktualisiert die Liste der installierten Bibliotheken.
Suche nach ‘accelstepper’ und suche die Bibliothek von Mike McCauley. Wähle die neueste Version aus und klicke auf Installieren.
1. Beispielcode für kontinuierliche Rotation mit AccelStepper
Das folgende Sketch kann verwendet werden, um einen oder mehrere Schrittmotoren kontinuierlich mit konstanter Geschwindigkeit laufen zu lassen. (Keine Beschleunigung oder Verzögerung).
/* Example sketch to control a stepper motor with L298N motor driver, Arduino UNO and AccelStepper.h library.
Contiuous rotation.
https://www.makerguides.com */
// Include the AccelStepper library:
#include "AccelStepper.h"
// Define the AccelStepper interface type:
#define MotorInterfaceType 4
// Create a new instance of the AccelStepper class:
AccelStepper stepper = AccelStepper(MotorInterfaceType, 8, 9, 10, 11);
void setup() {
// Set the maximum speed in steps per second:
stepper.setMaxSpeed(1000);
}
void loop() {
// Set the speed of the motor in steps per second:
stepper.setSpeed(500);
// Step the motor with constant speed as set by setSpeed():
stepper.runSpeed();
}
Wie der Code funktioniert:
Der erste Schritt ist das Einbinden der Bibliothek mit #include "AccelStepper.h„.
// Include the AccelStepper library: #include "AccelStepper.h"
Als nächstes definierst du den Motortyp. Der Motortyp muss auf 4 gesetzt werden, wenn du einen 4-Draht-Schrittmotor im Vollschrittmodus (200 Schritte/Umdrehung) verwendest. Die anderen Motortypen findest du here.
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 beim Kompilieren. Also überall, wo du motorInterfaceTypeerwähnst, ersetzt der Compiler es durch den Wert 4 beim Kompilieren.
// Define the AccelStepper interface type: #define MotorInterfaceType 4
Als Nächstes erstellst du eine neue Instanz der AccelStepper-Klasse mit dem passenden Motortyp und den Verbindungen.
Ich habe den Schrittmotor ‘stepper’ genannt, aber du kannst auch andere Namen verwenden, wie ‘z_motor’ oder ‘liftmotor’ usw. AccelStepper liftmotor = AccelStepper(motorInterfaceType, 8, 9, 10, 11);. Wie im vorherigen Beispiel wird der Name verwendet, um später 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, 8, 9, 10, 11);
Im setup() Teil 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 diesen Wert 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 eine andere Geschwindigkeit einstellen:
void setup() {
// Set the maximum speed in steps per second:
stepper.setMaxSpeed(1000);
stepper2.setMaxSpeed(300);
}
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-Teil des Codes machen).
stepper.runSpeed() fragt den Motor ab und führt einen Schritt aus, wenn es Zeit dafür ist. 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 einstellen: stepper.setSpeed(-400); dreht den Motor in die andere Richtung.
void loop() {
// Set the speed of the motor in steps per second:
stepper.setSpeed(500);
// Step the motor with constant speed as set by setSpeed():
stepper.runSpeed();
}
2. Beispielcode zur Steuerung der Schritt- oder Umdrehungsanzahl
Mit dem folgenden Sketch kannst du sowohl die Geschwindigkeit, die Richtung als auch die Anzahl der Schritte/Umdrehungen steuern.
In diesem Fall dreht der Schrittmotor 2 Umdrehungen im Uhrzeigersinn mit 200 Schritten/Sekunde, dann 1 Umdrehung gegen den Uhrzeigersinn mit 600 Schritten/Sekunde und zuletzt 3 Umdrehungen im Uhrzeigersinn mit 400 Schritten/Sekunde.
/* Example sketch to control a stepper motor with
L298N motor driver, Arduino UNO and AccelStepper.h library.
More info: https://www.makerguides.com */
// Include the AccelStepper library:
#include "AccelStepper.h"
// Define the AccelStepper interface type:
#define MotorInterfaceType 4
// Create a new instance of the AccelStepper class:
AccelStepper stepper = AccelStepper(MotorInterfaceType, 8, 9, 10, 11);
void setup() {
// Set the maximum steps per second:
stepper.setMaxSpeed(1000);
}
void loop() {
// Set the current position to 0:
stepper.setCurrentPosition(0);
// Run the motor forward at 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 zur loop()-Funktion ist genau wie im vorherigen Beispiel.
In der loop verwende ich eine while loop in Kombination mit der currentPosition() Funktion. Zuerst setze ich die aktuelle Position des Schrittmotors mit stepper.setCurrentPosition(0)auf Null.
// Set the current position to 0: stepper.setCurrentPosition(0);
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 200 Schritten ist (!= bedeutet: ist nicht gleich). Solange das zutrifft, läuft der Schrittmotor mit der durch setSpeed() festgelegten konstanten Geschwindigkeit.
// 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 loop machen wir genau dasselbe, nur mit anderer Geschwindigkeit und Zielposition.
3. Beispielcode für Beschleunigung und Verzögerung
In diesem Beispiel schauen wir uns einen der Hauptgründe an, warum man die AccelStepper Bibliothek verwendet.
Mit dem folgenden Sketch kannst du Beschleunigung und Verzögerung zu den Bewegungen des Schrittmotors hinzufügen, ohne komplizierten Code. Der erste Teil dieses Sketches ist wie im Beispiel 1, aber Setup und loop sind anders.
Der Motor dreht fünf Umdrehungen hin und her mit einer Geschwindigkeit von 200 Schritten pro Sekunde und einer Beschleunigung von 50 Schritten/Sekunde2.
/* Example sketch to control a stepper motor with
L298N motor driver, Arduino UNO and AccelStepper.h library.
Acceleration and deceleration.
More info: https://www.makerguides.com */
// Include the AccelStepper library:
#include "AccelStepper.h"
// Define the AccelStepper interface type:
#define MotorInterfaceType 4
// Create a new instance of the AccelStepper class:
AccelStepper stepper = AccelStepper(MotorInterfaceType, 8, 9, 10, 11);
void setup() {
// Set the maximum steps per second:
stepper.setMaxSpeed(200);
// Set the maximum acceleration in steps per second^2:
stepper.setAcceleration(50);
}
void loop() {
// Set target position:
stepper.moveTo(1000);
// Run to position with set speed and acceleration:
stepper.runToPosition();
delay(1000);
// Move back to original position:
stepper.moveTo(0);
// Run to position with set speed and acceleration:
stepper.runToPosition();
delay(1000);
}
Wie der Code funktioniert:
Im setup()müssen wir neben der maximalen Geschwindigkeit auch die Beschleunigung/Verzögerung definieren. Dafür verwenden wir die Funktion setAcceleration().
// Set the maximum steps per second: stepper.setMaxSpeed(200); // Set the maximum acceleration in steps per second^2: stepper.setAcceleration(50);
Im loop-Teil des Codes habe ich eine andere Methode verwendet, um den Motor eine vorgegebene Anzahl von Schritten drehen zu lassen. Zuerst setze ich die Zielposition mit der Funktion moveTo(). Dann verwenden wir einfach die Funktion runToPosition() , damit der Motor mit der eingestellten Geschwindigkeit und Beschleunigung zur Zielposition läuft. Der Motor wird vor Erreichen der Zielposition abbremsen.
// Set target position: stepper.moveTo(1000); // Run to position with set speed and acceleration: stepper.runToPosition();
Zum Schluss setzen wir die neue Zielposition wieder auf 0, damit wir zum Ursprung zurückkehren.
Fazit
In diesem Artikel habe ich dir gezeigt, wie du einen Schrittmotor mit einem L298N Motor-Treiber steuern kannst. Wir haben 4 Beispiele betrachtet, die sowohl die Stepper- als auch die AccelStepper-Bibliothek verwenden.
Wenn du mehr über andere Schrittmotortreiber lernen möchtest, könnten die folgenden Artikel nützlich 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
Beachte, dass der Arduino Motor Shield Rev3 ebenfalls einen L298 Treiber verwendet.
Wenn du Fragen, Vorschläge hast oder denkst, dass in diesem Tutorial etwas fehlt, hinterlasse bitte unten einen Kommentar.
