Contents List

1. Introduction
2. What Is a DC Motor?
3. How a DC Motor Works?
4. Types of DC Motors
5. Essential Motor Specifications
6. DC Motor Connections and Wiring
7. Choosing a Motor Driver
8. Controlling DC Motor Speed with PWM
9. Controlling Motor Direction with an H-Bridge
10. Programming a DC Motor with Arduino
11. Controlling Speed with a Potentiometer
12. Connecting and Controlling Two DC Motors
13. Common Applications and Hobby Projects
14. Troubleshooting and Safety Tips
15. Frequently Asked Questions
16. Conclusion

Time reading 20min.

1. Introduction

A DC Motor (Direct Current motor) converts electrical energy into rotational mechanical motion. It is widely used in robotics, small vehicles, fans, pumps, conveyors, and many electronics projects because it is relatively simple to operate and easy to integrate into embedded systems.

However, connecting a DC motor to a microcontroller is not as simple as connecting an LED. Motors can draw much more current than a microcontroller pin can safely provide, especially when starting or when the shaft is blocked. A suitable motor driver and an appropriately rated power supply are therefore essential for reliable operation.

In this guide, you will learn how to identify a DC motor’s important specifications, wire it correctly, select a suitable driver, control its speed and direction, and write Arduino code to operate it. You will also learn how to troubleshoot common problems and apply these techniques to practical hobby projects.

2. What Is a DC Motor?

A DC Motor is an electrical machine that uses direct current to produce rotational motion. In a common brushed DC motor, electrical current flows through windings in the rotor, creating a magnetic field that interacts with the motor’s permanent magnets or field windings. This interaction produces torque, which rotates the shaft.

Main parts of a typical brushed DC motor:

• Stator: The stationary part that produces a magnetic field.
• Rotor or armature: The rotating part containing the windings.
• Commutator: A segmented electrical contact that changes the current direction in the rotor windings.
• Brushes: Conduct current to the rotating commutator.
• Shaft: Transfers the motor’s rotational movement to a load.
• Bearings: Support the shaft and allow it to rotate smoothly.

A basic two-wire brushed DC motor is easy to control: applying a suitable DC voltage makes it rotate, reversing the polarity reverses its direction, and changing the effective voltage can change its speed.

A motor’s behavior depends on its design and mechanical load. Applying a higher voltage than the rated value can cause excessive speed, current, and heat, so always follow the motor’s datasheet.

3. How a DC Motor Works?

A brushed DC motor operates through the interaction between electric current and magnetic fields. When current passes through the rotor windings, a force acts on the conductors and produces torque.

As the rotor turns, the commutator and brushes switch the current through the windings to maintain rotation in the same general direction.

Three electrical and mechanical relationships are particularly useful when designing a motor-control system.

Voltage and Speed

For a given motor, increasing the applied voltage generally increases its speed under similar load conditions. However, speed does not depend on voltage alone. Load, friction, winding resistance, motor temperature, and the driver’s voltage drop also affect the result.

Current and Torque

Motor torque is approximately proportional to armature current over the motor’s normal operating range. A heavier load usually requires more torque, which generally means more current.

When the motor is first switched on, its back electromotive force (back EMF) is initially very low. The starting current can therefore be much higher than the normal running current.

If the shaft is blocked, the motor may draw its stall current, which can damage an undersized driver, wiring, or power supply.

Back EMF

When the motor rotates, it generates a voltage that opposes the applied voltage. This is called back EMF.

As speed increases, back EMF usually increases, reducing the current needed to sustain rotation under a given load. When the motor slows down under a heavier load, back EMF falls and current generally rises.

This explains why a motor may draw a large current during startup or when heavily loaded.

4. Types of DC Motors

Different motor types require different control methods. Before selecting a driver or writing code, identify which type you are using.

Brushed DC Motor

A brushed DC motor is a common choice for beginner electronics and robotics projects. It usually has two power wires and can be controlled with a transistor or MOSFET for one-direction operation, or an H-bridge for reversing direction.

Typical uses include small fans, toy vehicles, simple robotic mechanisms, and hobby gearmotors.

Geared DC Motor

A geared DC motor combines a motor with a gearbox. The gearbox reduces output speed and increases available output torque compared with the motor shaft alone, although some power is lost through the gears.

Geared motors are useful for robot wheels, small mobile platforms, and mechanisms that need more torque at lower speeds.

Brushless DC Motor (BLDC)

A brushless DC motor uses electronic commutation instead of mechanical brushes and a commutator. It normally requires a dedicated BLDC controller or electronic speed controller (ESC).

A typical two-wire brushed-motor circuit cannot directly control a BLDC motor. Hobby drone motors, for example, commonly use three motor phase wires connected to an ESC.

Coreless DC Motor

A coreless motor uses a rotor winding without a conventional iron core. Some designs offer low rotor inertia and fast response, making them useful for small precision mechanisms. Their voltage, current, and mechanical limits still need to be checked before use.

5. Essential Motor Specifications

Before wiring a motor, check its datasheet or reliable product documentation. The following specifications help determine the correct power supply, driver, and control method.

Important: Do not assume that a driver rated for the motor’s normal running current can also handle its stall current. Compare the driver’s continuous and peak current limits, voltage limits, and thermal requirements against the motor’s actual specifications.

Also distinguish between the motor’s rated current and its stall current. They describe different operating conditions and are not interchangeable.

6. DC Motor Connections and Wiring

The correct wiring depends on whether you need only on/off control, speed control, or speed and direction control.

Basic Two-Wire Motor Connection

A brushed DC motor usually has two terminals. Connecting a suitable DC supply across these terminals makes the motor rotate. Reversing the polarity reverses its direction.

For example, a motor rated for 6 V should normally be operated from a suitable supply near its specified operating voltage, subject to its datasheet and the requirements of the application.

This simple connection is useful for understanding motor operation, but it does not provide electronic speed control or safe microcontroller interfacing by itself.

Why You Should Not Connect a Motor Directly to an Arduino Pin?

Arduino GPIO pins are intended to provide control signals, not to supply the current required by most motors. A motor can draw excessive current, generate electrical disturbances, and produce voltage spikes that can damage the microcontroller.

Use an appropriate driver between the Arduino and the motor. The driver switches the motor’s current while the Arduino provides low-power logic signals.

Wiring a Motor Driver to Arduino

For a typical single brushed DC motor using an H-bridge module, the connections are generally as follows. Always confirm the terminal labels and logic requirements in the documentation for your particular module.

Use a common ground between the Arduino and the driver when the interface requires it. Without a shared reference, the driver may not reliably interpret the Arduino’s logic signals.

Do not assume that every module uses the same power arrangement. Some boards have separate logic and motor supplies; others include regulators or jumpers that change how the power terminals work.

Choosing a Power Supply

The supply must provide a voltage suitable for the motor and enough current for its startup and load conditions.

It must also be compatible with the driver’s voltage and current limits.

For example, a small motor rated at 6 V should not automatically be powered from a 12 V source just because the driver accepts 12 V.

The motor itself must remain within its permitted operating conditions.

Avoid relying on the Arduino’s onboard regulator or USB connection to power a motor unless the entire setup has been explicitly designed and verified for that load.

7. Choosing a Motor Driver

A motor driver is the power interface between the controller and the motor.

It allows a low-power signal from an Arduino or another microcontroller to control the higher current required by the motor.

Transistor or MOSFET Driver

For simple on/off or speed control in one direction, a suitable transistor or logic-level MOSFET can switch the motor current. The circuit must include appropriate inductive-load protection, such as a correctly rated flyback diode for a simple low-side switching circuit.

This arrangement is useful when you do not need to reverse the motor electrically.

H-Bridge Driver

An H-bridge allows current to flow through the motor in either direction. It is commonly used when an application needs forward and reverse rotation, such as a robot car.

The driver may also support PWM speed control. Some modules provide additional features such as current sensing, current limiting, thermal shutdown, or undervoltage protection.

Common Driver Modules

These are examples, not interchangeable parts. Board layouts, cooling, protection circuitry, and manufacturer ratings can differ. Before choosing a driver, compare the motor’s rated voltage, stall current, expected duty cycle, and the driver’s continuous current, peak current, voltage range, and thermal limits. Toshiba’s motor-driver documentation is a useful manufacturer-level reference for this selection process.

8. Controlling DC Motor Speed with PWM

Pulse-width modulation (PWM) is a common method for controlling the effective power delivered to a DC motor. Rather than generating a continuously adjustable voltage, the controller rapidly switches the driver on and off.

The percentage of each PWM cycle spent in the active state is called the duty cycle.

For example:

Increasing the duty cycle generally increases motor speed under similar conditions. However, duty cycle is not a direct measurement of RPM: the actual speed also depends on load, supply voltage, motor characteristics, and driver losses.

PWM with Arduino

On many classic Arduino boards, analogWrite() produces PWM on supported pins. For an 8-bit PWM interface, values typically range from 0 to 255:

PWM capabilities and resolution vary by board. Check the official documentation and pinout for your specific Arduino model before selecting a pin.

PWM Frequency and Motor Behavior

PWM frequency affects switching losses, audible noise, current ripple, and driver performance. A frequency that works well for one driver may not be ideal for another.

For beginner projects, use the motor driver’s recommended PWM range and the microcontroller’s supported settings. Avoid changing timer or PWM frequency settings without checking whether they interfere with other functions or libraries.

9. Controlling Motor Direction with an H-Bridge

To reverse a brushed DC motor electronically, the driver must reverse the polarity applied across the motor terminals. An H-bridge performs this function using switching transistors.

How the Direction Inputs Work?

A typical H-bridge has two direction inputs, often labeled IN1 and IN2. For a common control arrangement, the input combinations may work as follows:

These states are common examples, not a universal rule. Some drivers use different input logic, and some provide separate PWM, enable, or standby pins. Always check the specific driver’s truth table.

Coast vs. Brake

These two stopping behaviors are different:

• Coast: The driver stops actively powering the motor, allowing it to slow down naturally.

• Brake: The driver electrically brakes the motor, causing it to slow down more quickly.

The actual behavior depends on the driver’s design and input state. If the motor drives a heavy or fast-moving mechanism, consider how quickly it needs to stop and whether the driver can safely handle the resulting current and energy.

Reversing Direction Safely

Avoid switching directly from full-speed forward to full-speed reverse without considering motor speed and current. The abrupt change can cause high current, mechanical shock, or driver stress.

For a practical control system, reduce the PWM duty cycle, allow the motor to slow down, and then change the direction inputs. For demanding applications, use current monitoring, acceleration limits, or feedback control.

10. Programming a DC Motor with Arduino

This example uses an Arduino Uno and an L298N motor-driver module to control one brushed DC motor. The motor is powered by a suitable external supply, while the Arduino provides direction and PWM signals.

Required Components

Before powering the circuit, verify that the motor’s stall current is within the driver’s capabilities and that the motor supply voltage is suitable for both the motor and the driver.

Wiring Connections

This example assumes a common L298N module with an ENA enable input and IN1/IN2 direction inputs.

If the module has an ENA jumper, remove it when you need to control speed using Arduino PWM on ENA. Follow the board documentation for the correct logic and motor-supply connections. Do not connect an external voltage to an Arduino GPIO pin.

Important: The L298N has a relatively large voltage drop compared with many modern MOSFET-based motor drivers. The motor may therefore receive less voltage than the supply voltage, and the driver can become hot. For small, low-voltage motors, a more efficient driver may be a better choice.

Example Arduino Code

The following sketch runs the motor forward, gradually increases its speed, slows it down, then repeats the process in reverse.

const int ENA = 5;  // PWM speed control
const int IN1 = 7;  // Direction input 1
const int IN2 = 8;  // Direction input 2

void setup() {
  pinMode(ENA, OUTPUT);
  pinMode(IN1, OUTPUT);
  pinMode(IN2, OUTPUT);

  stopMotor();
}

void setMotor(int speedValue, bool forward) {
  speedValue = constrain(speedValue, 0, 255);

  if (forward) {
    digitalWrite(IN1, HIGH);
    digitalWrite(IN2, LOW);
  } else {
    digitalWrite(IN1, LOW);
    digitalWrite(IN2, HIGH);
  }

  analogWrite(ENA, speedValue);
}

void stopMotor() {
  analogWrite(ENA, 0);
  digitalWrite(IN1, LOW);
  digitalWrite(IN2, LOW);
}

void loop() {
  // Accelerate in the forward direction
  for (int speedValue = 0; speedValue <= 200; speedValue += 5) {
    setMotor(speedValue, true);
    delay(50);
  }

  delay(1000);

  // Gradually slow down
  for (int speedValue = 200; speedValue >= 0; speedValue -= 5) {
    setMotor(speedValue, true);
    delay(50);
  }

  stopMotor();
  delay(1000);

  // Accelerate in reverse
  for (int speedValue = 0; speedValue <= 200; speedValue += 5) {
    setMotor(speedValue, false);
    delay(50);
  }

  delay(1000);

  // Gradually slow down
  for (int speedValue = 200; speedValue >= 0; speedValue -= 5) {
    setMotor(speedValue, false);
    delay(50);
  }

  stopMotor();
  delay(2000);
}

Understanding the Code

The example uses a maximum PWM value of 200 rather than 255 to limit the commanded duty cycle. This does not guarantee a particular speed or current limit. If the motor is overloaded or its stall current exceeds the driver’s rating, the circuit can still be damaged.

The example also does not measure actual RPM. It provides open-loop control: the Arduino commands a PWM duty cycle, but it does not verify the motor’s real speed.

11. Controlling Speed with a Potentiometer

A potentiometer can provide a simple manual speed command. The Arduino reads the potentiometer’s analog voltage and converts it into a PWM value for the motor driver.

Potentiometer Connections

For a typical 10 kΩ potentiometer:

This arrangement assumes a board whose analog input accepts the selected voltage range.

For 3.3 V microcontrollers, use the appropriate supply and input-voltage limits.

Arduino Code

This example controls speed in one direction using the same L298N wiring as the previous section. It assumes that the ENA pin is connected to Arduino pin 5 and that IN1 and IN2 are connected to pins 7 and 8.

const int ENA = 5;
const int IN1 = 7;
const int IN2 = 8;
const int POT = A0;

void setup() {
  pinMode(ENA, OUTPUT);
  pinMode(IN1, OUTPUT);
  pinMode(IN2, OUTPUT);

  // Select one direction
  digitalWrite(IN1, HIGH);
  digitalWrite(IN2, LOW);
}

void loop() {
  int potValue = analogRead(POT);

  // Classic Arduino Uno: map 10-bit ADC to 8-bit PWM
  int motorSpeed = map(potValue, 0, 1023, 0, 255);

  analogWrite(ENA, motorSpeed);

  delay(10);
}

How It Works?

On a classic Arduino Uno, analogRead() typically returns values from 0 to 1023. The map() function converts this range to 0–255, which is suitable for the board’s usual 8-bit analogWrite() interface.

Turning the potentiometer changes the requested PWM duty cycle. At very low duty cycles, the motor may not start because it needs enough torque to overcome friction and the connected load. This is normal for many small motors.

If the motor behaves erratically near the minimum setting, you can add a minimum starting duty cycle or implement a brief startup boost. Such adjustments should be tested carefully because they can increase current and do not replace proper current protection.

12. Connecting and Controlling Two DC Motors

Two brushed DC motors are common in robot cars and small mobile robots. Each motor should have a driver channel capable of handling its own voltage and current requirements.

Dual-Motor Driver

A dual H-bridge module can control two motors independently. One channel drives the left motor, while the other drives the right motor. Each channel may have separate direction inputs and a PWM input or enable signal.

Before connecting both motors, check the driver’s total current limits as well as the limits of each channel. Two motors starting at the same time can place a substantial load on the supply.

Basic Robot Movement

A two-wheel differential-drive robot changes direction by varying the direction and speed of its left and right motors.

The exact logic levels depend on the physical motor wiring and the driver’s input arrangement. If one motor is mounted in the opposite orientation, its electrical direction may need to be reversed in software or by swapping its two motor leads.

Why Two Motors May Not Run at the Same Speed?

Even when two motors receive the same PWM duty cycle, their speeds may differ because of manufacturing tolerances, mechanical friction, wheel diameter, battery voltage, and load distribution.

For more accurate straight-line movement, use encoders or other speed sensors and implement feedback control.

PWM alone sets the drive command; it does not guarantee a specific RPM.

13. Common Applications and Hobby Projects

DC motors are useful in many practical electronics projects because they provide a straightforward way to convert electrical control into physical movement.

Robot Car

Use two geared DC motors with a dual H-bridge driver. An Arduino can control forward and reverse movement, speed, and turning. Add distance sensors or line sensors to make the robot respond to its environment.

Mini Conveyor Belt

A geared DC motor can drive a small conveyor. PWM provides basic speed adjustment, while a sensor can detect objects passing along the belt.

For applications that need consistent speed under changing loads, add a speed sensor and feedback control.

Fan Speed Controller

A brushed DC fan can often be controlled with a suitable transistor or motor driver. Select the control method according to the fan’s rated voltage, current, and internal electronics. Some fans require a dedicated control input rather than PWM applied to their supply.

Automatic Mechanism

A DC motor can drive a small gate, sliding platform, or other mechanism. For a safer design, add limit switches, mechanical stops, current monitoring, and a way to stop the motor if movement is obstructed.

A standard DC motor does not inherently know its shaft position. If accurate position control is required, use encoders, limit switches, or another suitable feedback method.

14. Troubleshooting and Safety Tips

Motor-control problems often come from power-supply limitations, wiring errors, driver selection, or incorrect assumptions about PWM and motor speed.

Electrical Safety

For higher-power motors, add appropriate fusing, wiring sized for the expected current, and emergency-stop provisions where needed. Mechanical hazards also matter: rotating shafts, gears, wheels, and belts can pinch fingers or catch loose clothing.

15. Frequently Asked Questions

Can I Connect a DC Motor Directly to an Arduino?

No, not for a typical DC motor. Arduino GPIO pins are designed for low-current logic signals. Use a suitable transistor or motor-driver module and an appropriate motor power supply.

How Can I Control a DC Motor’s Speed?

A common method is PWM. The microcontroller changes the duty cycle of the signal sent to a motor driver, which changes the effective power delivered to the motor. The actual speed depends on the motor, supply voltage, driver losses, and mechanical load.

How Can I Reverse a DC Motor’s Direction?

For a brushed DC motor, reverse the polarity across its terminals. An H-bridge motor driver allows the controller to do this electronically without manually swapping wires.

What Is the Difference Between PWM and Analog Voltage Control?

PWM rapidly switches a signal between its active and inactive states. The duty cycle controls the proportion of time the signal is active. True analog voltage control instead supplies a continuously adjustable voltage. A PWM signal is not automatically a true analog output, even though it can control a motor’s effective power.

Can I Use a 12 V Power Supply with a 6 V DC Motor?

Not directly unless the motor-control system limits the voltage and power delivered to the motor to appropriate levels. A 12 V supply may overdrive a 6 V motor, causing excessive speed, current, and heat. Select a supply and driver arrangement that respects the motor’s specifications.

Why Does My DC Motor Draw a High Current at Startup?

At startup, the motor is not yet rotating, so its back EMF is low. The current is therefore initially limited mainly by winding resistance and the rest of the circuit. As the motor speeds up, back EMF increases and the current typically falls.

Does a Higher PWM Value Always Mean a Higher Motor Speed?

Generally, increasing the duty cycle increases speed under similar operating conditions. However, PWM duty cycle is not a direct speed measurement. Load changes, supply voltage, friction, and motor characteristics all affect actual RPM.

Can I Control Two DC Motors with One Arduino?

Yes. You can control two motors using a dual-channel motor driver, provided the driver and power supply can handle both motors. Independent speed and direction control requires enough control signals or a suitable driver interface.

Do I Need an Encoder to Control Motor Speed?

An encoder is not necessary for basic open-loop speed adjustment using PWM. However, if you need to maintain a target speed as the load changes, an encoder or another suitable speed sensor can provide feedback for closed-loop control.

Which Motor Driver Is Best for Beginners?

There is no single best driver for every motor. Choose one based on motor voltage, stall current, required direction and speed control, thermal limits, and available protection features. Popular modules such as the L298N, TB6612FNG, and DRV8833 have different characteristics, so verify the exact module’s documentation before use.

16. Conclusion

DC motors are fundamental components in robotics, automation, and hobby electronics. Understanding their electrical and mechanical behavior makes it easier to select the right motor, design a reliable connection, and develop effective control software.

The most important principles are to use a suitable motor driver instead of powering a motor directly from a microcontroller pin, select a power supply that meets the motor’s requirements, and use PWM for basic speed control and an H-bridge when electronic direction reversal is needed.

With Arduino, these techniques provide a practical starting point for robot cars, fans, conveyors, and other motion-control projects. As your projects become more demanding, you can build on these fundamentals by adding encoders, feedback control, current sensing, and more advanced motor drivers.

const int ENA = 5;  // PWM speed control
const int IN1 = 7;  // Direction input 1
const int IN2 = 8;  // Direction input 2

void setup() {
  pinMode(ENA, OUTPUT);
  pinMode(IN1, OUTPUT);
  pinMode(IN2, OUTPUT);

  stopMotor();
}

void setMotor(int speedValue, bool forward) {
  speedValue = constrain(speedValue, 0, 255);

  if (forward) {
    digitalWrite(IN1, HIGH);
    digitalWrite(IN2, LOW);
  } else {
    digitalWrite(IN1, LOW);
    digitalWrite(IN2, HIGH);
  }

  analogWrite(ENA, speedValue);
}

void stopMotor() {
  analogWrite(ENA, 0);
  digitalWrite(IN1, LOW);
  digitalWrite(IN2, LOW);
}

void loop() {
  // Accelerate in the forward direction
  for (int speedValue = 0; speedValue <= 200; speedValue += 5) {
    setMotor(speedValue, true);
    delay(50);
  }

  delay(1000);

  // Gradually slow down
  for (int speedValue = 200; speedValue >= 0; speedValue -= 5) {
    setMotor(speedValue, true);
    delay(50);
  }

  stopMotor();
  delay(1000);

  // Accelerate in reverse
  for (int speedValue = 0; speedValue <= 200; speedValue += 5) {
    setMotor(speedValue, false);
    delay(50);
  }

  delay(1000);

  // Gradually slow down
  for (int speedValue = 200; speedValue >= 0; speedValue -= 5) {
    setMotor(speedValue, false);
    delay(50);
  }

  stopMotor();
  delay(2000);
}

const int ENA = 5;
const int IN1 = 7;
const int IN2 = 8;
const int POT = A0;

void setup() {
  pinMode(ENA, OUTPUT);
  pinMode(IN1, OUTPUT);
  pinMode(IN2, OUTPUT);

  // Select one direction
  digitalWrite(IN1, HIGH);
  digitalWrite(IN2, LOW);
}

void loop() {
  int potValue = analogRead(POT);

  // Classic Arduino Uno: map 10-bit ADC to 8-bit PWM
  int motorSpeed = map(potValue, 0, 1023, 0, 255);

  analogWrite(ENA, motorSpeed);

  delay(10);
}