Driving Stepper Motors with Quadratic Equations

Copyright 2002 Todd Fleming

Introduction

This paper describes a technique for controlling stepper motors using quadratic equations that are evaluated in real time without using multipliers. Digital stepper motor controllers can use this technique to generate smooth acceleration. It is an application of Dr. Jack Bresenham's work, which I unfortunately don't have a reference for.

1. Rational Derivation

Let's declare a function, , which describes our motor's target position at any time t. We would like a function that gives us a constant acceleration over its entire range. From Calculus, we know that quadratics fill this need, thus we have , where a, b, and c are constants.

Let's figure out how to compute a, b, and c. To simplify derivation, let's set our reference point such that 0; thus c0. Let's set the slope of x at time 0 to , where is an integer and is a positive integer. Let's also set the slope at some integer time n0 to , where is an integer and is a positive integer. We know that the slope, , of is , thus . Given , it follows that . The motor's acceleration will be .

Now that we have a formula, we need to consider how we can use it for controlling steppers. Stepper positions are discrete; the shaft of an ideal stepper can be positioned on a finite number of evenly spaced spots. In addition, clocked digital logic can only change the stepper's position at discrete points in time. Let's scale our function so that integer values of t map to discrete time steps and integer values of x map to discrete stepper positions. We need to design logic that causes the stepper's shaft to move to the integer position closest to x at every integer time t.

Let's restrict our stepper motor to move at most 1 position per time step. This fits well with most drivers since they accept a single-bit step input. Let's also restrict such that it is non-negative and non-decreasing over the interval 0n; the motor direction will be constant while it is following a given quadratic. We declare two functions, and , defined at integer values of t. is the final distance between x and the stepper position after the controller has decided whether to step the motor at time t or not. . is the distance between x and the stepper position immediately before the controller has decided whether to step the motor or not.

Since we want to minimize the distance between the stepper position and the quadratic after each time step, we place the following restrictions on : and . If then and are the same and we don't need to step the motor. Otherwise, and we need to step the motor.

Let's transform the condition to . If we apply previous results we get the following.

All of these divisions in the above equation run counter to our goal of using integer arithmetic. We can eliminate them by multiplying both sides of the above inequality by . This leads us to declare a new function, , with the definition . We can then apply previous results to get the following.

We can simplify this last equation if we define three constants, , , and :

This leads us to

Let's define yet another function, , such that . We now have our final equation for g: .

Let us turn our attention back to d. We have the following equation repeated from above:

If we multiply both sides by our magical expression , we get:

If we look at , we'll notice that . This leads to our final equation for f.

2.1. Rational Summary

The initial and final speeds are given by and respectively, where and are non-negative integers and and are positive integers. n, a positive integer, is the amount of time the move will take.

The constants , and are defined by , , and . n, , , and can be computed offline then passed to the controller.

The controller uses the following equations to control a stepper motor. The term 2t can be replaced by an accumulator.

The controller sends a step pulse at time if 0.

2. Fixed-Point Derivation

In this section, I plan to show how switching to a fixed-point representation can save hardware. (Hint: imagine what will happen to the equations if and they are a power of 2.) I'll also document the tradeoffs involved in selecting the number of bits used in the constants.

To be continued...