Motor Driver (L298N)

What is a motor driver?

A motor driver is an integrated circuit that uses power transistors (or MOSFETs) in an H-bridge configuration to deliver high current to a motor while being controlled by low-current logic signals from a microcontroller.

The L298N is a classic bipolar H-bridge IC manufactured by STMicroelectronics, first released in 1994 and still the most common motor driver in educational robotics. Each H-bridge can source up to 2 A continuously per channel, making it suitable for most hobby DC motors.

Why it matters for AI builders

Every wheeled robot, conveyor, and cable-driven actuator needs a motor driver between the microcontroller and the motor. The L298N is ubiquitous in entry-level builds:

• Current isolation — isolates the microcontroller's delicate logic circuitry from the motor's noisy, high-current supply
• Bidirectional control — both forward and reverse without rewiring
• PWM-compatible — Enable pin accepts PWM for speed control
• Dual channel — controls two DC motors (differential drive) or one stepper

Working principle

The L298N contains two independent H-bridges (channels A and B):

Control logic:

| IN1 | IN2 | ENA (PWM) | Motor A behaviour | |-----|-----|-----------|-------------------| | HIGH | LOW | HIGH | Forward (full speed) | | LOW | HIGH | HIGH | Reverse (full speed) | | HIGH | LOW | PWM | Forward (proportional speed) | | HIGH | HIGH | any | Brake (fast stop) | | LOW | LOW | any | Coast (free wheel) |

The same table applies to IN3/IN4/ENB for Motor B.

Voltage drop. The L298N uses bipolar transistors, not MOSFETs. Each transistor has a voltage drop of approximately 2V. If your motor needs 12V, supply 14V. This 2V loss is dissipated as heat — the large metal tab (heatsink fin) on the L298N module is essential.

Key parameters

Pinout

Wiring

Code

Full motor driver class with speed and direction

class MotorDriver {
public:
  int enPin, in1Pin, in2Pin;

  MotorDriver(int en, int in1, int in2) : enPin(en), in1Pin(in1), in2Pin(in2) {}

  void begin() {
    pinMode(enPin, OUTPUT);
    pinMode(in1Pin, OUTPUT);
    pinMode(in2Pin, OUTPUT);
    stop();
  }

  void forward(int speed = 255) {
    digitalWrite(in1Pin, HIGH);
    digitalWrite(in2Pin, LOW);
    analogWrite(enPin, constrain(speed, 0, 255));
  }

  void reverse(int speed = 255) {
    digitalWrite(in1Pin, LOW);
    digitalWrite(in2Pin, HIGH);
    analogWrite(enPin, constrain(speed, 0, 255));
  }

  void brake() {
    // Fast stop: both INs HIGH
    digitalWrite(in1Pin, HIGH);
    digitalWrite(in2Pin, HIGH);
    analogWrite(enPin, 255);
  }

  void stop() {
    // Coast: both INs LOW, disable
    digitalWrite(in1Pin, LOW);
    digitalWrite(in2Pin, LOW);
    analogWrite(enPin, 0);
  }
};

MotorDriver motorA(9, 7, 8);  // ENA, IN1, IN2
MotorDriver motorB(10, 5, 6); // ENB, IN3, IN4

void setup() {
  motorA.begin();
  motorB.begin();
}

void loop() {
  // Drive forward for 2 seconds
  motorA.forward(200);
  motorB.forward(200);
  delay(2000);

  // Brake
  motorA.brake();
  motorB.brake();
  delay(200);

  // Reverse for 1 second
  motorA.reverse(150);
  motorB.reverse(150);
  delay(1000);

  motorA.stop();
  motorB.stop();
  delay(1000);
}

PID velocity control with encoder feedback

// Encoder on Motor A
volatile int encoderCount = 0;
void IRAM_ATTR encoderISR() { encoderCount++; }

MotorDriver motorA(9, 7, 8);

float Kp = 2.0, Ki = 0.5, Kd = 0.1;
float targetRPM = 80.0;
float integral = 0, prevError = 0;
unsigned long prevTime = 0;
const int PULSES_PER_REV = 20;

void setup() {
  motorA.begin();
  attachInterrupt(digitalPinToInterrupt(2), encoderISR, RISING);
  prevTime = millis();
  Serial.begin(115200);
}

void loop() {
  unsigned long now = millis();
  float dt = (now - prevTime) / 1000.0;
  if (dt < 0.05) return;  // 20 Hz control rate

  noInterrupts();
  int pulses = encoderCount;
  encoderCount = 0;
  interrupts();

  float actualRPM = (pulses / (float)PULSES_PER_REV) / dt * 60.0;
  float error = targetRPM - actualRPM;
  integral += error * dt;
  float derivative = (error - prevError) / dt;
  float output = Kp * error + Ki * integral + Kd * derivative;

  motorA.forward(constrain((int)output, 0, 255));

  Serial.printf("Target: %.1f  Actual: %.1f  PWM: %.0f\n", targetRPM, actualRPM, output);
  prevError = error;
  prevTime = now;
}

Test procedure

Common mistakes

Robotics and AI use cases

Beginner project — Two-motor robot car

Wire two DC motors to a single L298N. Implement forward, reverse, left turn, right turn, and brake functions. Control via Serial Monitor commands ('F', 'B', 'L', 'R', 'S').

Key learning: Motor driver wiring, differential drive kinematics, serial command parsing.

Advanced project — Line-following robot with PID

Add an IR sensor array (3 or 5 sensors) to detect a black line on white paper. Compute the weighted average of sensor readings to get line position error. Feed error into a PID controller that outputs differential speed commands to the two motors. The robot should follow curves and handle intersections.

Key learning: Sensor array normalisation, cross-track error, PID tuning on a real physical system.