DC Motor Control Series
DC Motor Speed Control Part II: PID Feedback
From our previous article DC Motor Speed Control Part I: Open-loop Command, an
experimental setup for DC motor is constructed and tested. The result shows that the
command and actual motor speed differ significantly. Not a surprise. An open-loop
control scheme cannot regulate the speed because no feedback is applied. So in this
article, a PID control is deployed.
Figure 1 shows a simplified block diagram of closed-loop DC motor speed control.
This diagram is drawn as a big picture for general audience to understand. Speed
feedback is actually read from the QEI module of PIC24EP, so the leftmost
summing junction should be inside the microcontroller. Anyway, we draw it
explicitly to show the feedback structure more clearly.
Figure 1 a closed-loop DC motor speed control scheme
The PID algorithm is a discrete-time version with derivative term replaced by filter
transfer function
K i Ts z K d N ( z 1)
C( z) K p (1)
z 1 (1 NTs ) z 1
How to convert (1) to computer software algorithm is explained in Discrete-time
PID Controller Implementation. The algorithm is put into ISR of timer 1. Note that
the controller coefficients are functions of PID gains (Kp, Ki, Kd), filter coefficient
N, and sampling time Ts. So whenever any of these parameters changes, the
controller coefficients need to be recomputed. This can be written as a function
// ------------ PID control function ----------------------
void vPIDSetup(void)
// -- this function must be invoked anytime
scilab.ninja
DC Motor Speed Control Part II: PID Feedback
// -- any parameter involved is changed by user
{
_T1IE = 0; // disable timer 1
a0v = (1+Nv*Ts);
a1v = -(2 + Nv*Ts);
// a2 = 1;
b0v = Kpv*(1+Nv*Ts) + Kiv*Ts*(1+Nv*Ts) + Kdv*Nv;
b1v = -(Kpv*(2+Nv*Ts) + Kiv*Ts + 2*Kdv*Nv);
b2v = Kpv + Kdv*Nv;
ku1v = a1v/a0v;
ku2v = a2v/a0v;
ke0v = b0v/a0v;
ke1v = b1v/a0v;
ke2v = b2v/a0v;
_T1IE = 1; // enable timer 1
_T1IF = 0; // reset timer 1 interrupt flag
SysFlag.VPIDchg = FALSE; // reset PID change flag
}
Note that variable names are ended with v to indicate they are used in velocity
feedback loop, to distinquish from position feedback in case it is also implemented
in the same system. To guard against read-modify-write problem, timer 1 is disabled
during coefficient update.
For the PID algorithm, what is different from the code in our previous article is the
output part. Now we have to convert a single control variable to a pair of signals
PWMVal and DIR (see Part I). The conversion is straightforward. When the output
is positive, it is sent out directly (limited by maximum possible value) and DIR is set
to 0. On the other hand, when the output is negative, it is converted to positive value
and DIR is set to 1. The code below shows how to implement the PID algorithm for
our DC motor setup
e2v=e1v; // update variables
e1v=e0v;
u2v=u1v;
u1v=u0v;
e0v = scmd - srpm; // compute new error
u0v = -ku1v*u1v - ku2v*u2v + ke0v*e0v + ke1v*e1v + ke2v*e2v;
// Eq (5.29)
2
DC Motor Control Series
if (u0v>=0) { // positive sense
if (u0v>PWMMAX) u0v = PWMMAX; // limit to PWM range
PWMVal = (unsigned int)u0v;
DIR = 0;
}
else { // negative sense
u0vn = -u0v;
if (u0vn>PWMMAX) u0vn = PWMMAX;
PWMVal = (unsigned int)u0vn;
DIR = 1;
}
OC1R = PWMVal;
Closed-Loop Speed Control
A global variable is defined so that the feedback loop could be open or closed by
user command. Figure 2 shows step response of closed-loop system when the motor
is commanded to rotate at speed 10 RPM. The controller gains are set at Kp = 200,
Ki = 100, Kd = 50. We see that at steady state, the motor speed is regulated around
10 RPM, the commanded value. The response is not very smooth due to the speed
readout is rounded to integer value. Comparing this to the open-loop response in
part I, we see clearly the benefit of feedback.
Figure 2 closed-loop step response of DC motor to speed command at 10 RPM
3
DC Motor Speed Control Part II: PID Feedback
Another important property of feedback control is disturbance rejection
performance. Disturbance could be the result of, say, load change. An easy way to
demonstrate output disturbance for this small DC motor is by grabbing the motor
shaft with your fingers ( for your own safety, never attempt this on a high power
motor). With no feedback, you can momentarily slow down or stop the rotation. In
contrast, a closed-loop speed control commands the motor to generate more torque
to combat the speed loss. You could feel the torque increase on your fingers.
Figure 3 shows disturbance rejection property of the closed-loop motor speed
control. The motor is commanded to rotate at 100 RPM. Then at t = 5 seconds, I
apply more load by grabbing the motor shaft. The speed regulation is disturbed, but
then compensated by the controller so that the response remains regulated at 100
RPM.
Figure 3 closed-loop response when output disturbance is applied at t = 5 seconds
