Simple Torque Control Method for Hybrid Stepper Motors Implemented in FPGA

Abstract

Stepper motors are employed in a wide range of consumer and industrial applications. Their use is simple: a digital device generates pulse-bursts and a direction bit towards a power driver that produces the 2-phase currents feeding the motor windings. Despite its simplicity, this open-loop approach fails if the torque load exceeds the motor capacity, so the motor and driver should be oversized at the expense of efficiency and cost. Field-Oriented closed-loop Control (FOC) solves the problem, and the recent availability of low cost electronics devices like Digital Signal Processors, Field Programmable Gate Arrays (FPGA), or even Microcontrollers with dedicated peripherals, fostered the investigation and implementation of several variants of the FOC method. In this paper, a simple and economic FOC torque control method for hybrid stepper motors is presented. The load angle is corrected accordingly to the actual shaft position through pulse-bursts and direction commands issued towards a commercial stepper driver, which manages the 2-phase winding currents. Thanks to the FPGA implementation, the control loop updates the electrical position every 50 μs only, thus allowing a load angle accuracy of −1/100 rad for a rotor velocity up to 750 rev/min, as shown in the reported experiments.

1. Introduction

The stepper motor [1] is widely used nowadays in a large range of applications such as 3D printers, industrial manufacturing tools, robotic arms, etc. Part of its success is certainly due to its capability of moving in a sequence of accurate and discreet locations (steps). A microcontroller connected to one of the several power drivers available on the market through a “step” clock and a “direction” command is often sufficient for the motor control [2]: For every “step” pulse, the driver modifies the 2-phase currents that feed the motor so that the shaft rotates by a “step” (typically 1.8°) or a fraction of it (μ-step) [3].

Unfortunately, the performance of the stepper motor heavily depends on the load condition. Therefore, if the load accidentally increases over the motor capacity, the control misses the actual shaft position and the application fails. To prevent this catastrophic event, stepper motors (and their drivers) are typically selected with a torque capacity that abundantly exceeds the nominal requirement. This results in oversized motors, and waste of power and heat [4]. Closed-loop motor control with the Field Oriented Control (FOC) method [5,6] solves this problem. The typical FOC implementation is based on Direct-Quadrature (DQ) coordinate transformations [6,7] that, in the past, required a considerable calculation effort and correspondingly complex hardware, which was not compatible with economic consumer applications. In recent years, however, the availability of microcontrollers with dedicated peripherals and/or economic Field Programmable Gate Arrays (FPGAs) has supported the development and implementation of new closed-loop approaches. In particular, FPGA represents a standard device for industrial applications [8,9], including motor control. For example, a Proportional-Integral-Derivative (PID) controller [10] with velocity feed-forward was proposed in [11]; in [12] a closed-loop control system based on motor parameter identification was presented; in [13] and [14], motor controllers based on Neural Networks are proposed.

In this paper a closed-loop torque control method for hybrid stepper motors is presented with its FPGA implementation. The method is based on a simple control loop that, thanks to the FPGA’s performance, executes every few 10 s of μs. Every loop iteration, the motor shaft position is monitored through an incremental encoder, and the stator magnetic field position is updated so that the relative phase between the positions of the stator and the rotor generates the desired load angle. While this quick loop maintains accurate control of the load angle, the magnitude of the phase currents is adjusted to obtain the programmed torque.

The output of the control loop consists of the number of μ-steps and the direction bit the rotor should move to maintain the desired load angle. These data perfectly fit with the “step/direction” interface present in several commercial power devices which are typically employed for open-loop μ-step motor control. In other words, this method does not need custom power electronics for the generation and control of the motor phase currents, which can be delivered by one of the monolithic devices already available in the market.

The proposed control is implemented in a FPGA from the MAX10 family (Intel/Altera, San Jose, CA, USA), connected to the PowerStep01 stepper driver (STMicroelectronics, Geneva, Switzerland). The paper presents the basics of the applied method in the next section; the employed electronics system and the FPGA implementation are described in Section 3; finally, several experiments are reported in Section 4.

2. Methods

2.1. Torque Generation and Step Movement

In a hybrid 2-phase stepper motor, the torque is generated by the interaction of the field produced by the rotor fixed magnet, and the field dynamically generated by the stator windings. The torque is composed by 3 components: the cogging, the reluctance, and the electrodynamic component [15,16]; however, in this work, the electrodynamic component, being predominant, is the only one considered. With reference to Figure 1, if $I_a$ and $I_b$ are the currents flowing in the 2 windings, the magnitude and angle of the resulting current is $I=\sqrt{I_a^2+I_b^2}$ and ${\theta }_I={\tan }^{-1}\left(\frac{I_b}{I_a}\right)$. The motor torque ${\Gamma }_E$ is generated by $I$ combined to the load angle ${\theta }_L$, i.e., the phase angle between the rotor position ${\theta }_R$ and the current position ${\theta }_I$ [15]:

$${\Gamma }_E=K_t·I·\sin \left({\theta }_L\right)=K_t·I·\sin \left({\theta }_R-{\theta }_I\right)$$

(1)

where $K_t$ is the torque constant. The torque is null when ${\theta }_L$ = 0 independently from the current magnitude, and it is maximum when ${\theta }_L$ = π/2. A sinusoidal current excitation produces a continuous rotation of the current vector of amplitude $I$ and a corresponding movement of the equilibrium position of the rotor. However, the typical commercial stepper driver produces only a limited set of quantized values of the phase currents. If $N_M$ is the number of the different current levels the driver produces, 4$N_M$ equilibrium positions are generated around the electrical circle of Figure 1 in ${\theta }_R=0,\frac{\pi }{2N_M}, \frac{2 \pi }{2N_M}, \frac{3 \pi }{2N_M},\dots \frac{\left(4N_M-1\right)\pi }{2N_M}$ [3].

2.2. Torque Modulation

According to (1), the torque can be modulated by controlling the load angle, ${\theta }_L$, and/or the current, $I$. The typical FOC application regulates the motor windings currents to generate a load angle of ${\theta }_L$ = ±π/2, and the current magnitude $I$ modulates the torque. This is the most efficient approach, since the minimum current is used for a given torque. However, in some situations, maintaining $I$ fixed and modulating the torque through ${\theta }_L$ can be convenient. Let’s consider, for example, a 10 A motor driver that, at a particular moment, is required to produce a low torque of 1/100 of the nominal value. By controlling the load angle to 90°, the windings’ current magnitude should be reduced to 10/100 = 0.1 A. It is feasible that the driver, which typically employs chopper amplifiers designed for high currents, suffers reduced accuracy in this low current range [17]. Thus, imposing a current magnitude of, for example, $I$ = 1 A, and reducing the load angle at $\sin \left({\theta }_L\right)=1/10$, can help to make the driver produce the desired torque while working in its preferred current range.

In order to show that the proposed method is able to modulate the torque by changing both $I$ and ${\theta }_L$, in the proposed implementation we chose a double control approach, as summarized in

Table 1. Torque modulation control strategy (1/2).

Condition	Control Strategy	Angle	Current	Torque
$\frac{{\Gamma }_E}{{\Gamma }_M}>0.1$	Angle fixed, ${\Gamma }_E$ modulated by $I$	${\theta }_L=\pm \frac{\pi }{2}$	$I$	${\Gamma }_E=\pm K_{t}I$	(2a)
$\frac{{\Gamma }_E}{{\Gamma }_M}<0.1$	Current fixed ${\Gamma }_E$ controlled by ${\theta }_L$	${\theta }_L$	$I=\frac{I_M}{10}$	${\Gamma }_E=K_t\frac{I_M}{10}\sin \left({\theta }_L\right)$	(2b)

. Which of the 2 control approaches is applied depends on the instantaneous required torque ratio ${\Gamma }_E$/${\Gamma }_M,$ where ${\Gamma }_M=K_t·I_M$ is the nominal torque of the motor, produced at the nominal current $I_M$ with the maximum load angle. For high torque values, i.e., ${\Gamma }_E$/${\Gamma }_M$ > 10% (see first row of Table 1), the same approach as in the FOC is used: the load angle is fixed to ±π/2, and, from (1), the torque is ${\Gamma }_E=\pm K_{t}I$, which is modulated by controlling $I$ (the sign depends on the direction of rotation). On the other hand, when a torque lower than ${\Gamma }_E$/${\Gamma }_M$ = 10% is required (bottom row in the table), the current is fixed to $I$ = 0.1·$I_M$. From (1), the torque is ${\Gamma }_E=K_t\frac{I_M}{10}\sin \left({\theta }_L\right)$, which is modulated by changing ${\theta }_L$.

The Torque column of Table 1 describes the achieved torque when the current magnitude and the load angle are known. To control the motor we need the opposite, i.e., given a desired torque ${\Gamma }_E$, we need to know the load angle, ${\theta }_L$, and the current, $I$, which produce such a torque. This result is obtained by solving the torque equations present in the Torque column of Table 1 with respect to the current $I$ and the angle ${\theta }_L$ (first row and second row of

Table 2. Torque modulation control strategy (2/2).

Condition	Control Strategy	Angle	Current	Torque
$\frac{{\Gamma }_E}{{\Gamma }_M}>0.1$	Angle fixed, ${\Gamma }_E$ modulated by $I$	${\theta }_L=\pm \frac{\pi }{2}$	$I=\frac{{\Gamma }_E}{K_t}=\frac{{\Gamma }_E}{{\Gamma }_M}{I}_M$	${\Gamma }_E$	(3a)
$\frac{{\Gamma }_E}{{\Gamma }_M}<0.1$	Current fixed ${\Gamma }_E$ controlled by ${\theta }_L$	${\theta }_L={\sin }^{-1}\left(\frac{10·{\Gamma }_E}{{\Gamma }_M}\right)$	$I=\frac{I_M}{10}$	${\Gamma }_E$	(3b)

):

Table 2 should be read as follow: given the desired torque ${\Gamma }_E$, the load angle and current to be used with the the motor to generate such a torque are those reported in Angle and Current columns, at the row selected by the Condition column.

It is now convenient to distinguish the actual current $I$ and load angle ${\theta }_L$, from the target current $I_t$ and load angle ${\theta }_{Lt}$, respectively. With reference to Figure 1, the first are the values currently present in the motor, while the others are the values that the motor control should achieve for generating the imposed torque. According to the aforementioned strategy, the electronics control, during the rotor movement, should drive the 2-phase currents so that $I$ has the desired amplitude ($I=I_t$) and is dynamically positioned to maintain the target load angle (${\theta }_L={\theta }_{Lt}$). Thus, if ${\theta }_R$ and ${\theta }_I$ are the actual rotor and current positions, (see Figure 1), the current position should be incremented/decremented by an angle of:

$${\theta }_{In}={\theta }_{Lt}-{\theta }_L={\theta }_{Lt}+{\theta }_R-{\theta }_I.$$

(4)

For practical reasons, since we are going to use a μ-step driver where the current position can be incremented/decremented in discrete steps of amplitude 2π/4/$N_M$ rad, it is convenient to rewrite (4) as:

$$S{T}_i=L{A}_T+RP-CP$$

(5)

where $S{T}_i$, $L{A}_T$, $RP$, $CP$, correspond to ${\theta }_{In}$, ${\theta }_{Lt}$, ${\theta }_R$, ${\theta }_I$, respectively, now expressed in μ-step unit.

For a better understanding of the proposed method, Figure 2 summarizes the control procedure. The instantaneous desired torque, expressed as torque ratio $\raisebox{1ex}{${\Gamma }_E$}\!\left/ \!\raisebox{-1ex}{${\Gamma }_M$}\right.$, the present current position, $CP$, and rotor position, $RP$, are inputs to the procedure. The calculation is divided into 2 steps. In the first step (Figure 2, top), the torque ratio is compared to the 0.1 threshold. If higher (Y-branch of the graph in Figure 2), the load angle is fixed to the maximum, i.e., ${\theta }_{Lt}=\raisebox{1ex}{$\pi $}\!\left/ \!\raisebox{-1ex}{$2$}\right.$, corresponding to $L{A}_T=N_M$ µ-steps, and the current magnitude is calculated according to (3a). On the other hand, if the torque ratio is lower than the threshold (N-branch of the graph in Figure 2), the current module is set to its minimum $I_t=0.1·I_M$, and the torque is modulated through the load angle, as calculated by (3b).

In the second step (Figure 2, bottom), the target load angle $L{A}_T$ and the actual current and rotor positions are used in (5) to obtain the number of μ-steps $S{T}_i$ necessary to update the $CP$ position so that the load angle changes from ${\theta }_L$ to the target load angle ${\theta }_{Lt}$. The output values $I_t$ and $S{T}_i$ are finally sent to the motor drive. Please note that when the border value of ${\Gamma }_E=0.1·{\Gamma }_M$ is used in both the branches of the procedure, it produces the same current module $I_t=0.1·I_M$ and target load angle $L{A}_T=N_M$. This confirms that the decision above the threshold does not produce discontinuities in the generated currents and target angles.

The 2nd step of the descripted procedure represents the quick and simple control loop mentioned in Section 1. It should loop at a high rate, so that CP tracks RP accurately with the correct phase during the motion of the shaft, which can rotate at several rev/s. On the other hand, the 1st step is more relaxed, since the torque changes are affected by the relatively slow dynamics of the motor mechanics. For example, let us consider a motor running at a constant velocity of 1000 rpm and loaded by a constant resistant torque. In case of a 200-step/turn motor controlled with 16 μ-step per step, the shaft runs a μ-step every 20 μs. To maintain the load angle, the control loop should correct the CP position with comparable timing, while no change is made to $I_t$ and ${\theta }_{Lt}$.

3. Method Implementation

3.1. The Electronics

The proposed method was implemented in an electronics system based on 3 boards (see Figure 3). The DECA MAX10 (Arrow Electronics, Centennial, CO) includes an FPGA from the low-cost MAX10 family produced by Altera (San Jose, CA). It is connected to a homemade interface board that includes the basic electronics to read the quadrature signals from incremental encoders, and to connect to the evaluation boards of the PowerSTEP01 motor control device. The board and the device are both produced by STMicroelectronics (Geneva, Switzerland). PowerSTEP01 is able to drive a stepper motor with up to 80 V and 10 A currents in an open loop. In this work, the device was set for $N_M$ = 16 (1/16 μ-step mode), and used in “Step-clock” mode, where it rotates the current position, $CP$, by a single µ-step every rise-edge generated on the step-clock signal. The direction of the rotation and the current are set by specific commands sent through a SPI channel.

3.2. FPGA Implementation

The proposed method is implemented in the FPGA of the DECA MAX10 board, and is sketched in Figure 4. This implementation refers to a stepper driver set for $N_M$ = 16 and a 10 k pulse-per-turn encoder; however, it can easily be adapted to different settings. The time-critical calculations, like the control loop (5), are implemented in the FPGA fabric and coded directly in VHDL, while parts of the remaining tasks are coded in the C language and run in a NiosII® soft processor included in the FPGA. This approach allowed low execution time for the control loop (5) and a faster and easier code development for the other tasks. The sections coded in the soft-processor include a conventional Proportional-Integral (PI) controller [10] and a simple trajectory generator, which are ancillary blocks that are necessary to allow the experimental test of the torque control method.

With reference to Figure 4, the soft processor includes the simple trajectory loop, that according to a programmed trajectory, calculates the target position P_T every 1 ms. P_T feeds the PI controller [10] that compares P_T to the actual position PA and outputs the target torque ${\Gamma }_E$. The torque is then processed in the Torque block, which applies the first step of the control procedure detailed in Figure 2, and generates the required current $I_t$ and the target load angle $L{A}_T$. $L{A}_T$ is delivered to the LoadAngle block, while $I_t$ is directly programmed to the driver through the SPI. Both the PI and the load angle calculation run every 200 μs.

The FPGA fabrics include several interacting blocks. The EncCnt counter (Figure 4 top, right) tracks the actual rotor position PA by integrating the quadrature signals produced by the encoder. PA is then used by the PI and the Mapper block in the FPGA fabric.

In the Mapper block, the physical position of the rotor PA is converted from encoder to μ-step units [18] (8/25 factor for 10 k pulse/turn encoder and $N_M$ = 16). The least-significant 5 bits of this value maps the rotor position in the electrical circle of Figure 1, RP, expressed in μ-step unit, which is delivered to the LoadAngle block.

The current position CP is tracked in the StepMan block (see Figure 4). The number of μ-steps $S{T}_i$ demanded to the driver in every control cycle are accumulated in the “step counter” with a sign that depends on the direction of rotation. The counter works with a 4$N_M$ module: for $N_M$ = 16 a 5-bit counter is used.

The LoadAngle block (see Figure 4) finally calculates the μ-steps required to maintain the desired load angle, $S{T}_i$, by applying the second step of the control procedure described in Figure 2 to the inputs provided from the blocks previously described. Every 50 µs, $S{T}_i$ is delivered to the StepMan block that issues to the powerSTEP01 driver the direction command followed by a burst of $S{T}_i$ electrical pulses of 1 µs each.

3.3. Debug Memory

The FPGA includes a debug memory (see Figure 4 bottom, right), where P_A, $L{A}_T$, $I_t$, CP, RP, and $S{T}_i$ parameters are simultaneously saved with a sampling rate set by the user from 1 μs to 100 ms. Up to 4096 values of each parameter can be saved without interfering with the algorithm. The memory can be downloaded to a host PC when the motor is stopped. Although this feature has no impact on the algorithm, it is essential for debugging and performance analysis.

3.4. Timings and Resources

The trajectory controller updates the target position, P_T, every 1 ms, and executes in 1.0 μs on a Nios processor clocked at 100 MHz. The PI controller and the torque control run every 200 μs, and execute the calculations in 1.5 μs only. This result is obtained using a look-up table for the sin inversion necessary in control step 1 (see Table 2, second row) for low torque condition. The remaining tasks, performed in FPGA fabric, are simple mathematical calculations or logic operations that take a few clock cycles at most to execute. The LoadAngle block (step 2 in Figure 2) is evaluated every 50 μs. In this period, the StepMan block issues a SPI command and a step-clock burst to the driver (see Figure 5). The SPI transmission, 1 byte at 4 MHz, takes about 3 μs. PowerSTEP01 driver requires a step-clock period of 1 μs, so the maximum length of the burst is of 32 μs (every position in a 64 μ-steps electrical circle can be reached by, at maximum, 32 μ-steps towards the shorter path). The minimum temporal length of a torque control loop is thus 3 + 32 = 35 μs, which fits well in the 50 μs period used here.

The resources employed in the FPGA are reported in

Table 3. FPGA Resources employed by the control system.

FPGA Blok	Logic Cell	Dedicated Reg	Memory Bits	DSP
Nios	5017	3079	195,000	6
StepManager	45	30	-	-
LoadAngle + Mapper Blk	349	132	-	-
Enc CNT	167	67	-	-

. As expected, most of the resources are used by the Nios® soft processor, while the other control blocks need relatively few logic cells and registers, and no memory nor mathematical processors (DSPs).

4. Experiments

4.1. Experimental Set-Ups

The control method was implemented in the electronics system reported in Section 3.1, which was connected to the set-ups shown in Figure 6. The set-up is composed by the M1233041 stepper motor (Lam Technologies, Florence, Italy) connected to the REV621 (Elap, Milan, Italy) encoder through a flexible mechanical coupling.

Table 4. Features of the Motor and the Encoder used in the experimental set-up.

MOTOR
Model	M1233041
Manufacturer	Lam Technologies, Florence, Italy
Flange	NEMA23
Step angle	1.8° (200 step/rev)
Hold Torque	1.1 N·m
Detent Torque	0.035 N·m
Current	4.2 A
Phase Resistance	0.4 Ohm
Phase Inductance	1.2 mH
Rotor Inertia	0.280 kg·cm−2
ENCODER
Model	REV621
Manufacturer	Elap, Milan, Italy
Zero reference	yes
Pulse/revolution	10,000

reports the main features of the employed motor and encoder.

4.2. Control Procedure Test

In this test, the trajectory and PI control loops implemented in the Nios II® were bypassed. The soft processor was programmed to set a fixed torque ratio $\raisebox{1ex}{${\Gamma }_E$}\!\left/ \!\raisebox{-1ex}{${\Gamma }_M$}\right.=$ 0.5. Being the ratio higher than the 0.1 threshold, the control sets a fixed current $I_t=0.5·I_M=2.1$ A and a 90° load angle, i.e., $L{A}_T=N_M=16$ µ-steps. The debug memory in FPGA was programmed to acquire a complete set of parameters every 1 µs. The motor was enabled for 1 s, and when the rotor reached a stable velocity after the initial acceleration, the debug memory was downloaded and processed in Matlab (The Mathworks, Natick, MA, USA). The parameters trend is reported in Figure 7 for a period of about 1.6 ms. The rotor electrical position (RP, Figure 7 first row) completes an electrical revolution (i.e., 64 μ-steps) in 0.68 ms. An electrical revolution corresponds to 4 steps [3]; thus, since the employed motor features 200 step/rev, the shaft performs a complete physical turn in 200/4∙0.68 = 34 ms. The current electrical position, CP, is reported in the 2nd row of Figure 7. As expected, it has a step-like behavior, with each step being 50 μs, i.e., the loop period. Similarly to RP, CP performs an electrical revolution (0–64 μ-steps) in 34 ms.

Every 50 μs, the controller calculates $S{T}_i$ from RP and CP (see 3rd row of Figure 7). In this experiment, $S{T}_i$ is in the range 5 ± 1 μ-steps, but most of the time is exactly 5 μ-steps. The calculated value is then used to update CP in next control period. The measured load angle, calculated in Matlab® as $L{A}_M=\mathrm{CP}-\mathrm{RP}$ (see Figure 1) is reported in the last row of Figure 7, where it is compared to the target angle $L{A}_T$ represented by the horizontal dashed line at 16 μ-step. It features a rough triangular shape of 50 μs period. When the CP is updated by $S{T}_i$ μ-steps, $L{A}_M$ reaches $L{A}_T$ and the load angle error is zero. Then, in the following 50 μs, the shaft moves, RP rises, and $L{A}_M$ diminishes until the next control period zeroes the error again.

This experiment helps to clarify that the error between the measured and target angle depends on the motor velocity and the control period $\mathrm{T}$. In fact, the higher the velocity, the wider the angle turned by RP in the control period. Quantitatively, the load angle peak error, in μ-steps can be expressed as:

$$\mathrm{Lerr}=\frac{\mathsf{\omega }}{2\pi }·3200·\mathrm{T}$$

(6)

where ω is the motor velocity in rad/s and 3200 is the number of μ-steps per revolution. Since the error features a triangle-like shape (see last row of Figure 7), its mean value is half of the peak, i.e., Lerr/2.

4.3. Torque Load Disturbance Test

With the set-up used in previous experiment, the trajectory generator was disabled and the PI was enabled with its input fixed to P_T = 0 (see Figure 4). The debug memory was programmed to save a parameter set every 200 μs. In this test, the motor shaft was loaded with an external positive torque, which was released at time t = 0. Figure 8 reports the shaft position measured by the encoder, P_A, the current ratio, It/I_M, the target angle, $L{A}_T$, calculated by the motor control, and the measured load angle, $L{A}_M$, together with its error with respect to the target angle.

Before the torque was released (t < 0), the control system maintained the rotor at position P_A = 0 by imposing the maximum load angle $L{A}_T$ = −16 μ-steps and a current of about 50% of the nominal value. After the external torque was released (t > 0), the control system reacted by reducing the current to its minimum of 10% in about 40 ms, then further reduced the torque by lowering the load angle towards 0. Meanwhile, due to the sudden load change, the shaft rotated of about −1.5 rad out of position, so the PI responded by imposing a slight positive load angle (t > 60 ms), while maintaining the current at its minimum level. The shaft recovered the target position in about 250 ms and the load angle decreased to 0. The error between the target and measured load angles, shown in last row, is within ±1 μ-step, except for few outliers. The load angle error is the same with (t < 0), and without (t > 0) the presence of load. The position error calculated as mean ± standard deviation of the errors measured before torque release (t < 0) is 0.05 ± 1.3 mrad, while after a stable condition was reached at t > 250 ms, is 0.09 ± 1.4 mrad. The test shows that the control reacts to a strong load change recovering the original position and controlling the load angle with a high level of accuracy.

4.4. Trajectory Test in Different Load Conditions

The trajectory generator of Figure 4 was programmed to produce a forward movement of 2π rad, with a constant acceleration/deceleration of 270 rad/s² and a maximum velocity of 16.4 rad/s. The experiment was repeated with the motor free, i.e., no load except the encoder, and with the motor connected to a load. The load was realized with a weight suspended by wire wrapped around the shaft. In the movement, the motor raised up the weight generating a torque that corresponds to about 20% of the full motor capacity. Figure 9 reports the parameters acquired in the FPGA every 300 μs. Left and right columns report the measurements obtained without and with the load, respectively. The errors are expressed as mean ± standard deviation calculated on the samples population of the corresponding measurement.

The measured position P_A is reported on the 1st row of Figure 9. The movement lasted 0.83 s; it featured a typical “S” shape, which is barely visible because of the high acceleration used. The position error Perr is shown in the 2nd row. In the experiment with no load, the error peaks up to ±0.2 rad in the high acceleration/deceleration regions, but it is as low as 1 ± 2 mrad in the constant velocity region. The motor reacts to the acceleration in presence of load with an oscillation error of ±0.02 rad, which damps down in 200 ms. In the remaining part of the constant velocity region, the error is the same as in the no-load condition. With load, after the movement, the controller recovers the right steady position a bit more slowly with respect to no-load condition.

The measured velocity shows the expected trapezoidal shape with some oscillations. The velocity is reported on the 3rd row of Figure 9, where it is compared to the target value, i.e., 16.4 rad/s, highlighted by the red horizontal segment. The velocity error was 0.01 ± 0.58 rad/s with no load, and 0.02 ± 0.85 rad/s with the load.

Without load, as expected, the current was set to its 10% minimum (4th row, left) and the torque was modulated by the load angle ($L{A}_T$ 5th row, left), which, during the movement, was about 10 μ-steps and reduced in the steady region. The error on the load angle (Lerr, 6th row, left) was 0.03 ± 0.7 μ-step. With load, during the movement, the load angle was fixed to its maximum, i.e., 16 μ-step corresponding to 90° ($L{A}_T$ 5th row, right), and the torque was modulated by the current (4th row, right), which was about 20% of the nominal value. At the end of the movement, when the torque required reduced, the current went down to 10% and the torque was again modulated by the angle. In this case, the error on the load angle was −0.4 ± 0.5 μ-step.

5. Discussion and Conclusions

Stepper motors are pervasive in modern applications; however, their use of open loops has several drawbacks. This work aims at a simple closed-loop method for overcoming such disadvantages. The method is fully compatible with the commercial monolithic devices typically used for open-loop drive of stepper motors, so that the generation and control of phase currents can be achieved on such devices.

The heart of the method is represented by the loop control (5). It comprises a few simple operations that are executed at a high rate. In fact, the ripple on the load angle error depends on the loop execution period T, according to (6). In this implementation, we used T = 50 μs, which, for example, allowed us to reduce the load angle error to less than −5 μ-step (about 1/100 rad) for a rotor velocity up to 750 rev/min. The proposed method achieves a very low static error both in load (0.05 ± 1.3 mrad) and no-load (0.09 ± 1.4 mrad) conditions, as measured in the experiment reported in Section 4.4). This error can be compared, for example, to those obtained by similar closed loop controllers described in [19] and [20], where static errors of 0.5° (~8 mrad) and 0.2° (3.5 mrad) are reported, respectively. The position error present during constant velocity movement (see experiment 4.4) is similar or lower to that shown in Figure 5 of [11], where a different FOC closed loop controller for stepper motors is presented. The controller presented in [11], among other differences, is based on a microcontroller where the control loop runs at T = 350 μs, with respect to T = 50 μs proposed here.

The high execution rate used in this work would be critical—if not unfeasible—in full microprocess implementation; hence, the use of an FPGA, as proposed here. On the other hand, the remaining tasks, e.g., current calculation, are more time-relaxed, and a C-like microprocessor approach makes the development and the debug easier. The use of the FPGA fabric and the soft processor answers to both requirements with a single electronics device. However, in cases where FPGA resources must be saved, a full VHDL controller implementation is feasible.

Several improvements can be made to the proposed method, like the damping of the motor resonances [21], the use of optimal load angle [22], the sensor-less angle measurement [23,24], ripple reduction [25], and others.

The proposed method represents a simple and economic implementation of closed-loop control, which yields significant improvement in stepper motor performance with respect to the typical open-loop approach.