28BYJ-48: How To Use This Stepper Motor With Arduino

What is a Stepper Motor?

A stepper motor is a type of DC motor that moves in precise increments, or steps, allowing for accurate position control. Unlike continuous rotation motors, stepper motors can be controlled to rotate a specific number of degrees, making them ideal for applications requiring precise positioning, such as 3D printers, CNC machines, and robotics.

Advantages of Stepper Motors

1. Precise position control
2. High torque at low speeds
3. Excellent repeatability
4. No feedback sensor required for positioning
5. Low cost compared to servo motors

The 28BYJ-48 Stepper Motor

The 28BYJ-48 is a Unipolar Stepper motor with four phases, each requiring a separate control wire. It typically comes with a ULN2003 driver board, which simplifies the wiring and control of the motor.

28BYJ-48 Specifications

Wiring the 28BYJ-48 to Arduino

To control the 28BYJ-48 stepper motor with Arduino, you’ll need to connect the ULN2003 driver board to the Arduino’s digital pins. The driver board has six pins: four for the motor phases and two for power.

Connection Table

Programming the 28BYJ-48 with Arduino

To control the 28BYJ-48 stepper motor with Arduino, you can use the Arduino Stepper library or create your own functions using the digitalWrite() function.

Using the Arduino Stepper Library

1. Include the Stepper library in your Arduino sketch:

#include <Stepper.h>

1. Define the number of steps per revolution and the stepper object:

const int stepsPerRevolution = 2048;  // Change this to match your motor
Stepper myStepper(stepsPerRevolution, 8, 10, 9, 11);

1. Set the motor speed in the setup() function:

void setup() {
  myStepper.setSpeed(10);  // 10 rpm
}

1. Control the motor in the loop() function:

void loop() {
  myStepper.step(stepsPerRevolution);  // Rotate one revolution clockwise
  delay(500);
  myStepper.step(-stepsPerRevolution);  // Rotate one revolution counterclockwise
  delay(500);
}

Creating Custom Functions

1. Define the pin numbers connected to the ULN2003 board:

const int IN1 = 8;
const int IN2 = 9;
const int IN3 = 10;
const int IN4 = 11;

1. Create an array of step sequences:

const int stepsPerRevolution = 2048;
int stepSequence[8][4] = {
  {1, 0, 0, 0},
  {1, 1, 0, 0},
  {0, 1, 0, 0},
  {0, 1, 1, 0},
  {0, 0, 1, 0},
  {0, 0, 1, 1},
  {0, 0, 0, 1},
  {1, 0, 0, 1}
};

1. Initialize the pins as outputs in the setup() function:

void setup() {
  pinMode(IN1, OUTPUT);
  pinMode(IN2, OUTPUT);
  pinMode(IN3, OUTPUT);
  pinMode(IN4, OUTPUT);
}

1. Create functions to rotate the motor clockwise and counterclockwise:

void clockwise(int steps) {
  for (int i = 0; i < steps; i++) {
    for (int j = 0; j < 8; j++) {
      digitalWrite(IN1, stepSequence[j][0]);
      digitalWrite(IN2, stepSequence[j][1]);
      digitalWrite(IN3, stepSequence[j][2]);
      digitalWrite(IN4, stepSequence[j][3]);
      delay(2);
    }
  }
}

void counterclockwise(int steps) {
  for (int i = 0; i < steps; i++) {
    for (int j = 7; j >= 0; j--) {
      digitalWrite(IN1, stepSequence[j][0]);
      digitalWrite(IN2, stepSequence[j][1]);
      digitalWrite(IN3, stepSequence[j][2]);
      digitalWrite(IN4, stepSequence[j][3]);
      delay(2);
    }
  }
}

1. Call the functions in the loop() to control the motor:

void loop() {
  clockwise(stepsPerRevolution);  // Rotate one revolution clockwise
  delay(500);
  counterclockwise(stepsPerRevolution);  // Rotate one revolution counterclockwise
  delay(500);
}

Practical Examples

Controlling the 28BYJ-48 with a Potentiometer

1. Connect a potentiometer to analog pin A0.
2. Read the potentiometer value and map it to the number of steps:

int potValue = analogRead(A0);
int steps = map(potValue, 0, 1023, -stepsPerRevolution, stepsPerRevolution);

1. Use the steps value to control the motor direction and speed:

if (steps > 0) {
  clockwise(steps);
} else if (steps < 0) {
  counterclockwise(abs(steps));
}

Creating a Simple Robot with the 28BYJ-48

1. Connect two 28BYJ-48 motors to the Arduino, one for each wheel.
2. Define the pin numbers and create stepper objects for both motors:

const int stepsPerRevolution = 2048;
Stepper leftStepper(stepsPerRevolution, 2, 4, 3, 5);
Stepper rightStepper(stepsPerRevolution, 8, 10, 9, 11);

1. Create functions to move the robot forward, backward, left, and right:

void moveForward(int steps) {
  leftStepper.step(steps);
  rightStepper.step(steps);
}

void moveBackward(int steps) {
  leftStepper.step(-steps);
  rightStepper.step(-steps);
}

void turnLeft(int steps) {
  leftStepper.step(-steps);
  rightStepper.step(steps);
}

void turnRight(int steps) {
  leftStepper.step(steps);
  rightStepper.step(-steps);
}

1. Use the functions to control the robot’s movement in the loop() function:

void loop() {
  moveForward(stepsPerRevolution);  // Move forward one rotation
  delay(500);
  turnLeft(stepsPerRevolution / 4);  // Turn left 90 degrees
  delay(500);
  moveBackward(stepsPerRevolution);  // Move backward one rotation
  delay(500);
  turnRight(stepsPerRevolution / 4);  // Turn right 90 degrees
  delay(500);
}

FAQ

1. Q: Can I use the 28BYJ-48 stepper motor without the ULN2003 driver board?
   A: While it is possible to control the 28BYJ-48 without the ULN2003 driver board, it is not recommended. The driver board simplifies the wiring and provides the necessary current amplification to drive the motor efficiently.

2. Q: How can I increase the torque of the 28BYJ-48 stepper motor?
   A: To increase the torque of the 28BYJ-48, you can try the following:

3. Increase the current supplied to the motor by using an external power source.
4. Use a gear reduction system to increase the torque at the cost of speed.

5. Use multiple 28BYJ-48 motors in parallel to combine their torque output.

6. Q: What is the maximum speed I can achieve with the 28BYJ-48 stepper motor?
   A: The maximum speed of the 28BYJ-48 depends on factors such as the supply voltage, driver board, and load. In general, the motor can achieve speeds up to 15 RPM (revolutions per minute) when driven at its rated voltage of 5V.

7. Q: Can I control multiple 28BYJ-48 stepper motors with a single Arduino board?
   A: Yes, you can control multiple 28BYJ-48 stepper motors with a single Arduino board. However, keep in mind that each motor requires four digital pins for control. Make sure your Arduino has enough digital pins to accommodate all the motors you wish to control.

8. Q: Are there any libraries available for controlling the 28BYJ-48 with Arduino?
   A: Yes, there are several libraries available for controlling the 28BYJ-48 with Arduino, such as:

9. AccelStepper: A powerful library that supports acceleration and deceleration control.
10. Arduino Stepper: The official Arduino library for controlling stepper motors.
11. Stepper28BYJ48: A library specifically designed for the 28BYJ-48 stepper motor.

Conclusion

The 28BYJ-48 stepper motor is a versatile and affordable choice for Arduino-based projects requiring precise position control. By following the wiring and programming examples provided in this article, you can easily integrate the 28BYJ-48 into your projects and create a wide range of applications, from simple position control to complex robotics. Remember to experiment, learn, and have fun while exploring the possibilities of the 28BYJ-48 stepper motor with Arduino!