12 Stepper Motors: Drivers and Motion

12.1 Overview

This section: Overview — This first route builds counted motion from motor fundamentals through drivers, current, and acceleration.

This first route builds counted motion from motor fundamentals through drivers, current, and acceleration.

This is part 1 of 2. Continue with Stepper Motors: Precision and Reliability for the second focused route.

12.2 Start With the Story

This section: Start With the Story — Picture a label feeder that must move one sheet, stop at the print line, and return home after a jam.

Prove the Motion, Not Just the Pulse Count

Picture a label feeder that must move one sheet, stop at the print line, and return home after a jam. An actuator is a part that turns an electrical command into physical action. Here the action is counted rotation, but a count sent by the controller is not proof that the shaft or label moved.

Write the full motion promise. Name the travel, load, speed, power source, driver, home point, safe end stops, and owner. State whether a missed step only spoils a label or could hurt a person or machine.

Test a cold start, a warm driver, a sudden load, a fast change of speed, a blocked shaft, lost power, and a restart away from home. Measure the final position and current as well as the command count. Check that the machine finds home again and reports a miss instead of carrying an unknown position forward.

Keep immediate travel limits outside a remote service. The local machine must stop safely even when its dashboard or wider network is late.

This opening does not choose a motor size or promise that open-loop counting is always enough. Practitioner turns load and travel into a driver and motion plan. Under the Hood examines coil current, step shapes, resonance, heat, torque loss, and when feedback is needed.

Use a short motion check. Run one slow move, one fast move, one blocked move, and one restart away from home. Record the command, current, final place, heat, miss, and recovery. Repeat it after the load or speed changes.

Imagine a feeder that must move a gate exactly 12 millimetres, then return to the same home point every time. The actuator story is not “make the shaft spin”; it is “count motion, avoid missed steps, hold position, and recover if the load slips.”

Stepper motors fit that story when discrete movement and repeatability matter. The driver current, acceleration ramp, homing method, torque margin, and missed-step evidence are part of the actuator, not optional extras.

Math Bridge · guided foundationsWhy are equal microstep angles not equal current steps?Let Max connect the chapter's 1/16 table to sense voltage, sine steps, and coil lag. Learn the maths

12.3 Stepper Motor Fundamentals

This section: Stepper Motor Fundamentals — Stepper motors move in discrete steps, providing precise position control without feedback sensors (open-loop control).

Stepper motors move in discrete steps, providing precise position control without feedback sensors (open-loop control).

Characteristics:

• Precise angular positioning (typically 1.8 deg/step = 200 steps/rev)
• Open-loop control (no encoder needed)
• High holding torque at standstill
• Step-by-step movement (can be jerky at low speeds)
• Higher power consumption than servos

12.4 28BYJ-48 with ULN2003

This section: 28BYJ-48 with ULN2003 — Read across the forms as engineering evidence.

The photographs below make stepper motor (28byj-48 with uln2003 driver) a physical comparison: look for changes in package, exposed interfaces, mounting, scale, and service access before treating the forms as interchangeable.

Read across the forms as engineering evidence. They share a capability name, but packaging and installation change the electrical, mechanical, environmental, and maintenance constraints.

The 28BYJ-48 is a popular small stepper for hobby projects. Inspect Figure 12.1 to see the motor and driver as a matched current-path pair before using the library example.

+

In Figure 12.1, follow the coloured winding leads into the ULN2003 channels, then return to the geared output shaft. Sequencing the windings creates steps, while the gearbox trades speed for torque and changes the effective steps per output revolution used in the code.

Specifications:

• Full steps per output revolution: 2048 nominally (with a 64:1 gearbox)
• Operating voltage: 5V DC
• Current: 200-300mA
• Full-step angle: 11.25 deg/64 = 0.18 deg nominally; gearbox ratio may vary and needs calibration

#include <AccelStepper.h>

// 28BYJ-48 at nominal 64:1, HALF4WIRE = 4096 half-steps per output revolution
AccelStepper stepper(AccelStepper::HALF4WIRE, 19, 5, 18, 17);
const int STEPS_PER_REV = 4096;

void setup() {
  Serial.begin(115200);
  stepper.setMaxSpeed(1000);       // Steps per second
  stepper.setAcceleration(500);    // Steps per second^2
  Serial.println("Commands: 0-360 = angle, h = home, f = full rotation");
}

void loop() {
  if (Serial.available()) {
    String input = Serial.readStringUntil('\n');
    input.trim();

    if (input == "h") {
      stepper.moveTo(0);                                  // Home
    } else if (input == "f") {
      stepper.move(STEPS_PER_REV);                        // Full rotation
    } else {
      int angle = input.toInt();
      if (angle >= 0 && angle <= 360) {
        stepper.moveTo((long)angle * STEPS_PER_REV / 360);  // Go to angle
        Serial.printf("Moving to %d degrees\n", angle);
      }
    }
  }
  stepper.run();  // Must be called frequently — handles acceleration
}

12.5 NEMA 17 with A4988/DRV8825

This section: NEMA 17 with A4988/DRV8825 — For higher performance, NEMA 17 steppers with A4988 or DRV8825 drivers are a common choice.

For higher performance, NEMA 17 steppers with A4988 or DRV8825 drivers are a common choice. Inspect Figure 12.2 before copying a current setting, because the frame size identifies mechanical mounting rather than the winding’s electrical rating.

+

In the photo Figure 12.2, locate the square mounting face, shaft, and four-wire lead. Those features establish the mechanical interface and two-phase connection, but not a universal current limit; the actual winding current and driver cooling requirements must come from the motor and driver data.

Carry that distinction into the specifications: first confirm step angle and phase current from the actual motor, then set the A4988 or DRV8825 current limit, choose microstepping for the motion requirement, and test supply sag and driver temperature under the real acceleration profile. The frame label alone answers none of those electrical questions.

NEMA 17 Specifications:

• Steps per revolution: 200 (1.8 deg/step)
• Holding torque: around 40 N·cm (about 4 kgf·cm) for the example motor; check the chosen motor datasheet
• Phase current and winding voltage: use the chosen motor datasheet (for example, 1.7 A/phase at 2.8 V for Pololu #2267)
• Driver supply: may be 12–24 V with a compatible current-limited driver; set the phase-current limit to the motor rating

A4988 Driver Features:

• Microstepping: 1, 1/2, 1/4, 1/8, 1/16
• Current limit adjustment
• Sleep mode for power saving
• Step/direction interface

Microstepping Settings:

#include <AccelStepper.h>

#define STEP_PIN 25
#define DIR_PIN 26
#define ENABLE_PIN 27

// NEMA 17 with 1/16 microstepping = 3200 steps per revolution
AccelStepper stepper(AccelStepper::DRIVER, STEP_PIN, DIR_PIN);

const int STEPS_PER_REV = 3200;

void setup() {
  Serial.begin(115200);

  pinMode(ENABLE_PIN, OUTPUT);
  digitalWrite(ENABLE_PIN, LOW);  // Enable driver (active LOW)

  stepper.setMaxSpeed(3000);      // Steps per second
  stepper.setAcceleration(1000);  // Steps per second^2

  Serial.println("NEMA 17 Stepper Ready");
}

void loop() {
  if (Serial.available()) {
    char cmd = Serial.read();

    switch(cmd) {
      case 'f':  // Forward one revolution
        stepper.move(STEPS_PER_REV);
        break;
      case 'b':  // Backward one revolution
        stepper.move(-STEPS_PER_REV);
        break;
      case 'h':  // Home position
        stepper.moveTo(0);
        break;
      case 's':  // Stop
        stepper.stop();
        break;
      case 'd':  // Disable (power saving)
        digitalWrite(ENABLE_PIN, HIGH);
        break;
      case 'e':  // Enable
        digitalWrite(ENABLE_PIN, LOW);
        break;
    }
  }

  stepper.run();
}

12.6 Acceleration Profiles

This section: Acceleration Profiles — Treat acceleration as a torque-budget sequence rather than a cosmetic smoothing option.

Treat acceleration as a torque-budget sequence rather than a cosmetic smoothing option. Start from rest, where the driver must build phase current and overcome static friction. Increase step rate only while the motor’s available torque remains above load torque, reflected inertia, and friction. Hold the requested cruise rate inside the motor’s falling torque-speed envelope, then decelerate early enough that the load does not carry the rotor past commanded steps. A light bench shaft may tolerate an abrupt command that a lead screw, camera carriage, or valve cannot. Test the worst payload and supply voltage, record missed-step or homing evidence, and reduce acceleration before reducing position verification. This connects the profile directly to the chapter’s warning that commanded step count is not proof of achieved motion.

// Manual trapezoidal profile (if not using AccelStepper)
void moveWithAcceleration(int targetSteps, int maxSpeed, int acceleration) {
  int currentSpeed = 0;
  int position = 0;
  int direction = (targetSteps > 0) ? 1 : -1;
  targetSteps = abs(targetSteps);

  // Calculate distances for accel/decel phases
  int accelSteps = (maxSpeed * maxSpeed) / (2 * acceleration);
  int decelSteps = accelSteps;
  int constSteps = targetSteps - accelSteps - decelSteps;

  if (constSteps < 0) {
    // Can't reach max speed, use triangular profile
    accelSteps = targetSteps / 2;
    decelSteps = targetSteps - accelSteps;
    constSteps = 0;
    maxSpeed = sqrt(2 * acceleration * accelSteps);
  }

  // Acceleration phase
  for (int i = 1; i <= accelSteps; i++) {
    currentSpeed = sqrt(2 * acceleration * i);
    step(direction);
    delayMicroseconds(1000000 / currentSpeed);
  }

  // Constant speed phase
  for (int i = 0; i < constSteps; i++) {
    step(direction);
    delayMicroseconds(1000000 / maxSpeed);
  }

  // Deceleration phase
  for (int i = decelSteps; i > 0; i--) {
    currentSpeed = sqrt(2 * acceleration * i);
    step(direction);
    delayMicroseconds(1000000 / currentSpeed);
  }
}

12.7 Common Pitfalls

This section: Common Pitfalls

12.8 Continue to Part 2

This section: Continue to Part 2 — Continue with Stepper Motors: Precision and Reliability.

Continue with Stepper Motors: Precision and Reliability.