Driving a Bipolar Stepper Motor with Arduino and ULN2803AG

{adinserter Internal_left}While I’m getting ready to rip open some 10+ broken DVD-RW drives coming to me from an eBay seller, I though it would be great to have a testbed for the bipolar stepper motors I will harvest from those.

I have a bunch of ULN2803AG Eight Darlington Transistor Arrays with Common Emitters left from past projects and these can sink (but unfortunately not source) peak loads of 600mA (500mA continuous) and are well suited for power application like driving small motors. However, there is a problem with 4-wire bipolar stepper motors: they don’t have the common points of windings wired to the outside which would be needed for providing the motors with power. See the ULN2003 datasheet for more information about the IC: ULN2801,2802,2803,2804 and 2805 Darlington Array datasheet

Still, it looked to me that it would still be possible to make a small bipolar stepper work by floating the voltage using some 22 Ohm resistors to the motor supply voltage (motor you see on the video has 18 Ohm windings, so this was the closest resistor value).

At first I attempted to use for the motor voltage the same +5V supplied by Arduino but because of the floating middle point the max voltage across each winding was only 1.7V and that was not enough to move the rotor. When the motor supply voltage was increased to +9V (the 9V battery on the picture), things started working. There is still only 4V across each winding at any time it’s energized but it looks enough to make the linear slide move with some force which I hope will be enough for carrying the laser diode housing.

Here is the schematic of the whole setup and below is the Arduino sketch. Please note that the resistors needed to be at least 1/4W rated but I did not have the 22 Ohm needed for the project and used 1/8W ones. They did get noticeably hot, so it’s not the way to do it in real life.

Additionally, a better way to drive a 4-wire bipolar motor would be to use the quad half-H ICs like SN754410 (on which Arduino’s official bipolar instructions are based) but I thought many hobbyists would appreciate a possibility to make things run using a simpler hookup that ULN chips allow. Also, one $0.60 ULN2803AG chip can actually drive two motors, so it’s pretty much the cheapest way to drive your 4-way bipolar stepper. Please note that another common Darlington Array IC, ULN2003A (similarly priced) has 7 arrays instead of 8 and therefore can only be used to drive one stepper motor per IC.

Driving your 4-wire bipolar stepper via a ULN2803AG is not efficient because you’re wasting pretty much the same amount of energy on heating the resistors that float the median voltage point as you’re using for rotating the motor’s rotor but if efficiency is not your immediate concern, you can use this simple hookup with a little bit of programming that takes into consideration the different HIGH/LOW levels needed to drive the motor if hooked up this way.

In the code that follow below the main principal of driving the motor was changing the state of the ULN2803 outputs in this way:

Pins 1 and 2 represent the winding #1
Pins 3 and 4 represent the winding #2

When 1 is HIGH and 2 is LOW, the voltage across winding #1 is considered positive

When 1 is LOW and 2 is HIGH, the voltage across winding #1 is considered negative

When 1 is HIGH and 2 is HIGH, the voltage across winding #1 is considered zero or winding disabled. This is basically done to conserve motor supply power. It works in exact same way as more logical LOW-LOW but LOW-LOW will draw current through the respective resistors – simply wasteful.

The code below is driving the motor in Half Step Sequence

Here is a link to the zip file with the Arduino sketch for the Arduino IDE
BP_Stepper_ULN2803.pde

// Driving a bipolar stepper motor with Arduino and a ULN2803 
// Octal High Voltage High Current Darlington Transistor Array 
// This example code is in the public domain. Based on several 
// Arduino code samples
// http://elabz.com/

// constants won't change. They're used here to 
// set pin numbers:
const int buttonPin = 2;     // the number of the misc. pushbutton pin
const int buttonForwardPin = 6;     // the number of the misc. pushbutton pin
const int buttonBackwardPin = 7;     // the number of the misc. pushbutton pin
const int ledPin =  13;      // the number of the forward LED pin
const int ledForwardPin =  4;      // the number of the forward LED pin
const int ledBackwardPin =  5;      // the number of the backward LED pin
const int motorPin1 =8;
const int motorPin2 =9;
const int motorPin3 =10;
const int motorPin4 =11;
const int motorDelay=10;

// Variables will change:
int ledForwardState = LOW; // the current state of the forward LED output pin
int ledBackwardState = LOW; // the current state of the forward LED output pin
int buttonState;             // the current reading from the misc input pin
int buttonForwardState;             // the current reading from the forward input pin
int buttonBackwardState;             // the current reading from the backward input pin
int lastButtonState = LOW; 
int lastForwardButtonState = LOW;   // the previous reading from the input pin
int lastBackwardButtonState = LOW;   // the previous reading from the input pin

// the following variables are long's because the time, measured in miliseconds,
// will quickly become a bigger number than can be stored in an int.
long lastForwardDebounceTime = 0;  // the last time the output pin was toggled
long lastBackwardDebounceTime = 0;  // the last time the output pin was toggled
long lastDebounceTime = 0;  // the last time the output pin was toggled
long debounceDelay = 50;    // the debounce time; increase if the output flickers

void setup() {
  pinMode(buttonPin, INPUT);
  pinMode(buttonForwardPin, INPUT);
  pinMode(buttonBackwardPin, INPUT);
  pinMode(ledForwardPin, OUTPUT);
  pinMode(ledBackwardPin, OUTPUT);
  pinMode(motorPin1, OUTPUT);
  pinMode(motorPin2, OUTPUT);
  pinMode(motorPin3, OUTPUT);
  pinMode(motorPin4, OUTPUT);

}

void loop() {
  // read the state of the switch into a local variable:
  int reading = digitalRead(buttonPin);

  // check to see if you just pressed the button 
  // (i.e. the input went from LOW to HIGH),  and you've waited 
  // long enough since the last press to ignore any noise:  

  // If the switch changed, due to noise or pressing:
  if (reading != lastButtonState) {
    // reset the debouncing timer
    lastDebounceTime = millis();
  } 
  
  if ((millis() - lastDebounceTime) > debounceDelay) {
    // whatever the reading is at, it's been there for longer
    // than the debounce delay, so take it as the actual current state:
    buttonState = reading;
  }
  
  // set the LED using the state of the button:
  digitalWrite(ledPin, buttonState);

  // save the reading.  Next time through the loop,
  // it'll be the lastButtonState:
  lastButtonState = reading;
  
  
    int readingForward = digitalRead(buttonForwardPin);
    int readingBackward = digitalRead(buttonBackwardPin);
  // check to see if you just pressed the button 
  // (i.e. the input went from LOW to HIGH),  and you've waited 
  // long enough since the last press to ignore any noise:  

  // If the switch changed, due to noise or pressing:
  if (readingBackward != lastBackwardButtonState) {
    // reset the debouncing timer
    lastBackwardDebounceTime = millis();
  }   
  
  if (readingForward != lastForwardButtonState) {
    // reset the debouncing timer
    lastForwardDebounceTime = millis();
  } 
  
  if ((millis() - lastForwardDebounceTime) > debounceDelay) {
    // whatever the reading is at, it's been there for longer
    // than the debounce delay, so take it as the actual current state:
    buttonForwardState = readingForward;
    lastForwardButtonState = readingForward;
    forward();
}else if ((millis() - lastBackwardDebounceTime) > debounceDelay) {
    // whatever the reading is at, it's been there for longer
    // than the debounce delay, so take it as the actual current state:
    buttonBackwardState = readingBackward;
    lastBackwardButtonState = readingBackward;
    backward();
  }else{
   
   stopping(); 
   lastBackwardButtonState = LOW;
   lastForwardButtonState = LOW;
  }
  
  // set the LED using the state of the button:
  digitalWrite(ledPin, buttonState);

  // save the reading.  Next time through the loop,
  // it'll be the lastButtonState:

  
  
}

void forward()
{
   digitalWrite(ledForwardPin, HIGH);
  
// HALF STEP  
  
  digitalWrite(motorPin1, HIGH);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin3, HIGH);
  digitalWrite(motorPin4, LOW);
  delay(motorDelay);

  digitalWrite(motorPin1, HIGH);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin3, HIGH);
  digitalWrite(motorPin4, HIGH);
  delay(motorDelay);  
  
  digitalWrite(motorPin1, HIGH);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin4, HIGH);
  delay(motorDelay);  
  
  digitalWrite(motorPin1, HIGH);
  digitalWrite(motorPin2, HIGH);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin4, HIGH);
  delay(motorDelay); 
  
  digitalWrite(motorPin1, LOW);
  digitalWrite(motorPin2, HIGH);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin4, HIGH);
  delay(motorDelay); 

  digitalWrite(motorPin1, LOW);
  digitalWrite(motorPin2, HIGH);
  digitalWrite(motorPin3, HIGH);
  digitalWrite(motorPin4, HIGH);
  delay(motorDelay); 

  digitalWrite(motorPin1, LOW);
  digitalWrite(motorPin2, HIGH);
  digitalWrite(motorPin3, HIGH);
  digitalWrite(motorPin4, LOW);
  delay(motorDelay); 
  
  digitalWrite(motorPin1, HIGH);
  digitalWrite(motorPin2, HIGH);
  digitalWrite(motorPin3, HIGH);
  digitalWrite(motorPin4, LOW);
  delay(motorDelay); 

}
void backward()
{
  
 digitalWrite(ledBackwardPin, HIGH);
 
  digitalWrite(motorPin1, HIGH);
  digitalWrite(motorPin2, HIGH);
  digitalWrite(motorPin3, HIGH);
  digitalWrite(motorPin4, LOW);
  delay(motorDelay); 

  digitalWrite(motorPin1, LOW);
  digitalWrite(motorPin2, HIGH);
  digitalWrite(motorPin3, HIGH);
  digitalWrite(motorPin4, LOW);
  delay(motorDelay);  
  
  digitalWrite(motorPin1, LOW);
  digitalWrite(motorPin2, HIGH);
  digitalWrite(motorPin3, HIGH);
  digitalWrite(motorPin4, HIGH);
  delay(motorDelay);  
  
  digitalWrite(motorPin1, LOW);
  digitalWrite(motorPin2, HIGH);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin4, HIGH);
  delay(motorDelay); 
  
  digitalWrite(motorPin1, HIGH);
  digitalWrite(motorPin2, HIGH);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin4, HIGH);
  delay(motorDelay); 

  digitalWrite(motorPin1, HIGH);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin4, HIGH);
  delay(motorDelay); 

  digitalWrite(motorPin1, HIGH);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin3, HIGH);
  digitalWrite(motorPin4, HIGH);
  delay(motorDelay); 
  
  digitalWrite(motorPin1, HIGH);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin3, HIGH);
  digitalWrite(motorPin4, LOW);
  delay(motorDelay); 
  
}

void stopping()
{
  digitalWrite(ledForwardPin, LOW);
  digitalWrite(ledBackwardPin, LOW);
  digitalWrite(motorPin1, HIGH);
  digitalWrite(motorPin2, HIGH);
  digitalWrite(motorPin3, HIGH);
  digitalWrite(motorPin4, HIGH);
}

67 Responses to “Driving a Bipolar Stepper Motor with Arduino and ULN2803AG”