Wie man einen Schrittmotor mit dem Arduino Motor Shield Rev3 steuert

In diesem Tutorial lernst du, wie du einen Schrittmotor mit dem Arduino Motor Shield Rev3 steuerst. Ich habe ein Schaltbild und viele Beispielcodes beigefügt.

Zuerst schauen wir uns ein Beispiel an, das die Arduino Stepper-Bibliothek verwendet. Diese Bibliothek ist ideal für die grundlegende Steuerung von Schrittmotoren, bietet aber nicht viele Zusatzfunktionen.

Ich empfehle dir dringend, auch die Beispielcodes für die AccelStepper-Bibliothekam Ende dieses Tutorials anzusehen. Diese Bibliothek ist recht einfach zu verwenden und kann die Leistung deiner Hardware deutlich verbessern.

Materialien

Hardware-Komponenten

	Arduino Motor Shield Rev3	× 1	Amazon
	NEMA 17 stepper motor*	× 1	Amazon
	Arduino Uno Rev3	× 1	Amazon
	Power supply (5-12 V)	× 1	Amazon
	USB cable type A/B	× 1	Amazon

In diesem Tutorial habe ich einen bipolaren Schrittmotor mit 4 Drähten verwendet. Versuche, einen Schrittmotor zu finden, der mit 5-12 V betrieben werden kann und die Stromgrenze von 2 A nicht überschreitet. Dieser Stepper motor von Adafruit funktioniert bei 12 V sehr gut und zieht nicht zu viel Strom (350 mA).

Software

Arduino IDE

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 Arduino Motor Shield Rev3

Das Arduino Motor Shield Rev3 basiert auf dem L298 Dual-Full-Bridge-Treiber von STMicroelectronics. Mit dem Shield kannst du Gleichstrommotoren, einen Schrittmotor, Relais und Magnetventile steuern. Es verfügt über zwei separate Kanäle, genannt A und B, mit denen du 2 Gleichstrommotoren oder 1 Schrittmotor in Kombination betreiben kannst.

Wichtig zu wissen ist, dass der L298 ein Konstantspannungs-Treiberist. Das bedeutet, dass der Stromverbrauch von der Beziehung zwischen Induktivität und Widerstand (L/R) des Motors abhängt, den du anschließt.

Das bedeutet für dich, dass du bei der Auswahl des Schrittmotors und der Stromversorgung für dieses Shield vorsichtig sein musst. Nicht alle Schrittmotoren funktionieren! Das Shield arbeitet mit einer Betriebsspannung zwischen 5 und 12 Volt. Da das Shield maximal 2 Ampere pro Kanal liefern kann, musst du einen Schrittmotor finden, der in diesem Spannungsbereich betrieben werden kann und die maximale Stromstärke nicht überschreitet. Der Motor, den ich für dieses Tutorial verwendet habe, zieht bei 5 V etwa 1 A.

Wenn der Motor, den du betreiben möchtest, mit diesem Shield nicht funktioniert, empfehle ich die Verwendung eines Chopper-Treibers. Ich habe Tutorials für den A4988 und DRV8825 Treiber geschrieben, die mit vielen Schrittmotoren gut funktionieren.

Arduino Motor Shield Rev3 Spezifikationen

Betriebsspannung	5 V bis 12 V
Motorcontroller	L298P, steuert 2 Gleichstrommotoren oder 1 Schrittmotor
Maximalstrom	2A pro Kanal oder 4A max. (mit externer Stromversorgung)
Strommessung	1,65V/A
Funktionen	Freilauf, Stopp und Bremse
Kosten	Check price

Weitere Informationen findest du in den Datenblättern hier.

Ein- und Ausgänge

Funktion	Pins Kanal A	Pins Kanal B
Richtung	D12	D13
PWM	D3	D11
Bremse	D9	D8
Strommessung	A0	A1

Verdrahtung – Anschluss eines Schrittmotors an das Arduino Motor Shield Rev3

Das folgende Schaltbild zeigt, wie du einen Schrittmotor und die Stromversorgung an das Arduino Motor Shield anschließt.

Die Anschlüsse sind auch in der folgenden Tabelle aufgeführt.

Arduino Motor Shield Rev3 Anschlüsse

Arduino Motor Shield Rev3	Anschluss
Vin	5 – 12 V
GND	Masse der Stromversorgung
A-	Spule 1 des Schrittmotors
A+	Spule 1 des Schrittmotors
B-	Spule 2 des Schrittmotors
B+	Spule 2 des Schrittmotors

Warnung

Es ist möglich, das Shield direkt vom Arduino mit Strom zu versorgen, aber das wird nicht empfohlen. Wenn der Schrittmotor zu viel Strom zieht, kannst du sowohl das Shield als auch den Arduino beschädigen. Ich empfehle daher, eine externe Stromversorgung für die Motoren zu verwenden.

Dazu musst du den Vin Connect Jumper auf der Rückseite des Shields durchtrennen. Danach kannst du den Arduino separat über ein USB-Kabel oder den 5,5 mm DC-Stromanschluss mit Strom versorgen.

Wie bestimmt man die Verdrahtung des Schrittmotors?

Wenn du kein Datenblatt für deinen Schrittmotor findest, kann es schwierig sein herauszufinden, welcher Draht wohin gehört. Ich verwende folgenden Trick, um die Verdrahtung von 4-adrigen bipolaren Schrittmotoren zu bestimmen:

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:

1. Versuche, die Welle des Schrittmotors von Hand zu drehen und achte darauf, wie schwer sie sich dreht.
2. Nimm nun ein beliebiges Drahtpaar vom Motor und halte die blanken Enden zusammen.
3. 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 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 obigen Verdrahtungsdiagramm gezeigt sind.

Grundlegender Arduino Beispielcode für Schrittmotor und Arduino Motor Shield mit Stepper.h Bibliothek

Du kannst den folgenden Beispielcode mit dem Arduino IDE hochladen.

Dieses Beispiel verwendet die Stepper.h Bibliothek, die normalerweise mit der Arduino IDE vorinstalliert ist. Dieser 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 
   Arduino Motor Shield Rev3, Arduino UNO and Stepper.h library. 
   https://www.makerguides.com */

#include "Stepper.h"

// Define number of steps per revolution:
const int stepsPerRevolution = 200;

// Give the motor control pins names:
#define pwmA 3
#define pwmB 11
#define brakeA 9
#define brakeB 8
#define dirA 12
#define dirB 13

// Initialize the stepper library on the motor shield:
Stepper myStepper = Stepper(stepsPerRevolution, dirA, dirB);

void setup() {
  // Set the PWM and brake pins so that the direction pins can be used to control the motor:
  pinMode(pwmA, OUTPUT);
  pinMode(pwmB, OUTPUT);
  pinMode(brakeA, OUTPUT);
  pinMode(brakeB, OUTPUT);

  digitalWrite(pwmA, HIGH);
  digitalWrite(pwmB, HIGH);
  digitalWrite(brakeA, LOW);
  digitalWrite(brakeB, LOW);

  // Set the motor speed (RPMs):
  myStepper.setSpeed(60);
}


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);
}

Code-Erklärung:

Der Sketch beginnt mit dem Einbinden der Stepper.h Arduino-Bibliothek. Mehr Informationen zu dieser Bibliothek findest du auf der Arduino website.

#include "Stepper.h"

Als nächstes definiere ich, 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 definieren wir die Motoranschlüsse (siehe Spezifikationen und Verdrahtungsdiagramm oben).

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 pwmAerwähnst, ersetzt der Compiler es beim Kompilieren durch den Wert 3.

// Give the motor control pins names:
#define pwmA 3
#define pwmB 11
#define brakeA 9
#define brakeB 8
#define dirA 12
#define dirB 13

Als nächstes musst du eine neue Instanz der Stepper-Klasse erstellen, die einen bestimmten Schrittmotor repräsentiert, der an den Arduino angeschlossen ist. Dafür verwenden wir die Funktion Stepper(steps, pin1, pin2) wobei steps die Anzahl der Schritte pro Umdrehung ist und pin1 und pin2 die Pins sind, die den Schrittmotor antreiben. In unserem Fall sind das dirA und dirB.

// Initialize the stepper library on the motor shield:
Stepper myStepper = Stepper(stepsPerRevolution, dirA, dirB);

In diesem Fall habe ich den Schrittmotor ‘myStepper’ genannt, aber du kannst auch andere Namen verwenden, wie ‘z_motor’ oder ‘liftmotor’ usw. Stepper liftmotor = Stepper(stepsPerRevolution, dirA, dirB);.

Im Setup setzen wir zuerst die Brems- und PWM-Pins als Ausgang mit der Funktion pinMode(). Die PWM-Pins müssen mit der Funktion digitalWrite()auf HIGH und die Brems-Pins auf LOW gesetzt werden.

  // Set the PWM and brake pins so that the direction pins can be used to control the motor:
  pinMode(pwmA, OUTPUT);
  pinMode(pwmB, OUTPUT);
  pinMode(brakeA, OUTPUT);
  pinMode(brakeB, OUTPUT);

  digitalWrite(pwmA, HIGH);
  digitalWrite(pwmB, HIGH);
  digitalWrite(brakeA, LOW);
  digitalWrite(brakeB, LOW);

Du kannst die Geschwindigkeit des Motors in Umdrehungen pro Minute mit der Funktion setSpeed(rpm)einstellen. Ich habe sie auf 60 gesetzt, sodass wir 1 Umdrehung pro Sekunde sehen sollten.

  // Set the motor speed (RPMs):
  myStepper.setSpeed(60);

Loop

Im Loop-Teil des Codes rufen wir einfach die step(steps) Funktion auf, die den Motor eine bestimmte Anzahl von Schritten mit einer durch die setSpeed(rpm) Funktion bestimmten Geschwindigkeit dreht. Wenn du eine negative Zahl an diese Funktion ü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 beendet hat, bevor sie die Kontrolle an die nächste Zeile im Sketch übergibt.

Beispielcodes für Arduino Motor Shield und AccelStepper-Bibliothek

In den folgenden drei Beispielen zeige ich dir, wie du sowohl die Geschwindigkeit, die Richtung als auch die Anzahl der Schritte, die der Schrittmotor machen soll, steuern kannst. In diesen Beispielen 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 hat 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.

1. Beispielcode für kontinuierliche Rotation

Der folgende Sketch kann verwendet werden, um einen oder mehrere Schrittmotoren kontinuierlich mit konstanter Geschwindigkeit laufen zu lassen. (Keine Beschleunigung oder Verzögerung wird verwendet).

Du kannst den Code kopieren, indem du auf die Schaltfläche oben rechts im Codefeld klickst.

/* Example sketch to control a stepper motor with
   Arduino Motor Shield Rev3, Arduino UNO and AccelStepper.h library: 
   continuous rotation. More info: https://www.makerguides.com */

// Include the AccelStepper library:
#include "AccelStepper.h"

// Define number of steps per revolution:
const int stepsPerRevolution = 200;

// Give the motor control pins names:
#define pwmA 3
#define pwmB 11
#define brakeA 9
#define brakeB 8
#define dirA 12
#define dirB 13

// Define the AccelStepper interface type:
#define MotorInterfaceType 2

// Create a new instance of the AccelStepper class:
AccelStepper stepper = AccelStepper(MotorInterfaceType, dirA, dirB);

void setup() {
  // Set the PWM and brake pins so that the direction pins can be used to control the motor:
  pinMode(pwmA, OUTPUT);
  pinMode(pwmB, OUTPUT);
  pinMode(brakeA, OUTPUT);
  pinMode(brakeB, OUTPUT);

  digitalWrite(pwmA, HIGH);
  digitalWrite(pwmB, HIGH);
  digitalWrite(brakeA, LOW);
  digitalWrite(brakeB, LOW);

  // Set the maximum steps per second:
  stepper.setMaxSpeed(600);
}

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:

Wieder ist der erste Schritt, die Bibliothek mit #include <AccelStepper.h>einzubinden.

#include "AccelStepper.h"

Nachdem wir die Anschlüsse wie zuvor angegeben haben, müssen wir den Motor-Interface-Typ für die AccelStepper-Bibliothek definieren. In diesem Fall betreiben wir den Schrittmotor im Vollschrittmodus mit zwei Drähten, also setzen wir den Modus auf 2. Die anderen interface types findest du hier.

// Define the AccelStepper interface type:
#define MotorInterfaceType 2

Als nächstes musst du eine neue Instanz der AccelStepper-Klasse mit dem passenden Motor-Interface-Typ und den Anschlüssen 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, dirA, dirB);.

// Create a new instance of the AccelStepper class:
AccelStepper stepper = AccelStepper(MotorInterfaceType, dirA, dirB);

Der Setup-Teil des Codes ist größtenteils gleich wie im vorherigen Beispiel, aber ich habe auch die maximale Geschwindigkeit in Schritten pro Sekunde definiert. Geschwindigkeiten über 1000 Schritte pro Sekunde können unzuverlässig sein, daher habe ich sie auf 600 gesetzt (du musst experimentieren, um die maximale Geschwindigkeit für dein Setup herauszufinden). Beachte, dass ich den Namen des Schrittmotors (‘stepper’) angebe, für den ich die maximale Geschwindigkeit definieren möchte.

  // Set the maximum steps per second:
  stepper.setMaxSpeed(600);

Loop

Im Loop-Teil setzen wir zuerst die Geschwindigkeit, mit der der Motor laufen soll, mit der Funktion setSpeed(). (du kannst das auch im Setup-Teil des Codes machen).

Die Funktion stepper.runSpeed() fragt den Motor ab und wenn ein Schritt fällig ist, führt sie 1 Schritt aus. Das hängt von der eingestellten Geschwindigkeit und der Zeit seit dem letzten Schritt ab. Wenn du die Drehrichtung des Motors ändern möchtest, kannst du eine negative Geschwindigkeit setzen: 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. Sketch 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. Es wird keine Beschleunigung oder Verzögerung verwendet.

In diesem Fall dreht der Schrittmotor 1 Umdrehung im Uhrzeigersinn mit 400 Schritten/Sekunde, dann 1 Umdrehung gegen den Uhrzeigersinn mit 200 Schritten/Sekunde und zuletzt 3 Umdrehungen im Uhrzeigersinn mit 600 Schritten/Sekunde.

/* Example sketch to control a stepper motor with 
  Arduino Motor Shield Rev3, Arduino UNO and 
  AccelStepper.h library: number of steps or revolutions. 
  More info: https://www.makerguides.com */

#include "AccelStepper.h"

// Define number of steps per revolution:
const int stepsPerRevolution = 200;

// Give the motor control pins names:
#define pwmA 3
#define pwmB 11
#define brakeA 9
#define brakeB 8
#define dirA 12
#define dirB 13

// Define the AccelStepper interface type:
#define MotorInterfaceType 2

// Create a new instance of the AccelStepper class:
AccelStepper stepper = AccelStepper(MotorInterfaceType, dirA, dirB);

void setup() {
  // Set the PWM and brake pins so that the direction pins can be used to control the motor:
  pinMode(pwmA, OUTPUT);
  pinMode(pwmB, OUTPUT);
  pinMode(brakeA, OUTPUT);
  pinMode(brakeB, OUTPUT);

  digitalWrite(pwmA, HIGH);
  digitalWrite(pwmB, HIGH);
  digitalWrite(brakeA, LOW);
  digitalWrite(brakeB, LOW);

  // Set the maximum steps per second:
  stepper.setMaxSpeed(600);
}

void loop() {
  // Set the current position to 0:
  stepper.setCurrentPosition(0);

  // Run the motor forward at 400 steps/second until the motor reaches 200 steps (1 revolution):
  while (stepper.currentPosition() != 200) {
    stepper.setSpeed(400);
    stepper.runSpeed();
  }

  delay(1000);

  // Reset the position to 0:
  stepper.setCurrentPosition(0);

  // Run the motor backwards at 200 steps/second until the motor reaches -200 steps (1 revolution):
  while (stepper.currentPosition() != -200) {
    stepper.setSpeed(-200);
    stepper.runSpeed();
  }

  delay(1000);

  // Reset the position to 0:
  stepper.setCurrentPosition(0);

  // Run the motor forward at 600 steps/second until the motor reaches 600 steps (3 revolutions):
  while (stepper.currentPosition() != 600) {
    stepper.setSpeed(600);
    stepper.runSpeed();
  }

  delay(3000);
}

Code-Erklärung

Der erste Teil des Codes bis zum loop()-Abschnitt ist genau wie im vorherigen Beispiel.

Im 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);

Als nächstes 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 der Fall ist, läuft der Schrittmotor mit konstanter Geschwindigkeit, wie durch setSpeed()festgelegt.

  // Run the motor forward at 400 steps/second until the motor reaches 200 steps (1 revolution):
  while (stepper.currentPosition() != 200) {
    stepper.setSpeed(400);
    stepper.runSpeed();
  }

Im Rest des Loops machen wir genau dasselbe, nur mit anderer Geschwindigkeit und Zielposition.

3. Beispielcode für Beschleunigung und Verzögerung

In diesem Beispiel betrachten wir eine der Hauptfunktionen der AccelStepper-Bibliothek: das Hinzufügen von Beschleunigung und Verzögerung.

Mit dem folgenden Sketch kannst du Beschleunigung und Verzögerung zu den Bewegungen des Schrittmotors hinzufügen, ohne komplizierten Code. Der erste Abschnitt dieses Sketches ist wie in 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/Sekunde².

/* Example sketch to control a stepper motor with 
  Arduino Motor Shield Rev3, Arduino UNO and 
  AccelStepper.h library: acceleration and deceleration 
  More info: https://www.makerguides.com */

#include <AccelStepper.h>

// Define number of steps per revolution:
const int stepsPerRevolution = 200;

// Give the motor control pins names:
#define pwmA 3
#define pwmB 11
#define brakeA 9
#define brakeB 8
#define dirA 12
#define dirB 13

// Define the AccelStepper interface type:
#define MotorInterfaceType 2

// Create a new instance of the AccelStepper class:
AccelStepper stepper = AccelStepper(MotorInterfaceType, dirA, dirB);

void setup() {
  // Set the PWM and brake pins so that the direction pins can be used to control the motor:
  pinMode(pwmA, OUTPUT);
  pinMode(pwmB, OUTPUT);
  pinMode(brakeA, OUTPUT);
  pinMode(brakeB, OUTPUT);

  digitalWrite(pwmA, HIGH);
  digitalWrite(pwmB, HIGH);
  digitalWrite(brakeA, LOW);
  digitalWrite(brakeB, LOW);

  // 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(). Danach verwenden wir einfach die Funktion runToPosition(), um den Motor mit der eingestellten Geschwindigkeit und Beschleunigung zur Zielposition laufen zu lassen. 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 dem Arduino Motor Shield Rev3 steuern kannst. Wir haben uns 4 Beispiele angesehen, die sowohl die Stepper- als auch die AccelStepper-Bibliothek verwenden.

Ich hoffe, du fandest es nützlich und informativ. Wenn du mehr über andere (Microstepping-)Treiber wie den A4988 lernen möchtest, schau dir die untenstehenden Artikel an.

Weitere Schrittmotor-Tutorials:

• Control a stepper motor with L298N motor driver and Arduino
• 28BYJ-48 Stepper Motor with ULN2003 Driver and Arduino Tutorial
• How to control a stepper motor with A4988 driver and Arduino
• How to control a stepper motor with DRV8825 driver and Arduino

Wenn du weitere Fragen hast, hinterlasse einfach einen Kommentar unten.