L298N Motortreiber meistern: Arduino Steuerung, Schaltpläne & Beispielcode

In diesem Arduino Tutorial lernen wir, wie man DC-Motoren mit Arduino steuert. Wir betrachten einige grundlegende Techniken zur Steuerung von DC-Motoren und erstellen zwei Beispiele, durch die wir lernen, wie man DC-Motoren mit dem L298N Motortreiber und dem Arduino Board steuert.

Sie können das folgende Video ansehen oder die schriftliche Anleitung unten lesen.

PWM DC-Motor Steuerung

Wir können die Geschwindigkeit des DC-Motors einfach durch Steuerung der Eingangsspannung zum Motor kontrollieren. Die gängigste Methode dafür ist die Verwendung eines PWM-Signals.

PWM (Pulsweitenmodulation) ist eine Technik, die es uns ermöglicht, den Mittelwert der Spannung, die an das elektronische Gerät geht, einzustellen, indem wir die Stromversorgung schnell ein- und ausschalten. Die durchschnittliche Spannung hängt vom Tastverhältnis (Duty Cycle) ab – also dem Verhältnis der Zeit, in der das Signal EIN ist, zur Zeit, in der es AUS ist, in einem einzelnen Zeitintervall.

Je nach Größe des Motors können wir einfach einen Arduino PWM-Ausgang an die Basis eines Transistors oder das Gate eines MOSFETs anschließen und die Motorgeschwindigkeit durch Steuerung des PWM-Ausgangs regeln. Das niedrigleistige Arduino PWM-Signal schaltet das Gate des MOSFETs ein und aus, durch den der hochleistige Motor angetrieben wird.

H-Brücke DC-Motor Steuerung

Andererseits müssen wir für die Steuerung der Drehrichtung lediglich die Stromrichtung durch den Motor umkehren. Die gängigste Methode dafür ist die Verwendung einer H-Brücke. Eine H-Brückenschaltung enthält vier Schaltelemente (Transistoren oder MOSFETs), mit dem Motor in der Mitte, die eine H-ähnliche Konfiguration bilden. Durch Aktivieren zweier bestimmter Schalter gleichzeitig können wir die Stromrichtung ändern und damit die Drehrichtung des Motors.

Wenn wir diese beiden Methoden kombinieren – PWM und H-Brücke – haben wir die vollständige Kontrolle über den DC-Motor. Es gibt viele DC-Motortreiber mit diesen Eigenschaften, und der L298N ist einer davon.

L298N Treiber

Der L298N ist ein Dual-H-Brücken-Motortreiber, der die Geschwindigkeits- und Richtungssteuerung von zwei DC-Motoren gleichzeitig ermöglicht. Das Modul kann DC-Motoren mit Spannungen zwischen 5 und 35V antreiben, mit einem Spitzenstrom von bis zu 2A.

Sehen wir uns den Pinout des L298N-Moduls genauer an und erklären, wie es funktioniert. Das Modul hat zwei Schraubklemmenblöcke für Motor A und B sowie einen weiteren Schraubklemmenblock für den Ground-Pin, VCC für den Motor und einen 5V-Pin, der entweder Eingang oder Ausgang sein kann.

Dies hängt von der Spannung ab, die an der Motor-VCC verwendet wird. Das Modul verfügt über einen onboard 5V-Regler, der über einen Jumper aktiviert oder deaktiviert wird. Wenn die Motorversorgungsspannung bis zu 12V beträgt, können wir den 5V-Regler aktivieren, und der 5V-Pin kann als Ausgang verwendet werden – zum Beispiel zur Stromversorgung unseres Arduino-Boards. Wenn die Motorspannung jedoch größer als 12V ist, müssen wir den Jumper entfernen, da diese Spannungen den onboard 5V-Regler beschädigen würden. In diesem Fall wird der 5V-Pin als Eingang verwendet, da wir ihn an eine 5V-Stromversorgung anschließen müssen, damit der IC ordnungsgemäß funktioniert.

Wir können hier feststellen, dass dieser IC einen Spannungsabfall von ca. 2V verursacht. Wenn wir also z. B. ein 12V-Netzteil verwenden, beträgt die Spannung an den Motoranschlüssen ca. 10V, was bedeutet, dass wir die maximale Geschwindigkeit unseres 12V DC-Motors nicht erreichen können.

Als Nächstes sind die Logik-Steuereingänge. Die Enable-A- und Enable-B-Pins werden zum Aktivieren und Steuern der Motorgeschwindigkeit verwendet. Wenn ein Jumper auf diesem Pin vorhanden ist, ist der Motor aktiviert und läuft mit maximaler Geschwindigkeit. Entfernen wir den Jumper, können wir einen PWM-Eingang an diesen Pin anschließen und so die Motorgeschwindigkeit steuern. Verbinden wir diesen Pin mit Ground, wird der Motor deaktiviert.

Als Nächstes steuern die Input-1- und Input-2-Pins die Drehrichtung von Motor A, und die Inputs 3 und 4 die von Motor B. Mit diesen Pins steuern wir tatsächlich die Schalter der H-Brücke im L298N-IC. Wenn Input 1 LOW und Input 2 HIGH ist, dreht sich der Motor vorwärts; umgekehrt, wenn Input 1 HIGH und Input 2 LOW, dreht er sich rückwärts. Sind beide Eingänge gleich (entweder LOW oder HIGH), stoppt der Motor. Dasselbe gilt für Inputs 3 und 4 und Motor B.

Arduino und L298N Motortreiber

Jetzt machen wir einige praktische Anwendungen. Im ersten Beispiel steuern wir die Motorgeschwindigkeit mit einem Potentiometer und ändern die Drehrichtung mit einem Taster. Hier ist der Schaltplan.

Wir benötigen einen L298N Motortreiber, einen DC-Motor, ein Potentiometer, einen Taster und ein Arduino Board.

Sie erhalten die für dieses Arduino Tutorial benötigten Komponenten über die Links unten:

• L298N Treiber
• 12V High Torque DC Motor
• DC Motor mit Kunststoff Reifenrad
• Arduino Board
• Breadboard und Jumper Kabel

Arduino Code (Beispiel 1)

Hier ist der Arduino-Code:

/* Arduino DC Motor Control - PWM | H-Bridge | L298N - Example 01 by Dejan Nedelkovski, www.HowToMechatronics.com */
#define enA 9
#define in1 6
#define in2 7
#define button 4
int rotDirection = 0;
int pressed = false;

void setup() {
  pinMode(enA, OUTPUT);
  pinMode(in1, OUTPUT);
  pinMode(in2, OUTPUT);
  pinMode(button, INPUT);
  // Set initial rotation direction
  digitalWrite(in1, LOW);
  digitalWrite(in2, HIGH);
}

void loop() {
  int potValue = analogRead(A0); // Read potentiometer value
  int pwmOutput = map(potValue, 0, 1023, 0, 255); // Map the potentiometer value from 0 to 255
  analogWrite(enA, pwmOutput); // Send PWM signal to L298N Enable pin
  // Read button - Debounce
  if (digitalRead(button) == true) {
    pressed = !pressed;
  }
  while (digitalRead(button) == true);
  delay(20);
  // If button is pressed - change rotation direction
  if (pressed == true & rotDirection == 0) {
    digitalWrite(in1, HIGH);
    digitalWrite(in2, LOW);
    rotDirection = 1;
    delay(20);
  }
  // If button is pressed - change rotation direction
  if (pressed == false & rotDirection == 1) {
    digitalWrite(in1, LOW);
    digitalWrite(in2, HIGH);
    rotDirection = 0;
    delay(20);
  }
}

Beschreibung: Zuerst definieren wir die Pins und einige für das Programm benötigte Variablen. Im Setup setzen wir die Pin-Modi und die initiale Drehrichtung des Motors. Im Loop beginnen wir damit, den Potentiometer-Wert zu lesen und dann den Wert, den wir erhalten (0 bis 1023), auf einen Wert von 0 bis 255 für das PWM-Signal abzubilden – das entspricht 0 bis 100% Tastverhältnis des PWM-Signals. Dann senden wir mit der analogWrite()-Funktion das PWM-Signal an den Enable-Pin des L298N-Boards, der den Motor tatsächlich antreibt.

Als Nächstes prüfen wir, ob wir den Taster gedrückt haben. Falls ja, ändern wir die Drehrichtung des Motors, indem wir die Zustände von Input 1 und Input 2 invertieren. Der Taster funktioniert als Toggle-Schalter: Jedes Mal, wenn wir ihn drücken, ändert sich die Drehrichtung des Motors.

Arduino Roboterauto Steuerung mit L298N Motortreiber

Nachdem wir dies gelernt haben, können wir nun unser eigenes Arduino Roboterauto bauen. Hier ist der Schaltplan:

Alles, was wir brauchen, sind 2 DC-Motoren, der L298N Motortreiber, ein Arduino Board und ein Joystick für die Steuerung. Für die Stromversorgung wählte ich drei 3,7V Li-Ion-Akkus, die insgesamt 11V liefern. Ich baute das Chassis aus 3mm dickem Sperrholz, befestigte die Motoren mit Metallwinkeln, montierte Räder an den Motoren und vorne ein Lenkrad.

Sehen wir uns nun den Arduino-Code an und wie er funktioniert. (Unten finden Sie den vollständigen Code)

int xAxis = analogRead(A0); // Read Joysticks X-axis
int yAxis = analogRead(A1); // Read Joysticks Y-axis

Nach der Definition der Pins beginnen wir im Loop damit, die X- und Y-Achsen-Werte des Joysticks einzulesen. Der Joystick besteht eigentlich aus zwei Potentiometern, die an die analogen Eingänge des Arduino angeschlossen sind und Werte von 0 bis 1023 liefern. Wenn der Joystick in seiner Mittelposition verbleibt, beträgt der Wert beider Potentiometer (Achsen) ca. 512.

Wir fügen eine kleine Toleranz hinzu und betrachten Werte von 470 bis 550 als Mitte. Bewegen wir die Y-Achse des Joysticks nach hinten und der Wert geht unter 470, setzen wir die Drehrichtung beider Motoren auf rückwärts über die vier Eingangs-Pins. Dann wandeln wir die fallenden Werte von 470 bis 0 in steigende PWM-Werte von 0 bis 255 um – das ist tatsächlich die Motorgeschwindigkeit.

// Y-axis used for forward and backward control
if (yAxis < 470) {
  // Set Motor A backward
  digitalWrite(in1, HIGH);
  digitalWrite(in2, LOW);
  // Set Motor B backward
  digitalWrite(in3, HIGH);
  digitalWrite(in4, LOW);
  // Convert the declining Y-axis readings for going backward from 470 to 0 into 0 to 255 value for the PWM signal for increasing the motor speed
  motorSpeedA = map(yAxis, 470, 0, 0, 255);
  motorSpeedB = map(yAxis, 470, 0, 0, 255);
}

Ähnlich, wenn wir die Y-Achse nach vorne bewegen und der Wert über 550 geht, setzen wir die Motoren auf vorwärts und wandeln die Werte von 550 bis 1023 in PWM-Werte von 0 bis 255 um. Bleibt der Joystick in der Mitte, ist die Motorgeschwindigkeit null.

Als Nächstes sehen wir, wie wir die X-Achse für die Links-/Rechts-Steuerung des Autos verwenden.

// X-axis used for left and right control
if (xAxis < 470) {
  // Convert the declining X-axis readings from 470 to 0 into increasing 0 to 255 value
  int xMapped = map(xAxis, 470, 0, 0, 255);
  // Move to left - decrease left motor speed, increase right motor speed
  motorSpeedA = motorSpeedA - xMapped;
  motorSpeedB = motorSpeedB + xMapped;
  // Confine the range from 0 to 255
  if (motorSpeedA < 0) { motorSpeedA = 0; }
  if (motorSpeedB > 255) { motorSpeedB = 255; }
}

Wieder müssen wir zuerst die X-Achsen-Werte in Geschwindigkeitswerte von 0 bis 255 umwandeln. Für die Links-Bewegung verwenden wir diesen Wert, um die linke Motorgeschwindigkeit zu verringern und die rechte zu erhöhen. Aufgrund der arithmetischen Operationen verwenden wir zwei zusätzliche „if“-Anweisungen, um den Motorgeschwindigkeitsbereich von 0 bis 255 zu begrenzen.

Dieselbe Methode wird für die Rechts-Bewegung des Autos verwendet.

Related: How To Make a PWM DC Motor Speed Controller using the 555 Timer IC

Abhängig von der angewendeten Spannung und dem Motor selbst kann der Motor bei niedrigen Geschwindigkeiten nicht anlaufen und ein Brummen erzeugen. In meinem Fall konnten die Motoren nicht starten, wenn der PWM-Wert unter 70 lag. Daher begrenzte ich mit diesen beiden if-Anweisungen den Geschwindigkeitsbereich tatsächlich auf 70 bis 255. Am Ende senden wir einfach die endgültigen Motorgeschwindigkeiten bzw. das PWM-Signal an die Enable-Pins des L298N-Treibers.

// Prevent buzzing at low speeds (Adjust according to your motors. My motors couldn't start moving if PWM value was below value of 70)
if (motorSpeedA < 70) { motorSpeedA = 0; }
if (motorSpeedB < 70) { motorSpeedB = 0; }
analogWrite(enA, motorSpeedA); // Send PWM signal to motor A
analogWrite(enB, motorSpeedB); // Send PWM signal to motor B

Hier ist der vollständige Code des Arduino Roboterauto-Beispiels:

/* Arduino DC Motor Control - PWM | H-Bridge | L298N Example 02 - Arduino Robot Car Control by Dejan Nedelkovski, www.HowToMechatronics.com */
#define enA 9
#define in1 4
#define in2 5
#define enB 10
#define in3 6
#define in4 7
int motorSpeedA = 0;
int motorSpeedB = 0;

void setup() {
  pinMode(enA, OUTPUT);
  pinMode(enB, OUTPUT);
  pinMode(in1, OUTPUT);
  pinMode(in2, OUTPUT);
  pinMode(in3, OUTPUT);
  pinMode(in4, OUTPUT);
}

void loop() {
  int xAxis = analogRead(A0); // Read Joysticks X-axis
  int yAxis = analogRead(A1); // Read Joysticks Y-axis
  // Y-axis used for forward and backward control
  if (yAxis < 470) {
    // Set Motor A backward
    digitalWrite(in1, HIGH);
    digitalWrite(in2, LOW);
    // Set Motor B backward
    digitalWrite(in3, HIGH);
    digitalWrite(in4, LOW);
    // Convert the declining Y-axis readings for going backward from 470 to 0 into 0 to 255 value for the PWM signal for increasing the motor speed
    motorSpeedA = map(yAxis, 470, 0, 0, 255);
    motorSpeedB = map(yAxis, 470, 0, 0, 255);
  }
  else if (yAxis > 550) {
    // Set Motor A forward
    digitalWrite(in1, LOW);
    digitalWrite(in2, HIGH);
    // Set Motor B forward
    digitalWrite(in3, LOW);
    digitalWrite(in4, HIGH);
    // Convert the increasing Y-axis readings for going forward from 550 to 1023 into 0 to 255 value for the PWM signal for increasing the motor speed
    motorSpeedA = map(yAxis, 550, 1023, 0, 255);
    motorSpeedB = map(yAxis, 550, 1023, 0, 255);
  }
  // If joystick stays in middle the motors are not moving
  else {
    motorSpeedA = 0;
    motorSpeedB = 0;
  }
  // X-axis used for left and right control
  if (xAxis < 470) {
    // Convert the declining X-axis readings from 470 to 0 into increasing 0 to 255 value
    int xMapped = map(xAxis, 470, 0, 0, 255);
    // Move to left - decrease left motor speed, increase right motor speed
    motorSpeedA = motorSpeedA - xMapped;
    motorSpeedB = motorSpeedB + xMapped;
    // Confine the range from 0 to 255
    if (motorSpeedA < 0) { motorSpeedA = 0; }
    if (motorSpeedB > 255) { motorSpeedB = 255; }
  }
  if (xAxis > 550) {
    // Convert the increasing X-axis readings from 550 to 1023 into 0 to 255 value
    int xMapped = map(xAxis, 550, 1023, 0, 255);
    // Move right - decrease right motor speed, increase left motor speed
    motorSpeedA = motorSpeedA + xMapped;
    motorSpeedB = motorSpeedB - xMapped;
    // Confine the range from 0 to 255
    if (motorSpeedA > 255) { motorSpeedA = 255; }
    if (motorSpeedB < 0) { motorSpeedB = 0; }
  }
  // Prevent buzzing at low speeds (Adjust according to your motors. My motors couldn't start moving if PWM value was below value of 70)
  if (motorSpeedA < 70) { motorSpeedA = 0; }
  if (motorSpeedB < 70) { motorSpeedB = 0; }
  analogWrite(enA, motorSpeedA); // Send PWM signal to motor A
  analogWrite(enB, motorSpeedB); // Send PWM signal to motor B
}

Das war es für dieses Tutorial. In meinem nächsten Video werden wir dieses Arduino Roboterauto erweitern, indem wir Bluetooth- und Funkgeräte hinzufügen, um Smartphone- und kabellose Steuerung zu ermöglichen.

Stellen Sie gerne Fragen im Kommentarbereich unten und vergessen Sie nicht, meine Sammlung von Arduino-Projekten anzusehen.