Stepper Motor Control in raspberry pi

Steppers


Steppers, or stepping motors, are brushless DC motors. In the PyHack workshop we first started with brushed DC motors (2 wires), then using H bridges to make them rotate both ways, and used pulse width modulation (PWM) to vary their speed. We followed with servos and then we went into steppers.

Unfortunately, I've not posted on some of these aspects yet (I thought I had), but I'll definitely post the explanations (servo, PWM), diagrams and python code for these too.

Now, let's get back to our steppers. They do come in all kinds of shape and size:



Wired


For our discussion right now however, we'll focus on just one thing, the number of wires. Typically, you will have a stepper with 4, 5 or 6 wires:


5 wire unipolar, 4 wire bipolar

6 wire unipolar

As can be seen, 5 or 6 wires are fundamentally the same. They are what is called a Unipolar stepper. 4 wire steppers are Bipolar steppers. A different type of driver is needed depending if you have to drive one or the other.

5 wire unipolar stepper with a 6 position connector


Unipolar


We are focusing today on the unipolar kind. Last summer, I got a hold of a good quantity of some very small steppers (28BYJ-48). Their spec was 5V, 5 wire unipolars, originally designed to control louvers on air conditioning units.

The neat thing with them is they have a built-in gearhead with a 64:1 ratio, allowing for some torque and precision, and allowing for instant on full speed sequencing (no need to ramp up):



I had this as spec:

What is interesting to note is that we basically have 4 square waves driving the motor, with 2/3 offset.

If you don't have the specs like above (even with your google-fu being strong), you will need a multimeter to measure the resistance between the different wires to figure out which wire is the center tap and which wires are part of the same coil.

Let's say you measure 72 ohm between 2 wires, and 144 between 2 others, then you know that one of the wires that had 72 ohm is a center tap. The two giving 144 ohm (whatever the value, we are looking for ratios of 2:1) are the extremities of a coil.

Driver


With the above motor, we will need 4 GPIOs. The 28BYJ-48 is often sold with a small board that includes a ULN2003 darlington array (I got those with some subsequent buys of the steppers):






It is convenient because it even includes the headers. All you need are 6 jumper wires. 4 for the GPIOs, one for ground and one for 5V, and you are in business. That is sufficient to start playing with Python code, and you might be able to skip the next section.

If however you are like me, your odyssey is just beginning.

The ULN2003 were bread and butter circuits in the days of 7 segment led displays (remember those calculators with red led segment displays or even vacuum displays)? They had 7 Darlington pairs in the array. However, 7 is an inconvenient number. Our steppers need 4 channels (4 Darlington pairs). So we need 2 ULN2003 if we are going to drive 2 motors.

A better choice is the ULN 2803. The specs can be found here (Texas Instrument). Similar design to the ULN2003, it has 8 channels (8 Darlington pairs), hence a perfect match for 2 motors!

Prototyping


The ULN2803 has several built in features that will make our life oh so simple:



  • inputs all on one side
  • outputs all on the other
  • each output is protected by a free wheeling diode
  • each channel is an inverting amplifier
On the last point, that means that I can drive my GPIOs HIGH / 3V3 to mean high, and will complete the circuit of a coil between the output of the channel and the common positive supply (5V on pin 10, from the Raspberry Pi or an external supply with a common ground)


Interfacing With The Pi



The motor connects to the controller board with a pre-supplied connector. The controller board has  4+2 pins that need to be connected to the Pi header (P1).
  • 5V (P1-02)
  • GND (P1-06)
  • Inp1 (P1-18)
  • Inp2 (P1-22)
  • Inp3 (P1-24)
  • Inp4 (P1-26)
The P1-XX references above represent the Pi header pins I used. These are defined in the Python example below in the StepPins list so if you use different pins be sure to update the Python list as well. You can use other GPIO pins if required just remember to update your Python script.
To rotate the stepper motor you provide a sequence of “high” and “low” levels to each of the 4 inputs in sequence. By setting the correct sequence of high and low levels the motor spindle will rotate. The direction can be reversed by reversing the sequence

Program :- 

#!/usr/bin/python
# Import required libraries
import time
import RPi.GPIO as GPIO

# Use BCM GPIO references
# instead of physical pin numbers
GPIO.setmode(GPIO.BCM)

# Define GPIO signals to use
# Physical pins 11,15,16,18
# GPIO17,GPIO22,GPIO23,GPIO24
StepPins = [17,22,23,24]

# Set all pins as output
for pin in StepPins:
  print "Setup pins"
  GPIO.setup(pin,GPIO.OUT)
  GPIO.output(pin, False)

# Define advanced sequence
# as shown in manufacturers datasheet
Seq = [[1,0,0,1],
       [1,0,0,0],
       [1,1,0,0],
       [0,1,0,0],
       [0,1,1,0],
       [0,0,1,0],
       [0,0,1,1],
       [0,0,0,1]]
       
StepCount = len(Seq)
StepDir = 1 # Set to 1 or 2 for clockwise
            # Set to -1 or -2 for anti-clockwise

# Read wait time from command line
if len(sys.argv)>1:
  WaitTime = int(sys.argv[1])/float(1000)
else:
  WaitTime = 10/float(1000)

# Initialise variables
StepCounter = 0

# Start main loop
while True:

  print StepCounter,
  print Seq[StepCounter]

  for pin in range(0,4):
    xpin=StepPins[pin]# Get GPIO
    if Seq[StepCounter][pin]!=0:
      print " Enable GPIO %i" %(xpin)
      GPIO.output(xpin, True)
    else:
      GPIO.output(xpin, False)

  StepCounter += StepDir

  # If we reach the end of the sequence
  # start again
  if (StepCounter>=StepCount):
    StepCounter = 0
  if (StepCounter<0):
    StepCounter = StepCount+StepDir

  # Wait before moving on
  time.sleep(WaitTime)

Comments

Post a Comment

Popular posts from this blog

Turning on an LED with your Raspberry Pi's GPIO Pins

Image
One of the biggest selling points of the Raspberry Pi is its GPIO, or General Purpose Input/Output ports.  They are the little pins sticking out of the circuit board and allow you to plug various devices into your Pi.  With a little programming, you can then control them or detect what they are doing. In this tutorial I am going to show you how to light an LED.  In addition to your Raspberry Pi running Raspbian, what you will need is: A Breadboard An LED A 330 ohm resistor Two Male-Female jumper wires You can get all these, and more, in the £5 CamJam EduKit from The Pi Hut, which teaches you more about LEDs, buzzers and switches, and includes all the hardware and eight well-written worksheets about using the GPIO pins on your Pi. The Breadboard The breadboard is a way of connecting electronic components to each other without having to solder them together. They are often used to test a circuit design before creating a Printed Circu...
Read more

Simple SMPS

Image
circuit and working Fig shows the circuit of a simple 12V, 1A SMPS. The circuit is built around a low-power offline switcher TNY266 (IC1), photo-transistor photo-coupler EL817 (IC2), a flyback transformer (X1) and some other easily-available components. Low-power offline switcher (TNY266). The SMPS here has been designed using a TNY266 chip, which is affectionately called the ‘555’ of SMPS. This device has a 700V power MOSFET, an oscillator, a high-voltage switched current source, a current limiting and thermal shutdown circuitry integrated onto a monolithic device. The start-up and operating power is derived directly from the voltage on the drain (pin 5), eliminating the need for a bias winding and associated circuitry. In addition, the device incorporates auto-restart, line under-voltage sense, and frequency jittering. The drain-source breakdown voltage of the MOSFET in TNY266 is important. During the ‘off’ period, the MOSFET sees rectified 317V DC approximately. Addit...
Read more

Efficient LED Blinking for Embedded Systems

Image
 Efficient LED Blinking for Embedded Systems:- Smart hardware design can simplify the embedded software and make it more reliable. Designers use blinking LED signals to indicate different status and for inbuilt testability. Making an LED array blink requires an individual software loop for each LED or an individual timer and specific software to serve it. This can be an issue in a system that uses low-level MCUs which provide limited resources. The circuit presented here solves this problem by adding a simple hardware comprising low-cost inverters with Schmitt trigger for blinking as many LEDs as required. Circuit and working Fig shows the circuit for efficient LED blinking for embedded systems. It uses different arrangements to make five different LEDs (LED1 through LED5) blink at individual rates. The circuit is built around 74HC14 (IC1) containing six inverters with Schmitt triggers at the inputs. The frequency of blinking is usually selected in the 0.2-20...
Read more