Doppel-H-Brücke L298N, 2 DC-Motoren, 5-35V, 2A pro Kanal

Das Doppel-H-Brückenmodul L298N ist ein Treiber für Gleichstrommotoren, aufgebaut um den Schaltkreis L298N. Es kann zwei DC-Motoren unabhängig voneinander in Drehrichtung und Geschwindigkeit steuern oder einen bipolaren Schrittmotor. Man findet es in Rad-Robotern, ferngesteuerten Autos, kleinen Förderbändern und überall dort, wo ein Mikrocontroller einen Motor bewegen muss, der mehr Strom verbraucht, als ein Pin der Platine liefern kann.

In diesem Tutorial verwenden wir einen Arduino Uno R3, denn das Modul braucht einen Mikrocontroller, der ihm die Steuersignale liefert, und die 5-V-Logik der Uno-Platine passt direkt zu den Eingängen des Moduls. Wir steuern zwei TT-Getriebemotoren, die von einem Netzteil mit 9 VDC versorgt werden.

Funktionsweise:

Ein DC-Motor dreht sich je nach Polarität der Spannung an seinen Anschlüssen in die eine oder andere Richtung. Die H-Brücke ist eine Schaltung aus vier Schaltern, mit der sich diese Polarität über ein logisches Signal umkehren lässt. Der Schaltkreis L298N enthält zwei solche Brücken und kann daher zwei Motoren steuern. Für Motor A werden die Eingänge IN1 und IN2 verwendet, für Motor B die Eingänge IN3 und IN4.

Die Drehrichtung ergibt sich aus der Kombination der Pegel an den beiden Eingängen des Motors. Die Kombination HIGH an beiden Eingängen darf niemals verwendet werden, da sie das Modul beschädigen kann.

Die Geschwindigkeit wird mit einem PWM-Signal an den Pins ENA (Motor A) und ENB (Motor B) eingestellt. Auf dem Arduino Uno akzeptiert die Funktion analogWrite Werte von 0 bis 255. Der Wert 0 bedeutet Motor aus, 255 bedeutet Dauerbetrieb. Die mittlere Spannung, die am Motor ankommt, beträgt ungefähr Vmotor = (VS - Vabfall) x PWM / 255.

Der Schaltkreis L298N verliert intern einen Teil der Spannung, etwa 1,8 - 3,2 V bei einem Strom von 1 A und fast 5 V bei 2 A. In unserem Aufbau ist VS 9 V, also erhält ein Motor, der etwa 1 A verbraucht, bei PWM 255 ungefähr 7 V. Die TT-Motoren sind für 3 - 6 V ausgelegt, deshalb begrenzen wir den PWM-Wert auf 200. Bei 200 beträgt die mittlere Spannung ungefähr 7 x 200 / 255 = 5,5 V, also im sicheren Bereich der Motoren.

Das Modul hat außerdem einen Spannungsregler 78M05, der 5 V für die Logik liefern kann. Mit gestecktem Jumper 5V-EN ist der Regler aktiv und die Klemme +5V wird zum 5-V-Ausgang mit einem Strom von bis zu 0,5 A. Diese Variante wird nur verwendet, wenn VS höchstens 12 V beträgt. Über 12 V wird der Jumper entfernt und die Klemme +5V wird von außen versorgt.

Anschluss:

Versorgen Sie die Motoren über ein Netzteil mit 9 VDC und mindestens 1 A, angeschlossen über den Hohlstecker-Adapter mit Schraubklemmen. Die Arduino Uno bleibt separat über das USB-Kabel versorgt. Die Masse des Netzteils, die Masse des Moduls und die Masse der Uno-Platine müssen verbunden werden, sonst haben die Steuersignale keine gemeinsame Bezugsmasse und die Motoren reagieren nicht korrekt. Die Eingänge des Moduls akzeptieren direkt den logischen Pegel von 5 V der Uno-Platine, daher ist kein Pegelwandler nötig.

Entfernen Sie die Jumper von ENA und ENB, bevor Sie das Modul einschalten, damit Sie die Geschwindigkeit per PWM einstellen können. Das Modul hat auf der Platine bereits zwei Kondensatoren mit 220 uF und die Schutzdioden für die Motoren, es müssen also keine zusätzlichen Bauteile ergänzt werden.

Taster, Einstellungen und Anzeigen:

Jumper 5V-EN: Starten Sie mit gestecktem Jumper. In diesem Aufbau beträgt VS 9 V, daher kann der Regler aktiv bleiben. Die Klemme +5V wird nicht mit dem Arduino verbunden, da die Uno-Platine über USB versorgt wird. Versorgen Sie die Klemme +5V niemals von außen, solange der Jumper gesteckt ist.

Jumper ENA und ENB: Entfernen Sie beide vor dem ersten Start. Mit gestecktem Jumper läuft der jeweilige Motor dauerhaft mit Höchstgeschwindigkeit, und das PWM-Signal hat keine Wirkung. Die Regelung funktioniert, wenn sich die Motorgeschwindigkeit ändert, während das Programm den Wert von analogWrite variiert.

LED der Stromversorgung: Nach dem Anschluss des Netzteils muss sie sofort leuchten. Das ist das Erste, was man prüft, wenn etwas nicht funktioniert.

Platine und Bibliotheken:

Wählen Sie in der Arduino IDE Tools > Board > Arduino AVR Boards > Arduino Uno. Das Paket Arduino AVR Boards ist bereits in der Arduino IDE enthalten und muss daher nicht separat installiert werden. Das Programm verwendet nur die Grundfunktionen von Arduino, deshalb ist keine Bibliothek nötig.

Der Code:

Das Programm lässt jeden Motor vorwärts und rückwärts mit zwei Geschwindigkeiten laufen und danach beide Motoren gemeinsam. Kopieren Sie es in die Arduino IDE und laden Sie es auf die Uno-Platine.

/*
  L298N dual H-bridge motor driver demo
  Board: Arduino Uno (Tools > Board > Arduino AVR Boards > Arduino Uno)
  Libraries: none, the sketch uses only the core Arduino functions
  Wiring:
    ENA -> D9 (PWM)    IN1 -> D8    IN2 -> D7
    ENB -> D3 (PWM)    IN3 -> D5    IN4 -> D4
    L298N GND -> Arduino GND and the adapter minus
    L298N +12V -> adapter plus (9 VDC, min. 1 A)
    Remove the ENA and ENB jumpers so PWM can control the speed
*/
// Motor A pins
const int ENA = 9;   // Speed of motor A (PWM)
const int IN1 = 8;   // Direction input 1 of motor A
const int IN2 = 7;   // Direction input 2 of motor A
// Motor B pins
const int ENB = 3;   // Speed of motor B (PWM)
const int IN3 = 5;   // Direction input 1 of motor B
const int IN4 = 4;   // Direction input 2 of motor B
// Maximum PWM value, keeps 3-6 V motors in a safe range when VS is 9 V
const int MAX_PWM = 200;
// Run motor A at a given speed, forward or backward
void setMotorA(int speed, bool forward) {
  speed = constrain(speed, 0, MAX_PWM);   // Limit the speed
  // Write LOW first, so both inputs are never HIGH at the same time
  digitalWrite(forward ? IN2 : IN1, LOW);
  digitalWrite(forward ? IN1 : IN2, HIGH);
  analogWrite(ENA, speed);                // Apply the speed
  Serial.print("Motor A: ");
  Serial.print(forward ? "forward" : "backward");
  Serial.print(", PWM ");
  Serial.println(speed);
}
// Run motor B at a given speed, forward or backward
void setMotorB(int speed, bool forward) {
  speed = constrain(speed, 0, MAX_PWM);   // Limit the speed
  // Write LOW first, so both inputs are never HIGH at the same time
  digitalWrite(forward ? IN4 : IN3, LOW);
  digitalWrite(forward ? IN3 : IN4, HIGH);
  analogWrite(ENB, speed);                // Apply the speed
  Serial.print("Motor B: ");
  Serial.print(forward ? "forward" : "backward");
  Serial.print(", PWM ");
  Serial.println(speed);
}
// Stop motor A
void stopMotorA() {
  analogWrite(ENA, 0);        // No drive
  digitalWrite(IN1, LOW);     // Both inputs LOW
  digitalWrite(IN2, LOW);
  Serial.println("Motor A: stopped");
}
// Stop motor B
void stopMotorB() {
  analogWrite(ENB, 0);        // No drive
  digitalWrite(IN3, LOW);     // Both inputs LOW
  digitalWrite(IN4, LOW);
  Serial.println("Motor B: stopped");
}
void setup() {
  // Configure all control pins as outputs
  pinMode(ENA, OUTPUT);
  pinMode(IN1, OUTPUT);
  pinMode(IN2, OUTPUT);
  pinMode(ENB, OUTPUT);
  pinMode(IN3, OUTPUT);
  pinMode(IN4, OUTPUT);
  Serial.begin(9600);         // Start the serial monitor
  Serial.println("L298N motor driver test started");
  // Make sure both motors are off at start
  stopMotorA();
  stopMotorB();
  delay(1000);
}
void loop() {
  // Motor A: forward at two speeds, then backward
  setMotorA(120, true);
  delay(2000);
  setMotorA(200, true);
  delay(2000);
  stopMotorA();
  delay(1000);
  setMotorA(200, false);
  delay(2000);
  stopMotorA();
  delay(1000);
  // Motor B: forward, then backward
  setMotorB(200, true);
  delay(2000);
  stopMotorB();
  delay(1000);
  setMotorB(200, false);
  delay(2000);
  stopMotorB();
  delay(1000);
  // Both motors together
  setMotorA(150, true);
  setMotorB(150, true);
  delay(3000);
  stopMotorA();
  stopMotorB();
  delay(3000);            // Pause before the cycle repeats
}

Wie der Code funktioniert:

Zu Beginn werden die Pins mit den Konstanten ENA, IN1, IN2, ENB, IN3 und IN4 definiert, genau wie in der Anschlusstabelle. Die Konstante MAX_PWM hat den Wert 200 und begrenzt die Geschwindigkeit, damit die TT-Motoren nicht mehr als 6 V erhalten.

In der Funktion setup werden alle Pins als Ausgänge konfiguriert, der Serielle Monitor mit 9600 Baud gestartet und beide Motoren angehalten, damit beim Reset nichts Unerwünschtes anläuft.

Die Funktionen setMotorA und setMotorB erhalten Geschwindigkeit und Drehrichtung. Sie begrenzen die Geschwindigkeit mit constrain und setzen zuerst LOW auf dem Eingang, der inaktiv sein muss, und erst danach HIGH auf dem anderen. So sind die beiden Eingänge desselben Motors nie gleichzeitig HIGH. Zum Schluss legt analogWrite die Geschwindigkeit am Enable-Pin an. Die Funktionen stopMotorA und stopMotorB setzen beide Eingänge auf LOW und die Geschwindigkeit auf 0.

Die Funktion loop führt die Testsequenz aus: Motor A vorwärts mit zwei Geschwindigkeiten, Stopp, Motor A rückwärts, danach dieselben Schritte für Motor B und zum Schluss beide Motoren gemeinsam. Die Pausen werden mit delay gesetzt, und die Meldungen im Seriellen Monitor zeigen bei jedem Schritt an, welcher Befehl gesendet wurde.

Ergebnis:

Öffnen Sie den Seriellen Monitor mit 9600 Baud. Nach dem Hochladen des Programms sehen Sie die folgenden Meldungen, und die Motoren bewegen sich in derselben Reihenfolge. Wenn sich ein Motor entgegen der Meldung dreht, tauschen Sie die beiden Kabel dieses Motors an der Klemme OUT untereinander.

L298N motor driver test started
Motor A: stopped
Motor B: stopped
Motor A: forward, PWM 120
Motor A: forward, PWM 200
Motor A: stopped
Motor A: backward, PWM 200
Motor A: stopped
Motor B: forward, PWM 200
Motor B: stopped
Motor B: backward, PWM 200
Motor B: stopped

Häufige Probleme:

Die Motoren bewegen sich überhaupt nicht. Die übliche Ursache ist die Versorgung oder die Masse. Prüfen Sie, ob die LED der Stromversorgung leuchtet und ob GND der Uno-Platine mit GND des Moduls verbunden ist. Ohne gemeinsame Masse werden die Steuersignale nicht erkannt.

Ein Motor läuft immer mit Höchstgeschwindigkeit, unabhängig vom PWM-Wert. Der Jumper ENA oder ENB ist noch gesteckt. Entfernen Sie ihn, damit der Pin D9 oder D3 die Geschwindigkeit steuern kann.

Der Motor brummt, startet aber bei kleinen Geschwindigkeiten nicht. Unterhalb eines bestimmten PWM-Wertes ist die mittlere Spannung zu klein, um die Reibung des Getriebes zu überwinden. Erhöhen Sie den Wert von analogWrite oder verwenden Sie bei Bedarf eine höhere Spannung VS.

Der Motor dreht sich entgegengesetzt zur gewünschten Richtung. Tauschen Sie die beiden Kabel des Motors an der Klemme OUT oder vertauschen Sie im Code die Werte HIGH und LOW für diesen Motor.

Die Uno-Platine setzt sich zurück, wenn die Motoren starten. Die Motoren erzeugen Störungen und Spannungseinbrüche auf der Masse. Prüfen Sie die Masseleitungen, verwenden Sie ein Netzteil mit mindestens 1 A und halten Sie die Motorleitungen von den Signalleitungen fern.

Der Kühlkörper des Moduls wird warm. Das ist bei hohen Strömen normal, weil ein Teil der Leistung im Schaltkreis L298N verloren geht. Ist er zu heiß, um ihn längere Zeit zu berühren, verringern Sie die Last oder sorgen Sie für Belüftung.

Einschränkungen und Tipps:

Das Modul akzeptiert für die Motoren Spannungen von 5 - 35 VDC und kann bis zu 2 A pro Kanal liefern. Wegen des internen Spannungsabfalls erhält der Motor weniger als die Versorgungsspannung, wählen Sie VS deshalb 2 - 3 V über der Nennspannung des Motors. Für kleine Motoren mit 3 - 6 V ist ein Netzteil mit 9 V und einer PWM-Begrenzung auf etwa 200 eine sichere Wahl.

Der Schaltkreis L298N ist nicht besonders effizient, daher ist bei batteriebetriebenen Motoren mit hohem Verbrauch ein Treiber mit MOSFET-Transistoren besser geeignet. Dafür ist das Modul sehr gut zum Lernen und für kleine Roboter geeignet. Mit demselben Aufbau können Sie einen Roboter auf zwei Rädern bauen, indem Sie einen Abstandssensor oder eine Fernsteuerung ergänzen. Legen Sie niemals gleichzeitig HIGH an IN1 und IN2 oder an IN3 und IN4.