Controlling DC Motors with DRV8833 Motor Driver and Arduino

If you have used older drivers such as L293D or L298N, the DRV8833 feels much more efficient in low-voltage builds. The main reason is the MOSFET-based output stage, which typically wastes less power and generates less heat than older BJT-based solutions.

This guide is written as a complete bring-up workflow: what the pins do, how to wire everything safely, how to run a verified test sketch, and what to check when motors do not behave as expected.

[PHOTO PLACEHOLDER: DRV8833 module front, with all silkscreen labels readable]

DRV8833 Overview and Features

DRV8833 is a dual H-bridge motor driver IC from Texas Instruments. A single module can drive:

• Two brushed DC motors
• One bipolar stepper motor
• Other small inductive loads (within current and voltage limits)

Typical Module Specs

Integrated protections include undervoltage lockout, overcurrent, and overtemperature shutdown.

Datasheet: Texas Instruments DRV8833 Datasheet

Pinout and Electrical Behavior

[SKETCH PLACEHOLDER: annotated pinout with VM, GND, OUT1-OUT4, IN1-IN4, SLEEP/STBY, FAULT]

Breakout boards vary slightly in naming. OUT1/OUT2 may appear as AO1/AO2, and SLEEP may appear as STBY. The functional meaning remains the same.

Power and Outputs

• VM (or VCC): motor supply input
• GND: common ground (all GND pins are internally common)
• OUT1/OUT2: motor A terminals
• OUT3/OUT4: motor B terminals

Control Inputs

• IN1/IN2: direction and PWM for motor A
• IN3/IN4: direction and PWM for motor B

Sleep/Standby Pin

The sleep/standby pin disables the internal bridge logic when LOW and enables normal operation when HIGH. Many modules include a pull-up so the driver is active by default. If your board exposes a solder jumper for that pull-up, verify its state before debugging a "dead" motor channel.

After bringing SLEEP HIGH, wait at least 1ms before applying motor commands. During sleep the H-bridges, charge pump, internal clocks, and control logic are disabled, and input commands are ignored.

Fault Pin

FAULT is an active-low open-drain output. To read it with Arduino, use either an external pull-up or configure the MCU input with pull-up mode. A LOW level reports undervoltage, overcurrent, or overtemperature protection; the bridges resume operation after the fault condition clears.

Direction Truth Table (per channel)

PWM: Coast or Brake During the Off-Time

PWM behavior depends on the steady input. PWM one input while holding the other LOW to alternate between drive and coast (fast decay), as the example sketch does. PWM one input while holding the other HIGH to alternate between drive and brake (slow decay). Drive/brake usually produces stronger low-duty response, while drive/coast lets the motor freewheel during each PWM off-time.

Current Limiting on Real Breakout Boards

The DRV8833 IC supports current limiting through current-sense pins, but many low-cost breakout boards tie those sense pins directly to ground. On those boards, programmable current limiting is effectively not available.

Practical consequence: choose motors with safe stall current for your supply and thermal budget.

[PHOTO PLACEHOLDER: back side of module showing jumpers/sense routing]

Why There Is Usually No Trimmer to Adjust

Unlike A4988 or DRV8825, the DRV8833 has no Vref pin with a potentiometer. Its current regulation compares the voltage across external ISEN sense resistors against a fixed internal reference, so the current limit, where a board actually implements it, is set by the sense resistor's value rather than by something you can turn.

Most hobby-grade DRV8833 breakouts skip the sense resistors entirely and tie ISEN1/ISEN2 straight to GND, which disables current regulation completely. Before assuming your motor is protected, trace the ISEN pins on your specific board.

[PHOTO PLACEHOLDER: close-up of the ISEN1/ISEN2 pads or traces on the underside of the module, showing whether they connect to a small sense resistor or run directly to a GND plane]

Where a carrier does implement current regulation, the DRV8833 trips at a typical sense voltage of 200mV. The relationship is I_limit = V_trip / R_ISEN, so a 0.20 ohm resistor sets approximately 1.0A and a 0.40 ohm resistor approximately 0.5A. The resistor must also tolerate the resulting dissipation P = I_limit^2 × R_ISEN. Use the actual carrier schematic and the datasheet limits rather than assuming that a visible potentiometer controls a Vref input; the DRV8833 has no such pin.

Sense Resistor Examples

These nominal values use the typical 0.20V trip threshold. The threshold has component tolerance, so they are design estimates rather than precision current settings.

Required Materials

Hardware

• Arduino UNO R3 x 1
• DRV8833 module x 1
• 6V DC motors x 2
• Jumper wires
• External motor supply (for example 5V when testing 6V motors conservatively)

Software

• Arduino IDE

Wiring DRV8833 to Arduino

Safety First

• Always share ground between Arduino and motor supply.
• Switch motor power off before connecting, disconnecting, or rewiring a motor.
• Do not exceed the motor's rated voltage.
• For small 6V motors, start around 5V supply and validate thermal behavior.
• Keep 10-20% headroom during first tests (supply or PWM duty) and only increase after temperature checks.

Place local bypass and bulk capacitance close to VM/GND on the carrier, and keep the high-current loop from the supply through the bridge and motor short. The breakout may already contain the IC's required charge-pump and regulator capacitors, but those parts do not replace supply decoupling for motor leads and wiring inductance.

Recommended Pin Mapping

Connect motor A to OUT1/OUT2 and motor B to OUT3/OUT4. If a motor spins in the opposite direction than expected, swap that motor's two output wires.

[SKETCH PLACEHOLDER: complete wiring diagram with external motor supply and common ground]

Optional FAULT monitoring: connect FAULT to a digital input and enable pull-up in code.

Arduino Example Code

The following sketch demonstrates acceleration, reversal, full stop, and pivot turns for a two-motor base.

// DRV8833 + Arduino UNO two-motor demo

#define MOT_A1_PIN 10
#define MOT_A2_PIN 9
#define MOT_B1_PIN 6
#define MOT_B2_PIN 5

void setup() {
  pinMode(MOT_A1_PIN, OUTPUT);
  pinMode(MOT_A2_PIN, OUTPUT);
  pinMode(MOT_B1_PIN, OUTPUT);
  pinMode(MOT_B2_PIN, OUTPUT);

  digitalWrite(MOT_A1_PIN, LOW);
  digitalWrite(MOT_A2_PIN, LOW);
  digitalWrite(MOT_B1_PIN, LOW);
  digitalWrite(MOT_B2_PIN, LOW);

  Serial.begin(9600);
}

void setMotorPwm(int pwm, int pin1, int pin2) {
  if (pwm < 0) {
    analogWrite(pin1, -pwm);
    digitalWrite(pin2, LOW);
  } else {
    digitalWrite(pin1, LOW);
    analogWrite(pin2, pwm);
  }
}

void setMotorCurrents(int pwmA, int pwmB) {
  setMotorPwm(pwmA, MOT_A1_PIN, MOT_A2_PIN);
  setMotorPwm(pwmB, MOT_B1_PIN, MOT_B2_PIN);

  Serial.print("A=");
  Serial.print(pwmA);
  Serial.print(" B=");
  Serial.println(pwmB);
}

void spinAndWait(int pwmA, int pwmB, int durationMs) {
  setMotorCurrents(pwmA, pwmB);
  delay(durationMs);
}

void loop() {
  // Ramp up forward
  for (int i = 0; i < 11; i++) {
    spinAndWait(25 * i, 25 * i, 300);
  }

  // Hold forward
  spinAndWait(255, 255, 1200);

  // Ramp through zero into reverse
  for (int i = 0; i < 21; i++) {
    spinAndWait(255 - 25 * i, 255 - 25 * i, 250);
  }

  // Hold reverse
  spinAndWait(-255, -255, 1200);

  // Stop
  spinAndWait(0, 0, 1000);

  // Pivot examples
  spinAndWait(-255, 255, 900);
  spinAndWait(0, 0, 500);
  spinAndWait(255, -255, 900);
  spinAndWait(0, 0, 1200);
}

At very low PWM values you may hear a hum before the motor starts moving. That is normal; many small DC motors need a minimum effective voltage to overcome static friction.

[PHOTO PLACEHOLDER: running setup with both motors spinning]

Code Walkthrough

The sketch is built around three helper functions:

• setMotorPwm(): applies signed PWM for one channel
• setMotorCurrents(): updates both channels and prints telemetry
• spinAndWait(): executes one movement primitive for a fixed interval

This structure makes it easy to convert the demo into line-following, obstacle avoidance, or joystick control.

Troubleshooting Checklist

• No motion at all: check STBY/SLEEP level and shared ground first.
• One wheel dead: inspect OUT pair and corresponding IN pins for that channel.
• Frequent resets: improve supply decoupling and separate noisy motor supply from USB logic.
• Driver too hot: verify stall current and reduce duty cycle/load.
• Motor too hot: reduce average PWM, mechanical load, or supply and re-test with 10-20% headroom.
• FAULT always active: check for shorts on outputs and overcurrent conditions.

[SKETCH PLACEHOLDER: quick fault-debug flowchart]