Parts List

Whether you are using a Raspberry Pi or Arduino (or both), you are going to need the following parts to carry out this experiment:

If you are planning to try this experiment with a Raspberry Pi, you will need female-to-male jumper wires to connect the Raspberry Pi GPIO pins to the breadboard.

Design

Figure 10-5 shows the schematic diagram for this experiment. 

In this case, we are not going to use PWM and so the two Enable pins of the L293D are connected to 5V to leave both H-bridges permanently enabled. The stepper motor is controlled by the four connections In 1, In 2, In 3, and In 4 that will be driven by digital outputs on the Arduino or Raspberry Pi.

Figure 10-5. Schematic diagram for controlling a bipolar stepper motor

Arduino

The Arduino version of this experiment will use the Serial Monitor to send commands to the Arduino that will then control the motor. The three commands are represented by a single letter followed by a number. For example:

• f100 moves the motor forward by 100 steps

• r100 moves the motor 100 steps in the reverse direction

• p10 sets the period of the delay between step pulses to be 10 milliseconds

Figure 10-6 shows the Arduino version of the experiment.

Arduino Connections

The Arduino version of this experiment uses the following pins connected to the L293D:

Figure 10-7 shows the breadboard layout for Arduino.

Figure 10-6. Arduino stepper motor control

Make sure that the IC is positioned correctly (the notch should be at the top), and that C2 the 100µF capacitor has its positive lead connected to pin 8 of the L293D. The positive lead of an electrolytic capacitor like C2 is normally longer than the negative lead. The negative lead of C2 may also be marked on the body of the capacitor with a minus sign or diamond symbol.

Figure 10-7. Arduino breadboard layout for a bipolar stepper motor

Arduino Software (the Hard Way)

There are two versions of the Arduino software for this experiment. The first does things the hard way, by setting the control pins for the L293D in the sequence described in “Bipolar Stepper Motors”. This is a useful exercise for understanding exactly how the stepper motor works.

The second example sketch uses the Arduino Stepper library to do all the work and is therefore a lot shorter.

The first Arduino sketch can be found in arduino/experiments/bi_stepper_no_lib:

const int in1Pin = 10;    
const int in2Pin = 9;
const int in3Pin = 11;
const int in4Pin = 8;

int period = 20;       

void setup() {         
  pinMode(in1Pin, OUTPUT);
  pinMode(in2Pin, OUTPUT);
  pinMode(in3Pin, OUTPUT);
  pinMode(in4Pin, OUTPUT);
  Serial.begin(9600);
  Serial.println("Command letter followed by number");
  Serial.println("p20 - set the inter-step period to 20ms (control speed)");
  Serial.println("f100 - forward 100 steps");
  Serial.println("r100 - reverse 100 steps");
}

void loop() {       
  if (Serial.available()) {
    char command = Serial.read();
    int param = Serial.parseInt();
    if (command == 'p') {         
      period = param;
    }
    else if (command == 'f') {    
      stepForward(param, period);
    }
    else if (command == 'r') {
      stepReverse(param, period);
    }   
  } 
  setCoils(0, 0, 0, 0); // power down
}

void stepForward(int steps, int period) {      
  for (int i = 0; i < steps; i++) {
    singleStepForward(period);
  }
}

void singleStepForward(int period) {        
  setCoils(1, 0, 0, 1);
  delay(period);
  setCoils(1, 0, 1, 0);
  delay(period);
  setCoils(0, 1, 1, 0);
  delay(period);
  setCoils(0, 1, 0, 1);
  delay(period);
}

void stepReverse(int steps, int period) {
  for (int i = 0; i < steps; i++) {200
    singleStepReverse(period);
  }
}

void singleStepReverse(int period) {        
  setCoils(0, 1, 0, 1);
  delay(period);
  setCoils(0, 1, 1, 0);
  delay(period);
  setCoils(1, 0, 1, 0);
  delay(period);
  setCoils(1, 0, 0, 1);
  delay(period);
}

void setCoils(int in1, int in2, int in3, int in4) {    // 
  digitalWrite(in1Pin, in1);
  digitalWrite(in2Pin, in2);
  digitalWrite(in3Pin, in3);
  digitalWrite(in4Pin, in4);
}

The code starts by defining the pins that will be used to control the motor. You can, of course, change these pins as long as you also modify your breadboard to match.

The variable period is the delay between each coil activation in a step of the motors’ rotation. This is initially set to 20 milliseconds. You can change this value over the Serial Monitor to speed up or slow down the motor.

The setup() function sets the control pins to be digital outputs, starts serial communication with the Serial Monitor, and then prints out a message explaining the format of the commands that you can send.

The loop() function waits for commands to arrive over serial and then processes them. If a command has been received (indicated by Serial.available), then loop() first reads the command letter into the variable command and then reads the number parameter that follows it.

Next, a series of if statements take the appropriate action depending on the command.

If the command is 'p' then the period variable is set to the number supplied as a parameter.

If, however, the command is 'f' or 'r'then stepForward or stepReverse is called as appropriate accompanied by the number of steps to take and the period between each polarity change in the step as parameters.

stepForward and stepReverse are very similar and repeatedly call singleStepForward or singleStepReverse for the number of times specified in steps.

Next, we come to the function singleStepForward that holds the pattern of polarities needed for the four phases to advance the motor by one step. You can see the pattern in the parameters to setCoils. 

singleStepReverse is the same as singleStepForward but reverses the sequence. Compare the steps with Table 10-2.

Finally, the setCoils function sets the control pins according to the pattern supplied as its parameters.

Arduino Software (the Easy Way)

The Arduino IDE includes the Stepper library, which works just fine and will reduce the size of the sketch considerably. You can find this sketch in the arduino/experiments/ex_07_bi_stepper_lib/ directory (you’ll find this in the place where you downloaded the book’s code—see “Downloading the Software”): 

#include <Stepper.h>    

const int in1Pin = 10;
const int in2Pin = 9;
const int in3Pin = 8;
const int in4Pin = 11;

Stepper motor(200, in1Pin, in2Pin, in3Pin, in4Pin);     // 

void setup() {       
  pinMode(in1Pin, OUTPUT);
  pinMode(in2Pin, OUTPUT);
  pinMode(in3Pin, OUTPUT);
  pinMode(in4Pin, OUTPUT);
  while (!Serial);
  Serial.begin(9600);
  Serial.println("Command letter followed by number");
  Serial.println("p20 - set the motor speed to 20");
  Serial.println("f100 - forward 100 steps");
  Serial.println("r100 - reverse 100 steps");
  motor.setSpeed(20);        
}

void loop() {         
    if (Serial.available()) {
    char command = Serial.read();
    int param = Serial.parseInt();
    if (command == 'p') {
      motor.setSpeed(param);
    }
    else if (command == 'f') {
      motor.step(param);
    }
    else if (command == 'r') {
      motor.step(-param);
    }   
  } 
}

The first line of the sketch imports the Stepper library, which is included as part of the Arduino IDE and does not need to be specially installed. 

To use the library, a variable motor is defined of type Stepper. The parameters supplied to motor set up the motor so that it can be used. The first parameter is the number of steps the motor takes per revolution. The Adafruit stepper motor that I used is specified as 200 steps, which is a common number of steps. Actually this really means 200 phase changes per revolution, which is 50 actual shaft positions per revolution. The other four parameters are the coil pins to use.

The setup() function is almost the same as the long version of the sketch. The message is slightly different, because in this case, the 'p' command will set the motor’s speed in rpm (revolutions per minute) rather than the raw delay time. However, both have the effect of changing the motor’s speed.

The default speed is also set to 20rpm in setup() using motor.setSpeed.

The loop() function is also very similar to the long version of the sketch; however, in this case, the number of steps and direction for the motor are specified as a positive number for forward and a negative number for reverse.

The number of quarter-steps specified in the 'f' or 'r' parameter is in this case the number of phase changes, so for one complete revolution of the Adafruit motor you will need to enter a value of 200. 

Arduino Experimentation

Try out both versions of the stepper code by all means, but here I will assume that you have ex_05_bi_stepper_lib uploaded to your Arduino. Open the Serial Monitor and you should be greeted with the message shown in Figure 10-8.

Figure 10-8. Controlling the stepper motor in the Serial Monitor

Enter the command f200 and click Send. The motor should turn through one complete revolution. If it doesn’t turn, but rather jitters or hums, it probably means that you positioned one of the coil leads incorrectly. So, swap over the stepper leads that go to pins 3 and 6 of the L293D and try the command again.

Try r200 and the motor should turn through one revolution in the opposite direction.

Next, try experimenting with the speed using the command p followed by the speed in rpm. For example,  p5 followed by f200. Again the motor will turn one revolution, but very slowly. You can increase the speed by specifying a higher value, say p100, but you will find that there is a maximum speed somewhere around 130rpm before some steps get lost and the motor does not make one complete revolution.

Raspberry Pi

Controlling a stepper motor using Python or a Raspberry Pi is very similar to the non-library Arduino approach. Controlling the L293D will require four control outputs from the Raspberry Pi.

The Python program will prompt you to enter the inter-phase delay, direction, and number of steps to take.

Raspberry Pi Connections

You can keep the breadboard layout as the Arduino, but the header pins for connecting to the Raspberry Pi need to be female-to-male rather than male-to-male. Figure 10-9 shows the breadboard layout to connect to a Raspberry Pi.

Figure 10-9. Raspberry Pi breadboard layout for a stepper motor

Raspberry Pi Software

The Raspberry Pi version of the stepping code is almost a word-for-word translation of the non-library Arduino code. This program is called bi_stepper.py and is located in the python/experiments directory (you’ll find this in the place where you downloaded the book’s code):

import RPi.GPIO as GPIO
import time

GPIO.setmode(GPIO.BCM)

in_1_pin = 23      
in_2_pin = 24
in_3_pin = 25
in_4_pin = 18

GPIO.setup(in_1_pin, GPIO.OUT)
GPIO.setup(in_2_pin, GPIO.OUT)
GPIO.setup(in_3_pin, GPIO.OUT)
GPIO.setup(in_4_pin, GPIO.OUT)

period = 0.02

def step_forward(steps, period):     
  for i in range(0, steps):
    set_coils(1, 0, 0, 1)
    time.sleep(period)
    set_coils(1, 0, 1, 0)
    time.sleep(period)
    set_coils(0, 1, 1, 0)
    time.sleep(period)
    set_coils(0, 1, 0, 1)
    time.sleep(period)

def step_reverse(steps, period):   
  for i in range(0, steps):
    set_coils(0, 1, 0, 1)
    time.sleep(period)
    set_coils(0, 1, 1, 0)
    time.sleep(period)
    set_coils(1, 0, 1, 0)
    time.sleep(period)
    set_coils(1, 0, 0, 1)
    time.sleep(period)

  
def set_coils(in1, in2, in3, in4):      
  GPIO.output(in_1_pin, in1)
  GPIO.output(in_2_pin, in2)
  GPIO.output(in_3_pin, in3)
  GPIO.output(in_4_pin, in4)
  

try:
    print('Command letter followed by number');
    print('p20 - set the inter-step period to 20ms (control speed)');
    print('f100 - forward 100 steps');
    print('r100 - reverse 100 steps');
    
    while True:       
        command = raw_input('Enter command: ')
        parameter_str = command[1:] # from char 1 to end
        parameter = int(parameter_str)      
        if command[0] == 'p':      
            period = parameter / 1000.0
        elif command[0] == 'f':
            step_forward(parameter, period)
        elif command[0] == 'r':
            step_reverse(parameter, period)

finally:
    print('Cleaning up')
    GPIO.cleanup()

The program defines constants for the four control pins and sets them to be outputs.

The step_forward and step_reverse functions are just like their equivalents in the Arduino. The four coil activations take place in the appropriate order using the set_coils function. This is repeated steps times with a delay of period between each change in coil activation.

set_coils sets the digital output control pins according to its four parameters.

The main loop of the program reads the command string using raw_input. The parameter that follows the letter is first cut off the command using the syntax [1:], which for a Python string means the string from position 1 (the second character) to the end of the string.

This string parameter is then converted into a number using the int built-in function.

A series of three if statements then carry out the appropriate action for the command, either changing the value of the period variable or sending the motor in one direction or the other.

Raspberry Pi Experimentation

Run the Python program using the command sudo python ex_07_bi_stepper.py. You will be prompted with the possible commands that you can enter. These are just the same as for the Arduino version.

Test out running the motor in both directions and find the smallest value of delay that you can achieve before the motor starts missing steps:

$ sudo python ex_05_bi_stepper.py 
Command letter followed by number
p20 - set the inter-step period to 20ms (control speed)
f100 - forward 100 steps
r100 - reverse 100 steps
Enter command: p5
Enter command: f50
Enter command: p10
Enter command: r100
Enter command: 

Hardware

Figure 10-13 shows the circuit of Figure 10-11 reimplemented using a ULN2003. Note that there are still four unused Darlington transistors that could be used to control a second stepper motor. For higher-current stepper motors, you can even double-up the outputs by connecting two inputs together with the corresponding two outputs.

The motor used here is 5V and also low current enough to draw its power from the Raspberry Pi or Arduino. It draws about 150mA with two coils activated. If you have a hungrier motor, or one that operates at a higher voltage, you will need to use a separate power supply, as you did with the bipolar stepper motor.

Finding which leads are connected to what inside the motor can be done in the same way as for bipolar motors (see “Identifying Stepper Motor Leads”) with the added complication that there is a common lead. So, start by identifying the common lead, which will give resistance to turning when connected to any of the other leads. Then use the same method as for a bipolar motor on the remaining leads.

Figure 10-13. Schematic for unipolar motor control (lead colors may vary)

Parts List

Whether you are using a Raspberry Pi or Arduino (or both), you are going to need the following parts to carry out this experiment:

If you are planning to try this experiment with a Raspberry Pi, you will need female-to-male jumper wires to connect the Raspberry Pi GPIO pins to the breadboard.

Arduino Connections

Figure 10-14 shows how an Arduino Uno can be connected up to a ULN2803.

Figure 10-14. Connecting an Arduino to a ULN2803

You need to make sure that the capacitor is positioned properly, with the longer positive lead to the right. The chip should be positioned with the notch toward the top of the board.

The layout is actually really neat compared with that of the bipolar layout. 

Raspberry Pi Connections

Figure 10-15 shows the Raspberry Pi layout and connections.

Figure 10-15. Connecting a Raspberry Pi to a ULN2803

Software

Apart from the fact that some of the pins are swapped over, the software for both Arduino and Raspberry Pi is exactly the same as for “Experiment: Controlling a Bipolar Stepper Motor”. The programs with the modified pin connections are:

• For the Arduino: uni_stepper_lib.ino 
• For the Raspberry Pi: uni_stepper.py 

Parts List

You need the following parts to carry out this experiment:

Most 12V stepper motors will work OK at 6V, but feel free to substitute the battery pack for a 12V power supply.

Raspberry Pi Connections

Figure 10-17 shows the breadboard layout and connections to the Raspberry Pi.

Figure 10-17. Breadboard layout and connections for microstepping with a Raspberry Pi

The EasyDriver board has the capacitors on board that you would normally need to add to your circuit. It also has a voltage regulator chip that provides the power supply to its A3967 IC, so you do not even need to supply the board with power from the Pi. All that is needed is a common ground and four control signals. 

Software

As its name correctly suggests, the EasyDriver stepper motor is extremely easy to control using software. The main process of telling the motor to step is accomplished by just two control pins. When the step pin receives a HIGH pulse, the motor takes one step in the direction set by the direction pin.

Two other pins, ms1 and ms2, control the degree of microstepping from none to 1/8th.

The code for the following program is in the microstepping.py file (which you’ll find in the place where you downloaded the book’s code): 

import RPi.GPIO as GPIO
import time

GPIO.setmode(GPIO.BCM)

step_pin = 24
dir_pin = 25
ms1_pin = 23
ms2_pin = 18

GPIO.setup(step_pin, GPIO.OUT)
GPIO.setup(dir_pin, GPIO.OUT)
GPIO.setup(ms1_pin, GPIO.OUT)
GPIO.setup(ms2_pin, GPIO.OUT)

period = 0.02

def step(steps, direction, period):   
  GPIO.output(dir_pin, direction)  
  for i in range(0, steps):
    GPIO.output(step_pin, True)
    time.sleep(0.000002)
    GPIO.output(step_pin, False)
    time.sleep(period)

def step_mode(mode):                  
    GPIO.output(ms1_pin, mode & 1)    
    GPIO.output(ms2_pin, mode & 2)

try:
    print('Command letter followed by number');
    print('p20 - set the inter-step period to 20ms (control speed)');
    print('m - set stepping mode (0-none 1-half, 2-quater, 3-eighth)');
    print('f100 - forward 100 steps');
    print('r100 - reverse 100 steps');
    
    while True:                        
        command = raw_input('Enter command: ')
        parameter_str = command[1:] # from char 1 to end
        parameter = int(parameter_str)
        if command[0] == 'p':
            period = parameter / 1000.0
        elif command[0] == 'm':
            step_mode(parameter)
        elif command[0] == 'f':
            step(parameter, True, period)
        elif command[0] == 'r':
            step(parameter, False, period)

finally:
    print('Cleaning up')
    GPIO.cleanup()

By now, you should be familiar with the GPIO pin setup and initialization code that starts most of the Python programs in this book. If not, refer back to some of the earlier chapters.

The function step contains the actual code for moving the motor on by a number of steps (or microsteps). It takes parameters of the number of steps to take, the direction (0 to 1), and the period of the delay to leave between each step. The body of the function first of all sets the direction pin (dir_pin) of the EasyDriver board and then generates the required number of pulses on the step_pin. The duration of each step_pin pulse is just 2 microseconds. The datasheet for the A3967 says that the pulse must be at least 1 microsecond.

The step_mode function sets the stepping mode pins according to the value of mode that should be between 0 and 3.

The code inside step_mode separates the two bits of the mode number and sets ms1_pin and ms2_pin using the logical and operator (&). Table 10-3 shows the relationship between the mode number, the microstepping pins, and the behavior of the motor.

Table 10-3. Microstepping control pins

Value of mode	ms1_pin	ms2_pin	Microstepping mode
0	LOW	LOW	None
1	HIGH	LOW	Half stepping
2	LOW	HIGH	Quarter stepping
3	HIGH	HIGH	One eighth stepping

The main loop() function is very similar to that of the Python program for “Experiment: Controlling a Bipolar Stepper Motor” except that an extra command of m is added to allow the microstepping mode to be set.

Experimenting

Run the program microstepping.py and then the program will prompt you to enter a command:

$ sudo python microstepping.py 
Command letter followed by number
p20 - set the inter-step period to 20ms (control speed)
m - set stepping mode (0-none 1-half, 2-quater, 3-eighth)
f100 - forward 100 steps
r100 - reverse 100 steps
Enter command: m0
Enter command: p8
Enter command: f800

Enter the commands m0, p8, and then f800. This should result in the motor rotating through four revolutions (for a 200-step motor). Make a mental note of the smoothness (or otherwise) of the rotation. Next, enter the following commands: m3, p1, f6400.

The motor should still rotate four times and at the same speed but noticeably smoother.

Note that to keep the same speed, the period between steps was reduced by a factor of 8 and the number of steps (or in this case, microsteps) increased by a factor of 8.