Q3Microprocessor

A stepper motor rotates in discrete angular steps, with each step corresponding to energizing a specific combination of its stator winding coils in a defined sequence; the direction of rotation is reversed by simply reversing the order in which this excitation sequence is applied, and the rotational speed is controlled by varying the time delay between successive steps (a shorter delay produces faster rotation, up to the motor's maximum stepping rate, beyond which it may lose synchronization/'stall').

Interfacing Circuit

Since the 8051's I/O port pins can source/sink only a small amount of current (a few milliamps), while a stepper motor's winding coils require substantially more current (typically several hundred milliamps or more) to energize, a driver IC — most commonly the ULN2003 (containing 7 Darlington transistor pairs) — is used between the 8051's output port and the stepper motor's coil terminals. Four bits of an 8051 output port (commonly P1.0-P1.3) are connected to the four input pins of the ULN2003 driver, whose four corresponding output pins (open-collector Darlington transistor outputs, each capable of sinking substantial current) drive the four winding terminals of the stepper motor (assuming a common unipolar stepper motor with a center-tapped winding connected to the positive supply rail), with the ULN2003 also providing built-in flyback/freewheeling diodes to protect against the inductive voltage spikes generated when each winding is de-energized.

Assembly Language Program (4-step excitation sequence)

For a common single-coil-at-a-time 4-step excitation sequence, the 4-bit patterns applied to P1.0-P1.3 in order are typically 0001, 0010, 0100, 1000 (hexadecimal: 01H, 02H, 04H, 08H) for clockwise rotation, and the same four patterns in reverse order (08H, 04H, 02H, 01H) for counter-clockwise rotation; a delay subroutine (implemented using a nested register/timer-based loop, as discussed for other delay-generation questions) is called between each step to set the desired rotational speed.

        MOV DPTR, #STEPTAB   ; DPTR points to step-pattern table
        MOV R2, #04           ; 4 steps in the sequence
        MOV R1, #00           ; table index
CW_LOOP:
        MOV A, R1
        MOVC A, @A+DPTR       ; fetch step pattern from table
        MOV P1, A             ; output pattern to driver
        ACALL DELAY           ; delay between steps (sets speed)
        INC R1                ; forward direction: increment index
        DJNZ R2, CW_LOOP      ; repeat for all steps, then loop
        SJMP CW_LOOP
STEPTAB: DB 01H, 02H, 04H, 08H  ; clockwise sequence
; For counter-clockwise direction, replace INC R1 with DEC R1
; and initialize R1 to point to the last table entry (03H),
; or simply store the reverse-order table (08H,04H,02H,01H).

In this program, changing the direction of rotation is achieved simply by reversing the order in which the step-pattern table is traversed (incrementing vs decrementing the table index, or using a separately stored reverse-order table), while the rotational speed is controlled entirely by the duration of the DELAY subroutine called between successive steps — a shorter delay drives the motor faster (up to its maximum reliable stepping rate), while a longer delay drives it more slowly, giving straightforward independent software control over both the direction and speed of stepper motor rotation using the 8051.

Tracing the Program Logic

Walking through the code: MOV DPTR, #STEPTAB loads the Data Pointer with the base address of the STEPTAB lookup table stored in code memory, since the 8051 can only read lookup-table data out of program memory using the indexed MOVC instruction, which requires DPTR (or PC) as the base register. MOV R2, #04 initializes a loop counter to 4, matching the four entries in the excitation table, while MOV R1, #00 initializes the table index to the first entry. Inside CW_LOOP, MOV A, R1 copies the current index into the accumulator (since MOVC requires the offset in A), and MOVC A, @A+DPTR then fetches the byte stored at address DPTR+A — that is, the step pattern corresponding to the current index — replacing the index value in A with the actual 4-bit excitation pattern to be output. MOV P1, A then drives this pattern onto Port 1, energizing exactly the winding(s) specified by that pattern's set bits, and ACALL DELAY suspends execution for a calibrated interval before the next step is issued, which is what ultimately sets the mechanical stepping rate (and hence rotational speed) of the motor. INC R1 advances the index for the next iteration, and DJNZ R2, CW_LOOP decrements the step counter R2 and loops back if it has not yet reached zero, ensuring the loop body executes exactly four times per full cycle through the table before the program falls through to the (here illustrative) SJMP CW_LOOP that restarts the whole sequence indefinitely.

Practical hardware considerations: the specific 4-step sequence shown (01H, 02H, 04H, 08H) energizes only one winding at a time, giving lower torque but lower power consumption than the alternative 2-phase-on (half the maximum torque improvement) or half-step (8-step) excitation sequences commonly used to obtain finer angular resolution or higher holding torque; selecting among these sequence variants only requires substituting a different, longer or differently-valued STEPTAB and adjusting the loop counter and CJNE/DJNZ comparison value accordingly, with the rest of the driving logic (DPTR-based table lookup, port output, delay, index increment/decrement for direction) remaining unchanged. A further practical consideration is that abruptly changing direction while the motor is at high speed can cause the rotor to lose synchronization with the stepping sequence (an effect sometimes called 'slipping' or stalling), so well-designed stepper motor control firmware typically decelerates the motor (by gradually lengthening the inter-step delay) before reversing direction, rather than reversing instantaneously at full speed.

Generalization: this same table-driven approach — a lookup table of output-port bit patterns, an index variable that increments or decrements to select direction, and a calibrated inter-step delay to select speed — generalizes directly to any stepper motor excitation scheme (full-step, half-step, or micro-stepping with a PWM-driven analog current profile instead of simple on/off bits), and is a standard, reusable pattern for any application requiring cyclic, sequenced digital output generation from a microcontroller, such as multiplexed 7-segment display scanning or simple waveform generation via a DAC.