Computer Science 145.002
Introduction to Computing for Engineers
Fall 2008
Programming Assignment 10
“PID Controller Simulator”
Due: 7:30 AM, Thursday, December 11, 2008
A Proportional-Integral-Derivative (PID) controller is a
mechanism that is commonly used in engineering control
systems to get a particular variable to achieve a specific
value by repeatedly adjusting its current value until the
error between the current value and the goal value is
virtually eliminated.
Your assignment is to develop a program that simulates
the application of a PID controller to correct the error
between a process variable (PV) and a desired setpoint
(SP) by calculating and then applying a corrective action
that can adjust the process appropriately. For example,
an automobile's cruise control could use the car's speed
as its PV, with the car's desired speed as its SP.
There are three coefficients used to adjust the PV and eliminate the error. The proportional coefficient (Kp) is the factor
by which the PV error is multiplied in a single time unit. For example, if a car is going 50 MPH, the SP is 70 MPH, the Kp is
set to 0.2, and the time unit is one second, then the car will accelerate from 50 MPH to 54 MPH (0.2 times the 20 MPH
error) in one second; it would then accelerate from 54 MPH to 57.2 MPH (0.2 times the 16 MPH error) in the next
second
In order to control wild oscillations between high and low PV values, the derivative coefficient (Kd) is used. This
coefficient determines the factor by which the rate of the error change (i.e., the derivative of the error will be adjusted.
So, if the previous example had also had a Kd value of -0.0002, then the car will still accelerate from 50 MPH to 54 MPH
in the first second since no rate of error change has been established yet), but the adjustment in the next second will
include 3.2 MPH from the proportional term, but also Kd*(new error - old error)/(time elapsed) = (-0.0002)*(16 MPH - 20
MPH)/(1/3600 hour which calculates to 2.88 MPH. So, instead of winding up at 57.2 MPH after two seconds, the car
would have a speed of 60.08 MPH at that time.
Finally, to get the PV to settle down to the SP more quickly, the integral coefficient (Ki) is used. This coefficient is used as
the factor by which the accumulated error over time is multiplied to attempt to equalize that accumulated error and
thus get the PV oscillations to settle down. For instance, in the previous (Kp - 0.2, Kd = -0.0002) example, if Ki is set to -
0.018, then the first second's accumulated error of (20 MPH)*(1/3600 hour) is multiplied by Ki to adjust the speed by -
0.0001, so the speed at the end of the first second is 53.9999 MPH (not 54 MPH). While that doesn't seem to be much of
a difference, additional iterations create a cumulative effect that yields a faster convergence of the PV to the SP.
While the above formula for the PID adjustment seems
rather complicated, the steps needed to simulate PID
control are reasonably straightforward, as outlined at right.
Use one second (1/3600 of an hour) as your time increment
(t), and repeat the process for one minute (i.e., 60
iterations). An example interactive session and its resulting
output file are displayed on back of this page.
Since this is your last programming assignment, you are
expected to use as many of the features of C++ as you can
in this program. Use a class (in its own header file) to
implement the PID controller, with a default constructor, an
initializing constructor, a copy constructor, and all accessor and mutator member functions fully implemented. Use
another class (with a two-dimensional array of characters as its data member and an overloaded output operator) to
hold the image array that will be sent to the user-specified output file. Use the primary output commands
(.setf, .precision, and setw) to format the output properly.
1)
1) Initialize
Initialize Error
Error to
to SP
SP –
– PV
PV
2)
2) Initialize
Initialize P
P,
, I
I, and
, and D
D to zero
to zero
3)
3) Set
Set PreviousError
PreviousError to
to Error
Error
4)
4) Set
Set P
P to
to K
Kp
p
*
* Error
Error
5)
5) Add
Add K
Ki
i *
* Error
Error *
*
t to
t to I
I
6)
6) Set
Set D
D to
to K
Kd
d * (
* (Error
Error -
- PreviousError
PreviousError) /
) /
t
t
7)
7) Add
Add P
P +
+ I
I +
+ D
D to
to PV
PV
8) Repeat starting at #3 for the next time interval
Repeat starting at #3 for the next time interval
Kpe
(
t
)
+Ki∫
0
t
e
(
τ
)
dττ +Kdτ
dτe (t)
dτt
