Controlling Motors and Servos

Analogy categoryAnalogies

Why Motors Need Driver Circuits

An Arduino output pin can supply only about 20-40 milliamps, but even a small DC motor draws hundreds of milliamps and a stall current far higher. Connecting a motor directly to a pin will not spin it and can permanently damage the microcontroller. The solution is to let the pin control a switching device — a transistor or a dedicated motor-driver IC — while the motor draws its current from a separate power supply. Motors are also inductive loads that generate voltage spikes when switched off, so a flyback (freewheeling) diode across the motor protects your electronics.

🏏

Cricket analogy: A driver circuit is like a captain signaling a fast bowler rather than bowling himself; the Arduino gives the command while the transistor supplies the real power, just as the captain directs the pace attack.

Never connect a DC motor, stepper, or high-current servo directly to an Arduino pin or to the 5V pin for anything beyond a tiny load. Use a transistor or motor driver with a separate power supply, tie the grounds together, and always add a flyback diode across an inductive load to absorb switch-off voltage spikes.

Controlling Servos with the Servo Library

A hobby servo contains a motor, gearbox, and control circuit, and it moves to a commanded angle rather than spinning freely. You control it with a 50Hz PWM signal whose pulse width (typically 1000-2000 microseconds) encodes the target position. The Servo library hides this timing: you call myServo.attach(pin), then myServo.write(angle) with an angle from 0 to 180 degrees. Small servos can be powered from the Arduino's 5V for testing, but several servos or larger ones need an external 5-6V supply with common ground, because their current draw exceeds what the board can safely provide.

🏏

Cricket analogy: A servo moving to an exact angle is like a batsman placing the ball precisely to a fielding gap rather than slogging; write(90) commands a specific position, just as a placed drive targets a specific spot.

cpp

#include <Servo.h>

Servo myServo;

void setup() {
  myServo.attach(9);   // servo signal wire on pin 9
}

void loop() {
  // Sweep from 0 to 180 degrees and back
  for (int angle = 0; angle <= 180; angle++) {
    myServo.write(angle);
    delay(15);         // give the servo time to reach the position
  }
  for (int angle = 180; angle >= 0; angle--) {
    myServo.write(angle);
    delay(15);
  }
}

The Servo library on an Uno can control up to 12 servos but disables analogWrite() (PWM) on pins 9 and 10 while in use, because it repurposes Timer1 to generate the servo pulses. Plan your pin assignments accordingly if you also need PWM.

DC Motors and H-Bridges

A single transistor can switch a DC motor on and off and set its speed with PWM, but it cannot reverse direction. To spin a motor both ways you need an H-bridge, such as the L293D or an L298N module, which routes current through the motor in either polarity using four switching elements. You typically drive two direction pins to choose forward, reverse, or brake, and feed a PWM signal to an enable pin to control speed. Motor driver modules also isolate the motor's higher-current supply from the Arduino's logic supply while sharing a common ground.

🏏

Cricket analogy: An H-bridge reversing a motor is like a batsman able to work the ball to either side of the wicket; the four switches route current either way, just as good footwork lets a player hit leg or off side.

Stepper Motors

A stepper motor rotates in fixed increments — a common motor moves 1.8 degrees per step, giving 200 steps per revolution — which makes it ideal for precise positioning in 3D printers and CNC machines. Steppers require a specific sequence of coil energizations, so you use a driver like the ULN2003 (for the 28BYJ-48) or an A4988, plus the Stepper or AccelStepper library. You command a number of steps and the library energizes the coils in the correct order. Because there is no feedback, a stepper can lose steps if overloaded, but for most tasks it delivers repeatable, open-loop precision.

🏏

Cricket analogy: A stepper's fixed increments are like a batsman taking measured singles to rotate the strike precisely; each step is a defined unit, just as each single advances the score by exactly one in a controlled way.

Arduino pins supply only ~20-40mA, far too little to drive motors directly.
Use a transistor or motor-driver IC with a separate supply and shared ground.
Add a flyback diode across inductive loads to absorb switch-off voltage spikes.
Servos move to a commanded angle (0-180) via the Servo library's write() method.
The Servo library uses a timer and disables PWM on pins 9 and 10 on the Uno.
An H-bridge (L293D/L298N) lets a DC motor run forward and reverse; PWM on enable sets speed.
Stepper motors give precise open-loop positioning (e.g. 200 steps/rev) using a driver and library.