Dual H-Bridge L298N Module, 2 DC Motors, 5-35V, 2A per Channel

The L298N Dual H-Bridge module is a driver for DC motors, built around the L298N circuit. It can control two DC motors independently, in direction and speed, or one bipolar stepper motor. We find it in wheeled robots, remote-controlled cars, small conveyor belts and any project where a microcontroller must move a motor that draws more current than a board pin can provide.

In this tutorial we use an Arduino Uno R3, because the module needs a microcontroller to send it the control signals, and the 5 V logic of the Uno board matches the module inputs directly. We will control two TT geared motors, powered from a 9 VDC mains adapter.

How it works:

A DC motor rotates in one direction or the other depending on the polarity of the voltage at its terminals. An H-bridge is a circuit with four switches that allows this polarity to be reversed from a logic signal. The L298N circuit contains two such bridges, so it can control two motors. For motor A the IN1 and IN2 inputs are used, and for motor B the IN3 and IN4 inputs.

The direction of rotation is chosen from the combination of levels on the two inputs of the motor. The HIGH combination on both inputs must never be used, because it can damage the module.

Speed is adjusted with a PWM signal on the ENA (motor A) and ENB (motor B) pins. On the Arduino Uno, the analogWrite function accepts values from 0 to 255. The value 0 means motor off, and 255 means full continuous power. The average voltage reaching the motor is approximately Vmotor = (VS - Vdrop) x PWM / 255.

The L298N circuit internally loses part of the voltage, approximately 1.8 - 3.2 V at a current of 1 A and almost 5 V at 2 A. In our setup VS is 9 V, so at PWM 255 a motor drawing around 1 A receives approximately 7 V. TT motors are made for 3 - 6 V, so we limit the PWM value to 200. At 200, the average voltage is approximately 7 x 200 / 255 = 5.5 V, which is within the safe range of the motors.

The module also has a 78M05 regulator that can produce 5 V for the logic. With the 5V-EN jumper fitted, the regulator is active and the +5V terminal becomes a 5 V output, with a current of up to 0.5 A. This option is only used when the VS voltage is at most 12 V. Above 12 V the jumper is removed and the +5V terminal is powered from outside.

Connection:

Power the motors from a 9 VDC mains adapter with at least 1 A, connected through the jack adapter with screw terminals. The Arduino Uno board remains powered separately, through the USB cable. The adapter ground, the module ground and the Uno board ground must be joined, otherwise the control signals have no common reference and the motors will not respond correctly. The module inputs directly accept the 5 V logic level of the Uno board, so no level converter is needed.

Remove the jumpers from ENA and ENB before powering the module, so that you can adjust the speed with PWM. The module already has two 220 uF capacitors on the board and the protection diodes for the motors, so no additional components need to be added.

Buttons, adjustments and indicators:

5V-EN jumper: start with it fitted. In this setup VS is 9 V, so the regulator can stay active. The +5V terminal is not connected to the Arduino, because the Uno board is powered through USB. Never power the +5V terminal from outside while the jumper is fitted.

ENA and ENB jumpers: remove both of them before the first start. With the jumper fitted, the respective motor runs permanently at maximum speed and the PWM command has no effect. The adjustment works when the motor speed changes while the program varies the analogWrite value.

Power LED: after connecting the adapter, it must light up immediately. It is the first thing to check when something does not work.

Board and libraries:

In the Arduino IDE select Tools > Board > Arduino AVR Boards > Arduino Uno. The Arduino AVR Boards package comes with the Arduino IDE, so it does not need to be installed separately. The program uses only the basic Arduino functions, so no library needs to be installed.

The code:

The program runs each motor forward and backward, at two speeds, and then runs both motors together. Copy it into the Arduino IDE and upload it to the Uno board.

/*
  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
}

How the code works:

At the beginning the pins are defined with the constants ENA, IN1, IN2, ENB, IN3 and IN4, exactly as in the connection table. The constant MAX_PWM has the value 200 and limits the speed, so that the TT motors do not receive more than 6 V.

In the setup function all pins are configured as outputs, the serial monitor is started at 9600 baud, and both motors are stopped, so that nothing unwanted starts on reset.

The setMotorA and setMotorB functions receive the speed and the direction. They limit the speed with constrain, first write the LOW level on the input that must be inactive and only then HIGH on the other one. This way the two inputs of the same motor are never HIGH at the same time. Finally, analogWrite applies the speed to the enable pin. The stopMotorA and stopMotorB functions set both inputs to LOW and the speed to 0.

The loop function runs the test sequence: motor A forward at two speeds, stop, motor A backward, then the same steps for motor B, and finally both motors together. The pauses are made with delay, and the messages on the serial monitor show at each step which command was sent.

Result:

Open the Serial Monitor at 9600 baud. After uploading the program you will see the messages below, and the motors move in the same order. If a motor turns in the opposite direction to the message, swap between them the two wires of that motor at the OUT terminal.

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

Common problems:

The motors do not move at all. The usual cause is power or ground. Check that the power LED is lit and that the GND of the Uno board is joined with the GND of the module. Without a common ground the control signals are not recognized.

One motor always runs at maximum speed, regardless of the PWM value. The ENA or ENB jumper is still fitted. Remove it, so that pin D9 or D3 can control the speed.

The motor hums but does not start at low speeds. Below a certain PWM value the average voltage is too small to overcome the friction of the gearbox. Increase the analogWrite value or, if needed, use a higher VS voltage.

The motor turns in the opposite direction to the desired one. Swap the two motor wires at the OUT terminal or change the HIGH and LOW values in the code for that motor.

The Uno board resets when the motors start. The motors produce interference and voltage drops on the ground. Check the ground wires, use an adapter that gives at least 1 A and keep the motor wires away from the signal wires.

The module heatsink gets warm. This is normal at high currents, because part of the power is lost in the L298N circuit. If it is too hot to touch for a long time, reduce the load or provide ventilation.

Limitations and tips:

The module accepts 5 - 35 VDC for the motors and can deliver up to 2 A per channel. Because of the internal voltage drop, the motor receives less than the supply voltage, so choose VS 2 - 3 V above the nominal voltage of the motor. For small 3 - 6 V motors, a 9 V source with the PWM limited to approximately 200 is a safe choice.

The L298N circuit is not efficient, so for battery-powered motors with high consumption a driver with MOSFET transistors is more suitable. On the other hand, the module is very good for learning and for small robots. With the same setup you can build a two-wheeled robot, by adding a distance sensor or a remote control. Never apply HIGH simultaneously on IN1 and IN2 or on IN3 and IN4.