In diesem Tutorial gebe ich dir alle notwendigen Informationen zur Steuerung der Geschwindigkeit und Richtung eines Gleichstrommotors mit einem L293D Motor-Treiber-IC unter Verwendung eines Arduino UNO Boards.
Ich habe ein Schaltbild und Details zum Arduino-Code beigefügt, um den Gleichstrommotor durch das Senden von Zeichen über den Serial Monitor der Arduino IDE mit mehreren Beispielen zu steuern.
Materialien
Hardware-Komponenten
| Arduino Uno Rev3 | × 1 | Amazon |
| USB-Kabel Typ A/B | × 1 | Amazon |
| Gleichstrom-Getriebemotor | × 1 | Amazon |
| L293D Treiber-IC | × 1 | Amazon |
| Breadboard | × 1 | Amazon |
| Jumper-Kabel | × 15 | Amazon |
| Stromversorgung (5V) | × 1 | Amazon |
Software
| Arduino IDE | Arduino_IDE |
Makerguides.com nimmt am Amazon Services LLC Associates Program teil, einem Partner-Werbeprogramm, das Websites ermöglicht, durch Werbung und Verlinkung zu Produkten auf Amazon.com Werbegebühren zu verdienen.
Über den Motor-Treiber-IC L293D
Der L293D ist ein vierfacher Hochstrom-Halb-H-Treiber-IC, der sich zur Steuerung von Gleichstrommotoren eignet. Er kann einen bidirektionalen Antriebsstrom von bis zu 1 A bei Spannungen von 4,5 V bis 36 V liefern. Unten findest du das Datenblatt für den Chip.
Pinbelegung des L293D IC
Der L293D ist ein 16-poliger Motor-Treiber-IC, mit dem du zwei Gleichstrommotoren oder einen Schrittmotor mit bis zu 600 mA Strom steuern kannst.
Stromversorgungs-Pins
Pin 8 (VCC_2) und 16 (VCC_1) werden verwendet, um den L293D Motor-Treiber-IC mit Strom zu versorgen.
VCC_2 versorgt die interne H-Brücke des IC und kann zwischen 4,5 V und 36 V liegen. VCC_1 dient der internen Logikversorgung und sollte 5 V betragen. Pin 4, 5, 12 und 13 (GND) sind Masse- und Kühlkörperanschlüsse.
Richtungssteuerungs-Pins
Pin 2 (Input_1), Pin 7 (Input_2), Pin 10 (Input_3) und Pin 15 (Input_4) steuern die Schalter der H-Brücke im L293D IC.
Input_1 und Input_2 sind mit den beiden Anschlüssen von DC Motor_1 verbunden und steuern dessen Drehrichtung. Ebenso steuern Input_3 und Input_4 die Richtung von Motor_2.
Ich werde ein Arduino UNO verwenden, um Richtungssignale für alle Input-Pins zu erzeugen. Je nach Pegel dieser Pins (High oder Low) läuft der Motor vorwärts oder rückwärts.
Die Details zur Motor-Richtungssteuerung findest du in der folgenden Tabelle.
| Input_1 / Input_3 | Input_2 / Input_4 | Motorrichtung |
| Low | Low | Bremsen, Motor AUS |
| Low | High | Rückwärts (gegen den Uhrzeigersinn) |
| High | Low | Vorwärts (im Uhrzeigersinn) |
| High | High | Bremsen, Motor AUS |
Geschwindigkeitssteuerungs-Pins
Die Gleichstrommotoren können mit einer bestimmten Geschwindigkeit gedreht werden, die vom Arduino UNO an Pin 1 (Enable_A) für Motor_1 und Pin 9 (Enable_B) für Motor_2 eingestellt wird.
Ein aktives High-Signal am Enable-Pin schaltet den Treiberkanal des L293D IC ein, wodurch der Motor mit voller Geschwindigkeit läuft.
Ein aktives Low-Signal am Enable-Pin schaltet den Treiberkanal des L293D IC aus, wodurch der Motor stoppt. Um die Geschwindigkeit des Gleichstrommotors zu steuern, musst du PWM-Signale an den Enable-Pin des L293D IC senden. Die Geschwindigkeit des Motors ändert sich entsprechend dem Tastverhältnis der PWM-Signale.
Die Details werden im Code-Abschnitt erklärt.
Motor-Ausgangspins
Der L293D Motor-Treiber-IC liefert einen Ausgangsstrom von bis zu 600 mA an den Gleichstrommotor über Pin 3 (Output_1), Pin 6 (Output_2) für Motor_1 und Pin 11 (Output_3), Pin 14 (Output_4) für Motor_2.
Gleichstrommotor-Spezifikation
Spannung
Es gibt viele Gleichstrommotoren auf dem Markt mit Nennspannungen von 3 V bis 100 V; für Robotikanwendungen werden jedoch häufig 6 V, 12 V oder 24 V Motoren verwendet. In diesem Tutorial betrachten wir 3 V bis 6 V Getriebemotoren.
Strom
Du solltest einen Gleichstrommotor mit einer maximalen Stromaufnahme von 600 mA wählen, da der L293D Treiber-IC bei höheren Strömen heiß wird und beschädigt werden kann.
Drehmoment
Das Motordrehmoment ist wichtig, wenn eine Last auf den Motor wirkt. Wenn du eine Anwendung hast, bei der der Motor stärker belastet wird, solltest du einen Motor mit höherem Drehmoment wählen. Eine andere Möglichkeit, das Drehmoment zu erhöhen, ist die Verwendung eines Getriebes mit dem Motor.
In diesem Tutorial verwende ich einen Gleichstrommotor mit einem Getriebe mit einem Übersetzungsverhältnis von 1:48.
Anschluss des L293D Motor-Treiber-IC an Arduino UNO
In diesem Abschnitt lernst du, wie du die Gleichstrommotoren mit dem L293D Treiber-IC und dem Arduino UNO Board verbindest.
Schritt 1: Anschluss der Motoren an den L293D IC
Beginne am besten damit, die Motorleitungen an die Ausgangspins des L293D IC anzuschließen.
Verbinde die Leitungen von Motor_1 mit Pin 3 (Output_1) und Pin 6 (Output_2) und die Leitungen von Motor_2 mit Pin 11 (Output_3) und Pin 14 (Output_4).
Schritt 2: Anschluss des Arduino UNO an den L293D IC
Verbinde nun die digitalen Arduino-Ausgangspins 10 und 9 mit Pin 2 (Input_1) und Pin 7 (Input_2) des L293D für Motor_1.
Ebenso verbinde die digitalen Arduino-Pins 4 und 3 mit Pin 10 (Input_3) und Pin 15 (Input_4) des L293D für Motor_2.
Außerdem musst du PWM-Signale an die Enable-Pins senden, um die Geschwindigkeit der Gleichstrommotoren zu steuern.
Verbinde den PWM-Pin 11 des Arduino UNO mit Pin 1 (Enable_A) des L293D für Motor_1 und den PWM-Pin 5 des Arduino UNO mit Pin 9 (Enable_B).
Schritt 3: Stromversorgung des L293D IC
Jetzt kannst du den L293D IC mit 5 V versorgen, indem du Pin 8 (VCC_2) und Pin 16 (VCC_1) mit 5 V (Pluspol der Stromversorgung) verbindest.
Verbinde alle Masse-Pins des IC mit der gemeinsamen Masse auf dem Breadboard.
Alle Verbindungen sind im Bild dargestellt.
Arduino-Code – Steuerung eines Gleichstrommotors über das serielle Terminal
Wenn du deinen Gleichstrommotor testen möchtest, solltest du ihn steuern können.
Der folgende Code ermöglicht es dir, die Geschwindigkeit und Richtung beider Gleichstrommotoren einzeln und gleichzeitig durch das Senden von Zeichen über den Serial Monitor der Arduino IDE zu steuern.
Du kannst den Code kopieren, indem du auf die Schaltfläche oben rechts im Codefeld klickst und ihn auf dein Arduino UNO Board hochlädst.
Als Nächstes erkläre ich, wie der Code funktioniert.
// Motor_1 Connection
#define ENABLE_1 11
#define MOTOR_1_A 10
#define MOTOR_1_B 9
// Motor_2 Connection
#define ENABLE_2 5
#define MOTOR_2_A 4
#define MOTOR_2_B 3
// other variables
char serial_data;
int speed_value_m1;
int speed_value_m2;
void setup() {
Serial.begin(9600);
Serial.println("Motor Init..");
motor_1_init();
motor_2_init();
speed_value_m1 = 0;
speed_value_m2 = 0;
}
void loop() {
motor_speed_dir_control();
}
void motor_1_init() {
pinMode(MOTOR_1_A, OUTPUT);
pinMode(MOTOR_1_B, OUTPUT);
pinMode(ENABLE_1, OUTPUT);
digitalWrite(MOTOR_1_A, LOW);
digitalWrite(MOTOR_1_B, LOW);
analogWrite(ENABLE_1, LOW);
}
void motor_2_init() {
pinMode(MOTOR_2_A, OUTPUT);
pinMode(MOTOR_2_B, OUTPUT);
pinMode(ENABLE_2, OUTPUT);
digitalWrite(MOTOR_2_A, LOW);
digitalWrite(MOTOR_2_B, LOW);
analogWrite(ENABLE_2, LOW);
}
void motor_speed_dir_control() {
while (Serial.available()) {
serial_data = Serial.read();
switch (serial_data) {
case 's':
analogWrite(ENABLE_1, 255);
Serial.println("Enable Motor_1");
break;
case 'S':
analogWrite(ENABLE_2, 255);
Serial.println("Enable Motor_2");
break;
case 'h':
analogWrite(ENABLE_1, 0);
digitalWrite(MOTOR_1_A, LOW);
digitalWrite(MOTOR_1_B, LOW);
speed_value_m1 = 0;
Serial.println("Stop Motor_1");
break;
case 'H':
analogWrite(ENABLE_2, 0);
digitalWrite(MOTOR_2_A, LOW);
digitalWrite(MOTOR_2_B, LOW);
speed_value_m2 = 0;
Serial.println("Stop Motor_2");
break;
case 'f':
digitalWrite(MOTOR_1_A, HIGH);
digitalWrite(MOTOR_1_B, LOW);
Serial.println("Motor_1 Forward Direction");
break;
case 'F':
digitalWrite(MOTOR_2_A, HIGH);
digitalWrite(MOTOR_2_B, LOW);
Serial.println("Motor_2 Forward Direction");
break;
case 'b':
digitalWrite(MOTOR_1_A, LOW);
digitalWrite(MOTOR_1_B, HIGH);
Serial.println("Motor_1 Backward Direction");
break;
case 'B':
digitalWrite(MOTOR_2_A, LOW);
digitalWrite(MOTOR_2_B, HIGH);
Serial.println("Motor_2 Backward Direction");
break;
case 'a':
for (int i = 0; i < 256; i++) {
analogWrite(ENABLE_1, i);
}
Serial.println("Motor_1 acceleration");
break;
case 'A':
for (int i = 0; i < 256; i++) {
analogWrite(ENABLE_2, i);
}
Serial.println("Motor_2 acceleration");
break;
case 'd':
for (int i = 255; i > 1; i--) {
analogWrite(ENABLE_1, i);
delay(5);
}
Serial.println("Motor_1 deceleration");
break;
case 'D':
for (int i = 255; i > 1; i--) {
analogWrite(ENABLE_2, i);
delay(5);
}
Serial.println("Motor_2 deceleration");
break;
case 'i':
if (speed_value_m1 <= 245) {
speed_value_m1 += 10;
analogWrite(ENABLE_1, speed_value_m1);
Serial.println("Motor_1 increased Speed value: ");
Serial.print(speed_value_m1);
} else {
Serial.println("Maximum Speed Limit Reached for Motor_1: ");
Serial.print(speed_value_m1);
}
break;
case 'I':
if (speed_value_m2 <= 245) {
speed_value_m2 += 10;
analogWrite(ENABLE_2, speed_value_m2);
Serial.println("Motor_2 increased Speed value: ");
Serial.print(speed_value_m2);
} else {
Serial.println("Maximum Speed Limit Reached for Motor_2: ");
Serial.print(speed_value_m2);
}
break;
case 'r':
if (speed_value_m1 >= 10) {
speed_value_m1 -= 10;
analogWrite(ENABLE_1, speed_value_m1);
Serial.println("Motor_1 reduced Speed value: ");
Serial.print(speed_value_m1);
} else {
Serial.println("Minimum Speed Limit Reached for Motor_1: ");
Serial.print(speed_value_m1);
}
break;
case 'R':
if (speed_value_m2 >= 10) {
speed_value_m2 -= 10;
analogWrite(ENABLE_2, speed_value_m2);
Serial.println("Motor_2 reduced Speed value: ");
Serial.print(speed_value_m2);
} else {
Serial.println("Minimum Speed Limit Reached for Motor_2: ");
Serial.print(speed_value_m2);
}
break;
case 'X':
digitalWrite(MOTOR_1_A, HIGH);
digitalWrite(MOTOR_1_B, LOW);
digitalWrite(MOTOR_2_A, HIGH);
digitalWrite(MOTOR_2_B, LOW);
analogWrite(ENABLE_1, 255);
analogWrite(ENABLE_2, 255);
Serial.println("Motor_1 and Motor_2 Forward Direction");
break;
case 'Y':
digitalWrite(MOTOR_1_A, LOW);
digitalWrite(MOTOR_1_B, HIGH);
digitalWrite(MOTOR_2_A, LOW);
digitalWrite(MOTOR_2_B, HIGH);
analogWrite(ENABLE_1, 255);
analogWrite(ENABLE_2, 255);
Serial.println("Motor_1 and Motor_2 Backward Direction");
break;
case 'Z':
digitalWrite(MOTOR_1_A, LOW);
digitalWrite(MOTOR_1_B, LOW);
digitalWrite(MOTOR_2_A, LOW);
digitalWrite(MOTOR_2_B, LOW);
analogWrite(ENABLE_1, 0);
analogWrite(ENABLE_2, 0);
Serial.println("Motor_1 and Motor_2 Stop");
break;
default:
break;
}
}
}
Funktionsweise des Codes
Zuerst habe ich die Variablen für die Arduino UNO Pins entsprechend den Verbindungen und weitere Variablen zum Speichern der seriellen Daten und des Geschwindigkeitswerts definiert.
//Motor_1 Connection #define ENABLE_1 11 #define MOTOR_1_A 10 #define MOTOR_1_B 9 //Motor_2 Connection #define ENABLE_2 5 #define MOTOR_2_A 4 #define MOTOR_2_B 3 //other variables char serial_data; int speed_value_m1; int speed_value_m2;
Da ich die Gleichstrommotoren mit Befehlen aus dem Serial Monitor testen möchte, muss ich die serielle Verbindung des Arduino UNO initialisieren. Ich habe die Baudrate für die Kommunikation auf 9600 gesetzt.
Serial.begin(9600);
Als Nächstes habe ich die Richtung der Arduino UNO Pins als Ausgang gesetzt, um Signale an den L293D Treiber-IC zu senden, und alle Pins zunächst auf Low gesetzt.
void motor_1_init() {
pinMode(MOTOR_1_A, OUTPUT);
pinMode(MOTOR_1_B, OUTPUT);
pinMode(ENABLE_1, OUTPUT);
digitalWrite(MOTOR_1_A, LOW);
digitalWrite(MOTOR_1_B, LOW);
analogWrite(ENABLE_1, LOW);
}
void motor_2_init() {
pinMode(MOTOR_2_A, OUTPUT);
pinMode(MOTOR_2_B, OUTPUT);
pinMode(ENABLE_2, OUTPUT);
digitalWrite(MOTOR_2_A, LOW);
digitalWrite(MOTOR_2_B, LOW);
analogWrite(ENABLE_2, LOW);
}
Schließlich rufe ich in void loop(), einer Endlosschleife, die Funktion motor_speed_dir_control() auf, um je nach empfangenem Zeichen aus dem Serial Monitor verschiedene Aktionen an den Gleichstrommotoren auszuführen.
Ich habe die Funktion Serial.read() verwendet, um den Rx-Pin des Arduino UNO auszulesen, und das empfangene Zeichen wird in serial_data gespeichert.
Verschiedene Fälle sind nun in switch-Anweisungen geschrieben, um die Gleichstrommotoren zu steuern.
Du kannst die folgenden seriellen Befehle zur Steuerung von Geschwindigkeit und Richtung der Gleichstrommotoren verwenden:
| Motor_1 | Motor_2 | Ausgabe |
| s | S | Gleichstrommotor aktivieren |
| h | H | Gleichstrommotor stoppen |
| f | F | Vorwärtsrichtung für Gleichstrommotor einstellen |
| b | B | Rückwärtsrichtung für Gleichstrommotor einstellen |
| a | A | Gleichstrommotor von null auf maximale Geschwindigkeit beschleunigen |
| d | D | Gleichstrommotor von maximaler Geschwindigkeit auf null abbremsen |
| i | I | Gleichstrommotor-Geschwindigkeit um 10 erhöhen |
| r | R | Gleichstrommotor-Geschwindigkeit um 10 verringern |
| X | Beide Gleichstrommotoren in Vorwärtsrichtung laufen lassen |
| Y | Beide Gleichstrommotoren in Rückwärtsrichtung laufen lassen |
| Z | Beide Gleichstrommotoren stoppen |
Wie steuert man die Position eines Gleichstrommotors mit Arduino?
Um die Position in eine bestimmte Richtung zu steuern, musst du zuerst die Richtung des Gleichstrommotors einstellen und dann das PWM-Signal an den Enable-Pins anlegen.
Nehmen wir als Beispiel, Motor_1 mit voller Geschwindigkeit vorwärts zu bewegen. Zuerst musst du die Vorwärtsrichtung im Arduino-Code einstellen.
digitalWrite(MOTOR_1_A, HIGH);
digitalWrite(MOTOR_1_B, LOW);
Jetzt setze den Enable-Pin auf High, um Motor_1 vorwärts zu bewegen.
analogWrite(ENABLE_1, 255);
Ebenso kannst du für beide Motoren unterschiedliche Richtungen einstellen und ihre Positionen ändern, wie ich es in den verschiedenen Fällen gemacht habe.
Wie steuert man die Geschwindigkeit eines Gleichstrommotors mit Arduino?
Um die Geschwindigkeit des Gleichstrommotors zu steuern, musst du Pulsweitenmodulation (PWM) am Enable-Pin anlegen.
| Enable_A / Enable_B | Motorgeschwindigkeit |
| Low | Null (Stopp) |
| High | Volle Geschwindigkeit |
| PWM | Geschwindigkeitssteuerung entsprechend dem Wert des PWM-Signals |
analogWrite(pin, value) wird verwendet, um PWM an den Enable-Pins des L293D IC einzustellen. Mit dem Arduino UNO kannst du die Geschwindigkeit von null (0) bis maximal (255) einstellen. Siehe die Fälle ‘a’, ‘A’, ‘d’, ‘D’, ‘i’, ‘I’, ‘r’ und ‘R’ im Code.
Testen der Gleichstrommotoren
Nachdem du den Code auf das Arduino UNO Board hochgeladen hast, öffne in der Arduino IDE „Tools“ und klicke auf „Serial Monitor“ oder benutze die Tastenkombination „Strg+Shift+M“.
Stelle zuerst sicher, dass die richtige Baudrate, also 9600, eingestellt ist. Im Serial Monitor kannst du nun deinen Code mit den an das Arduino IDE angeschlossenen Gleichstrommotoren testen, indem du Befehle über den Serial Monitor sendest.
Beispiel 1: Lasse Motor_1 vorwärts laufen, dann abbremsen, beschleunigen, Geschwindigkeit erhöhen, verringern, Richtung umkehren und schließlich den Motor stoppen.
Sende die folgenden Zeichen nacheinander in Kleinbuchstaben über den Serial Monitor:
f, s, d, a, i, i, i, i, i, i, i, i, i, i, i, i, r, r, r, r, r, r, r, r, r, r, r, r, b, s, h
Ebenso kannst du Motor_2 steuern, indem du die oben genannten Zeichen in Großbuchstaben sendest. Beachte, dass du beide Motoren gleichzeitig durch das Senden der Zeichen nach Bedarf steuern kannst.
Beispiel 2: Lasse Motor_1 und Motor_2 gleichzeitig vorwärts, dann rückwärts laufen und stoppe beide Motoren.
Sende die folgenden Zeichen:
X, Y, Z
Fazit
Nach diesem Tutorial kannst du die verwendete Logik zur Steuerung von Geschwindigkeit und Richtung von Gleichstrommotoren anwenden, um innovative und kreative Elektronikprojekte mit Gleichstrommotoren und Arduino Board zu realisieren.
Wenn du Fragen oder Anregungen hast oder denkst, dass in diesem Tutorial etwas fehlt, hinterlasse bitte einen Kommentar unten.
