Arduino – Motors Connections, Control and Programming

Contents List

• Introduction of Arduino.
• Introduction of Motors.
• Difference between DC Motor vs Servo Motor vs Stepper Motor.
• Why Can’t We Connect a Motor Directly to an Arduino?
• Protecting the Arduino and Circuit.
• Arduino – Servo Motor Connections, Control and Programming.
  • Introduction of Servo Motor.
  • What Is a Servo Motor?
  • Pin Configuration of Servo Motor.
  • How Servo Motor work?
  • How Do You Communicate the Angle at Which the Servo Should Turn?
  • Important Power Considerations.
  • Common Applications of Servo Motor.
  • Components Required.
  • Connecting the Servo Motor to Arduino.
  • Example of Arduino – Servo Motor Connection.
  • Controlling a Servo Motor with Arduino.
  • Controlling the Servo Movement Speed.
  • Useful Arduino Servo Functions.
  • Using Multiple Servo Motors.
  • Common Problems and Important Precautions.
• Arduino – DC Motor Connections, Control and Programming.
  • Introduction of DC Motor.
  • Pin Configuration of DC Motor.
  • Common Applications of DC Motor.
  • Important Power Considerations
  • How to Control a DC Motor?
  • L298N Motor Driver.
  • Connecting Arduino to the L298N.
  • Controlling DC Motor Direction.
  • Controlling DC Motor Speed.
  • Example of Arduino – DC Motor Connection.
  • Common Problems and Important Precautions
• Arduino – Stepper Motor Connections, Control and Programming.
  • Introduction of Stepper Motor.
  • What Is a Stepper Motor?
  • How a Stepper Motor Works?
  • Why a Stepper Motor Driver Is Required?
  • Common Applications of Stepper Motor.
  • Examples of Stepper Motor Drivers
  • A4988 Stepper Motor Driver.
  • Connecting Arduino to the A4988 Driver.
  • Motor Power and Current Limit.
  • Microstepping.
  • Controlling the Motor with Arduino.
  • Controlling Speed and Direction.
  • Using the AccelStepper Library.
  • Common Problems and Important Precautions.
• Which Motor Should You Choose?
• Conclusion.

Time Reading Approximately is 20 minute 

Introduction of Arduino

Arduino Uno is a microcontroller board based on the ATmega328P (Datasheet). It has 14 digital input/output pins (of which 6 can be used as PWM outputs), 6 analog inputs, a 16 MHz ceramic resonator (CSTCE16M0V53-R0), a USB connection, a power jack, an ICSP header and a reset button. It contains everything needed to support the microcontroller; simply connect it to a computer with a USB cable or power it with a AC-to-DC adapter or battery to get started.. You can tinker with your Uno without worrying too much about doing something wrong, worst case scenario you can replace the chip for a few dollars and start over again.

“Uno” means one in Italian and was chosen to mark the release of Arduino Software (IDE) 1.0. The Uno board and version 1.0 of Arduino Software (IDE) were the reference versions of Arduino, now evolved to newer releases. The Uno board is the first in a series of USB Arduino boards, and the reference model for the Arduino platform; for an extensive list of current, past or outdated boards see the Arduino index of boards.

Introduction of Motors

Motors are one of the most useful components in Arduino projects. They allow a project to move, rotate, position, open, close, or control mechanical parts. However, connecting a motor to an Arduino is different from connecting a simple LED or sensor because motors usually require more current than an Arduino pin can safely provide.

In this article, we will look at the three motor types commonly used with Arduino:

• Servo Motors.
• DC Motors.
• Stepper Motors.

Difference between Servo Motor vs DC Motor vs Stepper Motor

Why Can’t We Connect a Motor Directly to an Arduino?

An Arduino GPIO pin is intended to control electronic signals and small loads. A motor can require considerably more current, especially when starting or when mechanically loaded.

Connecting a motor directly to an Arduino pin can:

• Exceed the pin’s current capability
• Cause voltage drops and Arduino resets
• Generate electrical noise
• Damage the Arduino

Therefore, a motor driver or other suitable interface is normally required.

The general arrangement is:

Arduino → Motor Driver/Control Circuit → Motor

The motor should also have an appropriate power supply. In many projects, the motor power supply is separate from the Arduino’s power supply.

Protecting the Arduino and Circuit

Motors are inductive loads and can produce voltage spikes when their current changes. Proper motor-driver circuits normally include protection against these effects. For a discrete transistor or MOSFET circuit driving a brushed DC motor, a suitable flyback diode is typically required.

There are several other important precautions:

• Check the motor’s rated voltage.
• Check its operating and stall current.
• Use a motor driver rated for the motor.
• Use an adequate external power supply when necessary.
• Connect grounds correctly.
• Do not draw motor current through an Arduino GPIO pin.
• Check the driver’s thermal limits.

The motor’s stall current is particularly important because it can be much higher than the current consumed by the motor while it is spinning freely.

Arduino – Servo Motor Connections, Control and Programming

Introduction of Servo Motor

A servo motor is an actuator that allows an Arduino to control the angular position of a mechanical shaft. Unlike a conventional DC motor, a standard servo motor can be commanded to move to a specific angle, typically within a range of 0° to 180°.

What Is a Servo Motor?

A Servo Motor is a small device that has an output shaft. This shaft can be positioned to specific angular positions by sending the servo a coded signal. As long as the coded signal exists on the input line, the servo will maintain the angular position of the shaft. If the coded signal changes, the angular position of the shaft changes.

The Types of Servo Motor :

• 90° Servo Motor.
• 180° Servo Motor.
• 360° Servo Motor.

The 360° Servo Motor is similar to DC motor, except for no hardware driver is required.

This makes a servo different from a standard DC motor. A DC motor is generally used when you want continuous rotation, while a standard servo is useful when you want to position something at a particular angle.

A servo motor is one of the easiest motors to control with an Arduino. Unlike a regular DC motor, a servo motor can be commanded to move to a specific angle, making it useful for robotics, automation, remote-controlled projects, and many other Arduino applications.

Pin Configuration of Servo Motor

Most small hobby servo motors have three wires.

The wire colors can vary between manufacturers, so always check the documentation for your particular servo. A common color arrangement is:

The three connections have different purposes.

VCC

• The VCC wire supplies power to the servo motor.
• Many small hobby servos are designed to operate from approximately 5 V, but the correct voltage depends on the specific servo. Always check the servo’s specifications before connecting a power supply.

GND

• The GND wire is the electrical ground connection.
• If you use an external power supply for the servo, the external supply’s negative terminal should be connected to the Arduino GND. This gives the Arduino and servo a common electrical reference.

Signal

• The signal wire receives the control signal from the Arduino.
• For example, you can connect the signal wire to Arduino digital pin 9 and then use the Arduino Servo library to command the servo to a particular angle.

How Servo Motor work?

The servo motor has some control circuits and a potentiometer (a variable resistor, aka pot) connected to the output shaft. In the picture above, the pot can be seen on the right side of the circuit board. This pot allows the control circuitry to monitor the current angle of the servo motor.

If the shaft is at the correct angle, then the motor shuts off. If the circuit finds that the angle is not correct, it will turn the motor until it is at a desired angle. The output shaft of the servo is capable of traveling somewhere around 180 degrees. Usually, it is somewhere in the 210-degree range, however, it varies depending on the manufacturer. A normal servo is used to control an angular motion of 0 to 180 degrees. It is mechanically not capable of turning any farther due to a mechanical stop built on to the main output gear.

The power applied to the motor is proportional to the distance it needs to travel. So, if the shaft needs to turn a large distance, the motor will run at full speed. If it needs to turn only a small amount, the motor will run at a slower speed. This is called proportional control.

How Do You Communicate the Angle at Which the Servo Should Turn?

The control wire is used to communicate the angle. The angle is determined by the duration of a pulse that is applied to the control wire. This is called Pulse Coded Modulation. The servo expects to see a pulse every 20 milliseconds (.02 seconds). The length of the pulse will determine how far the motor turns. A 1.5 millisecond pulse, for example, will make the motor turn to the 90-degree position (often called as the neutral position). If the pulse is shorter than 1.5 milliseconds, then the motor will turn the shaft closer to 0 degrees. If the pulse is longer than 1.5 milliseconds, the shaft turns closer to 180 degrees.

Important Power Considerations

Although a servo can sometimes be powered from the Arduino’s 5V output, this is not recommended for higher-current servo applications.

A servo motor can draw significant current, especially when:

• The servo is a high-torque model.
• The servo is carrying a heavy load.
• The servo starts moving.
• The servo is stalled or working against mechanical resistance.
• Several servo motors are used simultaneously.

Insufficient power can cause unstable operation, unexpected resets, or other problems.

For these applications, use a suitable external power supply for the servo.

Important Ground Connection

When an external power supply is used, the negative terminal of the external supply must be connected to the Arduino GND.

This creates a common reference between the Arduino control signal and the servo power supply.

The basic arrangement is:

• External supply positive → Servo VCC
• External supply negative → Servo GND
• External supply negative → Arduino GND
• Arduino digital pin → Servo Signal

Do not connect the positive terminal of the external servo power supply directly to the Arduino 5V pin unless the power arrangement has been specifically designed for that purpose.

Common Applications of Servo Motor

• Robotic Arms.
• Robot steering systems.
• Pan-and-tilt mechanisms.
• Camera platforms.
• Automatic doors and locks.
• Model vehicles.
• Mechanical control systems.

Components Required

For a basic Arduino servo project, you will need:

• Arduino Uno or compatible Arduino board
• Standard servo motor
• USB cable
• Jumper wires
• Suitable power supply for the servo
• Breadboard, if required

For projects using a high-torque servo or multiple servo motors, an external power supply is recommended.

Connecting the Servo Motor to Arduino

Basic Signal Connection

Connect the servo motor as follows:

Example of Arduino – Servo Motor Connection

The following program makes the servo move gradually from 0° to 180° and then back from 180° to 0°.

#include <Servo.h>

Servo servo;

void setup()
{
  servo.attach(9);
  servo.write(0);
}

void loop()
{
  // Move from 0° to 180°
  for (int pos = 0; pos <= 180; pos++)
  {
    servo.write(pos);
    delay(10);
  }

  // Move from 180° back to 0°
  for (int pos = 180; pos >= 0; pos--)
  {
    servo.write(pos);
    delay(10);
  }
}

How the Example Program Works

Step 1: Include the Servo Library

#include <Servo.h>

This makes the Arduino Servo library available to the program.

Step 2: Create a Servo Object

Servo servo;

The servo object represents the servo motor that will be controlled by the program.

If multiple servos are used, multiple Servo objects can be created.

For example:

Servo servo1;
Servo servo2;

Step 3: Attach the Servo to an Arduino Pin

servo.attach(9);

This assigns Arduino digital pin 9 as the control pin for the servo.

The servo’s signal wire should therefore be connected to pin 9.

Step 4: Set the Initial Position

servo.write(0);

This commands the servo to move toward the 0° position.

Step 5: Move from 0° to 180°

for (int pos = 0; pos <= 180; pos++)
{
  servo.write(pos);
  delay(10);
}

The variable pos starts at 0 and increases one degree at a time until it reaches 180.

The servo.write(pos) command sends the requested position to the servo.

The delay(10) introduces a short delay between position commands, producing a gradual movement.

Step 6: Move from 180° to 0°

for (int pos = 180; pos >= 0; pos--)
{
  servo.write(pos);
  delay(10);
}

The same process is repeated in reverse, causing the servo to return gradually from 180° to 0°.

Uploading the Program to Arduino

Follow these steps to run the project:

1. Connect the Arduino board to the computer using a USB cable.
2. Open the Arduino IDE.
3. Select the correct Arduino board.
4. Select the correct communication port.
5. Create a new sketch.
6. Copy the servo control program into the sketch.
7. Verify/compile the program.
8. Upload the program to the Arduino.
9. Observe the servo motor.

Expected Result

After the program is uploaded, the servo should repeatedly:

0° → 180° → 0°

The movement occurs gradually because the program changes the requested position in small one-degree steps and introduces a short delay between the commands.

Controlling a Servo Motor with Arduino

Arduino provides a Servo library that makes controlling a standard servo relatively simple.

Instead of manually generating the control waveform, the program can use functions provided by the library to:

1. Create a servo object.
2. Assign an Arduino pin to the servo.
3. Specify the desired angle.

The main functions used in this basic application are:

#include <Servo.h>

Servo myServo;

myServo.attach(9);

myServo.write(90);

In this example, Arduino uses digital pin 9 as the servo control pin and commands the servo to move to approximately 90°.

Controlling the Servo Movement Speed

The speed of the movement can be influenced by how frequently the target position is updated.

A simple approach is to change the delay:

delay(10);

For example:

delay(20);

will make the position updates occur less frequently.

However, using delay() blocks the execution of other code while the program waits. For projects where the Arduino must perform other tasks simultaneously, a non-blocking approach using millis() can be used.

Smooth Movement Using millis()

The millis() function allows the Arduino to measure elapsed time without stopping the entire program.

The general approach is:

1. Record the starting time.
2. Calculate how much time has passed.
3. Convert the elapsed time into a corresponding servo angle.
4. Update the servo position.
5. Continue executing other parts of the program.

The map() function can be used to convert elapsed time into an angle.

Example

#include <Servo.h>

Servo myServo;

unsigned long MOVING_TIME = 3000;
unsigned long moveStartTime;

int startAngle = 30;
int stopAngle = 90;

void setup()
{
  myServo.attach(9);

  moveStartTime = millis();
}

void loop()
{
  unsigned long progress = millis() - moveStartTime;

  if (progress <= MOVING_TIME)
  {
    long angle = map(
      progress,
      0,
      MOVING_TIME,
      startAngle,
      stopAngle
    );

    myServo.write(angle);
  }

  // Other code can run here
}

In this example, the servo moves from 30° to 90° over approximately 3 seconds, while the Arduino remains available to execute other tasks.

Useful Arduino Servo Functions

The Servo library provides several useful functions for controlling and monitoring servo motors.

Using Multiple Servo Motors

The Arduino Servo library can be used to control multiple servo motors.

For example:

Servo servo1;
Servo servo2;

Each servo can then be attached to its own control pin.

When using several servos, however, the power supply becomes especially important because the total current demand can increase significantly.

For larger numbers of servos, a dedicated servo driver such as a PCA9685 16-channel PWM servo driver can simplify wiring and reduce the number of Arduino pins required.

Common Problems and Important Precautions

Servo Does Not Move

Check the following:

• Verify the servo signal wire is connected to the correct Arduino pin.
• Check the VCC and GND connections.
• Confirm that the servo receives the correct supply voltage.
• Make sure the Arduino code uses the same pin connected to the signal wire.
• Check that the Servo library is included.

Arduino Resets When the Servo Moves

• This can occur when the servo draws more current than the Arduino’s power source can provide.
• A suitable external power supply for the servo may solve the problem.

Servo Behaves Erratically

Check that:

• The servo has a stable power supply.
• Arduino GND and the external power-supply GND are connected together.
• The wiring is secure.
• The servo is not mechanically overloaded.

Arduino – DC Motor Connections, Control and Programming

Introduction of DC Motor

A DC motor converts electrical energy into continuous rotational motion. Arduino can control a DC motor’s speed and direction, but a motor should not be connected directly to an Arduino output pin because the motor requires more current than the Arduino pin can safely provide.

A motor driver is therefore used between the Arduino and the motor. The driver receives low-power control signals from the Arduino and provides the required current to operate the motor.

Pin Configuration of DC Motor

A basic DC motor has two wires:

• The direction of rotation depends on the polarity applied to these two wires.
• Reversing the polarity reverses the motor’s direction.

Common Applications of DC Motor

• Robotics and robotic vehicles.
• Electric toys and model vehicles.
• Cooling fans and blowers.
• Pumps and water systems.
• Conveyor systems.
• Automatic doors and gates.
• Small power tools.
• Printers and scanners.
• Camera mechanisms.
• Automotive systems.
• Automated machines and actuators.
• DIY and Arduino projects.

Important Power Considerations

The Arduino output pin provides only a control signal. It should not be used to power the DC motor directly.

Use a suitable motor driver and an appropriate external power supply.

Before connecting the motor, check:

• Motor rated voltage.
• Motor operating current.
• Motor stall current.
• Motor driver voltage and current ratings.
• Power-supply capacity.

A motor can draw significantly more current during startup or when stalled, so the power supply and driver must be selected accordingly.

How to Control a DC Motor?

Two main parameters can be controlled:

Speed

Motor speed can be controlled using PWM (Pulse Width Modulation). A higher PWM duty cycle generally provides higher average power to the motor and therefore higher speed.

Direction

The motor direction is controlled by reversing the polarity applied to the motor. An H-bridge motor driver performs this electronically.

The basic control system is:

Arduino → Motor Driver → DC Motor

L298N Motor Driver

The L298N is a commonly used motor driver that can control up to two DC motors independently.

For each motor, the important pins are:

The L298N receives control signals from the Arduino while supplying the required motor current from the motor power source.

Connecting Arduino to the L298N

For Motor A, the following connections can be used:

Connect the DC motor to OUT1 and OUT2.

Connect a suitable external power supply to the motor-power input of the L298N.

Important: The motor power supply must be suitable for the motor’s rated voltage and current. The Arduino and L298N should share a common ground.

Controlling DC Motor Direction

The direction of Motor A is determined by IN1 and IN2.

If the actual direction is opposite to the expected direction, swap the motor wires connected to OUT1 and OUT2 or reverse the IN1/IN2 logic in the program.

Controlling DC Motor Speed

Connect the L298N ENA pin to an Arduino PWM-capable pin.

The Arduino analogWrite() function can then control the PWM duty cycle:

analogWrite(ENA_PIN, speed);

On a typical Arduino UNO, the value ranges from 0 to 255:

The actual motor speed is affected by the motor type, load, supply voltage, and other factors, so PWM value does not represent an exact RPM.

Example of Arduino – DC Motor Connection.

Arduino Code

The following example gradually increases the motor speed, changes direction, gradually decreases the speed, and then stops the motor.

const int ENA_PIN = 9;
const int IN1_PIN = 6;
const int IN2_PIN = 5;

void setup()
{
  pinMode(ENA_PIN, OUTPUT);
  pinMode(IN1_PIN, OUTPUT);
  pinMode(IN2_PIN, OUTPUT);
}

void loop()
{
  // Rotate in Direction 1
  digitalWrite(IN1_PIN, HIGH);
  digitalWrite(IN2_PIN, LOW);

  for (int speed = 0; speed <= 255; speed++)
  {
    analogWrite(ENA_PIN, speed);
    delay(10);
  }

  delay(1000);

  // Change direction
  digitalWrite(IN1_PIN, LOW);
  digitalWrite(IN2_PIN, HIGH);

  delay(1000);

  // Gradually stop
  for (int speed = 255; speed >= 0; speed--)
  {
    analogWrite(ENA_PIN, speed);
    delay(10);
  }

  delay(1000);
}

How the Program Works

The program uses three Arduino pins:

• Pin 9 controls motor speed through PWM.
• Pin 6 controls one direction input.
• Pin 5 controls the other direction input.

First, IN1 is HIGH and IN2 is LOW, causing the motor to rotate in one direction.

The for loop gradually increases the PWM value from 0 to 255, smoothly increasing the motor’s drive.

The direction is then reversed by changing IN1 and IN2.

Finally, the PWM value is gradually reduced from 255 to 0, stopping the motor.

Common Problems and Important Precautions

Motor Does Not Rotate

Check the motor power supply, L298N wiring, Arduino connections, ENA connection, and common ground.

Motor Rotates in the Wrong Direction

Swap the motor wires on OUT1 and OUT2 or reverse the IN1/IN2 logic.

Motor Speed Cannot Be Controlled

Make sure ENA is connected to a PWM-capable Arduino pin and that the ENA jumper configuration is appropriate for PWM control.

Arduino Resets When the Motor Starts

The motor may be drawing excessive current or causing electrical noise. Use a suitable external motor supply and ensure the Arduino and driver have a proper common ground.

Arduino – Stepper Motor Connections, Control and Programming

Introduction of Stepper Motor

A stepper motor is a brushless motor that rotates in precise, discrete steps. It is commonly used when controlled and repeatable movement is required.

Stepper motors are widely used in 3D printers, CNC machines, robotics, plotters, and positioning systems.

What Is a Stepper Motor?

A stepper motor is a unique type of brushless DC motor which position can be precisely controlled even without any feedback.

The working principle of a stepper motor is based on magnetic fields. It has two main components, a stator and a rotor. The rotor is usually a permanent magnet and it’s surrounded by some coils on the stator.

Stepper Motor main components – stator and a rotor

How a Stepper Motor Works?

The working principle of a stepper motor is based on magnetic fields. It has two main components, a stator and a rotor. The rotor is usually a permanent magnet and it’s surrounded by some coils on the stator.

Stepper Motor main components – stator and a rotor
When we energize or let current flow through the coils, particular magnetic fields are generated in the stator that either attract or repel the rotor. By activating the coils, step by step, one after another in a particular order, we can achieve continues motion of rotor, but also, we can make it stop at any position.

Stepper-Motor-Working-Principle
So, that’s why these motors are called stepper motors, they move in discrete steps.

By increasing the number of magnetic poles on the rotor, we can increase the number of possible stopping positions, thus increase the resolution or the precision of the motor. Please note that this is just a basic explanation and you can find more details in my How Stepper Motors Work tutorial.

Why a Stepper Motor Driver Is Required?

Arduino should not directly drive the coils of a stepper motor. A stepper motor driver is used to control the motor current and energize the coils correctly.

The basic system is:

Arduino → Stepper Driver → Stepper Motor

A driver can provide features such as:

• Direction control.
• Step control.
• Current limiting.
• Microstepping.

Common Applications of Stepper Motor

Stepper motors are commonly used in:

• 3D printers.
• CNC machines.
• Robotics.
• Laser engravers.
• Plotters.
• Camera sliders.
• Automated machines.
• Precision positioning systems.

Examples of Stepper Motor Drivers

A4988 Stepper Motor Driver

The A4988 is a popular driver for controlling NEMA 17 stepper motors with Arduino.

The two most important control inputs are:

Pin	Function
STEP	Moves the motor one step for each pulse.
DIR	Selects the rotation direction.

The motor receives its power through the driver’s motor-power input rather than directly from the Arduino.

Connecting Arduino to the A4988 Driver

A simple connection can be made as follows:

Arduino	A4988
5V	VDD
GND	GND
Digital Pin 2	STEP
Digital Pin 3	DIR

Connect the two motor coils to:

1A, 1B, 2A, and 2B.

Use a suitable external power supply for the motor through VMOT and GND.

Important: Identify the two motor coils correctly and ensure that the Arduino and driver have a common ground.

Motor Power and Current Limit

The motor power supply must match the requirements of both the motor and driver.

The A4988’s current limit must be adjusted correctly according to the motor’s rated current. Setting it too high can cause overheating, while setting it too low can reduce the motor’s available torque.

A suitable capacitor should also be placed close to the driver’s motor power connections to help reduce voltage fluctuations.

Microstepping

The A4988 supports microstepping, which divides each full step into smaller commanded steps.

For a 200-step motor:

Mode	Steps per Revolution
Full step	200
1/2 step	400
1/4 step	800
1/8 step	1600
1/16 step	3200

Microstepping can provide smoother and quieter movement, although higher commanded resolution does not necessarily mean the same level of absolute positioning accuracy.

Controlling the Motor with Arduino

Arduino controls the A4988 using STEP and DIR signals.

• DIR determines the rotation direction.
• STEP determines how many steps the motor moves.
• The time between STEP pulses determines the stepping speed.

A simple example:

const int stepPin = 2;

const int dirPin = 3;

void setup()

{

pinMode(stepPin, OUTPUT);

pinMode(dirPin, OUTPUT);

}

void loop()

{

digitalWrite(dirPin, HIGH);

for (int i = 0; i < 200; i++)

{

digitalWrite(stepPin, HIGH);

delayMicroseconds(500);

digitalWrite(stepPin, LOW);

delayMicroseconds(500);

}

delay(1000);

digitalWrite(dirPin, LOW);

for (int i = 0; i < 200; i++)

{

digitalWrite(stepPin, HIGH);

delayMicroseconds(500);

digitalWrite(stepPin, LOW);

delayMicroseconds(500);

}

delay(1000);

}

For a typical 200-step motor in full-step mode, 200 pulses correspond to approximately one revolution.

Controlling Speed and Direction

Direction

The motor direction is changed by changing the state of the DIR pin.

digitalWrite(dirPin, HIGH);

or:

digitalWrite(dirPin, LOW);

Speed

The motor speed depends on the frequency of the STEP pulses.

Shorter pulse intervals → Higher speed.

Longer pulse intervals → Lower speed.

A stepper motor should not usually be started instantly at very high speed because excessive acceleration can cause missed steps.

Using the AccelStepper Library

For more advanced projects, the AccelStepper library can simplify stepper motor control.

It supports features such as:

• Speed control.
• Acceleration.
• Deceleration.
• Position control.
• Multiple stepper motors.

It is especially useful for robotics, CNC, and automated positioning systems.

Common Problems and Important Precautions

Motor Does Not Rotate

Check the motor coil connections, power supply, STEP and DIR connections, common ground, and driver settings.

Motor Vibrates but Does Not Rotate

The motor coils may be connected incorrectly. Verify the two coil pairs.

Motor Overheats

Check the A4988 current-limit setting and make sure it is appropriate for the motor.

Motor Misses Steps

Reduce the speed or acceleration and check the motor power supply, current setting, and mechanical load.

Which Motor Should You Choose?

The best motor depends on what you need the project to do.

Choose a servo when:

You need to move something to a particular angle and do not need continuous rotation.

Choose a stepper when:

You need controlled incremental rotation and repeatable positioning.

Choose a DC motor when:

You need continuous rotation, such as driving a wheel, fan, or pump.

Conclusion

Connecting a motor to an Arduino is not simply a matter of connecting two wires to a digital pin. The Arduino provides the control signals, while an appropriate driver or control circuit handles the electrical power required by the motor.

The three common approaches are:

Servo Motor : Arduino → Control Signal → Servo Motor
Stepper Motor : Arduino → Stepper Driver → Stepper Motor
DC Motor : Arduino → Motor Driver → DC Motor

Once the correct driver, power supply, and wiring are selected, Arduino can provide precise control over motor position, speed, and direction. This makes motors a powerful building block for robotics, automation, and many other Arduino projects.

Conclusion of Arduino – Servo Moves

A standard servo motor provides a simple way for an Arduino to control angular position. The motor typically has three connections: VCC, GND, and Signal.

The Arduino Servo library simplifies servo control by providing functions such as attach() and write(). Once the servo is connected and the library is included, the Arduino can command the servo to move to different positions.

For basic projects, a servo may be controlled directly from the Arduino’s control pin, but the servo’s power requirements must be considered carefully. High-torque or multiple-servo applications should normally use an appropriate external power supply, with the external supply’s ground connected to the Arduino GND.

The basic control sequence is:

Connect the servo → Include the Servo library → Attach the signal pin → Set the desired angle → Upload the program → Observe the servo movement.

Conclusion of Arduino – DC Motor

Arduino can control a DC motor’s speed and direction, but the motor should be controlled through a suitable motor driver rather than directly from an Arduino output pin.

The L298N provides a simple solution for controlling one or two DC motors. Its ENA input controls speed using PWM, while IN1 and IN2 control the motor’s direction.

The basic system is:

Arduino → L298N Motor Driver → DC Motor

with a suitable external power supply for the motor.

By combining PWM speed control with H-bridge direction control, Arduino can smoothly accelerate, decelerate, reverse, and stop a DC motor.

Conclusion of Arduino – Stepper Motor

A stepper motor provides precise, controlled movement by rotating in discrete steps. Arduino can control it through a dedicated stepper driver such as the A4988.

The basic control system is:

Arduino → STEP/DIR Signals → A4988 Driver → Stepper Motor

The STEP signal controls movement, while DIR controls direction. Microstepping provides smoother movement, and correct current-limit adjustment is essential for safe and reliable operation.

For more advanced applications, libraries such as AccelStepper can provide speed, acceleration, deceleration, and position control.

&nbsp

#include <Servo.h>

Servo servo;

void setup()
{
  servo.attach(9);
  servo.write(0);
}

void loop()
{
  // Move from 0° to 180°
  for (int pos = 0; pos <= 180; pos++)
  {
    servo.write(pos);
    delay(10);
  }

  // Move from 180° back to 0°
  for (int pos = 180; pos >= 0; pos--)
  {
    servo.write(pos);
    delay(10);
  }
}

#include <Servo.h>

Servo servo;

Servo servo1;
Servo servo2;

servo.attach(9);

servo.write(0);

for (int pos = 0; pos <= 180; pos++)
{
  servo.write(pos);
  delay(10);
}

for (int pos = 180; pos >= 0; pos--)
{
  servo.write(pos);
  delay(10);
}

#include <Servo.h>

Servo myServo;

myServo.attach(9);

myServo.write(90);

delay(10);

delay(20);

#include <Servo.h>

Servo myServo;

unsigned long MOVING_TIME = 3000;
unsigned long moveStartTime;

int startAngle = 30;
int stopAngle = 90;

void setup()
{
  myServo.attach(9);
  moveStartTime = millis();
}

void loop()
{
  unsigned long progress = millis() - moveStartTime;

  if (progress <= MOVING_TIME)
  {
    long angle = map(
      progress,
      0,
      MOVING_TIME,
      startAngle,
      stopAngle
    );

    myServo.write(angle);
  }

  // Other code can run here
}

Servo servo1;
Servo servo2;

analogWrite(ENA_PIN, speed);

const int ENA_PIN = 9;
const int IN1_PIN = 6;
const int IN2_PIN = 5;

void setup()
{
  pinMode(ENA_PIN, OUTPUT);
  pinMode(IN1_PIN, OUTPUT);
  pinMode(IN2_PIN, OUTPUT);
}

void loop()
{
  // Rotate in Direction 1
  digitalWrite(IN1_PIN, HIGH);
  digitalWrite(IN2_PIN, LOW);

  for (int speed = 0; speed <= 255; speed++)
  {
    analogWrite(ENA_PIN, speed);
    delay(10);
  }

  delay(1000);

  // Change direction
  digitalWrite(IN1_PIN, LOW);
  digitalWrite(IN2_PIN, HIGH);

  delay(1000);

  // Gradually stop
  for (int speed = 255; speed >= 0; speed--)
  {
    analogWrite(ENA_PIN, speed);
    delay(10);
  }

  delay(1000);
}

const int stepPin = 2;
const int dirPin = 3;

void setup()
{
  pinMode(stepPin, OUTPUT);
  pinMode(dirPin, OUTPUT);
}

void loop()
{
  digitalWrite(dirPin, HIGH);

  for (int i = 0; i < 200; i++)
  {
    digitalWrite(stepPin, HIGH);
    delayMicroseconds(500);
    digitalWrite(stepPin, LOW);
    delayMicroseconds(500);
  }

  delay(1000);

  digitalWrite(dirPin, LOW);

  for (int i = 0; i < 200; i++)
  {
    digitalWrite(stepPin, HIGH);
    delayMicroseconds(500);
    digitalWrite(stepPin, LOW);
    delayMicroseconds(500);
  }

  delay(1000);
}

digitalWrite(dirPin, HIGH);

digitalWrite(dirPin, LOW);