Best Motor Drivers: L298N vs L293D vs L9110S vs TB6612

Every DC motor and stepper motor project that involves a microcontroller needs a motor driver — an intermediate circuit that lets a low-power Arduino or ESP32 control a motor that draws hundreds of milliamps or even amps. Without a motor driver, you would burn out your microcontroller instantly. The four most popular motor driver options for makers in India are the L298N, L293D, L9110S, and TB6612FNG. This guide breaks down how each one works, when to use it, and how to wire it up.

Why You Need a Motor Driver

An Arduino Uno can source at most 40mA per GPIO pin and 200mA total from all GPIO pins combined. A typical DC gearmotor draws 100–500mA, and a stepper motor coil draws 500mA–2A. Connecting a motor directly to an Arduino GPIO would cause the voltage to collapse, the pin driver to overheat, and potentially destroy the microcontroller permanently.

A motor driver solves this by acting as a power switch controlled by the microcontroller’s logic signal. It has its own power supply path (the motor supply) and only uses the GPIO signal to decide which transistors to turn on. The microcontroller never carries motor current — it only carries the tiny signal current needed to switch the driver.

Motor drivers also enable bidirectional control — running a motor forwards and backwards — through an H-bridge circuit. Simple transistor switches can only switch power on and off; H-bridge circuits can reverse polarity across the motor, enabling full directional control.

The H-Bridge Principle

An H-bridge is a circuit with four transistor switches arranged in an H shape around the motor load. Two switches connect the motor to positive supply, and two connect it to ground. By closing different pairs of switches, you can send current through the motor in either direction:

• Forward: Close switch 1 (left high side) and switch 4 (right low side) — current flows left to right through motor
• Reverse: Close switch 2 (right high side) and switch 3 (left low side) — current flows right to left through motor
• Brake: Close both low-side switches — motor terminals both connected to ground, creating dynamic braking
• Coast: Open all switches — motor spins freely with no load

PWM speed control is achieved by rapidly switching the enable line of the H-bridge on and off. At 50% duty cycle, the motor receives average half voltage and runs at roughly half speed. Motor driver ICs like the L298N and TB6612 have dedicated enable/PWM inputs for this purpose.

L298N Motor Driver

The L298N is the most popular motor driver module in the Arduino ecosystem. It is based on the ST L298N dual full H-bridge driver IC, mounted on a module with screw terminals, voltage regulator, and LED indicators. It has been the default motor driver for maker projects for over a decade.

Specifications:

• Supply voltage: 5V to 46V motor supply
• Output current: 2A per channel (4A peak), dual channel
• Logic supply: 5V (from onboard 7805 regulator if motor supply is 6–46V)
• PWM control for speed, direction pins for each channel
• Built-in protection diodes
• Onboard voltage regulator can supply 5V to Arduino (no separate USB needed if motor supply is 6–12V)

Main limitations:

• Uses bipolar junction transistors (BJTs) internally — voltage drop of 2–3V across the driver at rated current, wasting significant power as heat
• Large heatsink required for sustained loads above 1A
• Efficiency drops to around 60–70% at typical loads — a 12V motor effectively sees 9–10V from an L298N module
• The large module footprint is not ideal for compact designs

Best for: Learning, first Arduino motor projects, when you have a 12V power supply and do not need efficiency. Most beginner kits in India include an L298N module.

L293D Motor Driver IC

The L293D is a classic 16-pin DIP integrated circuit from Texas Instruments that contains four half-H-bridge drivers — effectively two full H-bridges. It was the industry standard motor driver for educational and hobby projects throughout the 1990s and 2000s.

Specifications:

• Supply voltage: 4.5V to 36V motor supply
• Output current: 600mA per channel (1.2A peak), dual H-bridge (4 channels)
• Built-in clamping diodes (the D in L293D)
• Can drive two DC motors bidirectionally or one bipolar stepper motor
• TTL-compatible logic inputs

Main limitations:

• Maximum 600mA continuous per channel limits it to small motors only
• Same BJT-based voltage drop issue as L298N — lower efficiency
• Gets hot quickly at sustained current near its rating
• Older technology superseded by more efficient alternatives

Best for: Small hobby DC motors (under 500mA), educational projects, projects where you already have L293D chips in your parts bin. The Arduino Motor Shield (official) uses the L293D.

L9110S Motor Driver

The L9110S (also written as L9110 or HG7881) is a compact two-channel motor driver module designed for small robots and toy-grade motors. Unlike the L298N and L293D which are large ICs, the L9110S module is a tiny PCB roughly 3cm x 2cm, making it excellent for compact builds.

Specifications:

• Supply voltage: 2.5V to 12V
• Output current: 800mA per channel continuous, dual channel
• Direct PWM control inputs
• Built-in protection diodes
• Can control 2 DC motors or 1 stepper motor
• Very low quiescent current (good for battery-powered projects)

Main limitations:

• 800mA maximum limits it to small motors (toy gear motors, small N20 motors)
• No separate enable pin — direction controlled entirely by IN1/IN2 logic levels
• Less documentation and community support than L298N

Best for: Small wheeled robots with N20 or BO gear motors (typically 100–300mA), compact line-following robots, battery-powered projects where size and current draw matter.

TB6612FNG Motor Driver

The TB6612FNG from Toshiba is the modern, efficient replacement for both the L298N and L293D. It uses MOSFET transistors instead of bipolar junction transistors, resulting in dramatically lower voltage drop (0.5V vs 2–3V), higher efficiency, less heat generation, and a smaller package. It is the motor driver used in the popular Adafruit Motor Shield v2 and Sparkfun Motor Driver modules.

Specifications:

• Supply voltage: 4.5V to 13.5V motor supply, 2.7V–5.5V logic supply
• Output current: 1.2A per channel continuous, 3.2A peak, dual channel
• MOSFET-based H-bridge — very low on-resistance (~0.5 ohm)
• Standby mode for power saving
• Separate PWMA/PWMB and direction inputs for independent speed control
• Built-in short-circuit and thermal shutdown protection

Main limitations:

• Maximum 13.5V motor supply — not suitable for 24V motors
• 1.2A continuous per channel — adequate for small to medium motors but not heavy-duty loads
• Smaller module means more careful wiring needed compared to L298N’s large screw terminals

Best for: Any project where efficiency and heat management matter, battery-powered robots, projects running on 5V or 9V power supplies, replacing L298N when heat is an issue.

Full Comparison Table

Wiring Each Driver to Arduino

L298N to Arduino Uno:

L298N Module    Arduino Uno
ENA         --> Pin 10 (PWM, Motor A speed)
IN1         --> Pin 9  (Motor A direction)
IN2         --> Pin 8  (Motor A direction)
IN3         --> Pin 7  (Motor B direction)
IN4         --> Pin 6  (Motor B direction)
ENB         --> Pin 5  (PWM, Motor B speed)
GND         --> GND
+5V         --> 5V (if motor supply 6-12V, use onboard regulator)
12V         --> External 12V power supply positive
GND (power) --> External power supply GND (common with Arduino GND)

TB6612FNG to Arduino Uno:

TB6612      Arduino Uno
PWMA    --> Pin 10 (PWM speed control for Motor A)
AIN1    --> Pin 9  (Motor A direction bit 1)
AIN2    --> Pin 8  (Motor A direction bit 2)
STBY    --> Pin 7  (Standby - HIGH to enable driver)
BIN1    --> Pin 6  (Motor B direction bit 1)
BIN2    --> Pin 5  (Motor B direction bit 2)
PWMB    --> Pin 4  (PWM speed control for Motor B)
VCC     --> 3.3V or 5V (logic supply)
VM      --> Motor supply (4.5V to 13.5V)
GND     --> GND

Arduino Code Examples

L298N: Control two motors forward/reverse with speed:

// L298N Motor Driver - Two motor control
int ENA = 10; // Motor A PWM speed
int IN1 = 9;  // Motor A direction
int IN2 = 8;
int ENB = 5;  // Motor B PWM speed
int IN3 = 7;  // Motor B direction
int IN4 = 6;

void setup() {
  pinMode(ENA, OUTPUT); pinMode(ENB, OUTPUT);
  pinMode(IN1, OUTPUT); pinMode(IN2, OUTPUT);
  pinMode(IN3, OUTPUT); pinMode(IN4, OUTPUT);
}

void motorA_forward(int speed) {
  analogWrite(ENA, speed); // 0-255
  digitalWrite(IN1, HIGH);
  digitalWrite(IN2, LOW);
}

void motorA_reverse(int speed) {
  analogWrite(ENA, speed);
  digitalWrite(IN1, LOW);
  digitalWrite(IN2, HIGH);
}

void motorA_stop() {
  analogWrite(ENA, 0);
}

void loop() {
  motorA_forward(180); // ~70% speed
  delay(2000);
  motorA_stop();
  delay(500);
  motorA_reverse(180);
  delay(2000);
  motorA_stop();
  delay(500);
}

TB6612: Same control with standby management:

// TB6612FNG Motor Driver
int PWMA = 10;
int AIN1 = 9;
int AIN2 = 8;
int STBY = 7; // Standby pin - must be HIGH to run

void setup() {
  pinMode(PWMA, OUTPUT);
  pinMode(AIN1, OUTPUT);
  pinMode(AIN2, OUTPUT);
  pinMode(STBY, OUTPUT);
  digitalWrite(STBY, HIGH); // Enable the driver
}

void forward(int speed) {
  digitalWrite(AIN1, HIGH);
  digitalWrite(AIN2, LOW);
  analogWrite(PWMA, speed); // 0-255
}

void reverse(int speed) {
  digitalWrite(AIN1, LOW);
  digitalWrite(AIN2, HIGH);
  analogWrite(PWMA, speed);
}

void brake() {
  digitalWrite(AIN1, HIGH);
  digitalWrite(AIN2, HIGH);
  analogWrite(PWMA, 0);
}

void loop() {
  forward(200);
  delay(2000);
  brake();
  delay(500);
  reverse(200);
  delay(2000);
  brake();
  delay(500);
}

Which Motor Driver Should You Choose?

Choose L298N if: You have motors that require 12V–24V, are learning motor control for the first time, already have an L298N module, or need the onboard 5V regulator to simplify your power wiring.

Choose L293D (Shield) if: You want a plug-and-play solution that stacks on Arduino, you are running very small motors, or you need to drive a stepper motor with a ready-made library.

Choose L9110S if: Your robot uses small gear motors (BO motors, N20 motors), you need the smallest possible footprint, or you are building on a tight budget for a simple line-following or obstacle-avoiding robot.

Choose TB6612 if: You are serious about efficiency, running on battery power, dealing with overheating issues on an L298N project, or need built-in thermal protection. The TB6612 is simply the better motor driver in almost every way except voltage range — if your supply is under 13.5V, use it.

Frequently Asked Questions

Q: Why does my L298N module get so hot?

The L298N uses bipolar junction transistors that have a voltage drop of 2–3V. At 2A load, that is 4–6W of heat dissipated in the IC. At sustained loads above 1A, always attach the heatsink (included with most modules). If it still overheats, consider switching to the TB6612FNG which has ~10x lower on-resistance and generates a fraction of the heat.

Q: Can I use these drivers for stepper motors?

Yes, but with limitations. The L298N, L293D, and L9110S can all drive bipolar stepper motors by controlling the two coil pairs. However, they lack microstepping capability and current regulation, which are essential for smooth, quiet stepper operation. For dedicated stepper control, use an A4988, DRV8825, or TMC2209 stepper driver which include hardware current limiting and microstepping.

Q: What is the difference between ENA/ENB and IN1/IN2/IN3/IN4 on the L298N?

IN1/IN2 set the direction of Motor A (HIGH/LOW = forward, LOW/HIGH = reverse, both same = brake). ENA is the enable/speed control pin — connecting it HIGH runs the motor at full speed; a PWM signal on ENA controls speed from 0 to 100%. By default on most L298N modules, ENA and ENB are connected to 5V via a jumper — remove the jumper and connect a PWM pin to control speed.

Q: Can I control 4 motors with one L298N module?

No — the L298N has two channels, so it controls two motors. For 4 motors, use two L298N modules (sharing the same power supply and microcontroller), or use the L293D shield which also controls 4 motors. Alternatively, use two TB6612 modules for a more efficient solution.