Arduino Motor Shield Rev3: Official Shield Guide

After designing custom motor control PCBs for years, I’ve developed a deep appreciation for the Arduino Motor Shield Rev3. It’s not just a convenient add-on—it’s a well-engineered solution that demonstrates thoughtful design choices at every level. The shield eliminates hours of breadboard wiring, reduces component count, and provides features like current sensing that would require additional circuitry to implement from scratch.

When I first examined the Arduino Motor Shield Rev3’s schematic, the design philosophy became clear. Arduino didn’t just slap an L298 driver onto a PCB and call it done. They added current sensing, brake control, TinkerKit compatibility, and configurable jumpers that give you real control over pin usage and power routing. For anyone working with motor control on Arduino, this shield represents the official reference implementation—and it’s worth understanding thoroughly.

Arduino Motor Shield Rev3 Core Architecture

The Arduino Motor Shield Rev3 builds around the L298P dual H-bridge driver from STMicroelectronics. This chip provides two independent full-bridge circuits, each capable of driving 2A continuous current at voltages from 7V to 12V (with an absolute maximum of 18V at the screw terminals).

What makes this shield special isn’t just the L298P—it’s the peripheral circuitry. The designers included current sense resistors (0.27Ω) in series with each channel output, connected through an amplification network to Arduino analog pins A0 and A1. This feature allows you to monitor motor current draw in real-time, enabling overcurrent protection, stall detection, and torque estimation without external instrumentation.

The brake functionality represents another thoughtful addition. Rather than relying solely on PWM duty cycle to slow motors, the shield includes dedicated brake pins that short both motor terminals together through the H-bridge when activated. This creates electromagnetic braking, stopping motors faster than simple coasting would allow.

Voltage Regulation and Power Architecture

Understanding the power routing prevents the most common shield failures. The L298P requires two separate power domains: logic power (for the internal control circuitry) and motor power (for the H-bridge outputs).

By default, the “Vin Connect” jumper on the shield’s underside connects these domains. When intact, motor supply voltage also powers the Arduino through its VIN pin. This works perfectly for 7-12V systems where you want simplified wiring. However, for motors requiring higher voltages (13-18V), you must cut this jumper to prevent overvoltage damage to Arduino’s 12V maximum VIN rating.

Complete Pin Assignment and Functions

The Arduino Motor Shield Rev3 uses eight Arduino pins for motor control, plus two analog inputs for current sensing. Here’s the complete breakdown:

Pin	Function	Channel	Type	Description
D12	DIR A	A	Digital Output	Direction control for Motor A (HIGH = forward)
D13	DIR B	B	Digital Output	Direction control for Motor B (HIGH = forward)
D3	PWM A	A	PWM Output	Speed control for Motor A (0-255)
D11	PWM B	B	PWM Output	Speed control for Motor B (0-255)
D9	BRAKE A	A	Digital Output	Brake control Motor A (HIGH = brake engaged)
D8	BRAKE B	B	Digital Output	Brake control Motor B (HIGH = brake engaged)
A0	SNS A	A	Analog Input	Current sensing Motor A (3.3V = 2A)
A1	SNS B	B	Analog Input	Current sensing Motor B (3.3V = 2A)

TinkerKit Compatibility Connectors

The shield includes six TinkerKit connectors that provide quick prototyping capability:

• Two analog inputs (white connectors) → Connected to A2 and A3
• Two analog outputs (orange connectors) → Connected to PWM pins D5 and D6
• Two TWI/I2C connectors (green) → Connected to SDA and SCL

These connectors accept TinkerKit modules directly, eliminating breadboard wiring for sensors and outputs in rapid prototyping scenarios.

Jumper Configuration Options

The shield’s underside contains several jumpers that modify functionality:

Vin Connect Jumper: Bridges motor power to Arduino VIN. Cut when using motor voltages >12V.

Brake A/B Jumpers: Connect brake functionality to pins D9 and D8. Cut to reclaim these pins for other uses if brake functionality isn’t needed.

Current Sensing Jumpers: Connect SNS0/SNS1 to analog pins A0/A1. Cut to reclaim analog pins if current monitoring isn’t required.

Technical Specifications and Ratings

Parameter	Specification	Notes
Motor Supply Voltage (VIN)	7V – 12V recommended	Absolute maximum 18V at screw terminals
Logic Supply Voltage	5V	Powered from Arduino
Continuous Current per Channel	2A	At 25°C ambient with proper ventilation
Peak Current per Channel	3A	Brief duration (<1 second)
Total Shield Current	4A maximum	Both channels combined
Voltage Drop (L298P)	1.8V – 4V	Depends on load current
PWM Frequency	490Hz (D3), 980Hz (D11)	Arduino default frequencies
Current Sense Calibration	3.3V = 2A	Linear relationship
Current Sense Resolution	~2mA per ADC count	10-bit ADC: 2000mA / 1023
Operating Temperature	-25°C to 130°C	L298P junction temperature
PCB Dimensions	68.6mm × 53.3mm	2.7″ × 2.1″
Weight	30g	Without Arduino

Current Rating Reality and Thermal Considerations

The 2A continuous rating assumes adequate cooling and 25°C ambient temperature. In enclosed spaces or higher ambient temperatures, you must derate this specification.

From thermal calculations: at 2A with 2V drop, each channel dissipates 4W. Both channels at full load generate 8W total heat dissipation. The L298P’s thermal resistance (junction-to-ambient) is approximately 35°C/W for the PowerSO20 package used on the shield.

Temperature rise calculation: ΔT = Power × Thermal Resistance = 8W × 35°C/W = 280°C rise above ambient. This exceeds the junction temperature limit significantly, which explains why sustained 2A operation requires heatsinking or reduced ambient temperature.

Practical guideline: For continuous operation in typical environments (25°C ambient), limit each channel to 1.5A without heatsinking, or 2A with proper heatsink and airflow.

Wiring and Power Connection

Proper wiring sequence prevents damage and ensures reliable operation.

Basic Dual Motor Setup

Shield Installation:

1. Align shield pins with Arduino UNO headers

2. Press down firmly until fully seated

3. Verify no pins are bent or missed sockets

Power Connections:

1. Motor supply positive → VIN screw terminal

2. Motor supply negative → GND screw terminal

3. Arduino USB or external power → Arduino power jack

Motor Connections:

– Motor A positive → Channel A (+) screw terminal

– Motor A negative → Channel A (-) screw terminal

– Motor B positive → Channel B (+) screw terminal

– Motor B negative → Channel B (-) screw terminal

Note: Motor polarity determines “forward” direction

Reversing wires changes which direction is “forward”

Power Supply Selection

For 6V motors: Use 7.5-9V supply to account for 1.8-2V L298P voltage drop.

For 12V motors: Use 14V supply for full performance, or separate Arduino and motor supplies by cutting Vin Connect jumper.

Current capacity: Minimum 2A per motor, 4A total recommended for dual motor operation. Use switching power supplies or lithium battery packs, not 9V alkaline batteries (insufficient current capacity).

Basic Motor Control Code

The Arduino Motor Shield Rev3 doesn’t require external libraries for basic operation—just standard Arduino functions.

Single Motor Control Example

// Arduino Motor Shield Rev3 – Single Motor Control

// Channel A demonstration

// Pin definitions for Channel A

const int dirA = 12;    // Direction control

const int pwmA = 3;     // Speed control (PWM)

const int brakeA = 9;   // Brake control

const int snsA = A0;    // Current sensing

void setup() {

  // Configure motor control pins

  pinMode(dirA, OUTPUT);

  pinMode(pwmA, OUTPUT);

  pinMode(brakeA, OUTPUT);

  Serial.begin(9600);

  Serial.println(“Arduino Motor Shield Rev3 Ready”);

  // Initialize motor stopped with brake released

  digitalWrite(dirA, LOW);

  digitalWrite(brakeA, LOW);

  analogWrite(pwmA, 0);

}

void loop() {

  // Forward at 70% speed

  digitalWrite(dirA, HIGH);    // Set forward direction

  digitalWrite(brakeA, LOW);   // Release brake

  analogWrite(pwmA, 179);      // 70% speed (179/255)

  Serial.print(“Forward – Current: “);

  Serial.print(readCurrent(snsA));

  Serial.println(“A”);

  delay(3000);

  // Brake for quick stop

  digitalWrite(brakeA, HIGH);  // Engage brake

  Serial.println(“Braking”);

  delay(1000);

  // Reverse at 50% speed

  digitalWrite(dirA, LOW);     // Set reverse direction

  digitalWrite(brakeA, LOW);   // Release brake

  analogWrite(pwmA, 128);      // 50% speed

  Serial.print(“Reverse – Current: “);

  Serial.print(readCurrent(snsA));

  Serial.println(“A”);

  delay(3000);

  // Coast to stop

  analogWrite(pwmA, 0);        // Zero speed

  Serial.println(“Coasting”);

  delay(2000);

}

// Function to read motor current in amps

float readCurrent(int sensePin) {

  int sensorValue = analogRead(sensePin);

  // 3.3V = 2A, so conversion: (sensorValue / 1023) * 3.3V * (2A / 3.3V)

  float current = (sensorValue * 2.0) / 1023.0;

  return current;

}

Dual Motor Robot Car Code

This example implements differential drive control for a two-wheel robot platform:

// Arduino Motor Shield Rev3 – Dual Motor Robot Car

// Differential drive implementation

// Motor A (Left wheel)

const int dirA = 12;

const int pwmA = 3;

const int brakeA = 9;

// Motor B (Right wheel)

const int dirB = 13;

const int pwmB = 11;

const int brakeB = 8;

void setup() {

  // Configure all motor pins

  pinMode(dirA, OUTPUT);

  pinMode(pwmA, OUTPUT);

  pinMode(brakeA, OUTPUT);

  pinMode(dirB, OUTPUT);

  pinMode(pwmB, OUTPUT);

  pinMode(brakeB, OUTPUT);

  // Initialize both motors stopped

  stopMotors();

  Serial.begin(9600);

  Serial.println(“Robot Car Ready”);

}

void loop() {

  moveForward(200, 3000);    // Forward at speed 200 for 3 seconds

  stopAndBrake(500);

  turnRight(180, 1000);      // Right turn

  stopAndBrake(500);

  moveBackward(200, 2000);   // Backward

  stopAndBrake(500);

  turnLeft(180, 1000);       // Left turn

  stopAndBrake(500);

}

void moveForward(int speed, int duration) {

  digitalWrite(dirA, HIGH);

  digitalWrite(dirB, HIGH);

  digitalWrite(brakeA, LOW);

  digitalWrite(brakeB, LOW);

  analogWrite(pwmA, speed);

  analogWrite(pwmB, speed);

  Serial.println(“Moving forward”);

  delay(duration);

}

void moveBackward(int speed, int duration) {

  digitalWrite(dirA, LOW);

  digitalWrite(dirB, LOW);

  digitalWrite(brakeA, LOW);

  digitalWrite(brakeB, LOW);

  analogWrite(pwmA, speed);

  analogWrite(pwmB, speed);

  Serial.println(“Moving backward”);

  delay(duration);

}

void turnRight(int speed, int duration) {

  // Left motor forward, right motor reverse

  digitalWrite(dirA, HIGH);

  digitalWrite(dirB, LOW);

  digitalWrite(brakeA, LOW);

  digitalWrite(brakeB, LOW);

  analogWrite(pwmA, speed);

  analogWrite(pwmB, speed);

  Serial.println(“Turning right”);

  delay(duration);

}

void turnLeft(int speed, int duration) {

  // Right motor forward, left motor reverse

  digitalWrite(dirA, LOW);

  digitalWrite(dirB, HIGH);

  digitalWrite(brakeA, LOW);

  digitalWrite(brakeB, LOW);

  analogWrite(pwmA, speed);

  analogWrite(pwmB, speed);

  Serial.println(“Turning left”);

  delay(duration);

}

void stopAndBrake(int duration) {

  digitalWrite(brakeA, HIGH);

  digitalWrite(brakeB, HIGH);

  Serial.println(“Braking”);

  delay(duration);

}

void stopMotors() {

  digitalWrite(brakeA, LOW);

  digitalWrite(brakeB, LOW);

  analogWrite(pwmA, 0);

  analogWrite(pwmB, 0);

}

Stepper Motor Control

The Arduino Motor Shield Rev3 excels at driving bipolar stepper motors by combining both channels. Each motor channel drives one stepper coil.

Stepper Motor Wiring

Connect your bipolar stepper motor coils as follows:

• Coil A (typically Red/Green wires) → Channel A terminals
• Coil B (typically Blue/Yellow wires) → Channel B terminals

Stepper Control with Arduino Library

#include <Stepper.h>

// Define steps per revolution for your stepper

// Common values: 200 (1.8° per step), 48 (7.5° per step)

const int stepsPerRevolution = 200;

// Initialize stepper library

// Parameters: steps per revolution, DIR_A, PWM_A, DIR_B, PWM_B

Stepper myStepper(stepsPerRevolution, 12, 13);

void setup() {

  // Set motor pins as outputs

  pinMode(9, OUTPUT);   // BRAKE A

  pinMode(8, OUTPUT);   // BRAKE B

  // Release brakes

  digitalWrite(9, LOW);

  digitalWrite(8, LOW);

  // Set speed in RPM

  myStepper.setSpeed(60);

  Serial.begin(9600);

  Serial.println(“Stepper Motor Ready”);

}

void loop() {

  Serial.println(“Clockwise rotation”);

  myStepper.step(stepsPerRevolution);

  delay(1000);

  Serial.println(“Counterclockwise rotation”);

  myStepper.step(-stepsPerRevolution);

  delay(1000);

}

Advanced Current Sensing Applications

The current sensing feature enables sophisticated motor control strategies beyond basic speed and direction.

Overcurrent Protection Implementation

const int snsA = A0;

const int currentLimit = 1800;  // 1.8A limit (900 ADC value)

void loop() {

  int currentReading = analogRead(snsA);

  if (currentReading > currentLimit) {

    // Overcurrent detected – engage brake and stop

    digitalWrite(brakeA, HIGH);

    analogWrite(pwmA, 0);

    Serial.println(“OVERCURRENT – Motor stopped!”);

    delay(5000);  // Wait before retry

  }

  // Normal operation continues if current acceptable

}

Stall Detection for Robotics

float readMotorCurrent(int sensePin) {

  int rawValue = analogRead(sensePin);

  return (rawValue * 2.0) / 1023.0;  // Convert to amperes

}

void detectStall() {

  float current = readMotorCurrent(A0);

  int motorSpeed = 200;  // Current PWM value

  // Stall detection: high current with low/medium speed

  if (current > 1.5 && motorSpeed < 220) {

    Serial.println(“Motor stall detected – obstacle or mechanical binding”);

    digitalWrite(brakeA, HIGH);

    analogWrite(pwmA, 0);

    // Implement recovery strategy here

  }

}

Common Problems and Solutions

Motors Don’t Run

Symptom: No motor movement despite code uploading successfully.

Diagnostic steps:

1. Verify external power supply connected to VIN and GND screw terminals
2. Check power LED on shield—should illuminate when power applied
3. Measure voltage at VIN terminal with multimeter (should read 7-12V)
4. Confirm brake pins set LOW in code (HIGH = brake engaged)
5. Verify PWM values >0 (analogWrite must be >50 for most motors)

Common causes:

• USB power only (insufficient current for motors)
• Brake accidentally engaged in code
• Power supply current limiting (use 2A+ supply)

Motors Run Weakly or Inconsistently

Root cause: Insufficient supply voltage accounting for L298P voltage drop.

Solution: For 6V motors, use minimum 8V supply. For 12V motors, use 14V supply or expect reduced performance.

Alternative cause: Power supply voltage sag under load. Measure VIN voltage while motors running—should remain stable. If voltage drops >1V, power supply has insufficient current capacity.

Shield Overheating

Thermal management required: The L298P generates significant heat at high currents.

Solutions:

• Add heatsink to L298P package (PowerSO20 package on shield)
• Reduce motor current by using lower supply voltage
• Implement PWM-based current limiting
• Ensure adequate ventilation around shield
• For sustained 2A operation, use external fan

Random Resets or Erratic Behavior

Typical cause: Ground loop issues or EMI from motors.

Fixes:

• Add 100μF electrolytic capacitor across VIN and GND screw terminals
• Add 0.1μF ceramic capacitors directly across motor terminals
• Use separate power supplies for Arduino (USB) and motors (external)
• Ensure all grounds connected at single star-ground point
• Keep motor wires twisted together to reduce EMI radiation

Shield Comparison Table

Feature	Motor Shield Rev3	L293D Shield	L298N Module
Driver IC	L298P	L293D (×2)	L298N
Channels	2	4	2
Current per Channel	2A	600mA	2A
Current Sensing	Yes (built-in)	No	No
Brake Function	Yes	No	No
Arduino Integration	Direct shield mount	Direct shield mount	Requires wiring
Voltage Drop	1.8-4V	1.4-2.5V	2-4V
TinkerKit Compatible	Yes	No	No
Price	$$$	$$	$

Useful Resources and Downloads

Official Arduino Documentation

• Motor Shield Rev3 Official Page – Complete specifications and purchase
• Motor Shield Rev3 Schematic – Full circuit diagram
• L298P Datasheet – Driver IC technical documentation

Tutorials and Guides

• Arduino Motor Shield Tutorial – Official – Getting started guide
• Stepper Motor Control Guide – Comprehensive stepper examples
• Current Sensing Application Note – Community discussion

Libraries and Code

• Arduino Stepper Library – Built-in Arduino library for steppers
• AccelStepper Library – Advanced stepper control with acceleration
• Example Code Repository – Official Arduino example sketches

Component Sources

• Arduino Official Store – Genuine Arduino shield
• Adafruit Industries – Alternative quality shields
• SparkFun Electronics – Motor drivers and accessories

Frequently Asked Questions

Q: Can I use the Arduino Motor Shield Rev3 with Arduino boards other than UNO?

Yes, but with caveats. The shield is designed for Arduino UNO Rev3 with the standard pin layout including the newer IOREF pin. It works with Arduino Mega by stacking normally—the shield only uses pins it needs. For older Arduino boards (pre-Rev3 UNO), the IOREF and duplicate I2C pins won’t align, but the shield functions if you carefully align the main pin headers. Leonardo and Due boards may have compatibility issues due to different pin assignments for PWM and I2C.

Q: How do I calculate actual motor current from the analog reading?

The current sense pins (A0 and A1) output 3.3V at maximum rated current (2A). Using Arduino’s 10-bit ADC (0-1023), the relationship is linear: Current (A) = (analogRead value × 2.0) / 1023. For example, analogRead(A0) = 512 indicates (512 × 2.0) / 1023 = 1.0A. Each ADC count represents approximately 1.95mA. For precise measurements, calibrate against known current using multimeter in series with motor.

Q: Can I parallel both channels to drive a single high-current motor?

No, this is not recommended and not officially supported. The L298P channels lack current-sharing circuitry needed for safe paralleling. Small timing differences between channels can cause one to carry most current, leading to thermal shutdown or damage. For motors requiring >2A, use a higher-current driver like VNH5019 (12A capability) or BTS7960 (43A capability) instead of attempting to parallel Motor Shield Rev3 channels.

Q: What’s the maximum voltage I can safely apply to the shield?

The absolute maximum voltage at the VIN screw terminals is 18V according to the datasheet. However, practical recommendations differ based on configuration: With Vin Connect jumper intact (default), use 7-12V maximum to stay within Arduino’s VIN rating. With Vin Connect jumper cut, you can use up to 18V for the motors while powering Arduino separately via USB or its own power supply. Exceeding 18V risks damaging the L298P driver IC and protection diodes.

Q: Why does my stepper motor vibrate or make noise but doesn’t rotate smoothly?

This typically indicates incorrect coil identification or wiring. Bipolar steppers have two coils that must be correctly identified and connected to separate channels. Use a multimeter to measure resistance between wire pairs—wires belonging to the same coil will show low resistance (typically 10-100Ω), while wires from different coils show infinite resistance. Verify coil A connects to Channel A terminals and coil B connects to Channel B terminals. Also ensure your code sends proper stepping sequences and that motor voltage/current ratings match your power supply.

Conclusion

The Arduino Motor Shield Rev3 represents thoughtful engineering that goes beyond simply mounting an H-bridge driver on a PCB. The integrated current sensing, brake control, and TinkerKit compatibility demonstrate Arduino’s understanding of real-world motor control requirements. These features would require additional components and custom PCB design to implement from discrete parts.

From a PCB engineer’s perspective, the shield showcases good design practices: proper thermal relief on the power traces, adequate copper weight for high-current paths, and accessible jumpers for configuration flexibility. The decision to include current sense resistors and amplification circuitry adds minimal BOM cost while enabling sophisticated control strategies like stall detection and overcurrent protection.

Understanding the voltage drop characteristics of the L298P is critical for successful implementation. This isn’t unique to the Motor Shield Rev3—all L298-based drivers exhibit 2-4V drops at load. Account for this in your power supply design by providing 2-3V headroom above your motor’s rated voltage.

The 2A per channel rating represents continuous operation under ideal thermal conditions. Real-world applications in enclosed spaces or elevated ambient temperatures require conservative derating to 1.5A or active cooling solutions. Monitor current via the sense pins and implement protective logic to prevent thermal damage during development.

For Arduino users graduating from basic LED blinkers to mechatronic systems, the Motor Shield Rev3 provides professional-grade motor control without the complexity of designing custom driver circuits. The shield’s open-source hardware license means you can study the schematic, understand the design decisions, and eventually create custom solutions when project requirements exceed the shield’s specifications.