# Intro to Stepper Motors

### What is it?

A stepper motor rotates in small precise increments named steps or phases. They theoretically move at a constant pace and as the speed increases the torque decreases. They are the most powerful when holding their position. Unlike servo motors that can determine their position by an angular value, stepper motor’s position can only be determined by tracking the steps from an initial point. They are very precise and reliable motors, capable of continuous rotation

There are two kinds of stepper motors, bipolar and unipolar. The bipolar motor usually has 4 wires and can be identified by using measuring the resistance between the wires. They are called bipolar because they have two coils, each with a pair of wires connecting. Each pair should have a matching resistance. Bipolar motors are harder to use and less popular for hobbyists. Unipolar motors have a simpler control scheme, so I will focus on those. They usually have between 5-8 wires, 5 of which go to the integrated controller circuit. Identifying the wires can be tricky, since there are no standard color conventions, but doing so properly is important.

First, you need to determine the common lead, the wire that connects all the others and will connect to the positive of the power supply.
If you have…
5 wires: Measure the resistance between each pair of wires- one of them will consistently read as having half the resistance compared to the values given by other pairs. This wire is the common.
6 wires: Measure the resistance between each pair of wires to isolate the two that read consistently lowest. These two wires will need to be joined to form the common.
8 wires: Measure the resistance between each pair until you have separated them into 4 pairs with infinite resistance between them. Once these sets are made, join one wire from each pair together to form the lead.

The 4 other wires’ position will be determined relative to the common lead. It is very important to keep their position the same throughout. To make this simpler, I recommend soldering the wires to headers as soon as you are sure of their correct order. The unipolar motor has four coils, so what we are doing now is determining which wire leads to which coil. Follow these steps to identify the wire
1- Connect the common lead to the positive end of your power supply.
2- Connect any of the other leads to ground and identify it as coil
3- One at a time, connect the other wires to ground as well and watch the motor shaft.
If it stays still then it is coil 2.
If it twitches clockwise it is coil 3.
If it twitches counter-clowise it is coil 1.

Once this order is determined, the easiest way to control a stepper motor is through a darlington array. This is an example using a darlington array and a unipolar stepper motor and a number pad You can see how to wire the number pad on the right.
You can send the stepper motor instructions on the number of steps to take with the number Pad. First, you press either A or B, A is for a positive number and B is for a negative number and influences the directionality of the steps. the code accepts a number between 0 and 999. You can press C to Clear the current number and D to send the number off to the motor. Use the serial monitor to see what you punched in. If you continue to press D, you continue to increment by the last submitted value.
Here’s the code:

```//For this example we're going to need both the stepper and keypad libraries
#include
#include
//The key pad in this example is 4x4
const byte rows = 4;
const byte cols = 4;

//1 or -1, starts as 0 to set the motor backwards or forwards
int polarity;

boolean isCounting = false;

//ensures that we have 3 digit number
int numSteps[] = {
0,0,0};
//keeps track of where to place the number
int currentIndex;
//keeps track of the current number of steps
int keyNum;
//set the keys according to the number pad
char keys[rows][cols] = {
{
'1','2','3', 'A' }
,
{
'4','5','6', 'B' }
,
{
'7','8','9', 'C' }
,
{
'#','0','*', 'D' }
};
//connect to the row pinouts of the keypad
byte rowPins[rows] = {
7,6,5,4};
//connect to the column pinouts of the keypad
byte colPins[cols] = {
12,10,9,8};
// Number of steps for a rotation (on average 100), control pin 1, control pin 2
Stepper myStepper(100, 11, 3);

void setup(){
//begin the Serial communication so we can see the feedback
Serial.begin(9600);
//speed at which the motor will step, doesn't actually make it move
myStepper.setSpeed(60);
//current index starts at 0
currentIndex =0;
//default keynumber is 0
keyNum =0;

//beginning println is more complex with instructions
Serial.println("////INSTRUCTIONS");
Serial.println("PRESS A or B to start punching in numbers");
Serial.println("PRESS A for positive numbers (Clockwise)");
Serial.println("PRESS B for negative numbers (Counter-Clockwise)");
Serial.println("PRESS C to CLEAR the number and start over");
Serial.println("PRESS D to SEND the steps to the motor and make it move.");
Serial.println("You can keep pressing D to keep sending the same number");
Serial.println("current number of steps");
Serial.println(keyNum);
}

void loop(){

//get the current key being pressed

//if a key is getting pressed
if (key != NO_KEY){
//switch depending on which key is being pressed
switch (key)
{
//A is for Positive numbers
case 'A':
polarity = 1;
isCounting = true;
resetArray();
break;
//B is for negative numbers
case 'B':
polarity = -1;
isCounting = true;
resetArray();
break;
//clear the number and start over
case 'C':
resetArray();
isCounting = false;
break;
//commit the steps to the motor
case 'D':
commitSteps();
resetArray();
isCounting = false;
break;

//send the value of the key to be added to keynum
case '0':
sortKey (0);
break;
case '1':
sortKey (1);
break;
case '2':
sortKey (2);
break;
case '3':
sortKey (3);
break;
case '4':
sortKey (4);
break;
case '5':
sortKey (5);
break;
case '6':
sortKey (6);
break;
case '7':
sortKey (7);
break;
case '8':
sortKey (8);
break;
case '9':
sortKey (9);
break;

}
//println the updated number
Serial.println("current number of steps");
Serial.println(keyNum);
}
}

//sort where to put the key input
void sortKey (int curKey)
{
//if we are listening for new inputs
if (isCounting)
{
//set the current inputed number to the current spot in the array
numSteps[currentIndex]=curKey;
//shift the index
currentIndex ++;
//reset it to 0 if at the end
if (currentIndex >2)
{
currentIndex = 0;
}
//set key num to be indexindexindex, using 10 to establish the position. Multiply it by polarity to establish positive or ne
ative
keyNum = polarity*(numSteps*100+numSteps*10+numSteps);
}
}
//reset the array and keynum
void resetArray ()
{
numSteps=0;
numSteps=0;
numSteps=0;
keyNum = polarity*(numSteps*100+numSteps*10+numSteps);

}
//send the steps to the motor
void commitSteps()
{
//debugging println
//Serial.println("STEPPING");
myStepper.step(keyNum);
}

Unless otherwise stated, this code is released under the MIT License – Please use, change and share it.

```