Arduino Motor Shield Tutorial

Mit dem Arduino Motor Shield können Sie die Motorrichtung und -geschwindigkeit mit einem Arduino einfach steuern. Indem Sie einfach Arduino-Pins ansprechen können, ist es sehr einfach, einen Motor in Ihr Projekt zu integrieren. Außerdem können Sie einen Motor mit einer separaten Stromversorgung von bis zu 12 V betreiben. Das Beste ist, dass der Schild sehr leicht zu finden ist. Aus all diesen Gründen ist das Arduino Motor Shield ein cooles kleines Element für schnelles Prototyping und allgemeines Experimentieren in Ihrem Arsenal.

Schritt 1: Installieren

Die Stifte des offiziellen Arduino-Motorschilds stimmen nur mit Arduino Uno Rev. 3 überein.

Damit es mit älteren Versionen des Arduino funktioniert, müssen Sie einige Stifte vom Motorschild abschneiden. Dies wird jedoch überhaupt nicht empfohlen.

Stecken Sie die Motorschutzstifte in die Buchse des Arduino Uno.

Schritt 2: Schildfunktionen

Die Motorabschirmung verfügt über 2 Kanäle, die die Steuerung von zwei Gleichstrommotoren oder 1 Schrittmotor ermöglichen.

Es hat auch 6 Header für die Anbringung von Tinkerkit-Eingängen, Ausgängen und Kommunikationsleitungen. Die Verwendung dieser Stifte ist etwas eingeschränkt und wird daher in diesem Lernprogramm nicht behandelt.

Mit einer externen Stromversorgung kann die Motorabschirmung sicher bis zu 12 V und 2 A pro Motorkanal (oder 4 A an einen einzelnen Kanal) liefern.

Es gibt Stifte am Arduino, die immer vom Schild benutzt werden. Durch Adressieren dieser Pins können Sie einen zu initiierenden Motorkanal auswählen, die Motorrichtung (Polarität) festlegen, die Motordrehzahl (PWM) einstellen, den Motor stoppen und starten sowie die Stromaufnahme jedes Kanals überwachen.

Die Pin-Aufteilung ist wie folgt:

Weitere Informationen zu den technischen Daten finden Sie auf der offiziellen Seite des Motorschilds auf der Arduino-Website.

Schritt 3: Programmieren

Schließen Sie das Arduino an den USB-Anschluss Ihres Computers an und öffnen Sie die Arduino-Entwicklungsumgebung.

Um die Karte dazu zu bringen, etwas zu tun, müssen Sie den Motorkanal durch Umschalten von drei Parametern initialisieren:

1. Zuerst müssen Sie die Motorrichtung (Polarität des Netzteils) einstellen, indem Sie entweder HIGH oder LOW einstellen.
2. Dann müssen Sie den Bremsstift für den Motorkanal lösen, indem Sie ihn auf LOW stellen.
3. Um den Motor in Bewegung zu setzen, müssen Sie die Drehzahl einstellen, indem Sie einen PWM-Befehl (analogWrite) an den entsprechenden Pin senden.

Wenn Sie nicht alle drei Dinge tun, schaltet sich der Motor nicht ein.

In den folgenden Schritten finden Sie einige gängige Beispiele für gängige Motoreinstellungen.

Schritt 4: Ein Motor

Um einen Motor mit dem Arduino Motor Shield zu steuern, stecken Sie zuerst das Pluskabel (rot) des Motors in die Klemme + von Kanal A auf der Motorabschirmung und das Erdungskabel (schwarz) des Motors in die Klemme von Kanal A - auf die Abschirmung.

Eine externe Stromversorgung ist nicht immer erforderlich, verbessert jedoch die Motorleistung drastisch. Es wird empfohlen, immer eine zu verwenden.

Um Ihr externes Netzteil anzuschließen, schließen Sie das Pluskabel (rot) vom Netzteil an den Anschluss "Vin" und das Erdungskabel (schwarz) an den Anschluss "GND" an.

Laden Sie abschließend den Code zur Steuerung des Motorschilds auf das Arduino hoch.

 / ******************************************************** ************ Motor Shield 1-Kanal-DC-Motor-Demo von Randy Sarafan Weitere Informationen finden Sie unter: //www.instructables.com/id/Arduino-Motor-Shield-Tutorial/ **** ********************************************************** ******* / void setup () {// Kanal A einrichten PinMode (12, OUTPUT); // Initiiert Motorkanal A Pin PinMode (9, OUTPUT); // Initiiert den Bremskanal A Pin} void loop () {// forward @ full speed digitalWrite (12, HIGH); // Richtet die Vorwärtsrichtung von Kanal A ein digitalWrite (9, LOW); // Bremse für Kanal A lösen analogWrite (3, 255); // dreht den Motor auf Kanal A mit voller Geschwindigkeit (3000); digitalWrite (9, HIGH); // Bremse für Kanal A-Verzögerung betätigen (1000); // rückwärts bei halber Geschwindigkeit digitalWrite (12, LOW); // Richtet die Rückwärtsrichtung von Kanal A ein digitalWrite (9, LOW); // Bremse für Kanal A lösen analogWrite (3, 123); // dreht den Motor auf Kanal A mit halber Drehzahlverzögerung (3000); digitalWrite (9, HIGH); // Bremse für Kanal A-Verzögerung betätigen (1000); }} 
Schritt 5: Zwei Motoren 
Die Schnittstelle mit zwei Motoren entspricht in etwa der Schnittstelle mit einem Motor. Stecken Sie den Motor einfach in Kanal B.
Der einzige Unterschied in Bezug auf den Code besteht darin, dass Sie einen zweiten Kanal einschalten müssen, um den zweiten Motor zu steuern.
Hier ist der Code zur Steuerung von zwei Motoren: 
 / ******************************************************** ************ Motor Shield 2-Kanal DC Motor Demo von Randy Sarafan Weitere Informationen finden Sie unter: //www.instructables.com/id/Arduino-Motor-Shield-Tutorial/ **** ********************************************************** ******* / void setup () {// Kanal A einrichten PinMode (12, OUTPUT); // Initiiert Motorkanal A Pin PinMode (9, OUTPUT); // Initiiert den Bremskanal A Pin // Setup Kanal B PinMode (13, OUTPUT); // Initiiert Motorkanal A Pin PinMode (8, OUTPUT); // Initiiert Bremskanal A Pin} void loop () {// Motor A vorwärts bei voller Geschwindigkeit digitalWrite (12, HIGH); // Richtet die Vorwärtsrichtung von Kanal A ein digitalWrite (9, LOW); // Bremse für Kanal A lösen analogWrite (3, 255); // dreht den Motor auf Kanal A mit voller Geschwindigkeit // Motor B rückwärts bei halber Geschwindigkeit digitalWrite (13, LOW); // Richtet die Rückwärtsrichtung von Kanal B ein digitalWrite (8, LOW); // Bremse für Kanal B lösen analogWrite (11, 123); // dreht den Motor auf Kanal B mit halber Drehzahlverzögerung (3000); digitalWrite (9, HIGH); // Bremse für Kanal A betätigen digitalWrite (9, HIGH); // Bremse für Kanal B Verzögerung betätigen (1000); // Motor A vorwärts @ volle Geschwindigkeit digitalWrite (12, LOW); // Richtet die Rückwärtsrichtung von Kanal A ein digitalWrite (9, LOW); // Bremse für Kanal A lösen analogWrite (3, 123); // dreht den Motor auf Kanal A mit halber Geschwindigkeit // Motor B vorwärts bei voller Geschwindigkeit digitalWrite (13, HIGH); // Richtet die Vorwärtsrichtung von Kanal B ein digitalWrite (8, LOW); // Bremse für Kanal B lösen analogWrite (11, 255); // dreht den Motor auf Kanal B mit voller Geschwindigkeit (3000); digitalWrite (9, HIGH); // Bremse für Kanal A betätigen digitalWrite (9, HIGH); // Bremse für Kanal B Verzögerung betätigen (1000); }} 
Schritt 6: Schrittmotor 
Es gibt verschiedene Arten von Schrittmotoren, aber in diesem Tutorial werden wir uns speziell mit bipolaren Schrittmotoren befassen. Bipolare Schrittmotoren haben typischerweise 4 Stifte, die zwei Spulen entsprechen. Um einen Stepper zu verwenden, müssen Sie diese beiden Spulen in Phase mit wechselnder Polarität versorgen.
Um herauszufinden, welche zwei Stifte eine einzelne Spule bilden, setzen Sie eine LED in zwei beliebige Stifte an der Buchse ein und drehen Sie die Motorwelle. Wenn die LED aufleuchtet, haben Sie eine Spule gefunden. Die anderen beiden Stifte sollten die andere Spule bilden.
So drehen Sie einen bipolaren Motor:
Versorgen Sie die erste Spule mit Strom.
Als nächstes die zweite Spule mit umgekehrter Polarität versorgen.
Versorgen Sie dann die erste Spule mit umgekehrter Polarität.
Zum Schluss die zweite Spule mit Strom versorgen.
Um die Motorrichtung eines bipolaren Steppers umzukehren, kehren Sie einfach die Polarität der zweiten Spule um.
Hier ist der Code, mit dem sich der Stepper in eine Richtung dreht: 
 / ******************************************************** ************ Motor Shield Stepper Demo von Randy Sarafan Weitere Informationen finden Sie unter: //www.instructables.com/id/Arduino-Motor-Shield-Tutorial/ ******** ********************************************************** *** / int delaylegnth = 30; void setup () {// Motorrichtungs-Umschaltstifte festlegen pinMode (12, OUTPUT); // CH A - HIGH = vorwärts und LOW = rückwärts ??? PinMode (13, OUTPUT); // CH B - HIGH = vorwärts und LOW = rückwärts ??? // Motorbremsstifte herstellen pinMode (9, OUTPUT); // bremse (deaktiviere) CH A pinMode (8, OUTPUT); // bremse (deaktiviere) CH B} void loop () {digitalWrite (9, LOW); // CH A digitalWrite AKTIVIEREN (8, HIGH); // CH B deaktivieren digitalWrite (12, HIGH); // Setzt die Richtung von CH A analogWrite (3, 255); // Verschiebt CH A delay (delaylegnth); digitalWrite (9, HIGH); // CH A digitalWrite deaktivieren (8, LOW); // CH B digitalWrite AKTIVIEREN (13, LOW); // Setzt die Richtung von CH B analogWrite (11, 255); // Verschiebt die CH B-Verzögerung (delaylegnth); digitalWrite (9, LOW); // CH A digitalWrite AKTIVIEREN (8, HIGH); // CH B deaktivieren digitalWrite (12, LOW); // Setzt die Richtung von CH A analogWrite (3, 255); // Verschiebt CH A delay (delaylegnth); digitalWrite (9, HIGH); // CH A digitalWrite deaktivieren (8, LOW); // CH B digitalWrite (13, HIGH) AKTIVIEREN; // Setzt die Richtung von CH B analogWrite (11, 255); // Verschiebt die CH B-Verzögerung (delaylegnth); }} 

Hier ist der Code, mit dem sich der Stepper in die entgegengesetzte Richtung dreht: 
 / ******************************************************** ************ Motor Shield Stepper Demo von Randy Sarafan Weitere Informationen finden Sie unter: //www.instructables.com/id/Arduino-Motor-Shield-Tutorial/ ******** ********************************************************** *** / int delaylegnth = 30; void setup () {// Motorrichtungs-Umschaltstifte festlegen pinMode (12, OUTPUT); // CH A - HIGH = vorwärts und LOW = rückwärts ??? PinMode (13, OUTPUT); // CH B - HIGH = vorwärts und LOW = rückwärts ??? // Motorbremsstifte herstellen pinMode (9, OUTPUT); // bremse (deaktiviere) CH A pinMode (8, OUTPUT); // bremse (deaktiviere) CH B} void loop () {digitalWrite (9, LOW); // CH A digitalWrite AKTIVIEREN (8, HIGH); // CH B deaktivieren digitalWrite (12, HIGH); // Setzt die Richtung von CH A analogWrite (3, 255); // Verschiebt CH A delay (delaylegnth); digitalWrite (9, HIGH); // CH A digitalWrite deaktivieren (8, LOW); // CH B digitalWrite (13, HIGH) AKTIVIEREN; // Setzt die Richtung von CH B analogWrite (11, 255); // Verschiebt die CH B-Verzögerung (delaylegnth); digitalWrite (9, LOW); // CH A digitalWrite AKTIVIEREN (8, HIGH); // CH B deaktivieren digitalWrite (12, LOW); // Setzt die Richtung von CH A analogWrite (3, 255); // Verschiebt CH A delay (delaylegnth); digitalWrite (9, HIGH); // CH A digitalWrite deaktivieren (8, LOW); // CH B digitalWrite AKTIVIEREN (13, LOW); // Setzt die Richtung von CH B analogWrite (11, 255); // Verschiebt die CH B-Verzögerung (delaylegnth); }}