Practical Controller Design for Dummies
Content
Practical Controller Design
For Dummies
By Chris McClellan
1
1.0 Introduction
Welcome to the Practical Controller Design for Dummies. This manual presents the field of Classical
Control Theory as taught in SYDE 352. This manual is intended as a basic framework for designing a
controller; with more experience and knowledge you can fill out this framework with more complex
techniques. It is broken in to 3 sections: System Identification, Controller Design and Controller
Validation. A simple brushed DC motor system is used as an example to illustrate the framework.
I would like to thank Dr. Eric ‘The Tool Man’ Kubica for freeing me from the deep, murky, nebulous hole
that is MME. I would also like to thank him for the opportunity to create this manual and for his
guidance and expertise on this project. I would also like to thank Professor Dan Davison, Professor
Glenn Heppler and Professor Nasser Lashgarian Azad for their support in making this manual possible.
I would also like to thank the good people at For Dummies for the use of their logo.
Figure 1.0 –Gratuitous Puppy Shot
2
2.0 System Identification
Shown below in Figure 2.0 is the typical feedback system. In general, this system consists of a Reference
Input Signal R(s), an Input Filter Transfer Function I(s), a Controller Transfer Function C(s), a Controller
Output Signal U(s), a Plant Transfer Function P(s), a Feedback Transfer Function H(s) and an Output
Signal Y(s). Also note the summation point where the Error Transfer Function E(s) is equal to R(s)βI(s). –
Y(s)βH(s).
R(s)
I(s)
E(s)
+
∑
U(s)
P(s)
C(s)
.
Y(s)
H(s)
Figure 2.0 – Typical Feedback System
The goal of System Identification is to derive a mathematical model for each of the following elements:
Reference Input Signal R(s) – The Reference Input Signal is the desired set-point(s) as requested by the
operator of the system. This input can take many forms, including impulse signals, step signals, ramp
signals, acceleration signals, sinusoidal signals etc [1]. Your goal is to identify the typical Reference Input
Signal(s) for your system and design a controller to adequately respond to these desired inputs.
Input Filter Transfer Function I(s) – The role of the Input Filter is to convert the Input Signal into a form
that is usable by the Controller Transfer Function. In most cases the Input Filter Transfer Function is a
gain but can sometimes take the form of a transfer function that filters the input in ways that improve
the system response.
Error Signal E(s) – The Error Signal is calculated by subtracting the output of the Feedback Transfer
Function from the output of the Input Filter Transfer Function. Though you don’t need to derive a
model for this part of the system, it’s important to know the units of this signal.
Controller Transfer Function C(s) – The Controller Transfer Function is the brains of your system and the
goal of Controller Design in Section 3.0. It takes the Error Signal and computes the Controller Output
Signal. The Controller can take many forms, but for this course we’ll focus on Proportional (P)
Controllers, Proportional plus Integral (PI) Controllers, Proportional plus Derivative (PD) Controllers,
Proportional plus Integral plus Derivative (PID) Controllers, Phase Lead Controllers, Phase Lag Controllers
and Feedforward Controllers.
3
Controller Output Signal U(s) – The Controller Output Signal is the signal that the Controller calculates
and applies to the Plant. Though you don’t need to derive a model for this part of the system, it’s
important to know the units of this signal. It also should be noted that sometimes when running
experiments on the model of your system, a limit function may be added here to replicate the real world
limits of your system. See Section 3.2.6 for more information.
Plant Transfer Function P(s) – The Plant Transfer Function generally consists of an actuator and the
process being controlled. Generally the most difficult task in designing a Controller is to come up with
an accurate model of the Plant. For our purposes, there are 2 main methods for developing a model of
the Plant. The first approach is to Apply First Principles Techniques. For a mechanical system, this will
start with drawing a Free-Body Diagram where we can apply Newton’s Second Law of Motion for linear
motion where:
πΉβ = ππβ
Where:
πΉβ is the net force acting on an object,
π is the mass of the object and
πβ is the acceleration of the object.
Or for rotational motion where:
ββ = πΌπΌβ
π
Where:
ββ is the net torque applied to an object about an axis of rotation,
π
πΌ is the inertia of the object about the same axis of rotation and
πΌβ is the angular acceleration of the object about the same axis of rotation.
If you have an electrical system, Kirchhoff’s voltage law (KVL) may be applied where:
π
∑ ππ = 0
π=1
Where:
ππ is the voltage across element k of n total elements.
4
Of course there are many other equations that could be used to predict the response of your Plant. This
technique can be used for any order of Plant but it does require complete knowledge of the Plant.
The second approach, Transient and Steady-State Response Analysis, is great for Plants where little is
known about the Plant. However, this technique is limited to first and second order Plants. The
technique is to apply a known input to your Plant and analyze the transient and steady-state response.
Section 2.2.7 goes into more detail on this approach.
The third approach, Data Driven Modeling, sometimes called gray box modeling, is a very effective tool
when attempting to model a Plant when very little is known, much like training a fuzzy-neural network,
but is beyond the scope of this course.
Feedback Transfer Function H(s) – The Feedback Transfer Function generally is a model of the sensor
used to measure the output of your Plant. In most cases this transfer function is modeled as a gain.
Output Signal Y(s) – The Output Signal is the physical variable being controlled. Though you don’t need
to derive a model for this part of the system, it’s important to know the units of this signal.
2.1 System Identification Flow Chart
Figure 2.1 is the flow chart for System Identification. Follow through it to derive a model for each of the
system components.
2.2 System Identification Example
In order to illustrate the process for System Identification, we’ll look at a brushed DC motor system.
Shown in Figure 2.2 is the top view of said system. You’ll notice there is a steel arm attached directly to
the motor in which we will control. The desired performance specifications for this system are:
1) Maximum overshoot of 5% for a unit step input.
2) Rise time of 0.1s for a unit step input.
3) Zero steady-state error to a unit step input.
5
Identify Elements of System
Make Assumptions and
Simplifications of System
Derive a Model for each
Element Except for the
Controller and Plant
Create Plant Model
Apply First Principles
Modeling
Analyze Transient and
Steady-State Response
Apply Data Driven
Modeling Techniques
Techniques
Test Model
Is Plant Model
Accurate Enough?
No
Yes
Can the System be
Simplified Further?
Yes
No
Figure 2.1 – System Identification Flow Chart
6
Figure 2.2 – Top View of Brushed DC Motor System
Motor
Optical Encoder
Figure 2.3 – Side View of Brushed DC Motor System
7
2.2.1 Step 1 – Identify Elements of System
For our system:
R(s)
Since our performance specifications are solely for a step input, our typical Reference Input
Signal will be the desired angle of rotation of the motor’s shaft, measured in radians.
I(s)
A coeficient that converts the desired angle of rotation in radians to encoder counts.
E(s)
The Error Signal will be in encoder counts.
C(s)
A Controller implemented on an Arduino Mega in series with a Dual MC33926 Motor Driver.
U(s)
The Controller Output Signal will be in volts.
P(s)
A brushed DC motor (Maxon 2332.968-51.236.200), as shown in Figure 2.3, with a steel arm
attached. Also, the slotted disk (See Figure 2.4) of the optical encoder is attached to the same motor
shaft.
Figure 2.4 – Optical Encoder Disk and Sensor
H(s)
An optical encoder (HEDS-5540 A11), as shown in Figures 2.2 and 2.4, and an encoder
counter (HCTL-2022) that converts the angular position of the motor’s shaft in radians to encoder
counts.
Y(s)
The angular position of the motor’s shaft, measured in radians.
2.2.2 Step 2 - Simplify System
Assumption #1 - We will assume the system is linear and time invariant.
Simplification #1 - We will add the effect of the arm and encoder wheel to the inertia of the motor
model.
8
2.2.3 Step 3 – Create Model of each Element Except for Controller and Plant
Feedback Transfer Function H(s) -Encoder
From the data sheet for the HEDS-5540 A11 optical encoder, it has a resolution of 500 CPR (Counts Per
Revolution) [2]. In order to free the Arduino Mega from the intensive task of counting the pulses
generated by the optical encoder, an encoder counter is used to count and store the current angular
position. From the data sheet for the HCTL-2022 encoder counter, it states that it has quadrature
decoding capabilities, meaning it can read the two out-of-phase pulse trains and increase the resolution
by a factor of 4 [3]. Therefore:
π»(π ) = 500
ππ’ππ ππ
πππ’ππ‘π 1 πππ£πππ’π‘πππ
πππ’ππ‘π
β4
β
= 318.3
πππ£πππ’π‘πππ
ππ’ππ π 2π πππππππ
ππππππ
Input Filter Transfer Function I(s)
The Input Filter is required to convert the desired angle of rotation of the motor’s shaft in radians to
encoder counts. Therefore, like the Encoder Model:
πΌ(π ) = 500
ππ’ππ ππ
πππ’ππ‘π 1 πππ£πππ’π‘πππ
πππ’ππ‘π
β4
β
= 318.3
πππ£πππ’π‘πππ
ππ’ππ π 2π πππππππ
ππππππ
Aside – Because the encoder/encoder counter combination can’t read fractional counts, a Floor
Rounding Function, that rounds down to the lowest integer value, will be added after the H(s) and I(s)
transfer functions to emulate this characteristic.
2.2.4 Step 4 – Create Plant Model
We have a choice on how to model our Plant. As mentioned, for this course, only First Principles
Modeling and Transient and Steady-State Response Analysis will be used. First Principles Techniques
are useful for any order of system; however, it requires complete knowledge of the system. In our case,
all of the parameters of the motor are available from its data sheet making this method possible.
However, if we had an unknown motor, this technique would not be possible. For the sake of interest,
let’s start with First Principles Techniques then confirm our model using Transient and Steady-State
Response Analysis.
9
2.2.4.1 Modeling Approach #1 – Apply First Principles Modeling
Using First Principle Techniques, we’ll start with the typical model of a brushed DC motor. Shown in
Figure 2.5 is the typical electrical circuit of the armature and the free-body diagram of the rotor [4].
La
Ra
θm
T
ia
+
Va
+
.
~
e=Keθm
-
M
-
Jm
.
bθm
(b)
(a)
Figure 2.5 – DC Motor: (a) Electric circuit of armature; (b) Free-body diagram of rotor [4]
Applying Kirchhoff’s voltage law (KVL) to the motor’s armature circuit results in:
πππ
+ πΎπ πΜπ − ππ = 0
ππ‘
π π ππ + πΏπ
(2.0)
Where:
Ra
is the resistance of the motor’s armature in ohms,
ia
is the current flowing through the motor’s armature in amps,
La
is the inductance of the motor’s armature in henrys,
Ke
is the back emf coefficient in sβV/rad,
πΜπ
is the rotational velocity of the motor’s rotor in rad/s,
Va
is the voltage applied to the motor in volts.
10
Using Newton’s second law of motion on the motor’s rotor results in:
πΎπ‘ ππ − ππΜπ = π½π πΜπ
(2.1)
Where:
Kt
is the torque motor constant in Nβm/A,
b
is the viscous friction coefficient in Nβmβs,
Jm
is the rotational inertia of the motor’s shaft and rotor in kgβm2,
πΜπ
is the rotational acceleration of the motor’s rotor in rad/s2.
Combining Equations 2.0 and 2.1 and applying Laplace transforms with initial conditions of zero results
in the motor’s transfer function:
ππ (π )
πΎπ‘
=
3
ππ (π ) π½π πΏπ π + (π½π π π + ππΏπ )π 2 + (ππ π + πΎπ‘ πΎπ )π
(2.2)
Applying Simplification #1 in which the rotational inertia of the arm and encoder disk is added to the
rotor’s rotational inertia results in:
π½π = π½π + π½π + π½π
(2.3)
Where:
JT
is the combined rotational inertia in kgβm2,
Ja
is the rotational inertia of the arm in kgβm2,
Je
is the rotational inertia of the encoder disk in kgβm2.
By combining Equations 2.2 and 2.3 our Plant Transfer Function is:
π(π ) =
πΎπ‘
(π½π + π½π + π½π )πΏπ π 3 + ((π½π + π½π + π½π )π π + ππΏπ )π 2 + (ππ π + πΎπ‘ πΎπ )π
(2.4)
11
From the motor’s data sheet, the following is given:
π π = 7.94 Ω
πΏπ = 1.50 ππ»
πΎπ‘ = 39.3 ππ β π/π΄
π½π = 27.8 π β ππ2
πΎπ−1 = 243 πππ/π
However, using a multimeter I checked the resistance across the leads of the motor to find the
combined resistance to be:
π πππ‘ππ+πππππ = 9.52 Ω
Furthermore, checking the data sheet of the MC33926 motor driver, it states its H-bridge mosfet has a
maximum on-resistance of:
π πππ πππ‘ = 225 πΩ
And since there is 2 mosfets in operation at any given time, we’ll combine the resistance of the motor,
the leads and the 2 mosfets to get a total resistance of:
π π = 9.97 Ω
2.2.4.2 Calculating the Viscous Friction Coefficient
The last motor specification we require is b, the viscous friction coefficient, and unfortunately the
manufacturer does not list it. The viscous friction coefficient is used in Equation 2.1, and if we were to
run the motor at a constant speed, this equation simplifies to:
πΎπ‘ ππ = ππΜπ
(2.5)
And by the motor specification, with no load:
πΜπ = 8410 πππ ππ 880.7 πππ/π
ππ = 30.9 ππ΄ ππ 0.0309 π΄
By submitting the aforementioned values into Equation 2.5 and rearranging for b we get:
π=
πΎπ‘ ππ (0.0393)(0.0309)
=
= 1.38π₯10−6 π β π β π
880.7
πΜπ
12
2.2.4.3 Estimating the Inertia of the Arm and Encoder Disk
The last pieces of information we need to complete our model of the Plant are the rotational inertias of
the arm and the encoder disk. There are a number of ways to do this, here are just 2 ways.
Estimating Approach #1 – Assume the effect of the encoder disk is negligible and model the arm as a
point mass located at half the arm’s length.
By finding the mass of the arm and its length, the following equation can be used:
ππ 2
π½π1 = ππ ππ 2 = ππ ( )
2
(2.6)
Where:
ππ = 0.049 ππ
ππ = 0.123 π
By substituting these values into Equation 2.6, we get the following:
0.123 2
π½π1 = (0.049) (
) = 1.85π₯10−4 ππ β π2
2
Therefore, using Equation 2.3:
π½π = π½π + π½π + π½π = 2.78π₯10−6 + 1.85π₯10−4 + 0 = 1.8778π₯10−4 ππ β π2
Estimating Approach #2 – Find the inertias of the both the encoder wheel and arm empirically.
By rearranging Equation 2.1 for JT, we get:
π½π = π½π + π½π + π½π =
πΎπ‘ ππ − ππΜπ
πΜπ
(2.7)
Therefore, if we collect the motor’s angular position and current and differentiate the angular position
twice to get πΜπ and πΜπ respectively, we can calculate the combined inertia at each time step. Since the
motor specifications are averages over its operating speeds anyways, we should be able to apply a ramp
function to the motor to get a range of results to average.
13
To do this, first, we’ll open the ControlsLabBaseCode.ino1 file and program the Arduino Mega 2560 for
Open Loop Ramp mode where:
Mode = 1, Ramp_Final = 200, I_Gain = 318.3, Time = 5 and Period = 10.
This puts the Mega into Mode 1 for Open-Loop Ramp Input operation that will output a linearly varying
voltage ramp to the motor for a Time of 5.0s with a Period of 10 ms. This ramp will start at the default
value of 0% duty cycle or 0 V and end at the Ramp_Final value of 200, which is the raw analogWrite
value that represents a duty cycle of (200/255)β100% = 78.4% or a voltage of (200/255)β12V or 9.4V. The
I_Gain value is the Input Filter Gain that converts radians to encoder counts. By uploading this file, the
Mega is ready to go and a test can be initiated by pressing the Start button. Remember, to keep your
hand close to the Stop but in case your test gets out of hand. To collect data, the collect.m Matlab script
should be used. It returns the following vectors:
R(t)
is the Reference Input Signal vector. In Open Loop mode it represents a voltage and is the
raw analogWrite value. It ranges from 0 – 255 and its the duty cycle of the Pulse Width Modulated
(PWM) signal where 0 represents a 0% duty cycle (always off), 127 represents a 50% duty cycle (on half
the time) and 255 represents a 100% duty cycle (always on). In Closed Loop mode it represents the
desired angle in radians.
Y(t)
is the Output Signal vector, which in this case is the angular position of the motor in radians.
I(t)
is the current vector ππ in amps flowing through the motor’s armature. It is important to note
that this value is always positive, regardless of the direction of the flow of current.
Aside – the collect.m script will prompt you for which communication port that the Arduino Mega is
currently connected to. To determine which port is being used, open the Device Manager and look
under Ports (COM & LPT), as shown in Figure 2.6.
Figure 2.6 –Device Manager Hardware Tree
1
This Arduino file, as well all the other Arduino and Matlab files used in this manual can be found on the C: drive of
your lab computer under SYDE 352/SYDE Code.
14
By running collect.m, 4 different plots are created, only 3 of which are important to us at this point.
Figure 2.7 – Plot of the Reference Input vs. Time
Figure 2.8 – Plot of the Motor Output vs. Time
15
Figure 2.9 – Plot of the Motor Current vs. Time
Shown in Figure 2.7 is the plot of the Reference Input vs. Time. As expected, the analogWrite signal that
represents the duty cycle of the PWM signal sent to the motor varies linearly from 0 to 200 over the 5
second duration. The Angular Position of the motor shown in Figure 2.8 exhibits a non-linear output for
the entire test, the worst section being the first 3.5 seconds of the test. Even though we’ve assumed
our system to be linear, and the input to the systems is a linear ramp, this clearly is not the case. A red
line has been added to the plot to mark the region we’ll consider as linear for our calculation of the
combined inertias. The plot of the motor current shown in Figure 2.9 is very noisy. It should be noted
that an averaging filter has been added to the ControlsLabBaseCode.ino file to help with the noise issue
from the current feedback and this plot is a vast improvement over what is was.
To calculate the angular velocity and acceleration of the motor, the angular position needs to be
differentiated. To help with this, a Matlab function called differ was created that employs the following
simple two-point estimation:
π¦Μ (π‘) =
π¦(π‘ + β) − π¦(π‘)
β
Where:
β = ππππππππ ππππππ = ππππ‘π π‘πππ
16
The differ function has the following syntax:
[data_vector_dot, time_vector_dot] = differ(data_vector, time_vector, freq)
Where:
data_vector_dot
is the returned differentiated data vector.
time_vector_dot
is the returned time vector used for plotting data_vector_dot vs. Time.
data_vector
is the input data vector to be differentiated.
time_vector
is the input time vector to be truncated by one sample point.
Shown in Figure 2.10 is the plot of the Angular Velocity vs Time. The signal exhibits a small amount of
noise but overall it is fairly smooth and should produce a decent result when using Equation 2.7.
However, this small amount of noise is greatly amplified in the signal of the Angular Acceleration, as
shown in Figure 2.11. This signal is basically a blur and will not produce an acceptable result when using
Equation 2.7.
Figure 2.10 – Plot of the Angular Velocity vs. Time
17
Figure 2.11 – Plot of the Angular Acceleration vs. Time
Out of curiosity, I created another Matlab script called J_calculation.m based on Equation 2.7 and
applied our vectors. Shown below in Figure 2.12 is the result.
Figure 2.12 – Plot of the Combined Inertias vs. Time
18
Even when we zoom-in on the region after 3.5s, the result is way off, as shown below in Figure 2.13.
Not surprising, the average combined inertias over this time period using this script results is an infinite
value.
Figure 2.13 –Plot of the Combined Inertias vs. Time from 3.5s to 5.0s
Post Process Filtering
It’s clear we’re going to do some post process filtering to get a decent result. I’ve created a function
called data_filter that uses Matlab’s butter function that returns the transfer function coefficients of an
nth-order low-pass Butterworth filter with a normalized cutoff frequency of Wn. These coefficients are
then applied using Matlab’s filter function. The user has the choice of 3 normalized cutoff frequencies
to expedite the process of finding the appropriate cutoff frequency. The order of the filter has been
hard-coded to be a second order low-pass filter. The data_filter function has the following syntax:
[v_f1, v_f2, vf_3] = data_filter(f1_n, f2_n, f3_n, vector_in)
Where:
v_f1, v_f2, v_f3
are the three returned vectors of the filtered vector_in at the normalized
frequencies f1, f2 and f3 respectively
f1_n, f2_n, f3_n
are the user defined normalized cutoff frequencies. These cutoff frequencies
must lie between 0 and 1, where 1 corresponds to the Nyquist rate of half the sample rate.
vector_in
is the input vector to be filtered.
19
By applying the aforementioned data_filter function to the angular velocity with arbitrarily determined
normalized cutoff frequencies of 0.2, 0.1 and 0.02, the following plot was created (Figure 2.14). With a
sampling period of 10ms, our sampling frequency is 100Hz and our Nyquist rate is 50 Hz. Therefore the
cutoff frequencies trialed correspond to 10Hz, 5Hz and 1Hz respectively.
Figure 2.14 – Data_filter Function Output of Angular Velocity with Cutoff Frequencies of 10Hz, 5Hz and
1Hz
Though it’s slightly difficult to see from the plot shown in Figure 2.14, all 3 cutoff frequencies do a nice
job of smoothing out the noise in the Ydot vector. However, the third cutoff frequency of 1Hz adds a
very noticeable shift to the data due to the aggressive 2nd order Butterworth filter being too close to the
cutoff frequency of the system which is not desired. To minimize this effect, the vector filtered at the
second cutoff frequency of 5Hz will be used. Applying the differ function on this new vector results in
plot shown below in Figure 2.15.
Clearly the result shown in Figure 2.15 when compared to the plot in Figure 2.11 is much better, but still
exhibits a fair amount of noise. Using the data_filter function with the same cutoff frequencies
produced the plot shown in Figure 2.16.
20
Figure 2.15 - Plot of the Angular Acceleration vs. Time
Figure 2.16 - Data_filter Function Output of Angular Acceleration with cutoff frequencies of 10Hz, 5Hz
and 1Hz
This time the cutoff frequencies of 10Hz and 5Hz did not do an adequate job where the cutoff frequency
of 1Hz did a nice job in smoothing the data but once again added a significant shift. A second trial with
normalized cutoff frequencies of 0.08, 0.04 and 0.02 were used to produce the plot shown in Figure
2.17.
21
Figure 2.17 - Data_filter Function Output of Angular Acceleration with Cutoff Frequencies of 4Hz, 2Hz
and 1Hz
The second cutoff frequency of 2Hz appears to do the best job of filtering the Angular Acceleration
because it produces the smoothest signal without adding a delay to the data and will be used to
calculate the combine inertias. Using the J_calculation script resulted in the following plot (Figure 2.18).
Figure 2.18 - Plot of the Combined Inertias vs. Time
22
The average combined inertias over the time period of 3.5s to 5.0s was calculated to be:
π½π = π½π + π½π + π½π = 2.4π₯10−4 ππ β π2
It was expected that the result of the first approach would yield a conservative estimate because it did
not consider the exact geometry of the arm or the inertia of the encoder wheel. Comparing the
combined inertias value just calculated with the value found using the first approach and we have a
value 28% greater. I’m very comfortable with the estimate of the second approach because I expected
it to be larger, but not drastically larger and I will continue with it.
Substituting all our Plant values into Equation 2.4, we now have a complete model of our Plant.
π(π ) =
0.0393
3.594π₯10−7 π 3 + 0.002389π 2 + 0.001558π
Or in normalized form:
π(π ) =
π 3
109348.9
+ 6647.1π 2 + 4335π
2.2.5 Step 5 – Test Model
To test the model of our system, we will subject our Plant model and actual Plant to a number of
different inputs and compare the results. In order to help with this a Simulink model called
base_open_loop_model has been created. Since we already have captured the data for a ramp input to
our actual Plant in the Matlab workspace, let’s apply it to our Simulink model and compare.
Note 1 – Our Simulink model reads in both the Time vector T and Reference Input vector R to run
through our Plant model and compares it to the Output vector Y. However, to do this successfully, T, R
and Y each need to be converted from a single row vector to a single column vector using the transpose
operator “ ‘ “.
Note 2 – As shown in Figure 2.19, I had to add a Zero-Order Hold and Quantizer function block to
base_open_loop_model. Since we’re using a microcontroller to implement our Controller, we are
actually implementing a discrete control system where this course deals strictly with systems in the
continuous time domain. In order to get the two systems to work together, the Zero-Order Hold
function block takes discrete data and converts it to continuous data where the Quantizer function block
converts continuous data to discrete data.
23
Figure 2.19 – Simulink base_open_loop_model
Shown in Figure 2.20 is the Angular Position vs Time plot generated by the Scope function block in
base_open_loop_model. It compares the results of our Plant model with the actual Plant when
subjected to a ramp input. The results are very encouraging.
Figure 2.20 – Comparison Plot of Plant Model and Actual Plant when Subjected to a Ramp Input
Let’s compare step input results. To do so we’ll open the ControlsLabBaseCode.ino file and program the
Arduino Mega for Open Loop Step mode where:
Mode = 0, Step_Input = 100, I_Gain = 318.3, Time = 5 and Period 10.
24
This will output a step voltage of (100/255)β12V or 4.7V for the entire test duration. Using the collect.m
Matlab script to collect the test data, transposing vectors T, R and Y, and running it through our
base_open_loop_model yielded the plot shown in Figure 2.21. Again, the results are very encouraging.
Figure 2.21 - Comparison Plot of Plant Model and Actual Plant when Subjected to a Step Input
One more test; let’s try a chirp input. A chirp is a signal in which the frequency increases (‘up-chirp’) or
decreases (‘down-chirp’) with time. The term chirp is used interchangeably with sweep signal [5]. Open
the ControlsLabBaseCode.ino file and program the Arduino Mega for Open Loop Chirp mode where:
Mode = 2, Freq_Final = 2, PWM_Amp = 50, I_Gain = 318.3, Time = 10 and Period = 10.
This will output a sinusoidal signal that will range between +/- (50/255)β12V or +/- 2.35V with the
frequency linearly increasing from 0 to 2Hz. Using the collect.m Matlab script to collect the test data,
transposing vectors T, R and Y, and running it through our base_open_loop_model yielded the plot
shown in Figure 2.22.
25
Figure 2.22 - Comparison Plot of Plant Model and Actual Plant when Subjected to a Chirp Input
Again, the results are very similar but it’s obvious the motor is struggling with oscillating the system’s
inertia at this frequency by the drift in the position and the reduction in magnitudes of the oscillations as
the frequency increases. Out of curiosity, I’ll perform the same test without the arm attached. By
changing the J value for our Plant model, the two results can be compared. As shown in Figure 2.23, the
motor does a lot better job in keeping up with the commanded chirp signal and the Plant model
accurately predicts this result.
There is no standard way of concluding whether a model is accurate enough. However, upon visual
inspection, the results are very similar and I’m comfortable with concluding that this model is
sufficiently accurate to proceed. However, can it be simplified?
Figure 2.23 - Comparison Plot of Unloaded Plant Model and Actual Unloaded Plant when Subjected to
a Chirp Input
26
2.2.6 Step 6 – Simplification
It would be nice to reduce the order of our model to a second order model so that we can use standard
second order methods to develop a Controller. Presented are two approaches for accomplishing this.
2.2.6.1 Simplification Approach #1
For many DC motor models, the relative effect of the inductance is considered negligible compared to
the mechanical time constant and can be neglected. Let’s test this out.
By setting:
πΏπ = 0
We get the following new Plant model, where:
ππππ€1 (π ) =
0.0393
0.002389π 2 + 0.001558π
Or in normalized form:
ππππ€1 (π ) =
π 2
16.45
+ 0.652π
(2.8)
Interestingly, the denominator of the old Plant model and new Plant model, before converting to
normalized form, are the same except for the missing π 3 term. By using Matlab’s bode function to
create a Bode Diagram of both Plant models, as shown in Figure 2.24, we can see that they’re almost
identical, except for a slight difference in phase at higher frequencies.
Based on the Bode Diagram, I’m very comfortable with this simplification and require no further testing
to verify its validity.
27
Figure 2.24 – Bode Diagram Comparing the Original Plant Model with the New Plant Model
2.2.6.2 Simplification Approach #2
Another approach to reducing the order of the system is by Model Reduction. This method looks at the
Plant’s poles and zeros that are a factor of 10 or greater than the dominant poles and zeros and replaces
them with a DC gain (i.e. when s = 0).
For example, if you have a transfer function such as:
ππΉ(π ) =
(π + π§2 )(π + π§1 )(π + π§0 )
(π + π3 )(π + π2 )(π + π1 )(π + π0 )
Which has a value of:
ππΉ(0) =
(0 + π§2 )(0 + π§1 )(0 + π§0 )
π§2 β π§1 β π§0
=
(0 + π3 )(0 + π2 )(0 + π1 )(0 + π0 ) π3 β π2 β π1 β π0
When s = 0. And you recognize that π2 is greater than π3, π1 and π0 by a factor of 10 or greater, you can
replace (π + π2 ) with π2 . Thereby simplifying our example transfer function to:
ππΉπππ€ (π ) =
(π + π§2 )(π + π§1 )(π + π§0 )
(π + π3 ) β π2 β (π + π1 )(π + π0 )
28
Which has the same value as the original transfer function when s = 0 and at low frequencies. Of course,
at high frequencies there will be slight differences, but it will be negligible because the lower frequency
poles will dominate the response of the transfer function.
This method is effective for systems with a low bandwidth. However, if you’re looking to create a
system with a high bandwidth, those high frequency poles and zeros may be very important. Another
approach is to look at the Plant’s poles and zeros to see if there are any poles and zeros that can cancel
each other.
Using Matlab’s pole function, the Plant’s poles were found at:
P1 @ 0, P2 @ -0.652 and P3 @ -6646
Since there are no s terms in the Plant numerator, there are no zeros.
Shown in Figure 2.25 is a plot of the Plant model’s poles and zeros using Matlab’s pzmap function.
Fortunately none of the poles lie in the unstable Right Half Plane (RHP), however, it does have a pole
directly on the Imaginary axis. Furthermore, none of the poles have any imaginary components,
meaning the system is critically damped or over-damped. Since none of the poles are at the same
location, the system is considered overdamped. Interestingly, there is a very high frequency pole at
-6646 which should have very little effect on how the model performs. By removing this pole and
replacing it with a DC gain, our new Plant model is the following:
ππππ€2 (π ) =
109348.9
π (π + 0.6523)(6646)
Or:
ππππ€2 (π ) =
16.45
π (π + 0.652)
(2.9)
This new Plant model is identical to the result obtained from the Approach #1. Let’s try the transient
and steady-state response analysis technique to verify this result.
29
Figure 2.25 – Plot of Plant Model’s Poles and Zeros
2.2.7 Modeling Approach #2 –Transient and Steady State Response
The goal of this approach is to apply different Reference Input Signals into the open-loop system you
want to model to gain insight into what order it is, and hopefully derive some values for this model. A
good starting point is to apply a step input into your system and see how it reacts. Reusing the test data
collected earlier, shown in Figure 2.26 is a step input of (100/255)β12V or 4.7V.
30
Figure 2.26 – Open-Loop Step Response
There are 2 things to note from this open-loop step response. First, the slope at t = 0 is zero, which
indicates that the system must be second order system or higher. Oscillations in the output would have
also indicated a second order system or higher. Second, the output position does not reach a steady
state. Instead a steady velocity is reached. This indicates that our system may look like a first order
system with an integrator term after, as shown in Figure 2.27:
πΎ
ππ + 1
1
π
Figure 2.27 – Proposed Plant Model
Note –
1
π
= π, or the real portion of the pole.
31
If we differentiate the position output to get velocity, we get the following plot shown in Figure 2.28:
Figure 2.28 – Differentiated Position Output
As you can tell in Figure 2.28, the output does have a slope greater than zero at t = 0, there are no
oscillations and the output reaches a steady state, indicating a first order system. Based on the
knowledge that a first order system reaches 63.2% of its final value after 1 time constant T [6], we can
find our time constant T when the response has reached 63.2% of its final value of 100rad/s or
63.2rad/s. As shown on the same plot, red lines have been added to indicate this intersection which is
when T = 1.07s. Also, since our gain K is the steady state result divided by the gain of the open-loop step
input, our gain K is 100/4.7 or 21.3. Therefore our Plant model is:
π(π ) =
21.3
π (1.07π + 1)
Rearranging the result in Modeling Approach #1 into the same form as just derived results in:
π(π ) =
25.27
π (1.53π + 1)
Creating Bode Diagrams to compare both Plant models results in the plots shown in Figure 2.29. As you
can see, they are very close. There is a slight difference in the Phase plot but the Magnitude plot is
almost identical.
32
Figure 2.29 – Bode Diagram Comparison between Both Plant Models
Using the data collected earlier to run through our Simulink base_open_loop_model resulted in the
following plots:
Figure 2.30 - Comparison Plot of Plant Model and Actual Plant when Subjected to a Step Input
33
Figure 2.31 - Comparison Plot of Plant Model and Actual Plant when Subjected to a Ramp Input
Figure 2.32 - Comparison Plot of Plant Model and Actual Plant when Subjected to a Chirp Input
34
2.2.7.1 Conclusion
Both approaches yield acceptable models. However, with Approach #2, Transient and Steady-State
Response Analysis, was much easier and far quicker. Comparing Figures 2.20-22 and Figure 2.30-32, the
results are very similar, with neither being perfect. Since our intended purpose for this system is for
position control, we’ll proceed with the Plant model derived by Approach #2 because its step input
result is better. This concludes the System Identification portion and we’ll proceed to Controller Design.
Aside – If our Plant was a typical second order system such as:
π(π ) =
πΎ′ππ2
π 2 + 2πππ π + π€π2
(2.10)
And was underdamped, the damping ratio could be calculated from the percent overshoot (%OS) from a
step input by using [7]:
%ππ
−ππ (
)
100
π=
√π 2 + ππ2 (%ππ)
100
Furthermore, the damped natural frequency can be measured off the plot of the step response using
the equation shown below, where Δπ‘ is the time interval between two consecutive peaks [7]:
ππ =
2π
Δt
The natural frequency can then be calculated using [7];
ππ =
ππ
√1 − π 2
The DC gain K is calculated as before using [7]:
πΎ=
π π‘ππππ¦ π π‘ππ‘π π π‘ππ πππ ππππ π
ππππππ‘π’ππ ππ π π‘ππ ππππ’π‘
A similar approach can be taken using a chirp input to create a Bode Plot. See Extras: System
Identification for more information [7].
35
3.0 Controller Design – Phase 1
There are numerous techniques available, which range in complexity, to design a Controller. However,
this course is an introductory course and can’t possibly cover every technique. Instead, we’ll break our
design approach into two phases. The first phase will focus on creating a Proportional (P), Proportional
plus Derivative (PD), Proportional plus Integral (PI) and Proportional plus Derivative plus Integral (PID)
Controller using Transient Response Equations to a step input and the Root Locus method which is a
graphical method for examining how the roots or poles of a system change with variation of a certain
system parameter, commonly a gain within a feedback system [8]. As we continue to gain more
understanding, in the second phase we’ll apply Phase Lead-Lag Control and Feed Forward Control
techniques. You will notice that most of the techniques employed are for first and second order
systems. Higher order systems are beyond the scope of this course. Of course, if your career as an
engineer involves Controller design, you can add to the framework presented here. More importantly, it
is hoped that the concepts demonstrated here will give you a solid understanding and intuition into
Controller design.
It should also be mentioned that the Transient Response Equations shown in Section 3.1.1 and 3.1.2
deal strictly with time domain response to step inputs. Unfortunately, this course doesn’t have any
techniques for designing a Controller for other inputs such as a ramp or impulse, and doing a survey of
many textbooks, very few techniques exist. Since a step input involves a wide range of frequencies,
there is a good chance that a Controller designed for a step input would also react well to other inputs.
However, if you’re given only specifications that relate to inputs other than a step input, the only
technique you have is trial and error by intuition.
3.1 Proportional Control (P Control)
Presented in Figures 3.1,8,9,18 and 19 is the framework for P, PD, PI and PID Controller design based on
the curriculum taught in this course. The starting framework in Figure 3.1 attempts to find an
appropriate Proportional Controller. The system will look like this:
R(s)
I(s)
E(s)
+
∑
U(s)
P(s)
KP
.
Y(s)
-
H(s)
Figure 3.0 – System with Proportional Controller
36
Start with a Proportional
Controller
1st Order System?
Yes
Apply 1st Order Transient
Response Equation
Yes
Apply 2nd Order Transient
Response Equations
No
nd
2 Order System?
No
Order of System > 2
Apply Root Locus Method
as a Starting Point
Trial and Error
Test
Figure 3.1 – Flow Chart of Proportional Controller Design
37
Which results in the following transfer function:
π(π ) =
(3.0)
π(π )
πΎπ β π(π )
= πΌ(π ) β
π (π )
1 + πΎπ β π(π ) β π»(π )
Or the following block diagram:
R(s)
πΌ(π ) β
πΎπ β π(π )
1 + πΎπ β π(π ) β π»(π )
Y(s)
Figure 3.2 – Simplified System with Proportional Controller
3.1.1 1st Order Transient Response Equations to a Step Input
Based on the Equation 3.0, a 1st Order System without a zero with a Proportional Controller will look like
the following:
πΎ
πΎπ β (π + π )
π(π )
πΎπ πΎ β πΌ(π )
1
π(π ) =
= πΌ(π ) β
=
πΎ
π (π )
1 + πΎπ β (π + π ) β π»(π ) π + π1 + πΎπ πΎ β π»(π )
1
Or in standard form:
π(π ) =
π(π )
πΎ′π
=
π (π ) π + π
Where:
π = π1 + πΎπ πΎ β π»(π )
(3.1)
And:
πΎ ′ π = πΎπ πΎ β πΌ(π )
(3.2)
Using either the Transient Response Equation for 1% settling time to a step input [9]:
π‘π =
4.6
π
(3.3)
38
Or the Transient Response Equation for rise time for a step input [9]:
π‘π =
2.2
π
(3.4)
We can back calculate for π and then back calculate for πΎπ using Equation 3.1.
If your Plant has a zero in the numerator, temporarily ignore it and apply the above equations as a
starting point. Afterwards, iteratively tune your Controller by trial and error with the zero included.
Aside - For a first order system, no overshoot is possible, therefore ππ = 0. This is because the one
pole for a 1st order system must lie on the real axis. To have any kind of overshoot, a system must have
poles that have an imaginary component. However, since complex poles, which have an imaginary
component, only come in pairs, it’s impossible for a 1st order system to have a lone complex pole to
produce overshoot.
3.1.2 2nd Order Transient Response Equations to a Step Input
Based on the Equation 3.0, a 2nd Order System without a zero with a Proportional Controller will look like
the following:
πΎ
πΎπ β (
)
π(π )
πΎπ πΎ β πΌ(π )
(π + π1 )(π + π2 )
π(π ) =
= πΌ(π ) β
= 2
πΎ
π (π )
1 + πΎπ β (
) β π»(π ) π + (π1 + π2 )π + (π1 π2 + πΎπ πΎ β π»(π ))
(π + π1 )(π + π2 )
Or in standard form:
π(π ) =
π(π )
πΎ ′ ππ2
= 2
π (π ) π + 2πππ π + ππ2
Where:
ππ2 = π1 π2 + πΎπ πΎ β π»(π )
(3.5)
2πππ = π1 + π2
(3.6)
πΎ ′ ππ2 = πΎπ πΎ β πΌ(π )
(3.7)
And:
And:
39
Depending on which specifications are given, use the following Transient Response Equations for a step
input [11]. For the rise time:
π‘π =
1.8
ππ
(3.8)
For an underdamped system, the percentage of overshoot:
2
ππ = π −ππ⁄√1−π , 0 ≤ π < 1
(3.9)
Which occurs at the peak time of:
π
ππ
π‘π =
(3.10)
Where:
ππ = ππ √1 − π 2
(3.11)
For a 1% settling time:
4.6
π
(3.12)
π = πππ
(3.13)
π‘π =
Where:
Im(s)
Im(s)
Im(s)
π = π ππ−1 π
π
ππ
Re(s)
Re(s)
Re(s)
Figure 3.3 – Graphs of Regions in the S-Plane for Rise Time, Overshoot and 1% Settling Time
Respectively for a Step Input [11]
40
Shown in Figure 3.3 are the graphs of regions in the s-plane that are produced by the aforementioned
Transient Response Equations for rise time, overshoot and 1% settling time for a step input.
For an undamped and underdamped 2nd order system, the resulting poles will be at:
π 1,2 = −π ± πππ
π€βππ 0 ≤ π < 1
For a critically damped 2nd order system, both poles will be at:
π 1,2 = −π
π€βππ π = 1
For an overdamped 2nd order system, both poles will be unique but lie on the Real axis.
If your Plant has one or more zeros in the numerator, temporarily ignore it/them and apply the above
equations as a starting point. Afterwards, iteratively tune your Controller by trial and error with the
zero(s) included. Know that a zero in the Left Half Plane (LHP) of the s-plane will increase the overshoot
to a step response if the zero is within a factor of 4 of the real part of the complex poles, and a zero in
the RHP will suppress the overshoot but may cause the step response to start out in the wrong direction
[12].
Note 1 – For the derivations in Sections 3.1.1 and 3.1.2, it was assumed that I(s) and H(s) were strictly
gains.
Note 2 - It should be noted that these equations are qualitative guides and not precise design formulas.
They are meant as a starting point for design iteration [10]. For tuning the Controller for a 2nd Order
System, if the system is responding too slow, increase the natural frequency ππ . If there is too much
overshoot, increase the damping coefficient π. If the transients persist too long, move the pole π left in
the s-plane. [9].
Note 3 – If you are given 1 specification to a step input, using the Transient Response Equations for a
second order system will result in one unique value for πΎπ . If you have been given 2 specifications to a
step input, each will produce a value for πΎπ and it most cases, each value will be unique and produce
transient responses that do not satisfy both specifications. If you were to combine specifications and
combine the regions shown in Figure 3.3, you will get a unique set of poles to meet the specifications.
However, there is a good chance that a Proportional Controller will not be able to produce that desired
result. This can be verified by plotting the system’s Root Locus.
41
3.1.3 Root Locus Method
As mentioned earlier, the Root Locus Method is a technique that shows how change in one system
parameter will modify the roots of the system’s characteristic equation. It’s a powerful technique that
can be used for any order of system comprised of both poles and zeros where the number of poles is
equal to or greater than the number of zeros. The only stipulation is that only one parameter can be
modified at one time. It’s beyond the scope of this guide to go into the details of drawing a Root Locus
by hand. Instead, we’ll focus on some of the equations derived from the formation of a Root Locus and
how to use Matlab to expedite the drawing process.
As shown in Figure 3.4, the typical focus of the Root Locus method are the elements inscribed within the
red box. It consists of the Controller πΎπ , the Plant P(s) and the Feedback Transfer Function H(s). It
should be noted that this method can be applied to any variable within a system but in this course, we’ll
only focus on Controller variables.
R(s)
I(s)
E(s)
+
∑
P(s)
KP
.
Y(s)
-
H(s)
Figure 3.4 – Focus of Typical Root Locus Shown in Red
This results in the characteristic equation of:
1 + πΎπ π(π ) β π»(π ) = 0
(3.14)
And if you vary πΎπ from zero to infinity, you will create the system’s Root Locus.
Breaking Equation 3.14 into its complex components you have the equation for the magnitude:
|πΎπ π(π ) β π»(π )| = 1
(3.15)
< πΎπ(π ) β π»(π ) = ±180°(2π + 1)
(3.16)
And the angle:
42
Or:
π
∑π
π=1 < (π + π§π ) + ∑π=1 < (π + ππ ) = ±180°(2π + 1)
(3.17)
Where:
k = # of poles − # of zeros − 1
(3.18)
And for a pole or zero with the form π = π + ππ, the angle is computed using the following:
π
< π = tan−1 ( )
π
(3.19)
When using the Root Locus method for a multi-order system, this technique will only help you to
visualize the system and how it changes with different values of πΎπ . This will allow you to see which
values of πΎπ produce a stable system whereby the system’s poles exist in the LHP but it will not allow
you to estimate its performance characteristics such as rise time, overshoot and settling time. These
features can only be determined by simulation in Simulink or testing on the physical system.
Aside - When using the Root Locus function rlocus(sys) in Matlab, keep in mind that:
π π¦π = π(π ) ∗ π»(π )
3.1.4 A Note on Higher-Order Systems
In some instances, it may be possible to temporarily reduce the order of the system to second order by
ignoring some of the system’s poles if they are much larger and less dominant than two of the slower
poles. Unlike the method of Model Reduction mentioned earlier where you replace high frequency
poles and zeros with a DC gain, you are temporarily ignoring them so that you can then use the 2nd order
Transient Response Equations shown earlier to give you a starting point. However, trial and error are
required to further tune the Controller when the other poles are reintroduced. Keep in mind that an
additional pole in the LHP will increase the rise time to a step response significantly if the extra pole is
within a factor of 4 of the real part of the complex poles [12].
43
3.1.5 Test
If the Proportional Controller meets the specifications given you can skip to the Section 5.0, Controller
Validation. Following Figure 3.8, if the Proportional Controller produces too much overshoot, proceed
to Proportional plus Derivative Control. If your Controller produces too much steady state error, skip to
Proportional plus Integral Control. If instead your Controller produces too much overshoot and steady
state error, skip to PID Control.
3.1.6 Example Continued – P Controller Design
As mentioned in Section 2.2, the desired performance specifications for this system are:
1) Maximum overshoot of 5% for a unit step input.
2) Rise time of 0.1s for a unit step input.
3) Zero steady-state error to a unit step input.
Since we have reduced our Plant Transfer Function to a second order system, and because a
Proportional Controller does not add a pole or zero to our closed-loop transfer function, we can apply
the 2nd Order Transient Response Equations presented in Section 3.1.2. But first we need to rearrange
our Plant Transfer Function to look like the following:
π(π ) =
πΎ
(π + π1 )(π + π2 )
Therefore our Plant Transfer Function, in the above form is:
π(π ) =
19.9
(π + 0)(π + 0.935)
3.1.6.1 π²π· Calculation Based on Overshoot Specification
We could try to rearrange Equation 3.9 to find the damping coefficient, but fortunately someone else
already did this and created a graph of this relationship. Using Figure 3.23 on page 118 of Feedback
Control of Dynamic Systems [11], a 5% overshoot results in a damping coefficient of:
π = 0.7
Rearranging Equation 3.6 for ππ results in:
ππ =
π1 + π2
2π
(3.20)
44
By substituting our values for π1 , π2 and π into Equation 3.20 results in:
ππ =
0 + 0.935
= 0.67 πππ/π
2(0.7)
Rearranging Equation 3.5 for πΎπ results in:
πΎπ =
ππ2 − π1 π2
πΎ β π»(π )
(3.21)
By substituting our values for ππ , π1 , π2 , πΎ and π»(π ) into Equation 3.21 results in:
πΎπ =
(0.67)2 − (0)(0.935)
π
= 7.04π₯10−5
19.9(318.3)
πππππππ πππ’ππ‘π
In order to test this result, I’ve created a Simulink model called base_closed_loop_model and added the
model elements particular to this example. I then setup a unit step input to inject into our model to see
the result. Shown in Figure 3.5 is a very smooth but slow response to a step input. Though it meets our
overshoot specification of 5%, it in no way comes close to our target rise time of 0.1s. Let’s apply the 2 nd
Order Transient Response Equations for rise time and compare.
Figure 3.5 – Unit Step Response for KP of 7.04x10-5
45
3.1.6.2 π²π· Calculation Based on Rise Time
Rearranging Equation 3.8 for ππ results in:
ππ =
1.8
π‘π
(3.22)
And substituting our value for π‘π into Equation 3.22 results in:
ππ =
1.8
= 18 πππ/π
0.1
And substituting our values for ππ , π1 , π2 , πΎ and π»(π ) into Equation 3.21 results in:
πΎπ =
(18)2 − (0)(0.935)
π
= 0.051
19.9(318.3)
πππππππ πππ’ππ‘π
Substituting this new value for πΎπ into our Simulink model resulted in the unit step response shown in
Figure 3.6. Yikes!
Figure 3.6 – Unit Step Response for KP of 0.051
46
3.1.6.3 π²π· Calculation for Zero Steady-State Error
Fortunately no calculation is required to find our system’s steady-state error. Since our system is a Type
1 system, and because it has one integrator term in the denominator, it inherently has zero steady-state
error for a step input regardless of the Controller chosen.
Aside – For more information on system Types and Steady-State Error Design, see Section 3.5.
3.1.6.4 Conclusion
We can only meet 2 of the 3 Design Specifications. As expected, the overshoot and rise time
specification conflict with each other. Out of interest I plotted the Root Locus using Matlab to see what
is really going on. As you can see from Figure 3.7, as you increase the value for ππ greater than 0.4675,
the value for πdecreases, so when we tried to decrease our rise time by increasing ππ , the value for
πdecreased creating a no-win situation.
Figure 3.7 – Root Locus of our Plant
To further understand why the Proportional Controller failed, let’s use the damping ratio of 0.7 that
results from the overshoot specification and the natural frequency of 18 rad/s that results from the rise
time specification to calculate the desired closed-loop poles where:
π π1,2 = −π ± πππ = −πππ ± πππ √1 − π 2
(3.23)
47
π π1,2 = −12.6 ± π12.85
This produces the same result as combining the regions shown in Figure 3.3 to create a unique set of
poles. It should be obvious by our Root Locus, as shown in Figure 3.7, that no value for πΎπ will intersect
with these locations.
Since we met our steady-state specification, we’ll try a Proportional plus Derivative Controller.
3.2 Proportional plus Derivative Control (PD Control)
Following Figure 3.8, if your Proportional Controller produces too much overshoot but the steady state
error is acceptable, apply Proportional plus Derivative Control as shown in Figure 3.9. As a starting
point, apply the 2nd Order Transient Response Equations. If you’ve been given 1 time domain
specification to a step input you will end up with a region as in Figure 3.3 or if you’ve been given 2 time
domain specifications to a step input you can calculate ππ and π in order to calculate the desired closedloop poles with Equation 3.23. If you have a second order system and you’ve been given 2 time domain
specifications for a step input and there are no zeros in your Plant, apply Coefficient Mapping otherwise
apply Root Contour Iteration. Keep in mind that both of these methods will not produce the desired
Controller after one iteration. It is meant as a starting point to an iterative approach driven by intuition
and trial and error.
No
Too much Overshoot?
Apply Proportional plus
Integral Control
Yes
Too much Steady
State Error?
No
Apply Proportional plus
Derivative Control
Yes
Apply PID Control
Figure 3.8 – Flowchart for PI, PD and PID Controller Design
48
nd
Apply 2 Order Transient
Response Equations as a
Starting Point
Yes
Order = 2?
2 Specifications
Given and No Zero in
Plant?
No
Apply Root Contour
Iteration
Yes
No
Apply Root Contour
Iteration
Apply Coefficient
Mapping
Test
Trial and Error
Figure 3.9 – Flowchart for PD Controller Design
3.2.1 Coefficient Mapping
Coefficient Mapping is a simple method to find Controller gains whereby you compare the terms of the
characteristic equation of a second order system with like terms of the polynomial of the desired closedloop poles. From the generic system model we have the following characteristic equation:
1 + πΆ(π ) β π(π ) β π»(π ) = 0
(3.24)
Where a PD Controller is:
πΆ(π ) = πΎπ + πΎπ· π
49
And for a normalized 2nd order system without any zeros:
π(π ) =
π(π )
πΎ
= 2
π·(π ) π + π1 π + π0
And the Feedback Transfer Function is assumed to be a gain, where:
π»(π ) = π»1
We now can rearrange Equation 3.24 to look like the following:
π·(π ) + π»1 (πΎπ + πΎπ· π ) β π(π ) = 0
And if we substitute our equations we get:
π 2 + (π1 + π»1 πΎπ· πΎ)π + (π0 + π»1 πΎπ πΎ) = 0
(3.25)
Which we can equate to our desired closed-loop poles of:
π π1,2 = −π ± ππ
We get:
π 2 + (π1 + π»1 πΎπ· πΎ)π + (π0 + π»1 πΎπ πΎ) = (π + π + ππ)(π + π − ππ) = π 2 + 2ππ + (π2 + π 2 )
Now if we match coefficients, we get the following equations:
π1 + π»1 πΎπ· πΎ = 2π
π0 + π»1 πΎπ πΎ = π2 + π 2
(3.26)
(3.27)
And rearranging Equations 3.26 and 3.27 will give us our gains for our PD Controller.
3.2.2 Root Contour Iteration
Root Contour Iteration is an iterative approach to applying Root Locus methods. It’s best suited for
situations where you have one or two or (at most) three parameters that you want to vary, i.e. in a PID
Controller. The basic idea is to successively hold all but one of the parameters in the Controller
constant, and vary the one parameter that is not fixed via a Root Locus plot to see the effect on the
desired closed-loop region or poles. The parameter that was varied is then fixed, and another
parameter is varied in the same way. This process continues until your Root Locus intersects with the
desired closed-loop region or poles [13].
50
3.2.3 Trial and Error
Both Coefficient Mapping and Root Contour Iteration will get you into the ball park but will not directly
get you to the Controller you want. However, with experience you can take the results of an iteration
and apply your intuition to move the desired closed-loop region or poles to improve system response.
3.2.4 Example Continued – PD Controller Design
Since our P Controller produced too much overshoot but the steady error specification was met, let’s try
a PD Controller. Fortunately, since we have a second order Plant with no zeros and a have been given 2
time domain specifications to a step input we have two methods available. We’ll start with Coefficient
Mapping and then try Root Contour Iteration to verify our results.
3.2.4.1 PD Controller Design Approach #1 - Coefficient Mapping
In Section 3.1.6.4 we calculated our desired closed-loop poles as:
π π1,2 = −12.6 ± π12.85
Following the instructions in Section 3.2.1, we get the following characteristic equation:
π 2 + (0.935 + (318.3)πΎπ· (19.9))π + (0 + (318.3)πΎπ (19.9)) =
π 2 + (0.935 + 6336.3πΎπ· )π + 6336.3πΎπ
Which we’ll equate with our desired characteristic equation:
(π + 12.6 + π12.85)(π + 12.6 − π12.85) = π 2 + 25.2π + 324
By using Equation 3.26 and rearranging for πΎπ· we get:
πΎπ· =
2π − π1 2(12.6) − 0.935
πβπ
=
= 3.83π₯10−3
π»1 πΎ
318.3(19.9)
πππππππ πππ’ππ‘π
By using Equation 3.27 and rearranging for πΎπ we get:
π2 + π 2 − π0 (12.6)2 + (12.85)2 − 0
π
πΎπ =
=
= 0.051
π»1 πΎ
318.3(19.9)
πππππππ πππ’ππ‘π
Which gives us the following PD Controller:
πΆ(π ) = πΎπ + πΎπ· π = 0.051 + 3.83π₯10−3 π
51
3.2.4.2 PD Controller Design Approach #2 – Root Contour Iteration
1st Iteration - Since there is no defined starting point for this method, I’ll arbitrarily set πΎπ to 1 and vary
πΎπ· . This results in the following characteristic equation:
π 2 + (0.935 + (318.3)πΎπ· (19.9))π + (0 + (318.3)(1)(19.9)) = π 2 + (0.935 + 6336.3πΎπ· )π + 6336.3
Now if we arrange our characteristic equation into the following form:
1+πΎβ
π(π )
=0
π(π )
We get:
1 + 6336.3πΎπ· β
π 2
π
=0
+ 0.935π + 6336.3
Using Matlab’s rlocus(sys) function make sure that:
π π¦π =
π(π )
π
= 2
π(π ) π + 0.935π + 6336.3
Doing so we get the Root Locus plot shown in Figure 3.10 where I’ve found the closest points of
intersection. Note the desired closed-loop poles in red.
Figure 3.10 – Root Locus Plot with π²π· = 1 and π²π« Varied
52
Note that both the positive and negative real components of our desired closed loop poles result in
approximately the same gain value of:
πΎ = 24.4
And this produces a Derivative gain value of:
πΎπ· =
24.4
πβπ
= 3.85π₯10−3
6336.3
πππππππ πππ’ππ‘π
2nd Iteration - Now let’s set πΎπ· to 3.85x10-3 and vary πΎπ . . This results in the following characteristic
equation:
π 2 + (0.935 + (318.3)(3.85π₯10−3 )(19.9))π + (0 + (318.3)πΎπ (19.9)) = π 2 + 25.2π + 6336.3πΎπ
Or:
1 + 6336.3πΎπ β
π 2
1
=0
+ 25.2π
Using Matlab’s rlocus function where:
π π¦π =
1
π 2 + 25.2π
We get the Root Locus plot shown in Figure 3.11. As you can see, this Root Locus plot goes through our
desired closed-loop poles, which are estimated by Matlab to produce 4.57% of overshoot with a
damping ratio of approximately 0.7 and natural frequency of 18rad/s. Our gain for these points is found
to be:
πΎ = 323
Which results in the Proportional gain of:
πΎπ =
323
π
= 0.051
6336.3
πππππππ πππ’ππ‘π
And the following PD Controller:
πΆ(π ) = πΎπ + πΎπ· π = 0.051 + 3.85π₯10−3 π
53
Figure 3.11 – Root Locus Plot with π²π« = 3.85x10-3 and π²π· Varied
3.2.5 Conclusion
As expected, both methods produced almost identical gains for our PD Controller. Now let’s test our
Controller. By modifying the Simulink model called base_closed_loop_model created earlier I got the
results shown in Figure 3.12. I also added the 2nd order approximation as a means of comparison.
Figure 3.12 - Unit Step Response for PD Controlled System and 2nd Order Approximation
54
With respect to our PD Controller, the result shown in yellow in Figure 3.12 shows 20% overshoot but a
rise time of 0.05s. This leads us to ask why our rise time is easily met but our overshoot is off when we
designed our PD Controller to match the characteristics of our desired closed-loop poles. The short
answer is that we didn’t factor in the result of our added zero by the addition of the Derivative term.
Looking at the poles and zeros of our closed-loop system we get:
P1 and P2 @ -12.6 ± j12.82 and Z1 @ -13.32
As you’ll notice, the real portion of the poles and the zero are very close which would account for
greater overshoot. As mentioned previously in Section 3.1.2, any additional zero within a factor of 4 of
the real component of the nearest pole will have a noticeable effect. Comparing the rise times between
the PD controlled system with the result of the 2nd order approximation, the PD controlled system is
much quicker, which is a nice bonus of the additional zero.
With respect to the 2nd order approximation results, you’ll notice that the overshoot specification is met
but the rise time is not. As mentioned previously, the 2nd Order Transient Response equations are an
approximation and we’re noticing this inaccuracy. You’ll also notice that we now have a steady state
error which was not there previously. Why is that? It’s because our 2nd order approximation, with its
two complex poles has lost its zero in the denominator, reducing it to a Type 0 system.
3.2.6 Reality Check - Saturation
Digging a little deeper into our model highlights a problem with the physical limits of our system.
Figure 3.13 – System Model
55
However, before I get into the problem, let me first explain the system model shown in Figure 3.13. I’ve
created 3 separate models that get routed through a multiplexer to be plotted on the same graph. One
of the quirks I found in Matlab is that a function block has to be proper. That means that the order of
the denominator must be equal or greater than the order of the numerator. This means that you can’t
implement a PD or PID Controller using a function block. To work around this, in the top model I
switched the numerator of the Plant with the numerator of the Controller. A little confusing but it
works. However, it creates another problem in that I can’t monitor the Controller Output Signal U(s).
To work around this I created a second model using Matlab’s PD Controller transfer function. Now I’m
sure you’re going to ask ‘Why didn’t I use it in the first place dummy?’. I would have liked to but Matlab
implements their PD Controller using the following equation:
ππ· πΆπππ‘ππππππ = π + π·
π
1+π
1
π
Searching the documentation they call their Derivative implementation a ‘Filtered Derivative’ where N
determines the pole location. This high-pass filter is used to get around the original quirk I found where
the transfer function has to be proper. (This kind of Filtered Derivative is also called a Phase Lead
Controller. See Section 4.3 for more information.) I was able to achieve matching results between the
top two models when I set N to 1000, which puts the pole at 1000rad/s and well outside the system’s
bandwidth. (For more information in system bandwidth see Section 5.1.1) Now that the second model
works I was able to add a scope after the PD Controller function block and found the following:
Figure 3.14 – Controller Output Signal Response from Unit Step Input
56
It may be a little hard to tell by Figure 3.14 but the Controller Output Signal initially jumps to 1400V then
settles out to something a little more reasonable. Realistically though, we don’t have a power supply
that could source the lethal voltage of 1400V. Furthermore, even if we could find that kind of power, it
would surely fry the motor controller and the motor itself. For our tests we’ve been running the motor
off a 12V power supply so to model this physical limitation, as shown in Figure 3.15, I’ll add a saturation
block after the Controller.
Figure 3.15 – Saturation Block in Simulink Model
As shown in the plot from the scope placed after the saturation block in Figure 3.16, the voltage
supplied to the Plant is now limited to ±12V.
Figure 3.16 - Controller Output Signal Response After Saturation Block from Unit Step Input
However, as shown in Figure 3.17, the addition of the saturation block has a drastic effect on our
system’s performance (shown in purple). Our system response to a step input with the addition of the
saturation block now resembles the 2nd order approximation in that the overshoot is close to our
specification but the rise time is quite sluggish. What do we do next?
57
3.2.7 Trial and Error
Our first stab at developing a PD Controller was close but still needs some tweaking, but how? Since our
most salient problem seems to be rise time, and since we know from Figure 3.3 the rise time is governed
by the system’s natural frequency, let’s keep our damping frequency the same and increase ππ . By
increasing the natural frequency arbitrarily to 25 rad/s we get the following desired closed-loop poles:
π π1,2 = −πππ ± πππ √1 − π 2 = −0.7(25) ± π25√1 − (0.7)2 = −17.5 ± π17.8
Figure 3.17 – Unit Step Response of PD Controlled System Without Saturation Block, With Saturation
Block and 2nd Order Approximation Without Saturation Block
Using Equation 3.26 and rearranging for the Derivative gain we get:
πΎπ· =
2π − π1 2(17.5) − 0.935
πβπ
=
= 5.4π₯10−3
π»1 πΎ
318.3(19.9)
πππππππ πππ’ππ‘π
And using Equation 3.27 and rearranging for the Proportional gain we get:
πΎπ =
π2 + π 2 − π0 (17.5) + (17.8)2 − 0
π
=
= 0.1
π»1 πΎ
318.3(19.9)
πππππππ πππ’ππ‘π
And the following PD Controller:
πΆ(π ) = πΎπ + πΎπ· π = 0.1 + 5.4π₯10−3 π
58
As shown in Figure 3.18, our new PD Controller, shown in purple, meets all our specifications with an
overshoot of 3.7% and a rise time of 0.9s. You’ll also notice that it has zero steady-state error for a step
input. The next step is to validate our Controller by implementing it on our physical system and then to
look into its stability. However, before we do that let’s talk about PI and PID control and then look into
Phase Lead/Lag Controller Design and Feedforward Design.
Figure 3.18 – Unit Step Response of PD Controlled System Without Saturation Block, With Saturation
Block and 2nd Order Approximation
3.3 Proportional plus Integral Control (PI Control)
Following Figure 3.8, if your Proportional Controller produces too much steady state error but the
overshoot is acceptable, apply Proportional plus Integral Control as shown in Figure 3.19. Since a PI
Controller adds both a zero and a pole to the closed-loop transfer function, our 2nd 0rder Transient
Response Equations do not directly apply; however, they can be used as a starting point. If you’ve been
given 1 time domain specification to a step input you will end up with a region or if you’ve been given 2
time domain specifications to a step input you can calculate ππ and π in order to calculate the desired
closed-loop poles with Equation 3.23. If you have a first order system and you’ve been given 2 time
domain specifications for a step input and there are no zeros in your Plant, apply Coefficient Mapping
otherwise apply Root Contour Iteration. Keep in mind that both of these methods will not produce the
desired Controller after one iteration. It is meant as a starting point to an iterative approach driven by
intuition and trial and error.
59
3.3.1 Integral Windup
One of the unique side effects from the addition of the Integral term is something called Integral
Windup. This applies to both PI and PID Controllers. Because the Integral term accumulates the error
between the desired reference and the actual output, when a large change in set-point occurs, the
output will continue to overshoot until the error accumulated before reaching the set-point equals the
error accumulated while exceeding the set-point. There are many techniques to combat this
phenomenon but they’re beyond the scope of this course.
nd
Apply 2 Order Transient
Response Equations as a
Starting Point
Yes
Order = 1?
2 Specifications
Given and No Zero in
Plant?
No
Apply Root Contour
Iteration
Yes
No
Apply Root Contour
Iteration
Apply Coefficient
Mapping
Test
Trial and Error
Figure 3.19 – Flowchart for PI Controller Design
60
3.4 Proportional plus Integral plus Derivative Control (PID Control)
Following Figure 3.8, if your Proportional Controller produces too much steady state error and too much
overshoot, apply Proportional plus Integral plus Derivative Control as shown in Figure 3.20. Since a PID
Controller adds a zero and two poles to the closed-loop transfer function, our 2nd order Transient
Response Equations do not directly apply; however, they can be used as a starting point for Root
Contour Iteration. Keep in mind that this method will not produce the desired Controller after one
iteration. It is meant as a starting point to an iterative approach driven by intuition and trial and error.
Aside - For another technique on tuning a PID Controller, try the Zeigler-Nichols Method.
nd
Apply 2 Order Transient
Response Equations as a
Starting Point
Apply Root Contour
Iteration
Test
Trial and Error
Figure 3.20 – Flowchart for PID Controller Design
61
3.5 Steady State Error Design
Using the Final Value Theorem we can calculate the Steady State Error, as shown below:
ππ π = lim π(π‘) = lim π πΈ(π ) = lim π [ π (π )πΌ(π ) − π»(π )π(π )]
π‘→∞
π →0
π →0
ππ π = lim π π (π )πΌ(π ) [1 −
π →0
ππ π = lim π π (π )πΌ(π ) [
π →0
π»(π ) πΆ(π )π(π )
]
1 + πΆ(π )π(π )π»(π )
1
]
1 + πΆ(π )π(π )π»(π )
Fortunately, this type of calculation is quite common and a table based on system Type for common
inputs is available. As shown in Table 3.0 we have the Steady State Errors for Step inputs, Ramp Inputs
and Parabola inputs based on the system Type. The system Type is based on the total number of poles
at the origin or integrator terms in the Controller C(s), the Plant P(s) and the Feedback Transfer Function
H(s).
System Type
Step Input
Ramp Input
πΌ(0)
1 + πΆ(0)π(0)π»(0)
Type 0
Type 1
0
Type 2
0
Parabola Input
∞
∞
πΌ(0)
πΆ(0)π(0)π»(0)
∞
0
πΌ(0)
πΆ(0)π(0)π»(0)
Table 3.0 – Steady State Errors as a Transfer Function Type
62
4.0 Controller Design – Phase 2
Now that we’ve had a chance to try our hand at different forms of PID Controllers, let’s try some more
advanced techniques. First, let’s try Phase Lead/Lag Controllers
4.1 Phase Lead/Lag Controllers
Interestingly, a Phase Lead Controller is much like a PD Controller in that it acts to speed up response
and increasing stability by shifting the Root Locus to the left. Furthermore, a Phase Lag Controller is
much like a PI Controller in that it attempts to eliminate steady-state error by shifting the Root Locus to
the right.
For myself, I like to think of Phase Lead/Lag Controllers as hybrid Controllers. In the case of a Phase
Lead Controller, we start with the following general equation but set p greater than z:
πΆπΏπππ/πΏππ (π ) =
π +π§
π +π
If we arbitrarily set z equal to 1 and p equal to 10 and compare it to a PD Controller with unity gains we
get the following Bode Diagram:
PD Controller
Phase Lead Controller
Figure 4.0 – Bode Diagram of Phase Lead Controller vs PD Controller
63
When comparing the Bode Diagrams in Figure 4.0 you’ll notice that both Magnitude plots start to ramp
at 20dB per decade at 1rad/s or the location of the zero. However, because of the pole in the
denominator of the Phase Lead Controller, its Magnitude plot levels off at 10rad/s where the Magnitude
plot for the PD Controller continues to ramp indefinitely. You’ll also notice one of the drawbacks of the
Phase Lead Controller in the reduction in magnitude at low frequencies. Furthermore, the Phase Lead
Controller produces a hump in its Phase plot centered in between its zero and pole locations, starting at
0 degrees and ending at 0 degrees where the Phase plot for the PD Controller starts at 0 degrees and
ramps up to 90 degrees where it levels off. The length, height and centre point of this hump is the focus
of Phase Lead Controller design in the effort to increase Phase Margin.
Conversely, a Phase Lag Controller produces a valley centered about its zero and pole locations (Figure
4.1). This is the consequence of having z greater than p. This valley is actually the main drawback of
Phase Lag Controller design. Instead, the focus of Phase Lag Controller design is to balance the sideeffects of the phase lag distortion by appropriately designing the size and location of this valley in order
to boost the gain of the system at low frequencies, thereby improving steady-state tracking
performance and disturbance rejection. As shown in Figure 4.1, both Controllers boost low frequency
gain.
PI Controller
Phase Lag Controller
Figure 4.1 – Bode Diagram of Phase Lag Controller vs. PI Controller
64
4.1.2 Introduction to Gain and Phase Margins
The concept of Gain and Phase Margins are best explained with the use of an example. Consider the
following closed-loop system:
R(s)
1.5
+
∑
1
π +1
π 2
2
+ 2π + 1
.
Y(s)
-
1.5
Figure 4.2 – Block Diagram of Example Closed-Loop System
Using Matlab’s margin(sys) function for an open-loop system where:
π π¦π = πΌ(π ) β πΆ(π ) β π(π )
And for our example:
π π¦π = 1.5 β
1
2
β 2
π + 1 π + 2π + 1
We get the Bode Diagram shown in Figure 4.3. Matlab tells us that the Gain Margin is 8.52dB at the
Phase Crossover Frequency πππ of 1.73rad/s and I’ve added an arrow to indicate this. The Gain Margin
is calculated using the following equation:
πΊπππ ππππππ = 0ππ΅ − πΊπππ
Where Gain is the distance between the curve and 0dB at the Phase Crossover Frequency πππ . Notice
that if the Gain Margin is below 0dB at the Phase Crossover Frequency the Gain is negative resulting in a
positive Gain Margin and if it’s above 0dB the Gain is positive, resulting in a Gain Margin that’s negative.
If the Phase plot never dips below -180°, the Gain Margin is considered to be infinite.
Matlab has also calculated our Phase Margin to be 41.7° at the Gain Crossover Frequency πππ
of 1.04 rad/s and I’ve added an arrow to indicate this. The Phase Margin is calculated using the
following equation:
πβππ π ππππππ = 180° + πβππ π
Where Phase is the value of the curve at the Gain Crossover Frequency πππ . Notice that if the Phase
Margin is above -180° the Phase Margin is positive and if the Phase Margin is below -180° the Phase
Margin is negative. If the Magnitude plot never dips below 0dB, the Phase Margin is considered to be
infinite.
65
πππ
Phase Margin
Gain Margin
πππ
Figure 4.3 – Bode Diagram of Example Closed-Loop System
When designing a Controller, the conservative rule of thumb for stability margins are:
πΊπππ ππππππ ≥ 10ππ΅ and
πβππ π ππππππ ≥ 60°
However, some texts promote typical stability margins as low as:
πΊπππ ππππππ ≥ 6ππ΅ and
πβππ π ππππππ ≥ 30°
The idea behind the Gain and Phase Margins are that they provide a factor of safety. If you were
walking along the a cliff, would you feel comfortable with walking right along the edge, or would say 10
feet from the edge make you feel more comfortable? With experience you’ll know when you can get
away with less conservative stability margins but for now it would probably be wise to stick with the
conservative approach.
66
4.1.3 Phase Lead Controller Design
Following Figure 4.4, if your Proportional Controller produces too much overshoot but the steady state
error is acceptable, apply Phase Lead Control.
No
Apply Phase Lag Control
Too much Overshoot?
Yes
Too much Steady
State Error?
No
Apply Phase Lead
Control
Yes
Apply Phase Lead and
Lag Control
Figure 4.4 – Flowchart for Phase Lead/Lag Controller Design
Following the procedure laid out by Prof. Dan Davison in his SYDE 352 Course Notes [13], our objective is
to satisfy the specifications using:
πΆ(π ) = πΎ β πΆπΏπππ (π ) = πΎ
1 1 + πππ
√π 1 + ππ
(4.0)
Where:
K = Controller gain
a = ratio of pole position to zero positon (a > 1)
T = pole time constant (T > 0)
67
Which results in the following Bode Diagram:
20πππ10 √π
0
-20πππ10 √π
ππ
0
1
ππ
ππ
1
π
Figure 4.5 – Bode Diagram of General Phase Lead Controller
Step 1: Sketch the Bode plot of the open-loop system. As shown in Figure 2.0, our open-loop system
will consist of:
πππ = πΌ(π ) β πΆ(π ) β π(π )
Where:
πΆ(π ) = 1
Step 2: If a desired Gain Crossover Frequency πππ is known, adjust the gain K so that the Gain Crossover
Frequency of KβP(s) is equal to the desired Gain Crossover frequency. Accomplish this by trial and error
with Matlab’s margin function or by inspection of the Bode Diagram and convert the value in dB using
the following equation:
πΎ = 10
(
ππ΅ π£πππ’π
)
20
68
Set:
ππ = πππ
OrUsing the Final Value Theorem, calculate the gain K to meet the steady-state error specification and add
a buffer of 10dB in anticipation of the decrease in gain that will result from the Lead Controller.
Set:
ππ = πππ
OrIf no specifications are given that the gain can influence, set:
πΎ = 1 πππ ππ = πππ
Step 3: Determine the Phase Margin of the augmented open-loop system where:
π π¦π = πΌ(π ) β πΎ β π(π )
Step 4: Determine the additional phase lead ππ required to meet the Phase Margin required. If no
Phase Margin has been specified, use the following approximation to determine the desired Phase
Margin for a Second Order System:
πππ ≈ 100π,
π€βπππ 0 ≤ π ≤ 0.7
Or the rule of thumb of:
πππ ≥ 60°
If the phase lead ππ is greater than 60Μ°, using two Phase Lead Controllers, each contributing ππ /2.
Step 5: Use the phase lead ππ to compute the ratio of the pole position to the zero position by:
π=
1 + π ππππ
1 − π ππππ
(4.1)
Step 6: Compute the pole time constant using:
π=
1
ππ √π
(4.2)
Step 7: Test to see if specifications are met. If not, go back to Step 1.
69
4.1.4 Example Continued – Phase Lead Controller Design
Since our P Controller produced too much overshoot but the steady-state error specification was met,
let’s try a Phase Lead Controller. Following the procedure laid out in Section 4.1.3, our first step is to
plot the Bode Diagram of our open-loop system. As shown in Figure 4.6, we have a:
πΊπππ ππππππ = ∞ and
πβππ π ππππππ = 0.676° @79.2πππ/π
Figure 4.6 – Bode Diagram of Open-Loop Example System
Clearly our Phase Margin needs some adjustment. Since a Gain Crossover Frequency has not been given
and our steady-state error for a step input has been satisfied by our Type 1 system, we’ll set:
πΎ = 1 and
ππ = πππ = 79.2πππ/π
Since we have a K value of 1, the augmented Phase Margin is the same as our original Phase Margin of:
πβππ π ππππππ = 0.676°
70
Since our Plant is second order, we can use the damping ratio based on the percentage of overshoot to
calculate our desired Phase Margin of:
πππ ≈ 100π = 100(0.7) = 70°
Therefore our additional phase lead required is:
ππ = πππ − ππ = 70° − 0.676° = 69.324°
However, this additional phase lead is greater than 60°, so we’ll have to design for two Controllers, each
contributing half the additional phase lead of:
ππ =
69.324°
= 34.662°
2
Using Equation 4.1 we can compute the pole/zero ratio.
π=
1 + π ππππ 1 + sin(34.662)
=
= 3.64
1 − π ππππ 1 − π ππ(34.662)
Using Equation 4.2 we can compute the pole time constant.
π=
1
ππ √π
=
1
79.2√3.64
= 6.62π₯10−3 π ππππππ
Using the parameters just calculated, we get the following Phase Lead Controller:
πΆ(π ) = πΎ
1 1 + πππ
1 1 + 3.64(6.62π₯10−3 )π
1 + 0.024π
= (1)
= 0.52
−3
1 + 6.62π₯10 π
1 + 6.62π₯10−3 π
√π 1 + ππ
√3.64
However, since we had to create two equal Controllers to get the additional phase lead required we’ll
put them in series like this:
πΆ(π ) = 0.52
1 + 0.024π
1 + 0.024π
β 0.52
−3
1 + 6.62π₯10 π
1 + 6.62π₯10−3 π
Or:
πΆ(π ) = 0.25
1 + 0.024π
1 + 0.024π
β
−3
1 + 6.62π₯10 π 1 + 6.62π₯10−3 π
By modifying the Simulink model called base_closed_loop_model created earlier, I tested our Phase
Lead Controller versus the PD Controller designed earlier. As shown in Figure 4.7, the overshoot is
approximately 3.6% and the rise time is 0.077s, both below the specifications and better than the PD
Controller. You’ll also notice that both Controllers produce zero steady-state error for a step input.
71
Figure 4.7 - PD Controller vs Phase Lead Controller for a Step Input
Out of interest I rechecked the Gain and Phase Margins for our new Phase Lead Controller. As shown in
Figure 4.8, our Gain Margin has stayed at infinity and our Phase Margin has increased to 69.6°. You’ll
also notice that the Magnitude Plot of the open-loop system with the Controller has been shifted down
before the Gain Crossover Frequency and shifted up after. This was one of the expected side effects of
the Phase Lead Controller. However, the Phase Plot shows a pronounced hump at the Gain Crossover
Frequency which created the boost in Phase Gain we were looking for.
Figure 4.8 – Bode Diagram of Open-Loop System With and Without Phase Lead Controller
72
We now have 2 Controllers we will need to validate, but before we do, let’s look at two more
Controllers.
4.2 Phase Lag Controller Design
Following Figure 4.4, if your Proportional Controller produces too much steady state error but the
overshoot is acceptable, apply Phase Lag Control. Following the procedure laid out by Prof. Dan Davison
in his SYDE 352 Course Notes [13], our objective is to satisfy the specifications using:
(4.3)
1 + ππ
πΆ(π ) = πΎ β πΆπΏππ (π ) = πΎπ
1 + πππ
Where:
K = Controller gain
a = ratio of zero position to pole positon (a > 1)
T = zero time constant (T > 0)
Which results in the following Bode Diagram:
20πππ10 π
0
0
0
ππ
1
ππ
ππ
1
π
Figure 4.9 – Bode Diagram of General Phase Lag Controller
73
Step 1: Sketch the Bode plot of the open-loop system. As shown in Figure 2.0, our open-loop system
will consist of:
πππ = πΌ(π ) β πΆ(π ) β π(π )
Where:
πΆ(π ) = 1
Step 2: If a desired Gain Crossover Frequency πππ is known, adjust the gain K so that the Gain Crossover
Frequency of KβP(s) is equal to the desired Gain Crossover frequency. Accomplish this by trial and error
with Matlab’s margin function or by inspection of the Bode Diagram and convert the value in dB using
the following equation:
πΎ = 10
(
ππ΅ π£πππ’π
)
20
Set:
ππ = πππ
OrIf the desired Phase Margin is known, adjust the gain K so that Phase Margin of KβP(s) is the desired
value plus an extra 5° in anticipation of the loss of Phase Margin that will occur when we include the lag
compensation. Set:
ππ = πππ
If no Phase Margin has been specified, use the following approximation to determine the desired Phase
Margin for a Second Order System:
πππ ≈ 100π,
π€βπππ 0 ≤ π ≤ 0.7
Or the rule of thumb of:
πππ ≥ 60°
If it is not possible to get the desired Phase Margin, then a Phase Lead Controller will be required to
boost the Phase Margin. Skip to Section 4.3.
Step 3: Using the Final Value Theorem, determine if the steady-state error has been satisfied by the
augmented Plant KβP(s). If it is, then you don’t need a Phase Lag Controller because a P Controller will
suffice. Otherwise, determine the extra gain factor that you need to satisfy the steady-state error. This
is the value of a. If a is greater than 15, use two Phase Lag Controllers, each contributing a gain factor of
√π.
74
Step 4: Use the Gain Crossover Frequency πππ of KβP(s) to calculate the zero time constant by:
10
(4.4)
π=
πππ
Step 5: Test to see if specifications are met. If not, go back to Step 1.
4.3 Phase Lead/Lag Controller Design
Sometimes the Design Specifications cannot be met by using a Phase Lead Controller or a Phase Lag
Controller alone, but only by using a combination of lead and lag compensation. The Phase Lag
Controller is used at low frequencies to boost the Gain, and the Phase Lead Controller is used at midfrequencies (near the Gain Crossover Frequency) to improve Phase Margin [13].
Following the procedure laid out by Prof. Dan Davison in his SYDE 352 Course Notes [13], our objective is
to satisfy the specifications using:
1 1 + πππ
1 + π′π
πΆ(π ) = πΎ β πΆπΏπππ πΆπΏππ = πΎ (
) (π′
)
1 + π′π′π
√π 1 + ππ
(4.5)
Where:
K = Controller gain
a = ratio of pole position to zero positon (a > 1)
T = pole time constant (T > 0)
a’ = ratio of zero position to pole positon (a’ > 1)
T’ = zero time constant (T’ > 0)
Step 1: Sketch the Bode plot of the open-loop system. As shown in Figure 2.0, our open-loop system
will consist of:
πππ = πΌ(π ) β πΆ(π ) β π(π )
Where:
πΆ(π ) = 1
Step 2: If a desired Gain Crossover Frequency πππ is known, adjust the gain K so that the Gain Crossover
Frequency of KβP(s) is equal to the desired Gain Crossover frequency. Accomplish this by trial and error
with Matlab’s margin function or by inspection of the Bode Diagram and convert the value in dB using
75
the following equation:
πΎ = 10
(
ππ΅ π£πππ’π
)
20
Set:
ππ = πππ
OrUsing the Final Value Theorem, calculate the gain K to meet the steady-state error specification and add
a buffer of 10dB in anticipation of the decrease in gain that will result from the Lead Controller.
Set:
ππ = πππ
OrIf no specifications are given that the gain can influence, set:
πΎ = 1 πππ ππ = πππ
Step 3: Determine the Phase Margin of the augmented open-loop system where:
π π¦π = πΌ(π ) β πΎ β π(π )
Step 4: Determine the additional phase lead ππ required to meet the Phase Margin required. Be sure
to add an extra 5° to offset the effects of the Phase Lag Controller. If no Phase Margin has been
specified, use the following approximation to determine the desired Phase Margin for a Second Order
System:
πππ ≈ 100π,
π€βπππ 0 ≤ π ≤ 0.7
Or the rule of thumb of:
πππ ≥ 60°
If the phase lead ππ is greater than 60Μ°, using two Phase Lead Controllers, each contributing ππ /2.
Step 5: Use Equation 4.1 to compute the ratio of the pole position to the zero position.
Step 6: Use Equation 4.2 to compute the pole time constant.
Step 7: Using the Final Value Theorem, determine the extra gain factor that you need to satisfy the
steady-state error for the augmented Plant πΎ β πΆπΏπππ . This is the value of a’. If a’ is greater than 15, use
two Phase Lag Controllers, each contributing a gain factor of √π.
76
Step 8: Use the Gain Crossover Frequency πππ of πΎ β πΆπΏπππ to calculate the zero time constant by:
π′ =
10
πππ
(4.6)
Step 9: Test to see if specifications are met. If not, go back to Step 1.
4.4 Feedforward Design
There seems to be two very different topologies that are considered Feedforward Design. The one
topology attempts to read and react to disturbances in an effort to account for future deviations.
Basically, this topology attempts to control the disturbances. I would consider this a multi input, single
output system and not a true Feedforward system. Instead we’ll consider the following arrangement:
F(s)
R(s)
.
I(s)
E(s)
+
∑
C(s)
+
+
P(s)
∑
.
Y(s)
U(s)
-
H(s)
Figure 4.10 – Typical Feedforward Control Topology
With this topology, a transfer function connects the Reference Input Signal R(s) with the Controller
Output Signal U(s). By adding the Feedforward transfer function in parallel with the Controller, a second
degree of freedom is added to the system, meaning that the Controller and the Feedforward transfer
functions can be designed separately. In comparison, the topology previously discussed in Figure 2.0 is
considered a one degree of freedom system. By adding the second degree of freedom, the Controller
can be designed so that the error transfer function has certain desirable characteristics where the
Feedforward transfer function can be selected to help satisfy the performance requirements with
reference to the input/output relationship. Other benefits to this design are that it unburdens the
Controller feedback loop because, under ideal circumstances, the Feedforward path generates most of
the signal, thereby allowing the Controller to provide only corrections and to respond to disturbances or
77
modelling inaccuracies. Problems with the Feedforward topology include requiring accurate knowledge
of the system to be controlled and extra computation requirements.
By looking at the closed-loop transfer function shown below:
π(π ) =
π(π )
(πΉ(π ) + πΆ(π )) β π(π )
= πΌ(π ) β
π (π )
1 + πΆ(π ) β π(π ) β π»(π )
(4.7)
You’ll notice that the Characteristic Equation is the same as the one degree of system we looked at
earlier. Therefore, our Controller can be designed using the methods outlined earlier. This also means
that our Feedforward transfer function can be non-linear and not affect how we design our Controller.
But how do we design the transfer function for the Feedforward term? Well, that’s only possible for a
process that is well understood. Usually it’s the inverse of the Plant or a portion of the Plant. Let’s
revisit our brushed DC motor system example to see how this works.
4.4.1 Example Continued – Feedforward Controller Design
By combining Equation 2.0 and 2.1, assuming the inductance to be negligible and applying Laplace
transforms assuming initial conditions of zero, we get the following equation:
ππ πΎπ‘ − ππ π ππ π − πΎπ‘ πΎπ ππ π = π½π π π ππ π 2
(4.8)
Now, this is where the art of Feedforward Design begins. We know from Section 2.2.1 where we
identified the system elements that the Controller Output Signal U(s) will be in volts, so let’s rearrange
Equation 4.8 to be in terms of volts.
ππ =
π½π π π
πΎπ‘ πΎπ +ππ π
ππ π 2 +
ππ π
πΎπ‘
πΎπ‘
(4.9)
In general, each of the two terms on the right side of Equation 4.9 could be used independently or
together for our Feedforward transfer function. However, since we’re looking to develop a Controller
for a step input, the first term will attempt to differentiate a step input twice. The first differentiation
will produce an impulse and the second differentiation will result in a doublet, which in this case is
effectively zero, making this option useless. The second term will produce an impulse, giving the system
a boost as the step input is applied but after that it will go back to zero. Since the addition of the
Feedforward term doesn’t affect our Controller design, I’ll reuse the PD Controller designed earlier in
Section 3.2.6. As shown in Figure 4.11, we have the original one degree of freedom design with a PD
Controller and our only viable Feedforward design with the same PD Controller.
As mentioned in
Section 3.2.6, Matlab won’t implement a pure derivative term because it’s an improper transfer
function. To get around this quirk I applied the solution they used for their PID Controller function block
by implementing a normalized high pass filter with a pole at 1000rad/s.
78
Figure 4.11 – Matlab Models of Original One Degree of Freedom Design Compared to Feedforward
Design
Interestingly, both models produce the same result. Why is that? Since our model is in continuous time,
there is no noticeable delay between the application of the step input and an error being produced for
the Controller to react to. And since the Controller has its largest output, basically at the same time as
impulse from the Feedforward term, and both outputs are greater than our physical saturation limit of
±12V, there is no difference in input to the Plant and its output.
Obviously this wasn’t the best example to apply Feedforward design to. My hope was that it would
show you how to apply the technique. Though Feedforward design is not that common, there are a
bunch of examples where it can come in handy. A useful instance is when you have a gravity term
affecting position control. You will be looking at this more in-depth with the inverted pendulum lab.
79
5.0 Controller Validation
Controller Validation is broken into two parts, Physical Testing and Stability Analysis. For Physical
Testing, you’ll implement your Controller on the actual system and run the required tests based on the
Design Specifications in order to determine if the specifications are met. This will also further confirm
the accuracy of your model. If the Physical Testing goes well, you’ll next look at the stability of your
system using your derived model. If your system meets the stability criterion, you can be confident that
your Controller will perform as required.
5.1 Physical Testing
In order to implement your Controller design, program the Arduino Mega 2560 by augmenting the
ControlsLabBaseCode.ino code. Using Mode 3 will allow you to implement a PID Controller and Mode 4
has been left blank for you to write your own code for other Controller types. In order to record your
system’s performance and validate your Controller design, use the Matlab program collect.m created
earlier.
5.1.1 Choosing the Proper Control Loop Frequency
This course only deals with control systems in the continuous time domain that we describe using the
Laplace operator s. This kind of system is generally built using analog electronics but this usually isn’t
the case in practice today. Usually you’ll be dealing with discrete systems implemented on
microcontrollers that operate at a controlled frequency fast enough to emulate analog control. This
kind of analysis uses the Z-transform as a mathematical tool. As a control engineer you’ll need to define
an appropriate Control Loop Frequency. A general rule of thumb is to use a frequency that is a factor of
10 or larger than the -3db cutoff point of the system. Of course, if you can operate at frequencies
greater than that, system performance will improve.
When using the ControlsLabBaseCode.ino code on the Arduino Mega 2560, each Mode has an input for
the Control Loop Frequency by the input variable Period. When setting the input variable Period, you
are selecting the Control Loop Period, which is the inverse of the Control Loop Frequency, in
milliseconds.
5.1.2 Example Continued – Physical Testing of PD Controller
We have 2 Controllers we want to validate, a PD Controller and a Phase Lead Controller, but first, we’ll
implement the PD Controller where:
πΆ(π ) = πΎπ + πΎπ· π = 0.1 + 5.4π₯10−3 π
80
To do so we’ll open the ControlsLabBaseCode.ino file and program the Arduino Mega for PID Closed
Loop Control for a Step Input mode where:
Mode = 3, Kp = 0.1, Ki = 0, Kd = 0.0054, Reference_Input = 1, I_Gain = 318.3, V_In = 12, Time = 5 and
Period 2.
Based on the discussion in Section 5.1.1 about Choosing the Proper Control Loop Frequency, I chose a
Control Loop Frequency of 500Hz. As shown in Figure 5.0, the bandwidth of the closed-loop system with
the PD Controller designed in Section 3.2.7 is 50.95Hz. (This same value can be verified using Matlab’s
bandwidth(sys) function.) Based on the prescribed rule of thumb of a factor of 10, we get a Control
Loop Frequency of 508Hz which we’ll approximate as 500Hz.
-3db
50.95Hz
Figure 5.0 – Bode Diagram of Example Closed-Loop System using PD Controller
Using the collect.m function created in Matlab, I was able to record and plot the response for a unit step
input of our system with the PD Controller devised earlier. As shown in Figure 5.1, the unit step
response looks good. It has a 2.7% overshoot, a rise time of 0.092s and zero steady-state error.
81
Figure 5.1 – Step Response for Example Closed-Loop System using PD Controller
Since we’ve met our Design Specifications, no more tests need to run. However, there is one last thing I
would like to do. I’d like to compare the response of our physical system with our modeled response.
Using the Simulink model I created called base_closed_loop_model_test, I was able to compare both
results. This program is very similar to the program created in Section 2.2.5 to compare open loop
results. As shown in Figure 5.2 our modeled response shown in yellow is very close to the actual
response shown in purple. I’m very confident our model is accurate enough to predict the system’s
stability in the Section 5.2.
5.1.3 Example Continued – Physical Testing of Phase Lead Controller
Using the ControlsLabBaseCode.ino file to program the Arduino Mega for Mode 4 operation, I wrote my
own code to implement the following Phase Lead Controller devised in Section 4.1.4:
πΆ(π ) = 0.25
1 + 0.024π
1 + 0.024π
β
−3
1 + 6.62π₯10 π 1 + 6.62π₯10−3 π
82
Figure 5.2 – Comparison Plot of Unit Step Response of Modeled System vs. Actual System using a PD
Controller
However, to write the code for this Controller requires the Controller Transfer Function to be first
converted from the Laplace domain to the discrete domain and then into a difference equation. To
convert from the Laplace domain to the z-domain, I used the following equation to convert its zeros and
poles:
π§ = π π π
(5.0)
Where T is the Control Loop Period in seconds.
However, before we can go any further, we’ll need to decide on the Control Loop Frequency for this
system using the Phase Lead Controller. Using Matlab’s bode function, the figure shown in Figure 5.3
was plotted and the closed-loop bandwidth was found to be 111.1Hz. Using the rule of thumb of a
factor of 10, we get a Control Loop Frequency of 1111Hz. Unfortunately, as mentioned in the previous
section, our Arduino Mega can only operate up to 1000Hz so we’re stuck with the Control Loop Period
of:
π = 0.001π
We’ll see what affect this has on the system’s performance.
83
-3db
111.1Hz
Stupid Matlab
Figure 5.3 – Bode Diagram of Example Closed-Loop System using Phase Lead Controller
Rearranging our Phase Lead Controller Transfer Function in terms of zeros and poles, we get the
following:
πΆ(π ) =
3.29(π + 41.6667)(π + 41.6667)
(π + 151.0574)(π + 151.0574)
Using Equation 5.0, we can covert our Laplace domain zeros to z-domain zeros as follows:
π§ = π π π = π −41.6667(0.001) = 0.9592
Using Equation 5.0, we can covert our Laplace domain poles to z-domain poles as follows:
π§ = π π π = π −151.0574(0.001) = 0.8598
This leaves us with the following transfer function:
πΆ(π§) =
π(π§ − 0.9592) (π§ − 0.9592)
(π§ − 0.8598)(π§ − 0.8598)
84
To calculate the value of k, the usual method is to equate the DC gain when s = 0 and z = 1. This results
in:
3.29(0 + 41.6667)(0 + 41.6667) π(1 − 0.9592) (1 − 0.9592)
=
(0 + 151.0574)(0 + 151.0574)
(1 − 0.8598)(1 − 0.8598)
Which gives us:
π = 2.96
And the following discrete Controller:
πΆ(π§) =
2.96(π§ − 0.9592) (π§ − 0.9592)
(π§ − 0.8598)(π§ − 0.8598)
Or in normalized form:
πΆ(π§) =
2.96π§ 2 − 5.678π§ + 2.723
π§ 2 − 1.72π§ + 0.7393
Now that our Controller is in the z-domain, our next step is to convert it into a difference equation.
Following the procedure laid out by Silvano Balemi [14], where he converts the general discrete
Controller:
π(π§) ππ β π§ π + ππ−1 β π§ π−1 + ππ−2 β π§ π−2 + β― π1 β π§ + π0
πΆ(π§) =
=
πΈ(π§)
π§ π + ππ−1 β π§ π−1 + ππ−2 β π§ π−2 + β― π1 β π§ + π0
Into the following form:
π’π = −ππ−1 β π’π−1 − β― −π0 β π’π−π + ππ β ππ + β― + π1 β ππ−π+1 + π0 β ππ−π
Where in this case k represents the discrete time step, we get the following Phase Lead Controller in
difference equation:
π’π = 1.72π’π−1 − 0.7393π’π−2 + 2.96ππ − 5.678ππ−1 + 2.723ππ−2
Coding and uploading this equation into the Arduino Mega and using the collect.m function in Matlab to
record and plot the response for a unit step input of our system results in the plot shown in Figure 5.4.
The unit step response looks good as well, with a 3.36% overshoot, a rise time of 0.095s and zero
steady-state error. Interestingly, the Phase Lead Controller did not perform as well on the physical
system as the PD Controller, which does not match our simulation results. Why is that? It’s most likely
because we were not able to implement our Phase Lead Controller at the required Control Loop
Frequency of 1111Hz.
85
Figure 5.4 – Step Response for Example Closed-Loop System using Phase Lead Controller
Since we’ve met our Design Specifications, no more tests need to run. However, again, I’d like to
compare the response of our physical system with our modeled response. As shown in Figure 5.5, the
actual response shown in purple seems to lag noticeably to the modeled response shown in yellow.
Fortunately, this deviation is most likely a result of the Control Loop Frequency implemented on the
Arduino Mega being lower then desired. I’m still very confident our model is accurate enough to predict
the system’s stability.
5.2 Stability Analysis
There are a number of ways to analyse the stability of your system but the best way to determine how
stable your system is, is to determine its Gain and Phase margins. In this course we’ll focus on two
methods. The first method, which I prefer, uses a Bode Diagram of the open-loop system and in Matlab
the margin function will plot the Bode Diagram and calculate the margins for you. The second method
uses a Nyquist Plot of the open-loop system, and I think it was devised by Electrical Engineers to punish
the world. Matlab has a nyquist function that draws the Nyquist Plot but you have to determine the
margins from the plot. Nyquist Plots are preferred when your system has a delay in it.
You might be asking, if our closed-loop poles are in the LHP, aren’t we good? Yes and no. If your system
was able to exist under perfect conditions and not change with time, then yes, it would remain stable.
86
Unfortunately, stupid reality gets in the way. The main culprits are model inaccuracies, aging, noise and
disturbances. Remember, the poles represent physical properties, and as a system ages, the properties
change and so do the locations of the poles. Likewise, noise and disturbances can push a stable pole to
the right of the Imaginary Axis and cause the system to go unstable. As a result, the best way to protect
your system from going unstable is to insure it has a sufficiently large stability margin.
Figure 5.5 – Comparison Plot of Unit Step Response of Modeled System vs. Actual System using a
Phase Lead Controller
5.2.1 Stability Analysis using Bode Diagrams
As discussed in Section 4.1.2, Bode Diagrams can be used to determine the Gain and Phase Margins so I
won’t go into further detail other than reiterating that the conservative rule of thumb for stability
margins are:
πΊπππ ππππππ ≥ 10ππ΅ and
πβππ π ππππππ ≥ 60°
87
5.2.1.1 Example Continued - Stability Analysis using Bode Diagrams for System with PD Controller
Using Matlab’s margin function for an open-loop system with the PD Controller, the following Bode
Diagram was plotted:
Figure 5.6 – Bode Diagram of Example System with a PD Controller
Using this function, Matlab calculates a Gain Margin of infinity and a Phase Margin of 65.5° at 38rad/s.
Both values exceed our conservative rule of thumb for Gain and Phase Margins so I’m confident our PD
Controller will remain stable regardless of aging, noise and/or disturbances.
5.2.1.2 Example Continued – Stability Analysis using Bode Diagrams for System with Phase Lead
Controller
Using Matlab’s margin function for an open-loop system with the PD Controller, the Bode Diagram in
Figure 5.7 was plotted.
88
Figure 5.7 – Bode Diagram of Example System with a Phase Lead Controller
Using this function, Matlab calculates a Gain Margin of infinity and a Phase Margin of 69.9° at 71.4rad/s.
Both values exceed our conservative rule of thumb for Gain and Phase Margins so I’m confident our
Phase Lead Controller will remain stable regardless of aging, noise and/or disturbances.
5.2.1 Stability Analysis using Nyquist Plots
Using Matlab’s nyquist function to draw our Nyquist Plot, we’re left to determine the Gain and Phase
margins ourselves. For Nyquist Plots, the Gain Margin is defined as the amount that the Nyquist Plot
would have to increase to intersect the (-1, 0) point. On a Nyquist Plot, the distance along the negative
real axis is measured between the origin and the intersection of the Nyquist Plot and the negative real
axis. This distance is the inverse of the Gain Factor. The Gain Margin, expressed in decibels, is calculated
using the following:
πΊπππ ππππππ(ππ΅) = 20πππ10 (
1
) = 20πππ10 (πΊπππ πΉπππ‘ππ)
πππ π‘ππππ ππππ π’πππ
(5.1)
89
If the Nyquist Plot intersects the real axis at the origin or on the positive real axis, the Gain Margin is
considered infinite.
Similarly, the Phase Margin is defined as the angle that the Nyquist Plot would have to change to move
to intersect the (-1, 0) point. On a Nyquist Plot, the angle is measured from the negative real axis about
the origin towards the intersection between the Nyquist Plot and the unit circle. If the angle is counterclockwise direction, it is considered positive. If the Nyquist Plot never intersects the unit circle, the
Phase Margin is considered infinite.
As shown below in Figure 5.8, the Sample Nyquist Plot has a Phase Margin of 112°. It also has a Distance
of 0.2, and using Equation 5.1, the Gain Margin is:
πΊπππ ππππππ(ππ΅) = 20πππ10 (
1
) = 20πππ10 (5) = 15ππ΅
0.2
Unit Circle
Distance = 0.2
Phase Margin = 112°
Figure 5.8 – Sample Nyquist Plot
We’ll use the same conservative rule of thumb for Gain and Phase margins that we used stability
analysis using Bode Diagrams.
90
6.0 References
[1] Ogata, Katsuhiko, “Modern Control Engineering”, page 159, Prentice Hall, New Jersey, 5th Edition,
2010.
[2] “Avago Download Page”, Accessed June 1st, 2015, http://www.avagotech.com/docs/AV02-1046EN.
[3] “Avago Download Page”, Accessed June 1st 2015, http://www.avagotech.com/docs/AV02-0096EN.
[4] Franklin, Gene and Powell, J. David and Emami-Naeini, Abbas,”Feedback Control of Dynamic
Systems”, page 48, Prentice Hall, New Jersey, 6th Edition, 2010.
[5] “Chirp”, Wikipedia: The Free Encyclopedia, Wikimedia Foundation Inc., May 5, 2015, Accessed June
12th, 2015, http://en.wikipedia.org/wiki/Chirp.
[6] Ogata, Katsuhiko, “Modern Control Engineering”, page 161, Prentice Hall, New Jersey, 5 th Edition,
2010.
[7]
“Extras:
System
Identification”,
Accessed
http://ctms.engin.umich.edu/CTMS/index.php?aux=Extras_Identification.
13th,
June
[8] “Root Locus”, Wikipedia: The Free Encyclopedia, Wikimedia Foundation Inc., January 24, 2015,
Accessed June 20th, 2015, http://en.wikipedia.org/wiki/Root_locus.
[9] Franklin, Gene and Powell, J. David and Emami-Naeini, Abbas, ”Feedback Control of Dynamic
Systems”, page 120, Prentice Hall, New Jersey, 6th Edition, 2010.
[10] Franklin, Gene and Powell, J. David and Emami-Naeini, Abbas, ”Feedback Control of Dynamic
Systems”, page 119, Prentice Hall, New Jersey, 6th Edition, 2010.
[11] Franklin, Gene and Powell, J. David and Emami-Naeini, Abbas, ”Feedback Control of Dynamic
Systems”, pages 116-119, Prentice Hall, New Jersey, 6th Edition, 2010.
[12] Franklin, Gene and Powell, J. David and Emami-Naeini, Abbas, ”Feedback Control of Dynamic
Systems”, page 129, Prentice Hall, New Jersey, 6th Edition, 2010.
[13] SYDE 352, Introduction to Control Systems, Course Notes, Package 2 of 2, Winter 2006, Prof. Dan
Davison, Dept. of Electrical and Computer Engineering, University of Waterloo.
[14] Balemi, Silvano, “Advanced Control”, June
http://www.dti.supsi.ch/~smt/courses/DigImpl.pdf.
3,
2011,
Accessed
August
13,
2015,
91
For Dummies
By Chris McClellan
1
1.0 Introduction
Welcome to the Practical Controller Design for Dummies. This manual presents the field of Classical
Control Theory as taught in SYDE 352. This manual is intended as a basic framework for designing a
controller; with more experience and knowledge you can fill out this framework with more complex
techniques. It is broken in to 3 sections: System Identification, Controller Design and Controller
Validation. A simple brushed DC motor system is used as an example to illustrate the framework.
I would like to thank Dr. Eric ‘The Tool Man’ Kubica for freeing me from the deep, murky, nebulous hole
that is MME. I would also like to thank him for the opportunity to create this manual and for his
guidance and expertise on this project. I would also like to thank Professor Dan Davison, Professor
Glenn Heppler and Professor Nasser Lashgarian Azad for their support in making this manual possible.
I would also like to thank the good people at For Dummies for the use of their logo.
Figure 1.0 –Gratuitous Puppy Shot
2
2.0 System Identification
Shown below in Figure 2.0 is the typical feedback system. In general, this system consists of a Reference
Input Signal R(s), an Input Filter Transfer Function I(s), a Controller Transfer Function C(s), a Controller
Output Signal U(s), a Plant Transfer Function P(s), a Feedback Transfer Function H(s) and an Output
Signal Y(s). Also note the summation point where the Error Transfer Function E(s) is equal to R(s)βI(s). –
Y(s)βH(s).
R(s)
I(s)
E(s)
+
∑
U(s)
P(s)
C(s)
.
Y(s)
H(s)
Figure 2.0 – Typical Feedback System
The goal of System Identification is to derive a mathematical model for each of the following elements:
Reference Input Signal R(s) – The Reference Input Signal is the desired set-point(s) as requested by the
operator of the system. This input can take many forms, including impulse signals, step signals, ramp
signals, acceleration signals, sinusoidal signals etc [1]. Your goal is to identify the typical Reference Input
Signal(s) for your system and design a controller to adequately respond to these desired inputs.
Input Filter Transfer Function I(s) – The role of the Input Filter is to convert the Input Signal into a form
that is usable by the Controller Transfer Function. In most cases the Input Filter Transfer Function is a
gain but can sometimes take the form of a transfer function that filters the input in ways that improve
the system response.
Error Signal E(s) – The Error Signal is calculated by subtracting the output of the Feedback Transfer
Function from the output of the Input Filter Transfer Function. Though you don’t need to derive a
model for this part of the system, it’s important to know the units of this signal.
Controller Transfer Function C(s) – The Controller Transfer Function is the brains of your system and the
goal of Controller Design in Section 3.0. It takes the Error Signal and computes the Controller Output
Signal. The Controller can take many forms, but for this course we’ll focus on Proportional (P)
Controllers, Proportional plus Integral (PI) Controllers, Proportional plus Derivative (PD) Controllers,
Proportional plus Integral plus Derivative (PID) Controllers, Phase Lead Controllers, Phase Lag Controllers
and Feedforward Controllers.
3
Controller Output Signal U(s) – The Controller Output Signal is the signal that the Controller calculates
and applies to the Plant. Though you don’t need to derive a model for this part of the system, it’s
important to know the units of this signal. It also should be noted that sometimes when running
experiments on the model of your system, a limit function may be added here to replicate the real world
limits of your system. See Section 3.2.6 for more information.
Plant Transfer Function P(s) – The Plant Transfer Function generally consists of an actuator and the
process being controlled. Generally the most difficult task in designing a Controller is to come up with
an accurate model of the Plant. For our purposes, there are 2 main methods for developing a model of
the Plant. The first approach is to Apply First Principles Techniques. For a mechanical system, this will
start with drawing a Free-Body Diagram where we can apply Newton’s Second Law of Motion for linear
motion where:
πΉβ = ππβ
Where:
πΉβ is the net force acting on an object,
π is the mass of the object and
πβ is the acceleration of the object.
Or for rotational motion where:
ββ = πΌπΌβ
π
Where:
ββ is the net torque applied to an object about an axis of rotation,
π
πΌ is the inertia of the object about the same axis of rotation and
πΌβ is the angular acceleration of the object about the same axis of rotation.
If you have an electrical system, Kirchhoff’s voltage law (KVL) may be applied where:
π
∑ ππ = 0
π=1
Where:
ππ is the voltage across element k of n total elements.
4
Of course there are many other equations that could be used to predict the response of your Plant. This
technique can be used for any order of Plant but it does require complete knowledge of the Plant.
The second approach, Transient and Steady-State Response Analysis, is great for Plants where little is
known about the Plant. However, this technique is limited to first and second order Plants. The
technique is to apply a known input to your Plant and analyze the transient and steady-state response.
Section 2.2.7 goes into more detail on this approach.
The third approach, Data Driven Modeling, sometimes called gray box modeling, is a very effective tool
when attempting to model a Plant when very little is known, much like training a fuzzy-neural network,
but is beyond the scope of this course.
Feedback Transfer Function H(s) – The Feedback Transfer Function generally is a model of the sensor
used to measure the output of your Plant. In most cases this transfer function is modeled as a gain.
Output Signal Y(s) – The Output Signal is the physical variable being controlled. Though you don’t need
to derive a model for this part of the system, it’s important to know the units of this signal.
2.1 System Identification Flow Chart
Figure 2.1 is the flow chart for System Identification. Follow through it to derive a model for each of the
system components.
2.2 System Identification Example
In order to illustrate the process for System Identification, we’ll look at a brushed DC motor system.
Shown in Figure 2.2 is the top view of said system. You’ll notice there is a steel arm attached directly to
the motor in which we will control. The desired performance specifications for this system are:
1) Maximum overshoot of 5% for a unit step input.
2) Rise time of 0.1s for a unit step input.
3) Zero steady-state error to a unit step input.
5
Identify Elements of System
Make Assumptions and
Simplifications of System
Derive a Model for each
Element Except for the
Controller and Plant
Create Plant Model
Apply First Principles
Modeling
Analyze Transient and
Steady-State Response
Apply Data Driven
Modeling Techniques
Techniques
Test Model
Is Plant Model
Accurate Enough?
No
Yes
Can the System be
Simplified Further?
Yes
No
Figure 2.1 – System Identification Flow Chart
6
Figure 2.2 – Top View of Brushed DC Motor System
Motor
Optical Encoder
Figure 2.3 – Side View of Brushed DC Motor System
7
2.2.1 Step 1 – Identify Elements of System
For our system:
R(s)
Since our performance specifications are solely for a step input, our typical Reference Input
Signal will be the desired angle of rotation of the motor’s shaft, measured in radians.
I(s)
A coeficient that converts the desired angle of rotation in radians to encoder counts.
E(s)
The Error Signal will be in encoder counts.
C(s)
A Controller implemented on an Arduino Mega in series with a Dual MC33926 Motor Driver.
U(s)
The Controller Output Signal will be in volts.
P(s)
A brushed DC motor (Maxon 2332.968-51.236.200), as shown in Figure 2.3, with a steel arm
attached. Also, the slotted disk (See Figure 2.4) of the optical encoder is attached to the same motor
shaft.
Figure 2.4 – Optical Encoder Disk and Sensor
H(s)
An optical encoder (HEDS-5540 A11), as shown in Figures 2.2 and 2.4, and an encoder
counter (HCTL-2022) that converts the angular position of the motor’s shaft in radians to encoder
counts.
Y(s)
The angular position of the motor’s shaft, measured in radians.
2.2.2 Step 2 - Simplify System
Assumption #1 - We will assume the system is linear and time invariant.
Simplification #1 - We will add the effect of the arm and encoder wheel to the inertia of the motor
model.
8
2.2.3 Step 3 – Create Model of each Element Except for Controller and Plant
Feedback Transfer Function H(s) -Encoder
From the data sheet for the HEDS-5540 A11 optical encoder, it has a resolution of 500 CPR (Counts Per
Revolution) [2]. In order to free the Arduino Mega from the intensive task of counting the pulses
generated by the optical encoder, an encoder counter is used to count and store the current angular
position. From the data sheet for the HCTL-2022 encoder counter, it states that it has quadrature
decoding capabilities, meaning it can read the two out-of-phase pulse trains and increase the resolution
by a factor of 4 [3]. Therefore:
π»(π ) = 500
ππ’ππ ππ
πππ’ππ‘π 1 πππ£πππ’π‘πππ
πππ’ππ‘π
β4
β
= 318.3
πππ£πππ’π‘πππ
ππ’ππ π 2π πππππππ
ππππππ
Input Filter Transfer Function I(s)
The Input Filter is required to convert the desired angle of rotation of the motor’s shaft in radians to
encoder counts. Therefore, like the Encoder Model:
πΌ(π ) = 500
ππ’ππ ππ
πππ’ππ‘π 1 πππ£πππ’π‘πππ
πππ’ππ‘π
β4
β
= 318.3
πππ£πππ’π‘πππ
ππ’ππ π 2π πππππππ
ππππππ
Aside – Because the encoder/encoder counter combination can’t read fractional counts, a Floor
Rounding Function, that rounds down to the lowest integer value, will be added after the H(s) and I(s)
transfer functions to emulate this characteristic.
2.2.4 Step 4 – Create Plant Model
We have a choice on how to model our Plant. As mentioned, for this course, only First Principles
Modeling and Transient and Steady-State Response Analysis will be used. First Principles Techniques
are useful for any order of system; however, it requires complete knowledge of the system. In our case,
all of the parameters of the motor are available from its data sheet making this method possible.
However, if we had an unknown motor, this technique would not be possible. For the sake of interest,
let’s start with First Principles Techniques then confirm our model using Transient and Steady-State
Response Analysis.
9
2.2.4.1 Modeling Approach #1 – Apply First Principles Modeling
Using First Principle Techniques, we’ll start with the typical model of a brushed DC motor. Shown in
Figure 2.5 is the typical electrical circuit of the armature and the free-body diagram of the rotor [4].
La
Ra
θm
T
ia
+
Va
+
.
~
e=Keθm
-
M
-
Jm
.
bθm
(b)
(a)
Figure 2.5 – DC Motor: (a) Electric circuit of armature; (b) Free-body diagram of rotor [4]
Applying Kirchhoff’s voltage law (KVL) to the motor’s armature circuit results in:
πππ
+ πΎπ πΜπ − ππ = 0
ππ‘
π π ππ + πΏπ
(2.0)
Where:
Ra
is the resistance of the motor’s armature in ohms,
ia
is the current flowing through the motor’s armature in amps,
La
is the inductance of the motor’s armature in henrys,
Ke
is the back emf coefficient in sβV/rad,
πΜπ
is the rotational velocity of the motor’s rotor in rad/s,
Va
is the voltage applied to the motor in volts.
10
Using Newton’s second law of motion on the motor’s rotor results in:
πΎπ‘ ππ − ππΜπ = π½π πΜπ
(2.1)
Where:
Kt
is the torque motor constant in Nβm/A,
b
is the viscous friction coefficient in Nβmβs,
Jm
is the rotational inertia of the motor’s shaft and rotor in kgβm2,
πΜπ
is the rotational acceleration of the motor’s rotor in rad/s2.
Combining Equations 2.0 and 2.1 and applying Laplace transforms with initial conditions of zero results
in the motor’s transfer function:
ππ (π )
πΎπ‘
=
3
ππ (π ) π½π πΏπ π + (π½π π π + ππΏπ )π 2 + (ππ π + πΎπ‘ πΎπ )π
(2.2)
Applying Simplification #1 in which the rotational inertia of the arm and encoder disk is added to the
rotor’s rotational inertia results in:
π½π = π½π + π½π + π½π
(2.3)
Where:
JT
is the combined rotational inertia in kgβm2,
Ja
is the rotational inertia of the arm in kgβm2,
Je
is the rotational inertia of the encoder disk in kgβm2.
By combining Equations 2.2 and 2.3 our Plant Transfer Function is:
π(π ) =
πΎπ‘
(π½π + π½π + π½π )πΏπ π 3 + ((π½π + π½π + π½π )π π + ππΏπ )π 2 + (ππ π + πΎπ‘ πΎπ )π
(2.4)
11
From the motor’s data sheet, the following is given:
π π = 7.94 Ω
πΏπ = 1.50 ππ»
πΎπ‘ = 39.3 ππ β π/π΄
π½π = 27.8 π β ππ2
πΎπ−1 = 243 πππ/π
However, using a multimeter I checked the resistance across the leads of the motor to find the
combined resistance to be:
π πππ‘ππ+πππππ = 9.52 Ω
Furthermore, checking the data sheet of the MC33926 motor driver, it states its H-bridge mosfet has a
maximum on-resistance of:
π πππ πππ‘ = 225 πΩ
And since there is 2 mosfets in operation at any given time, we’ll combine the resistance of the motor,
the leads and the 2 mosfets to get a total resistance of:
π π = 9.97 Ω
2.2.4.2 Calculating the Viscous Friction Coefficient
The last motor specification we require is b, the viscous friction coefficient, and unfortunately the
manufacturer does not list it. The viscous friction coefficient is used in Equation 2.1, and if we were to
run the motor at a constant speed, this equation simplifies to:
πΎπ‘ ππ = ππΜπ
(2.5)
And by the motor specification, with no load:
πΜπ = 8410 πππ ππ 880.7 πππ/π
ππ = 30.9 ππ΄ ππ 0.0309 π΄
By submitting the aforementioned values into Equation 2.5 and rearranging for b we get:
π=
πΎπ‘ ππ (0.0393)(0.0309)
=
= 1.38π₯10−6 π β π β π
880.7
πΜπ
12
2.2.4.3 Estimating the Inertia of the Arm and Encoder Disk
The last pieces of information we need to complete our model of the Plant are the rotational inertias of
the arm and the encoder disk. There are a number of ways to do this, here are just 2 ways.
Estimating Approach #1 – Assume the effect of the encoder disk is negligible and model the arm as a
point mass located at half the arm’s length.
By finding the mass of the arm and its length, the following equation can be used:
ππ 2
π½π1 = ππ ππ 2 = ππ ( )
2
(2.6)
Where:
ππ = 0.049 ππ
ππ = 0.123 π
By substituting these values into Equation 2.6, we get the following:
0.123 2
π½π1 = (0.049) (
) = 1.85π₯10−4 ππ β π2
2
Therefore, using Equation 2.3:
π½π = π½π + π½π + π½π = 2.78π₯10−6 + 1.85π₯10−4 + 0 = 1.8778π₯10−4 ππ β π2
Estimating Approach #2 – Find the inertias of the both the encoder wheel and arm empirically.
By rearranging Equation 2.1 for JT, we get:
π½π = π½π + π½π + π½π =
πΎπ‘ ππ − ππΜπ
πΜπ
(2.7)
Therefore, if we collect the motor’s angular position and current and differentiate the angular position
twice to get πΜπ and πΜπ respectively, we can calculate the combined inertia at each time step. Since the
motor specifications are averages over its operating speeds anyways, we should be able to apply a ramp
function to the motor to get a range of results to average.
13
To do this, first, we’ll open the ControlsLabBaseCode.ino1 file and program the Arduino Mega 2560 for
Open Loop Ramp mode where:
Mode = 1, Ramp_Final = 200, I_Gain = 318.3, Time = 5 and Period = 10.
This puts the Mega into Mode 1 for Open-Loop Ramp Input operation that will output a linearly varying
voltage ramp to the motor for a Time of 5.0s with a Period of 10 ms. This ramp will start at the default
value of 0% duty cycle or 0 V and end at the Ramp_Final value of 200, which is the raw analogWrite
value that represents a duty cycle of (200/255)β100% = 78.4% or a voltage of (200/255)β12V or 9.4V. The
I_Gain value is the Input Filter Gain that converts radians to encoder counts. By uploading this file, the
Mega is ready to go and a test can be initiated by pressing the Start button. Remember, to keep your
hand close to the Stop but in case your test gets out of hand. To collect data, the collect.m Matlab script
should be used. It returns the following vectors:
R(t)
is the Reference Input Signal vector. In Open Loop mode it represents a voltage and is the
raw analogWrite value. It ranges from 0 – 255 and its the duty cycle of the Pulse Width Modulated
(PWM) signal where 0 represents a 0% duty cycle (always off), 127 represents a 50% duty cycle (on half
the time) and 255 represents a 100% duty cycle (always on). In Closed Loop mode it represents the
desired angle in radians.
Y(t)
is the Output Signal vector, which in this case is the angular position of the motor in radians.
I(t)
is the current vector ππ in amps flowing through the motor’s armature. It is important to note
that this value is always positive, regardless of the direction of the flow of current.
Aside – the collect.m script will prompt you for which communication port that the Arduino Mega is
currently connected to. To determine which port is being used, open the Device Manager and look
under Ports (COM & LPT), as shown in Figure 2.6.
Figure 2.6 –Device Manager Hardware Tree
1
This Arduino file, as well all the other Arduino and Matlab files used in this manual can be found on the C: drive of
your lab computer under SYDE 352/SYDE Code.
14
By running collect.m, 4 different plots are created, only 3 of which are important to us at this point.
Figure 2.7 – Plot of the Reference Input vs. Time
Figure 2.8 – Plot of the Motor Output vs. Time
15
Figure 2.9 – Plot of the Motor Current vs. Time
Shown in Figure 2.7 is the plot of the Reference Input vs. Time. As expected, the analogWrite signal that
represents the duty cycle of the PWM signal sent to the motor varies linearly from 0 to 200 over the 5
second duration. The Angular Position of the motor shown in Figure 2.8 exhibits a non-linear output for
the entire test, the worst section being the first 3.5 seconds of the test. Even though we’ve assumed
our system to be linear, and the input to the systems is a linear ramp, this clearly is not the case. A red
line has been added to the plot to mark the region we’ll consider as linear for our calculation of the
combined inertias. The plot of the motor current shown in Figure 2.9 is very noisy. It should be noted
that an averaging filter has been added to the ControlsLabBaseCode.ino file to help with the noise issue
from the current feedback and this plot is a vast improvement over what is was.
To calculate the angular velocity and acceleration of the motor, the angular position needs to be
differentiated. To help with this, a Matlab function called differ was created that employs the following
simple two-point estimation:
π¦Μ (π‘) =
π¦(π‘ + β) − π¦(π‘)
β
Where:
β = ππππππππ ππππππ = ππππ‘π π‘πππ
16
The differ function has the following syntax:
[data_vector_dot, time_vector_dot] = differ(data_vector, time_vector, freq)
Where:
data_vector_dot
is the returned differentiated data vector.
time_vector_dot
is the returned time vector used for plotting data_vector_dot vs. Time.
data_vector
is the input data vector to be differentiated.
time_vector
is the input time vector to be truncated by one sample point.
Shown in Figure 2.10 is the plot of the Angular Velocity vs Time. The signal exhibits a small amount of
noise but overall it is fairly smooth and should produce a decent result when using Equation 2.7.
However, this small amount of noise is greatly amplified in the signal of the Angular Acceleration, as
shown in Figure 2.11. This signal is basically a blur and will not produce an acceptable result when using
Equation 2.7.
Figure 2.10 – Plot of the Angular Velocity vs. Time
17
Figure 2.11 – Plot of the Angular Acceleration vs. Time
Out of curiosity, I created another Matlab script called J_calculation.m based on Equation 2.7 and
applied our vectors. Shown below in Figure 2.12 is the result.
Figure 2.12 – Plot of the Combined Inertias vs. Time
18
Even when we zoom-in on the region after 3.5s, the result is way off, as shown below in Figure 2.13.
Not surprising, the average combined inertias over this time period using this script results is an infinite
value.
Figure 2.13 –Plot of the Combined Inertias vs. Time from 3.5s to 5.0s
Post Process Filtering
It’s clear we’re going to do some post process filtering to get a decent result. I’ve created a function
called data_filter that uses Matlab’s butter function that returns the transfer function coefficients of an
nth-order low-pass Butterworth filter with a normalized cutoff frequency of Wn. These coefficients are
then applied using Matlab’s filter function. The user has the choice of 3 normalized cutoff frequencies
to expedite the process of finding the appropriate cutoff frequency. The order of the filter has been
hard-coded to be a second order low-pass filter. The data_filter function has the following syntax:
[v_f1, v_f2, vf_3] = data_filter(f1_n, f2_n, f3_n, vector_in)
Where:
v_f1, v_f2, v_f3
are the three returned vectors of the filtered vector_in at the normalized
frequencies f1, f2 and f3 respectively
f1_n, f2_n, f3_n
are the user defined normalized cutoff frequencies. These cutoff frequencies
must lie between 0 and 1, where 1 corresponds to the Nyquist rate of half the sample rate.
vector_in
is the input vector to be filtered.
19
By applying the aforementioned data_filter function to the angular velocity with arbitrarily determined
normalized cutoff frequencies of 0.2, 0.1 and 0.02, the following plot was created (Figure 2.14). With a
sampling period of 10ms, our sampling frequency is 100Hz and our Nyquist rate is 50 Hz. Therefore the
cutoff frequencies trialed correspond to 10Hz, 5Hz and 1Hz respectively.
Figure 2.14 – Data_filter Function Output of Angular Velocity with Cutoff Frequencies of 10Hz, 5Hz and
1Hz
Though it’s slightly difficult to see from the plot shown in Figure 2.14, all 3 cutoff frequencies do a nice
job of smoothing out the noise in the Ydot vector. However, the third cutoff frequency of 1Hz adds a
very noticeable shift to the data due to the aggressive 2nd order Butterworth filter being too close to the
cutoff frequency of the system which is not desired. To minimize this effect, the vector filtered at the
second cutoff frequency of 5Hz will be used. Applying the differ function on this new vector results in
plot shown below in Figure 2.15.
Clearly the result shown in Figure 2.15 when compared to the plot in Figure 2.11 is much better, but still
exhibits a fair amount of noise. Using the data_filter function with the same cutoff frequencies
produced the plot shown in Figure 2.16.
20
Figure 2.15 - Plot of the Angular Acceleration vs. Time
Figure 2.16 - Data_filter Function Output of Angular Acceleration with cutoff frequencies of 10Hz, 5Hz
and 1Hz
This time the cutoff frequencies of 10Hz and 5Hz did not do an adequate job where the cutoff frequency
of 1Hz did a nice job in smoothing the data but once again added a significant shift. A second trial with
normalized cutoff frequencies of 0.08, 0.04 and 0.02 were used to produce the plot shown in Figure
2.17.
21
Figure 2.17 - Data_filter Function Output of Angular Acceleration with Cutoff Frequencies of 4Hz, 2Hz
and 1Hz
The second cutoff frequency of 2Hz appears to do the best job of filtering the Angular Acceleration
because it produces the smoothest signal without adding a delay to the data and will be used to
calculate the combine inertias. Using the J_calculation script resulted in the following plot (Figure 2.18).
Figure 2.18 - Plot of the Combined Inertias vs. Time
22
The average combined inertias over the time period of 3.5s to 5.0s was calculated to be:
π½π = π½π + π½π + π½π = 2.4π₯10−4 ππ β π2
It was expected that the result of the first approach would yield a conservative estimate because it did
not consider the exact geometry of the arm or the inertia of the encoder wheel. Comparing the
combined inertias value just calculated with the value found using the first approach and we have a
value 28% greater. I’m very comfortable with the estimate of the second approach because I expected
it to be larger, but not drastically larger and I will continue with it.
Substituting all our Plant values into Equation 2.4, we now have a complete model of our Plant.
π(π ) =
0.0393
3.594π₯10−7 π 3 + 0.002389π 2 + 0.001558π
Or in normalized form:
π(π ) =
π 3
109348.9
+ 6647.1π 2 + 4335π
2.2.5 Step 5 – Test Model
To test the model of our system, we will subject our Plant model and actual Plant to a number of
different inputs and compare the results. In order to help with this a Simulink model called
base_open_loop_model has been created. Since we already have captured the data for a ramp input to
our actual Plant in the Matlab workspace, let’s apply it to our Simulink model and compare.
Note 1 – Our Simulink model reads in both the Time vector T and Reference Input vector R to run
through our Plant model and compares it to the Output vector Y. However, to do this successfully, T, R
and Y each need to be converted from a single row vector to a single column vector using the transpose
operator “ ‘ “.
Note 2 – As shown in Figure 2.19, I had to add a Zero-Order Hold and Quantizer function block to
base_open_loop_model. Since we’re using a microcontroller to implement our Controller, we are
actually implementing a discrete control system where this course deals strictly with systems in the
continuous time domain. In order to get the two systems to work together, the Zero-Order Hold
function block takes discrete data and converts it to continuous data where the Quantizer function block
converts continuous data to discrete data.
23
Figure 2.19 – Simulink base_open_loop_model
Shown in Figure 2.20 is the Angular Position vs Time plot generated by the Scope function block in
base_open_loop_model. It compares the results of our Plant model with the actual Plant when
subjected to a ramp input. The results are very encouraging.
Figure 2.20 – Comparison Plot of Plant Model and Actual Plant when Subjected to a Ramp Input
Let’s compare step input results. To do so we’ll open the ControlsLabBaseCode.ino file and program the
Arduino Mega for Open Loop Step mode where:
Mode = 0, Step_Input = 100, I_Gain = 318.3, Time = 5 and Period 10.
24
This will output a step voltage of (100/255)β12V or 4.7V for the entire test duration. Using the collect.m
Matlab script to collect the test data, transposing vectors T, R and Y, and running it through our
base_open_loop_model yielded the plot shown in Figure 2.21. Again, the results are very encouraging.
Figure 2.21 - Comparison Plot of Plant Model and Actual Plant when Subjected to a Step Input
One more test; let’s try a chirp input. A chirp is a signal in which the frequency increases (‘up-chirp’) or
decreases (‘down-chirp’) with time. The term chirp is used interchangeably with sweep signal [5]. Open
the ControlsLabBaseCode.ino file and program the Arduino Mega for Open Loop Chirp mode where:
Mode = 2, Freq_Final = 2, PWM_Amp = 50, I_Gain = 318.3, Time = 10 and Period = 10.
This will output a sinusoidal signal that will range between +/- (50/255)β12V or +/- 2.35V with the
frequency linearly increasing from 0 to 2Hz. Using the collect.m Matlab script to collect the test data,
transposing vectors T, R and Y, and running it through our base_open_loop_model yielded the plot
shown in Figure 2.22.
25
Figure 2.22 - Comparison Plot of Plant Model and Actual Plant when Subjected to a Chirp Input
Again, the results are very similar but it’s obvious the motor is struggling with oscillating the system’s
inertia at this frequency by the drift in the position and the reduction in magnitudes of the oscillations as
the frequency increases. Out of curiosity, I’ll perform the same test without the arm attached. By
changing the J value for our Plant model, the two results can be compared. As shown in Figure 2.23, the
motor does a lot better job in keeping up with the commanded chirp signal and the Plant model
accurately predicts this result.
There is no standard way of concluding whether a model is accurate enough. However, upon visual
inspection, the results are very similar and I’m comfortable with concluding that this model is
sufficiently accurate to proceed. However, can it be simplified?
Figure 2.23 - Comparison Plot of Unloaded Plant Model and Actual Unloaded Plant when Subjected to
a Chirp Input
26
2.2.6 Step 6 – Simplification
It would be nice to reduce the order of our model to a second order model so that we can use standard
second order methods to develop a Controller. Presented are two approaches for accomplishing this.
2.2.6.1 Simplification Approach #1
For many DC motor models, the relative effect of the inductance is considered negligible compared to
the mechanical time constant and can be neglected. Let’s test this out.
By setting:
πΏπ = 0
We get the following new Plant model, where:
ππππ€1 (π ) =
0.0393
0.002389π 2 + 0.001558π
Or in normalized form:
ππππ€1 (π ) =
π 2
16.45
+ 0.652π
(2.8)
Interestingly, the denominator of the old Plant model and new Plant model, before converting to
normalized form, are the same except for the missing π 3 term. By using Matlab’s bode function to
create a Bode Diagram of both Plant models, as shown in Figure 2.24, we can see that they’re almost
identical, except for a slight difference in phase at higher frequencies.
Based on the Bode Diagram, I’m very comfortable with this simplification and require no further testing
to verify its validity.
27
Figure 2.24 – Bode Diagram Comparing the Original Plant Model with the New Plant Model
2.2.6.2 Simplification Approach #2
Another approach to reducing the order of the system is by Model Reduction. This method looks at the
Plant’s poles and zeros that are a factor of 10 or greater than the dominant poles and zeros and replaces
them with a DC gain (i.e. when s = 0).
For example, if you have a transfer function such as:
ππΉ(π ) =
(π + π§2 )(π + π§1 )(π + π§0 )
(π + π3 )(π + π2 )(π + π1 )(π + π0 )
Which has a value of:
ππΉ(0) =
(0 + π§2 )(0 + π§1 )(0 + π§0 )
π§2 β π§1 β π§0
=
(0 + π3 )(0 + π2 )(0 + π1 )(0 + π0 ) π3 β π2 β π1 β π0
When s = 0. And you recognize that π2 is greater than π3, π1 and π0 by a factor of 10 or greater, you can
replace (π + π2 ) with π2 . Thereby simplifying our example transfer function to:
ππΉπππ€ (π ) =
(π + π§2 )(π + π§1 )(π + π§0 )
(π + π3 ) β π2 β (π + π1 )(π + π0 )
28
Which has the same value as the original transfer function when s = 0 and at low frequencies. Of course,
at high frequencies there will be slight differences, but it will be negligible because the lower frequency
poles will dominate the response of the transfer function.
This method is effective for systems with a low bandwidth. However, if you’re looking to create a
system with a high bandwidth, those high frequency poles and zeros may be very important. Another
approach is to look at the Plant’s poles and zeros to see if there are any poles and zeros that can cancel
each other.
Using Matlab’s pole function, the Plant’s poles were found at:
P1 @ 0, P2 @ -0.652 and P3 @ -6646
Since there are no s terms in the Plant numerator, there are no zeros.
Shown in Figure 2.25 is a plot of the Plant model’s poles and zeros using Matlab’s pzmap function.
Fortunately none of the poles lie in the unstable Right Half Plane (RHP), however, it does have a pole
directly on the Imaginary axis. Furthermore, none of the poles have any imaginary components,
meaning the system is critically damped or over-damped. Since none of the poles are at the same
location, the system is considered overdamped. Interestingly, there is a very high frequency pole at
-6646 which should have very little effect on how the model performs. By removing this pole and
replacing it with a DC gain, our new Plant model is the following:
ππππ€2 (π ) =
109348.9
π (π + 0.6523)(6646)
Or:
ππππ€2 (π ) =
16.45
π (π + 0.652)
(2.9)
This new Plant model is identical to the result obtained from the Approach #1. Let’s try the transient
and steady-state response analysis technique to verify this result.
29
Figure 2.25 – Plot of Plant Model’s Poles and Zeros
2.2.7 Modeling Approach #2 –Transient and Steady State Response
The goal of this approach is to apply different Reference Input Signals into the open-loop system you
want to model to gain insight into what order it is, and hopefully derive some values for this model. A
good starting point is to apply a step input into your system and see how it reacts. Reusing the test data
collected earlier, shown in Figure 2.26 is a step input of (100/255)β12V or 4.7V.
30
Figure 2.26 – Open-Loop Step Response
There are 2 things to note from this open-loop step response. First, the slope at t = 0 is zero, which
indicates that the system must be second order system or higher. Oscillations in the output would have
also indicated a second order system or higher. Second, the output position does not reach a steady
state. Instead a steady velocity is reached. This indicates that our system may look like a first order
system with an integrator term after, as shown in Figure 2.27:
πΎ
ππ + 1
1
π
Figure 2.27 – Proposed Plant Model
Note –
1
π
= π, or the real portion of the pole.
31
If we differentiate the position output to get velocity, we get the following plot shown in Figure 2.28:
Figure 2.28 – Differentiated Position Output
As you can tell in Figure 2.28, the output does have a slope greater than zero at t = 0, there are no
oscillations and the output reaches a steady state, indicating a first order system. Based on the
knowledge that a first order system reaches 63.2% of its final value after 1 time constant T [6], we can
find our time constant T when the response has reached 63.2% of its final value of 100rad/s or
63.2rad/s. As shown on the same plot, red lines have been added to indicate this intersection which is
when T = 1.07s. Also, since our gain K is the steady state result divided by the gain of the open-loop step
input, our gain K is 100/4.7 or 21.3. Therefore our Plant model is:
π(π ) =
21.3
π (1.07π + 1)
Rearranging the result in Modeling Approach #1 into the same form as just derived results in:
π(π ) =
25.27
π (1.53π + 1)
Creating Bode Diagrams to compare both Plant models results in the plots shown in Figure 2.29. As you
can see, they are very close. There is a slight difference in the Phase plot but the Magnitude plot is
almost identical.
32
Figure 2.29 – Bode Diagram Comparison between Both Plant Models
Using the data collected earlier to run through our Simulink base_open_loop_model resulted in the
following plots:
Figure 2.30 - Comparison Plot of Plant Model and Actual Plant when Subjected to a Step Input
33
Figure 2.31 - Comparison Plot of Plant Model and Actual Plant when Subjected to a Ramp Input
Figure 2.32 - Comparison Plot of Plant Model and Actual Plant when Subjected to a Chirp Input
34
2.2.7.1 Conclusion
Both approaches yield acceptable models. However, with Approach #2, Transient and Steady-State
Response Analysis, was much easier and far quicker. Comparing Figures 2.20-22 and Figure 2.30-32, the
results are very similar, with neither being perfect. Since our intended purpose for this system is for
position control, we’ll proceed with the Plant model derived by Approach #2 because its step input
result is better. This concludes the System Identification portion and we’ll proceed to Controller Design.
Aside – If our Plant was a typical second order system such as:
π(π ) =
πΎ′ππ2
π 2 + 2πππ π + π€π2
(2.10)
And was underdamped, the damping ratio could be calculated from the percent overshoot (%OS) from a
step input by using [7]:
%ππ
−ππ (
)
100
π=
√π 2 + ππ2 (%ππ)
100
Furthermore, the damped natural frequency can be measured off the plot of the step response using
the equation shown below, where Δπ‘ is the time interval between two consecutive peaks [7]:
ππ =
2π
Δt
The natural frequency can then be calculated using [7];
ππ =
ππ
√1 − π 2
The DC gain K is calculated as before using [7]:
πΎ=
π π‘ππππ¦ π π‘ππ‘π π π‘ππ πππ ππππ π
ππππππ‘π’ππ ππ π π‘ππ ππππ’π‘
A similar approach can be taken using a chirp input to create a Bode Plot. See Extras: System
Identification for more information [7].
35
3.0 Controller Design – Phase 1
There are numerous techniques available, which range in complexity, to design a Controller. However,
this course is an introductory course and can’t possibly cover every technique. Instead, we’ll break our
design approach into two phases. The first phase will focus on creating a Proportional (P), Proportional
plus Derivative (PD), Proportional plus Integral (PI) and Proportional plus Derivative plus Integral (PID)
Controller using Transient Response Equations to a step input and the Root Locus method which is a
graphical method for examining how the roots or poles of a system change with variation of a certain
system parameter, commonly a gain within a feedback system [8]. As we continue to gain more
understanding, in the second phase we’ll apply Phase Lead-Lag Control and Feed Forward Control
techniques. You will notice that most of the techniques employed are for first and second order
systems. Higher order systems are beyond the scope of this course. Of course, if your career as an
engineer involves Controller design, you can add to the framework presented here. More importantly, it
is hoped that the concepts demonstrated here will give you a solid understanding and intuition into
Controller design.
It should also be mentioned that the Transient Response Equations shown in Section 3.1.1 and 3.1.2
deal strictly with time domain response to step inputs. Unfortunately, this course doesn’t have any
techniques for designing a Controller for other inputs such as a ramp or impulse, and doing a survey of
many textbooks, very few techniques exist. Since a step input involves a wide range of frequencies,
there is a good chance that a Controller designed for a step input would also react well to other inputs.
However, if you’re given only specifications that relate to inputs other than a step input, the only
technique you have is trial and error by intuition.
3.1 Proportional Control (P Control)
Presented in Figures 3.1,8,9,18 and 19 is the framework for P, PD, PI and PID Controller design based on
the curriculum taught in this course. The starting framework in Figure 3.1 attempts to find an
appropriate Proportional Controller. The system will look like this:
R(s)
I(s)
E(s)
+
∑
U(s)
P(s)
KP
.
Y(s)
-
H(s)
Figure 3.0 – System with Proportional Controller
36
Start with a Proportional
Controller
1st Order System?
Yes
Apply 1st Order Transient
Response Equation
Yes
Apply 2nd Order Transient
Response Equations
No
nd
2 Order System?
No
Order of System > 2
Apply Root Locus Method
as a Starting Point
Trial and Error
Test
Figure 3.1 – Flow Chart of Proportional Controller Design
37
Which results in the following transfer function:
π(π ) =
(3.0)
π(π )
πΎπ β π(π )
= πΌ(π ) β
π (π )
1 + πΎπ β π(π ) β π»(π )
Or the following block diagram:
R(s)
πΌ(π ) β
πΎπ β π(π )
1 + πΎπ β π(π ) β π»(π )
Y(s)
Figure 3.2 – Simplified System with Proportional Controller
3.1.1 1st Order Transient Response Equations to a Step Input
Based on the Equation 3.0, a 1st Order System without a zero with a Proportional Controller will look like
the following:
πΎ
πΎπ β (π + π )
π(π )
πΎπ πΎ β πΌ(π )
1
π(π ) =
= πΌ(π ) β
=
πΎ
π (π )
1 + πΎπ β (π + π ) β π»(π ) π + π1 + πΎπ πΎ β π»(π )
1
Or in standard form:
π(π ) =
π(π )
πΎ′π
=
π (π ) π + π
Where:
π = π1 + πΎπ πΎ β π»(π )
(3.1)
And:
πΎ ′ π = πΎπ πΎ β πΌ(π )
(3.2)
Using either the Transient Response Equation for 1% settling time to a step input [9]:
π‘π =
4.6
π
(3.3)
38
Or the Transient Response Equation for rise time for a step input [9]:
π‘π =
2.2
π
(3.4)
We can back calculate for π and then back calculate for πΎπ using Equation 3.1.
If your Plant has a zero in the numerator, temporarily ignore it and apply the above equations as a
starting point. Afterwards, iteratively tune your Controller by trial and error with the zero included.
Aside - For a first order system, no overshoot is possible, therefore ππ = 0. This is because the one
pole for a 1st order system must lie on the real axis. To have any kind of overshoot, a system must have
poles that have an imaginary component. However, since complex poles, which have an imaginary
component, only come in pairs, it’s impossible for a 1st order system to have a lone complex pole to
produce overshoot.
3.1.2 2nd Order Transient Response Equations to a Step Input
Based on the Equation 3.0, a 2nd Order System without a zero with a Proportional Controller will look like
the following:
πΎ
πΎπ β (
)
π(π )
πΎπ πΎ β πΌ(π )
(π + π1 )(π + π2 )
π(π ) =
= πΌ(π ) β
= 2
πΎ
π (π )
1 + πΎπ β (
) β π»(π ) π + (π1 + π2 )π + (π1 π2 + πΎπ πΎ β π»(π ))
(π + π1 )(π + π2 )
Or in standard form:
π(π ) =
π(π )
πΎ ′ ππ2
= 2
π (π ) π + 2πππ π + ππ2
Where:
ππ2 = π1 π2 + πΎπ πΎ β π»(π )
(3.5)
2πππ = π1 + π2
(3.6)
πΎ ′ ππ2 = πΎπ πΎ β πΌ(π )
(3.7)
And:
And:
39
Depending on which specifications are given, use the following Transient Response Equations for a step
input [11]. For the rise time:
π‘π =
1.8
ππ
(3.8)
For an underdamped system, the percentage of overshoot:
2
ππ = π −ππ⁄√1−π , 0 ≤ π < 1
(3.9)
Which occurs at the peak time of:
π
ππ
π‘π =
(3.10)
Where:
ππ = ππ √1 − π 2
(3.11)
For a 1% settling time:
4.6
π
(3.12)
π = πππ
(3.13)
π‘π =
Where:
Im(s)
Im(s)
Im(s)
π = π ππ−1 π
π
ππ
Re(s)
Re(s)
Re(s)
Figure 3.3 – Graphs of Regions in the S-Plane for Rise Time, Overshoot and 1% Settling Time
Respectively for a Step Input [11]
40
Shown in Figure 3.3 are the graphs of regions in the s-plane that are produced by the aforementioned
Transient Response Equations for rise time, overshoot and 1% settling time for a step input.
For an undamped and underdamped 2nd order system, the resulting poles will be at:
π 1,2 = −π ± πππ
π€βππ 0 ≤ π < 1
For a critically damped 2nd order system, both poles will be at:
π 1,2 = −π
π€βππ π = 1
For an overdamped 2nd order system, both poles will be unique but lie on the Real axis.
If your Plant has one or more zeros in the numerator, temporarily ignore it/them and apply the above
equations as a starting point. Afterwards, iteratively tune your Controller by trial and error with the
zero(s) included. Know that a zero in the Left Half Plane (LHP) of the s-plane will increase the overshoot
to a step response if the zero is within a factor of 4 of the real part of the complex poles, and a zero in
the RHP will suppress the overshoot but may cause the step response to start out in the wrong direction
[12].
Note 1 – For the derivations in Sections 3.1.1 and 3.1.2, it was assumed that I(s) and H(s) were strictly
gains.
Note 2 - It should be noted that these equations are qualitative guides and not precise design formulas.
They are meant as a starting point for design iteration [10]. For tuning the Controller for a 2nd Order
System, if the system is responding too slow, increase the natural frequency ππ . If there is too much
overshoot, increase the damping coefficient π. If the transients persist too long, move the pole π left in
the s-plane. [9].
Note 3 – If you are given 1 specification to a step input, using the Transient Response Equations for a
second order system will result in one unique value for πΎπ . If you have been given 2 specifications to a
step input, each will produce a value for πΎπ and it most cases, each value will be unique and produce
transient responses that do not satisfy both specifications. If you were to combine specifications and
combine the regions shown in Figure 3.3, you will get a unique set of poles to meet the specifications.
However, there is a good chance that a Proportional Controller will not be able to produce that desired
result. This can be verified by plotting the system’s Root Locus.
41
3.1.3 Root Locus Method
As mentioned earlier, the Root Locus Method is a technique that shows how change in one system
parameter will modify the roots of the system’s characteristic equation. It’s a powerful technique that
can be used for any order of system comprised of both poles and zeros where the number of poles is
equal to or greater than the number of zeros. The only stipulation is that only one parameter can be
modified at one time. It’s beyond the scope of this guide to go into the details of drawing a Root Locus
by hand. Instead, we’ll focus on some of the equations derived from the formation of a Root Locus and
how to use Matlab to expedite the drawing process.
As shown in Figure 3.4, the typical focus of the Root Locus method are the elements inscribed within the
red box. It consists of the Controller πΎπ , the Plant P(s) and the Feedback Transfer Function H(s). It
should be noted that this method can be applied to any variable within a system but in this course, we’ll
only focus on Controller variables.
R(s)
I(s)
E(s)
+
∑
P(s)
KP
.
Y(s)
-
H(s)
Figure 3.4 – Focus of Typical Root Locus Shown in Red
This results in the characteristic equation of:
1 + πΎπ π(π ) β π»(π ) = 0
(3.14)
And if you vary πΎπ from zero to infinity, you will create the system’s Root Locus.
Breaking Equation 3.14 into its complex components you have the equation for the magnitude:
|πΎπ π(π ) β π»(π )| = 1
(3.15)
< πΎπ(π ) β π»(π ) = ±180°(2π + 1)
(3.16)
And the angle:
42
Or:
π
∑π
π=1 < (π + π§π ) + ∑π=1 < (π + ππ ) = ±180°(2π + 1)
(3.17)
Where:
k = # of poles − # of zeros − 1
(3.18)
And for a pole or zero with the form π = π + ππ, the angle is computed using the following:
π
< π = tan−1 ( )
π
(3.19)
When using the Root Locus method for a multi-order system, this technique will only help you to
visualize the system and how it changes with different values of πΎπ . This will allow you to see which
values of πΎπ produce a stable system whereby the system’s poles exist in the LHP but it will not allow
you to estimate its performance characteristics such as rise time, overshoot and settling time. These
features can only be determined by simulation in Simulink or testing on the physical system.
Aside - When using the Root Locus function rlocus(sys) in Matlab, keep in mind that:
π π¦π = π(π ) ∗ π»(π )
3.1.4 A Note on Higher-Order Systems
In some instances, it may be possible to temporarily reduce the order of the system to second order by
ignoring some of the system’s poles if they are much larger and less dominant than two of the slower
poles. Unlike the method of Model Reduction mentioned earlier where you replace high frequency
poles and zeros with a DC gain, you are temporarily ignoring them so that you can then use the 2nd order
Transient Response Equations shown earlier to give you a starting point. However, trial and error are
required to further tune the Controller when the other poles are reintroduced. Keep in mind that an
additional pole in the LHP will increase the rise time to a step response significantly if the extra pole is
within a factor of 4 of the real part of the complex poles [12].
43
3.1.5 Test
If the Proportional Controller meets the specifications given you can skip to the Section 5.0, Controller
Validation. Following Figure 3.8, if the Proportional Controller produces too much overshoot, proceed
to Proportional plus Derivative Control. If your Controller produces too much steady state error, skip to
Proportional plus Integral Control. If instead your Controller produces too much overshoot and steady
state error, skip to PID Control.
3.1.6 Example Continued – P Controller Design
As mentioned in Section 2.2, the desired performance specifications for this system are:
1) Maximum overshoot of 5% for a unit step input.
2) Rise time of 0.1s for a unit step input.
3) Zero steady-state error to a unit step input.
Since we have reduced our Plant Transfer Function to a second order system, and because a
Proportional Controller does not add a pole or zero to our closed-loop transfer function, we can apply
the 2nd Order Transient Response Equations presented in Section 3.1.2. But first we need to rearrange
our Plant Transfer Function to look like the following:
π(π ) =
πΎ
(π + π1 )(π + π2 )
Therefore our Plant Transfer Function, in the above form is:
π(π ) =
19.9
(π + 0)(π + 0.935)
3.1.6.1 π²π· Calculation Based on Overshoot Specification
We could try to rearrange Equation 3.9 to find the damping coefficient, but fortunately someone else
already did this and created a graph of this relationship. Using Figure 3.23 on page 118 of Feedback
Control of Dynamic Systems [11], a 5% overshoot results in a damping coefficient of:
π = 0.7
Rearranging Equation 3.6 for ππ results in:
ππ =
π1 + π2
2π
(3.20)
44
By substituting our values for π1 , π2 and π into Equation 3.20 results in:
ππ =
0 + 0.935
= 0.67 πππ/π
2(0.7)
Rearranging Equation 3.5 for πΎπ results in:
πΎπ =
ππ2 − π1 π2
πΎ β π»(π )
(3.21)
By substituting our values for ππ , π1 , π2 , πΎ and π»(π ) into Equation 3.21 results in:
πΎπ =
(0.67)2 − (0)(0.935)
π
= 7.04π₯10−5
19.9(318.3)
πππππππ πππ’ππ‘π
In order to test this result, I’ve created a Simulink model called base_closed_loop_model and added the
model elements particular to this example. I then setup a unit step input to inject into our model to see
the result. Shown in Figure 3.5 is a very smooth but slow response to a step input. Though it meets our
overshoot specification of 5%, it in no way comes close to our target rise time of 0.1s. Let’s apply the 2 nd
Order Transient Response Equations for rise time and compare.
Figure 3.5 – Unit Step Response for KP of 7.04x10-5
45
3.1.6.2 π²π· Calculation Based on Rise Time
Rearranging Equation 3.8 for ππ results in:
ππ =
1.8
π‘π
(3.22)
And substituting our value for π‘π into Equation 3.22 results in:
ππ =
1.8
= 18 πππ/π
0.1
And substituting our values for ππ , π1 , π2 , πΎ and π»(π ) into Equation 3.21 results in:
πΎπ =
(18)2 − (0)(0.935)
π
= 0.051
19.9(318.3)
πππππππ πππ’ππ‘π
Substituting this new value for πΎπ into our Simulink model resulted in the unit step response shown in
Figure 3.6. Yikes!
Figure 3.6 – Unit Step Response for KP of 0.051
46
3.1.6.3 π²π· Calculation for Zero Steady-State Error
Fortunately no calculation is required to find our system’s steady-state error. Since our system is a Type
1 system, and because it has one integrator term in the denominator, it inherently has zero steady-state
error for a step input regardless of the Controller chosen.
Aside – For more information on system Types and Steady-State Error Design, see Section 3.5.
3.1.6.4 Conclusion
We can only meet 2 of the 3 Design Specifications. As expected, the overshoot and rise time
specification conflict with each other. Out of interest I plotted the Root Locus using Matlab to see what
is really going on. As you can see from Figure 3.7, as you increase the value for ππ greater than 0.4675,
the value for πdecreases, so when we tried to decrease our rise time by increasing ππ , the value for
πdecreased creating a no-win situation.
Figure 3.7 – Root Locus of our Plant
To further understand why the Proportional Controller failed, let’s use the damping ratio of 0.7 that
results from the overshoot specification and the natural frequency of 18 rad/s that results from the rise
time specification to calculate the desired closed-loop poles where:
π π1,2 = −π ± πππ = −πππ ± πππ √1 − π 2
(3.23)
47
π π1,2 = −12.6 ± π12.85
This produces the same result as combining the regions shown in Figure 3.3 to create a unique set of
poles. It should be obvious by our Root Locus, as shown in Figure 3.7, that no value for πΎπ will intersect
with these locations.
Since we met our steady-state specification, we’ll try a Proportional plus Derivative Controller.
3.2 Proportional plus Derivative Control (PD Control)
Following Figure 3.8, if your Proportional Controller produces too much overshoot but the steady state
error is acceptable, apply Proportional plus Derivative Control as shown in Figure 3.9. As a starting
point, apply the 2nd Order Transient Response Equations. If you’ve been given 1 time domain
specification to a step input you will end up with a region as in Figure 3.3 or if you’ve been given 2 time
domain specifications to a step input you can calculate ππ and π in order to calculate the desired closedloop poles with Equation 3.23. If you have a second order system and you’ve been given 2 time domain
specifications for a step input and there are no zeros in your Plant, apply Coefficient Mapping otherwise
apply Root Contour Iteration. Keep in mind that both of these methods will not produce the desired
Controller after one iteration. It is meant as a starting point to an iterative approach driven by intuition
and trial and error.
No
Too much Overshoot?
Apply Proportional plus
Integral Control
Yes
Too much Steady
State Error?
No
Apply Proportional plus
Derivative Control
Yes
Apply PID Control
Figure 3.8 – Flowchart for PI, PD and PID Controller Design
48
nd
Apply 2 Order Transient
Response Equations as a
Starting Point
Yes
Order = 2?
2 Specifications
Given and No Zero in
Plant?
No
Apply Root Contour
Iteration
Yes
No
Apply Root Contour
Iteration
Apply Coefficient
Mapping
Test
Trial and Error
Figure 3.9 – Flowchart for PD Controller Design
3.2.1 Coefficient Mapping
Coefficient Mapping is a simple method to find Controller gains whereby you compare the terms of the
characteristic equation of a second order system with like terms of the polynomial of the desired closedloop poles. From the generic system model we have the following characteristic equation:
1 + πΆ(π ) β π(π ) β π»(π ) = 0
(3.24)
Where a PD Controller is:
πΆ(π ) = πΎπ + πΎπ· π
49
And for a normalized 2nd order system without any zeros:
π(π ) =
π(π )
πΎ
= 2
π·(π ) π + π1 π + π0
And the Feedback Transfer Function is assumed to be a gain, where:
π»(π ) = π»1
We now can rearrange Equation 3.24 to look like the following:
π·(π ) + π»1 (πΎπ + πΎπ· π ) β π(π ) = 0
And if we substitute our equations we get:
π 2 + (π1 + π»1 πΎπ· πΎ)π + (π0 + π»1 πΎπ πΎ) = 0
(3.25)
Which we can equate to our desired closed-loop poles of:
π π1,2 = −π ± ππ
We get:
π 2 + (π1 + π»1 πΎπ· πΎ)π + (π0 + π»1 πΎπ πΎ) = (π + π + ππ)(π + π − ππ) = π 2 + 2ππ + (π2 + π 2 )
Now if we match coefficients, we get the following equations:
π1 + π»1 πΎπ· πΎ = 2π
π0 + π»1 πΎπ πΎ = π2 + π 2
(3.26)
(3.27)
And rearranging Equations 3.26 and 3.27 will give us our gains for our PD Controller.
3.2.2 Root Contour Iteration
Root Contour Iteration is an iterative approach to applying Root Locus methods. It’s best suited for
situations where you have one or two or (at most) three parameters that you want to vary, i.e. in a PID
Controller. The basic idea is to successively hold all but one of the parameters in the Controller
constant, and vary the one parameter that is not fixed via a Root Locus plot to see the effect on the
desired closed-loop region or poles. The parameter that was varied is then fixed, and another
parameter is varied in the same way. This process continues until your Root Locus intersects with the
desired closed-loop region or poles [13].
50
3.2.3 Trial and Error
Both Coefficient Mapping and Root Contour Iteration will get you into the ball park but will not directly
get you to the Controller you want. However, with experience you can take the results of an iteration
and apply your intuition to move the desired closed-loop region or poles to improve system response.
3.2.4 Example Continued – PD Controller Design
Since our P Controller produced too much overshoot but the steady error specification was met, let’s try
a PD Controller. Fortunately, since we have a second order Plant with no zeros and a have been given 2
time domain specifications to a step input we have two methods available. We’ll start with Coefficient
Mapping and then try Root Contour Iteration to verify our results.
3.2.4.1 PD Controller Design Approach #1 - Coefficient Mapping
In Section 3.1.6.4 we calculated our desired closed-loop poles as:
π π1,2 = −12.6 ± π12.85
Following the instructions in Section 3.2.1, we get the following characteristic equation:
π 2 + (0.935 + (318.3)πΎπ· (19.9))π + (0 + (318.3)πΎπ (19.9)) =
π 2 + (0.935 + 6336.3πΎπ· )π + 6336.3πΎπ
Which we’ll equate with our desired characteristic equation:
(π + 12.6 + π12.85)(π + 12.6 − π12.85) = π 2 + 25.2π + 324
By using Equation 3.26 and rearranging for πΎπ· we get:
πΎπ· =
2π − π1 2(12.6) − 0.935
πβπ
=
= 3.83π₯10−3
π»1 πΎ
318.3(19.9)
πππππππ πππ’ππ‘π
By using Equation 3.27 and rearranging for πΎπ we get:
π2 + π 2 − π0 (12.6)2 + (12.85)2 − 0
π
πΎπ =
=
= 0.051
π»1 πΎ
318.3(19.9)
πππππππ πππ’ππ‘π
Which gives us the following PD Controller:
πΆ(π ) = πΎπ + πΎπ· π = 0.051 + 3.83π₯10−3 π
51
3.2.4.2 PD Controller Design Approach #2 – Root Contour Iteration
1st Iteration - Since there is no defined starting point for this method, I’ll arbitrarily set πΎπ to 1 and vary
πΎπ· . This results in the following characteristic equation:
π 2 + (0.935 + (318.3)πΎπ· (19.9))π + (0 + (318.3)(1)(19.9)) = π 2 + (0.935 + 6336.3πΎπ· )π + 6336.3
Now if we arrange our characteristic equation into the following form:
1+πΎβ
π(π )
=0
π(π )
We get:
1 + 6336.3πΎπ· β
π 2
π
=0
+ 0.935π + 6336.3
Using Matlab’s rlocus(sys) function make sure that:
π π¦π =
π(π )
π
= 2
π(π ) π + 0.935π + 6336.3
Doing so we get the Root Locus plot shown in Figure 3.10 where I’ve found the closest points of
intersection. Note the desired closed-loop poles in red.
Figure 3.10 – Root Locus Plot with π²π· = 1 and π²π« Varied
52
Note that both the positive and negative real components of our desired closed loop poles result in
approximately the same gain value of:
πΎ = 24.4
And this produces a Derivative gain value of:
πΎπ· =
24.4
πβπ
= 3.85π₯10−3
6336.3
πππππππ πππ’ππ‘π
2nd Iteration - Now let’s set πΎπ· to 3.85x10-3 and vary πΎπ . . This results in the following characteristic
equation:
π 2 + (0.935 + (318.3)(3.85π₯10−3 )(19.9))π + (0 + (318.3)πΎπ (19.9)) = π 2 + 25.2π + 6336.3πΎπ
Or:
1 + 6336.3πΎπ β
π 2
1
=0
+ 25.2π
Using Matlab’s rlocus function where:
π π¦π =
1
π 2 + 25.2π
We get the Root Locus plot shown in Figure 3.11. As you can see, this Root Locus plot goes through our
desired closed-loop poles, which are estimated by Matlab to produce 4.57% of overshoot with a
damping ratio of approximately 0.7 and natural frequency of 18rad/s. Our gain for these points is found
to be:
πΎ = 323
Which results in the Proportional gain of:
πΎπ =
323
π
= 0.051
6336.3
πππππππ πππ’ππ‘π
And the following PD Controller:
πΆ(π ) = πΎπ + πΎπ· π = 0.051 + 3.85π₯10−3 π
53
Figure 3.11 – Root Locus Plot with π²π« = 3.85x10-3 and π²π· Varied
3.2.5 Conclusion
As expected, both methods produced almost identical gains for our PD Controller. Now let’s test our
Controller. By modifying the Simulink model called base_closed_loop_model created earlier I got the
results shown in Figure 3.12. I also added the 2nd order approximation as a means of comparison.
Figure 3.12 - Unit Step Response for PD Controlled System and 2nd Order Approximation
54
With respect to our PD Controller, the result shown in yellow in Figure 3.12 shows 20% overshoot but a
rise time of 0.05s. This leads us to ask why our rise time is easily met but our overshoot is off when we
designed our PD Controller to match the characteristics of our desired closed-loop poles. The short
answer is that we didn’t factor in the result of our added zero by the addition of the Derivative term.
Looking at the poles and zeros of our closed-loop system we get:
P1 and P2 @ -12.6 ± j12.82 and Z1 @ -13.32
As you’ll notice, the real portion of the poles and the zero are very close which would account for
greater overshoot. As mentioned previously in Section 3.1.2, any additional zero within a factor of 4 of
the real component of the nearest pole will have a noticeable effect. Comparing the rise times between
the PD controlled system with the result of the 2nd order approximation, the PD controlled system is
much quicker, which is a nice bonus of the additional zero.
With respect to the 2nd order approximation results, you’ll notice that the overshoot specification is met
but the rise time is not. As mentioned previously, the 2nd Order Transient Response equations are an
approximation and we’re noticing this inaccuracy. You’ll also notice that we now have a steady state
error which was not there previously. Why is that? It’s because our 2nd order approximation, with its
two complex poles has lost its zero in the denominator, reducing it to a Type 0 system.
3.2.6 Reality Check - Saturation
Digging a little deeper into our model highlights a problem with the physical limits of our system.
Figure 3.13 – System Model
55
However, before I get into the problem, let me first explain the system model shown in Figure 3.13. I’ve
created 3 separate models that get routed through a multiplexer to be plotted on the same graph. One
of the quirks I found in Matlab is that a function block has to be proper. That means that the order of
the denominator must be equal or greater than the order of the numerator. This means that you can’t
implement a PD or PID Controller using a function block. To work around this, in the top model I
switched the numerator of the Plant with the numerator of the Controller. A little confusing but it
works. However, it creates another problem in that I can’t monitor the Controller Output Signal U(s).
To work around this I created a second model using Matlab’s PD Controller transfer function. Now I’m
sure you’re going to ask ‘Why didn’t I use it in the first place dummy?’. I would have liked to but Matlab
implements their PD Controller using the following equation:
ππ· πΆπππ‘ππππππ = π + π·
π
1+π
1
π
Searching the documentation they call their Derivative implementation a ‘Filtered Derivative’ where N
determines the pole location. This high-pass filter is used to get around the original quirk I found where
the transfer function has to be proper. (This kind of Filtered Derivative is also called a Phase Lead
Controller. See Section 4.3 for more information.) I was able to achieve matching results between the
top two models when I set N to 1000, which puts the pole at 1000rad/s and well outside the system’s
bandwidth. (For more information in system bandwidth see Section 5.1.1) Now that the second model
works I was able to add a scope after the PD Controller function block and found the following:
Figure 3.14 – Controller Output Signal Response from Unit Step Input
56
It may be a little hard to tell by Figure 3.14 but the Controller Output Signal initially jumps to 1400V then
settles out to something a little more reasonable. Realistically though, we don’t have a power supply
that could source the lethal voltage of 1400V. Furthermore, even if we could find that kind of power, it
would surely fry the motor controller and the motor itself. For our tests we’ve been running the motor
off a 12V power supply so to model this physical limitation, as shown in Figure 3.15, I’ll add a saturation
block after the Controller.
Figure 3.15 – Saturation Block in Simulink Model
As shown in the plot from the scope placed after the saturation block in Figure 3.16, the voltage
supplied to the Plant is now limited to ±12V.
Figure 3.16 - Controller Output Signal Response After Saturation Block from Unit Step Input
However, as shown in Figure 3.17, the addition of the saturation block has a drastic effect on our
system’s performance (shown in purple). Our system response to a step input with the addition of the
saturation block now resembles the 2nd order approximation in that the overshoot is close to our
specification but the rise time is quite sluggish. What do we do next?
57
3.2.7 Trial and Error
Our first stab at developing a PD Controller was close but still needs some tweaking, but how? Since our
most salient problem seems to be rise time, and since we know from Figure 3.3 the rise time is governed
by the system’s natural frequency, let’s keep our damping frequency the same and increase ππ . By
increasing the natural frequency arbitrarily to 25 rad/s we get the following desired closed-loop poles:
π π1,2 = −πππ ± πππ √1 − π 2 = −0.7(25) ± π25√1 − (0.7)2 = −17.5 ± π17.8
Figure 3.17 – Unit Step Response of PD Controlled System Without Saturation Block, With Saturation
Block and 2nd Order Approximation Without Saturation Block
Using Equation 3.26 and rearranging for the Derivative gain we get:
πΎπ· =
2π − π1 2(17.5) − 0.935
πβπ
=
= 5.4π₯10−3
π»1 πΎ
318.3(19.9)
πππππππ πππ’ππ‘π
And using Equation 3.27 and rearranging for the Proportional gain we get:
πΎπ =
π2 + π 2 − π0 (17.5) + (17.8)2 − 0
π
=
= 0.1
π»1 πΎ
318.3(19.9)
πππππππ πππ’ππ‘π
And the following PD Controller:
πΆ(π ) = πΎπ + πΎπ· π = 0.1 + 5.4π₯10−3 π
58
As shown in Figure 3.18, our new PD Controller, shown in purple, meets all our specifications with an
overshoot of 3.7% and a rise time of 0.9s. You’ll also notice that it has zero steady-state error for a step
input. The next step is to validate our Controller by implementing it on our physical system and then to
look into its stability. However, before we do that let’s talk about PI and PID control and then look into
Phase Lead/Lag Controller Design and Feedforward Design.
Figure 3.18 – Unit Step Response of PD Controlled System Without Saturation Block, With Saturation
Block and 2nd Order Approximation
3.3 Proportional plus Integral Control (PI Control)
Following Figure 3.8, if your Proportional Controller produces too much steady state error but the
overshoot is acceptable, apply Proportional plus Integral Control as shown in Figure 3.19. Since a PI
Controller adds both a zero and a pole to the closed-loop transfer function, our 2nd 0rder Transient
Response Equations do not directly apply; however, they can be used as a starting point. If you’ve been
given 1 time domain specification to a step input you will end up with a region or if you’ve been given 2
time domain specifications to a step input you can calculate ππ and π in order to calculate the desired
closed-loop poles with Equation 3.23. If you have a first order system and you’ve been given 2 time
domain specifications for a step input and there are no zeros in your Plant, apply Coefficient Mapping
otherwise apply Root Contour Iteration. Keep in mind that both of these methods will not produce the
desired Controller after one iteration. It is meant as a starting point to an iterative approach driven by
intuition and trial and error.
59
3.3.1 Integral Windup
One of the unique side effects from the addition of the Integral term is something called Integral
Windup. This applies to both PI and PID Controllers. Because the Integral term accumulates the error
between the desired reference and the actual output, when a large change in set-point occurs, the
output will continue to overshoot until the error accumulated before reaching the set-point equals the
error accumulated while exceeding the set-point. There are many techniques to combat this
phenomenon but they’re beyond the scope of this course.
nd
Apply 2 Order Transient
Response Equations as a
Starting Point
Yes
Order = 1?
2 Specifications
Given and No Zero in
Plant?
No
Apply Root Contour
Iteration
Yes
No
Apply Root Contour
Iteration
Apply Coefficient
Mapping
Test
Trial and Error
Figure 3.19 – Flowchart for PI Controller Design
60
3.4 Proportional plus Integral plus Derivative Control (PID Control)
Following Figure 3.8, if your Proportional Controller produces too much steady state error and too much
overshoot, apply Proportional plus Integral plus Derivative Control as shown in Figure 3.20. Since a PID
Controller adds a zero and two poles to the closed-loop transfer function, our 2nd order Transient
Response Equations do not directly apply; however, they can be used as a starting point for Root
Contour Iteration. Keep in mind that this method will not produce the desired Controller after one
iteration. It is meant as a starting point to an iterative approach driven by intuition and trial and error.
Aside - For another technique on tuning a PID Controller, try the Zeigler-Nichols Method.
nd
Apply 2 Order Transient
Response Equations as a
Starting Point
Apply Root Contour
Iteration
Test
Trial and Error
Figure 3.20 – Flowchart for PID Controller Design
61
3.5 Steady State Error Design
Using the Final Value Theorem we can calculate the Steady State Error, as shown below:
ππ π = lim π(π‘) = lim π πΈ(π ) = lim π [ π (π )πΌ(π ) − π»(π )π(π )]
π‘→∞
π →0
π →0
ππ π = lim π π (π )πΌ(π ) [1 −
π →0
ππ π = lim π π (π )πΌ(π ) [
π →0
π»(π ) πΆ(π )π(π )
]
1 + πΆ(π )π(π )π»(π )
1
]
1 + πΆ(π )π(π )π»(π )
Fortunately, this type of calculation is quite common and a table based on system Type for common
inputs is available. As shown in Table 3.0 we have the Steady State Errors for Step inputs, Ramp Inputs
and Parabola inputs based on the system Type. The system Type is based on the total number of poles
at the origin or integrator terms in the Controller C(s), the Plant P(s) and the Feedback Transfer Function
H(s).
System Type
Step Input
Ramp Input
πΌ(0)
1 + πΆ(0)π(0)π»(0)
Type 0
Type 1
0
Type 2
0
Parabola Input
∞
∞
πΌ(0)
πΆ(0)π(0)π»(0)
∞
0
πΌ(0)
πΆ(0)π(0)π»(0)
Table 3.0 – Steady State Errors as a Transfer Function Type
62
4.0 Controller Design – Phase 2
Now that we’ve had a chance to try our hand at different forms of PID Controllers, let’s try some more
advanced techniques. First, let’s try Phase Lead/Lag Controllers
4.1 Phase Lead/Lag Controllers
Interestingly, a Phase Lead Controller is much like a PD Controller in that it acts to speed up response
and increasing stability by shifting the Root Locus to the left. Furthermore, a Phase Lag Controller is
much like a PI Controller in that it attempts to eliminate steady-state error by shifting the Root Locus to
the right.
For myself, I like to think of Phase Lead/Lag Controllers as hybrid Controllers. In the case of a Phase
Lead Controller, we start with the following general equation but set p greater than z:
πΆπΏπππ/πΏππ (π ) =
π +π§
π +π
If we arbitrarily set z equal to 1 and p equal to 10 and compare it to a PD Controller with unity gains we
get the following Bode Diagram:
PD Controller
Phase Lead Controller
Figure 4.0 – Bode Diagram of Phase Lead Controller vs PD Controller
63
When comparing the Bode Diagrams in Figure 4.0 you’ll notice that both Magnitude plots start to ramp
at 20dB per decade at 1rad/s or the location of the zero. However, because of the pole in the
denominator of the Phase Lead Controller, its Magnitude plot levels off at 10rad/s where the Magnitude
plot for the PD Controller continues to ramp indefinitely. You’ll also notice one of the drawbacks of the
Phase Lead Controller in the reduction in magnitude at low frequencies. Furthermore, the Phase Lead
Controller produces a hump in its Phase plot centered in between its zero and pole locations, starting at
0 degrees and ending at 0 degrees where the Phase plot for the PD Controller starts at 0 degrees and
ramps up to 90 degrees where it levels off. The length, height and centre point of this hump is the focus
of Phase Lead Controller design in the effort to increase Phase Margin.
Conversely, a Phase Lag Controller produces a valley centered about its zero and pole locations (Figure
4.1). This is the consequence of having z greater than p. This valley is actually the main drawback of
Phase Lag Controller design. Instead, the focus of Phase Lag Controller design is to balance the sideeffects of the phase lag distortion by appropriately designing the size and location of this valley in order
to boost the gain of the system at low frequencies, thereby improving steady-state tracking
performance and disturbance rejection. As shown in Figure 4.1, both Controllers boost low frequency
gain.
PI Controller
Phase Lag Controller
Figure 4.1 – Bode Diagram of Phase Lag Controller vs. PI Controller
64
4.1.2 Introduction to Gain and Phase Margins
The concept of Gain and Phase Margins are best explained with the use of an example. Consider the
following closed-loop system:
R(s)
1.5
+
∑
1
π +1
π 2
2
+ 2π + 1
.
Y(s)
-
1.5
Figure 4.2 – Block Diagram of Example Closed-Loop System
Using Matlab’s margin(sys) function for an open-loop system where:
π π¦π = πΌ(π ) β πΆ(π ) β π(π )
And for our example:
π π¦π = 1.5 β
1
2
β 2
π + 1 π + 2π + 1
We get the Bode Diagram shown in Figure 4.3. Matlab tells us that the Gain Margin is 8.52dB at the
Phase Crossover Frequency πππ of 1.73rad/s and I’ve added an arrow to indicate this. The Gain Margin
is calculated using the following equation:
πΊπππ ππππππ = 0ππ΅ − πΊπππ
Where Gain is the distance between the curve and 0dB at the Phase Crossover Frequency πππ . Notice
that if the Gain Margin is below 0dB at the Phase Crossover Frequency the Gain is negative resulting in a
positive Gain Margin and if it’s above 0dB the Gain is positive, resulting in a Gain Margin that’s negative.
If the Phase plot never dips below -180°, the Gain Margin is considered to be infinite.
Matlab has also calculated our Phase Margin to be 41.7° at the Gain Crossover Frequency πππ
of 1.04 rad/s and I’ve added an arrow to indicate this. The Phase Margin is calculated using the
following equation:
πβππ π ππππππ = 180° + πβππ π
Where Phase is the value of the curve at the Gain Crossover Frequency πππ . Notice that if the Phase
Margin is above -180° the Phase Margin is positive and if the Phase Margin is below -180° the Phase
Margin is negative. If the Magnitude plot never dips below 0dB, the Phase Margin is considered to be
infinite.
65
πππ
Phase Margin
Gain Margin
πππ
Figure 4.3 – Bode Diagram of Example Closed-Loop System
When designing a Controller, the conservative rule of thumb for stability margins are:
πΊπππ ππππππ ≥ 10ππ΅ and
πβππ π ππππππ ≥ 60°
However, some texts promote typical stability margins as low as:
πΊπππ ππππππ ≥ 6ππ΅ and
πβππ π ππππππ ≥ 30°
The idea behind the Gain and Phase Margins are that they provide a factor of safety. If you were
walking along the a cliff, would you feel comfortable with walking right along the edge, or would say 10
feet from the edge make you feel more comfortable? With experience you’ll know when you can get
away with less conservative stability margins but for now it would probably be wise to stick with the
conservative approach.
66
4.1.3 Phase Lead Controller Design
Following Figure 4.4, if your Proportional Controller produces too much overshoot but the steady state
error is acceptable, apply Phase Lead Control.
No
Apply Phase Lag Control
Too much Overshoot?
Yes
Too much Steady
State Error?
No
Apply Phase Lead
Control
Yes
Apply Phase Lead and
Lag Control
Figure 4.4 – Flowchart for Phase Lead/Lag Controller Design
Following the procedure laid out by Prof. Dan Davison in his SYDE 352 Course Notes [13], our objective is
to satisfy the specifications using:
πΆ(π ) = πΎ β πΆπΏπππ (π ) = πΎ
1 1 + πππ
√π 1 + ππ
(4.0)
Where:
K = Controller gain
a = ratio of pole position to zero positon (a > 1)
T = pole time constant (T > 0)
67
Which results in the following Bode Diagram:
20πππ10 √π
0
-20πππ10 √π
ππ
0
1
ππ
ππ
1
π
Figure 4.5 – Bode Diagram of General Phase Lead Controller
Step 1: Sketch the Bode plot of the open-loop system. As shown in Figure 2.0, our open-loop system
will consist of:
πππ = πΌ(π ) β πΆ(π ) β π(π )
Where:
πΆ(π ) = 1
Step 2: If a desired Gain Crossover Frequency πππ is known, adjust the gain K so that the Gain Crossover
Frequency of KβP(s) is equal to the desired Gain Crossover frequency. Accomplish this by trial and error
with Matlab’s margin function or by inspection of the Bode Diagram and convert the value in dB using
the following equation:
πΎ = 10
(
ππ΅ π£πππ’π
)
20
68
Set:
ππ = πππ
OrUsing the Final Value Theorem, calculate the gain K to meet the steady-state error specification and add
a buffer of 10dB in anticipation of the decrease in gain that will result from the Lead Controller.
Set:
ππ = πππ
OrIf no specifications are given that the gain can influence, set:
πΎ = 1 πππ ππ = πππ
Step 3: Determine the Phase Margin of the augmented open-loop system where:
π π¦π = πΌ(π ) β πΎ β π(π )
Step 4: Determine the additional phase lead ππ required to meet the Phase Margin required. If no
Phase Margin has been specified, use the following approximation to determine the desired Phase
Margin for a Second Order System:
πππ ≈ 100π,
π€βπππ 0 ≤ π ≤ 0.7
Or the rule of thumb of:
πππ ≥ 60°
If the phase lead ππ is greater than 60Μ°, using two Phase Lead Controllers, each contributing ππ /2.
Step 5: Use the phase lead ππ to compute the ratio of the pole position to the zero position by:
π=
1 + π ππππ
1 − π ππππ
(4.1)
Step 6: Compute the pole time constant using:
π=
1
ππ √π
(4.2)
Step 7: Test to see if specifications are met. If not, go back to Step 1.
69
4.1.4 Example Continued – Phase Lead Controller Design
Since our P Controller produced too much overshoot but the steady-state error specification was met,
let’s try a Phase Lead Controller. Following the procedure laid out in Section 4.1.3, our first step is to
plot the Bode Diagram of our open-loop system. As shown in Figure 4.6, we have a:
πΊπππ ππππππ = ∞ and
πβππ π ππππππ = 0.676° @79.2πππ/π
Figure 4.6 – Bode Diagram of Open-Loop Example System
Clearly our Phase Margin needs some adjustment. Since a Gain Crossover Frequency has not been given
and our steady-state error for a step input has been satisfied by our Type 1 system, we’ll set:
πΎ = 1 and
ππ = πππ = 79.2πππ/π
Since we have a K value of 1, the augmented Phase Margin is the same as our original Phase Margin of:
πβππ π ππππππ = 0.676°
70
Since our Plant is second order, we can use the damping ratio based on the percentage of overshoot to
calculate our desired Phase Margin of:
πππ ≈ 100π = 100(0.7) = 70°
Therefore our additional phase lead required is:
ππ = πππ − ππ = 70° − 0.676° = 69.324°
However, this additional phase lead is greater than 60°, so we’ll have to design for two Controllers, each
contributing half the additional phase lead of:
ππ =
69.324°
= 34.662°
2
Using Equation 4.1 we can compute the pole/zero ratio.
π=
1 + π ππππ 1 + sin(34.662)
=
= 3.64
1 − π ππππ 1 − π ππ(34.662)
Using Equation 4.2 we can compute the pole time constant.
π=
1
ππ √π
=
1
79.2√3.64
= 6.62π₯10−3 π ππππππ
Using the parameters just calculated, we get the following Phase Lead Controller:
πΆ(π ) = πΎ
1 1 + πππ
1 1 + 3.64(6.62π₯10−3 )π
1 + 0.024π
= (1)
= 0.52
−3
1 + 6.62π₯10 π
1 + 6.62π₯10−3 π
√π 1 + ππ
√3.64
However, since we had to create two equal Controllers to get the additional phase lead required we’ll
put them in series like this:
πΆ(π ) = 0.52
1 + 0.024π
1 + 0.024π
β 0.52
−3
1 + 6.62π₯10 π
1 + 6.62π₯10−3 π
Or:
πΆ(π ) = 0.25
1 + 0.024π
1 + 0.024π
β
−3
1 + 6.62π₯10 π 1 + 6.62π₯10−3 π
By modifying the Simulink model called base_closed_loop_model created earlier, I tested our Phase
Lead Controller versus the PD Controller designed earlier. As shown in Figure 4.7, the overshoot is
approximately 3.6% and the rise time is 0.077s, both below the specifications and better than the PD
Controller. You’ll also notice that both Controllers produce zero steady-state error for a step input.
71
Figure 4.7 - PD Controller vs Phase Lead Controller for a Step Input
Out of interest I rechecked the Gain and Phase Margins for our new Phase Lead Controller. As shown in
Figure 4.8, our Gain Margin has stayed at infinity and our Phase Margin has increased to 69.6°. You’ll
also notice that the Magnitude Plot of the open-loop system with the Controller has been shifted down
before the Gain Crossover Frequency and shifted up after. This was one of the expected side effects of
the Phase Lead Controller. However, the Phase Plot shows a pronounced hump at the Gain Crossover
Frequency which created the boost in Phase Gain we were looking for.
Figure 4.8 – Bode Diagram of Open-Loop System With and Without Phase Lead Controller
72
We now have 2 Controllers we will need to validate, but before we do, let’s look at two more
Controllers.
4.2 Phase Lag Controller Design
Following Figure 4.4, if your Proportional Controller produces too much steady state error but the
overshoot is acceptable, apply Phase Lag Control. Following the procedure laid out by Prof. Dan Davison
in his SYDE 352 Course Notes [13], our objective is to satisfy the specifications using:
(4.3)
1 + ππ
πΆ(π ) = πΎ β πΆπΏππ (π ) = πΎπ
1 + πππ
Where:
K = Controller gain
a = ratio of zero position to pole positon (a > 1)
T = zero time constant (T > 0)
Which results in the following Bode Diagram:
20πππ10 π
0
0
0
ππ
1
ππ
ππ
1
π
Figure 4.9 – Bode Diagram of General Phase Lag Controller
73
Step 1: Sketch the Bode plot of the open-loop system. As shown in Figure 2.0, our open-loop system
will consist of:
πππ = πΌ(π ) β πΆ(π ) β π(π )
Where:
πΆ(π ) = 1
Step 2: If a desired Gain Crossover Frequency πππ is known, adjust the gain K so that the Gain Crossover
Frequency of KβP(s) is equal to the desired Gain Crossover frequency. Accomplish this by trial and error
with Matlab’s margin function or by inspection of the Bode Diagram and convert the value in dB using
the following equation:
πΎ = 10
(
ππ΅ π£πππ’π
)
20
Set:
ππ = πππ
OrIf the desired Phase Margin is known, adjust the gain K so that Phase Margin of KβP(s) is the desired
value plus an extra 5° in anticipation of the loss of Phase Margin that will occur when we include the lag
compensation. Set:
ππ = πππ
If no Phase Margin has been specified, use the following approximation to determine the desired Phase
Margin for a Second Order System:
πππ ≈ 100π,
π€βπππ 0 ≤ π ≤ 0.7
Or the rule of thumb of:
πππ ≥ 60°
If it is not possible to get the desired Phase Margin, then a Phase Lead Controller will be required to
boost the Phase Margin. Skip to Section 4.3.
Step 3: Using the Final Value Theorem, determine if the steady-state error has been satisfied by the
augmented Plant KβP(s). If it is, then you don’t need a Phase Lag Controller because a P Controller will
suffice. Otherwise, determine the extra gain factor that you need to satisfy the steady-state error. This
is the value of a. If a is greater than 15, use two Phase Lag Controllers, each contributing a gain factor of
√π.
74
Step 4: Use the Gain Crossover Frequency πππ of KβP(s) to calculate the zero time constant by:
10
(4.4)
π=
πππ
Step 5: Test to see if specifications are met. If not, go back to Step 1.
4.3 Phase Lead/Lag Controller Design
Sometimes the Design Specifications cannot be met by using a Phase Lead Controller or a Phase Lag
Controller alone, but only by using a combination of lead and lag compensation. The Phase Lag
Controller is used at low frequencies to boost the Gain, and the Phase Lead Controller is used at midfrequencies (near the Gain Crossover Frequency) to improve Phase Margin [13].
Following the procedure laid out by Prof. Dan Davison in his SYDE 352 Course Notes [13], our objective is
to satisfy the specifications using:
1 1 + πππ
1 + π′π
πΆ(π ) = πΎ β πΆπΏπππ πΆπΏππ = πΎ (
) (π′
)
1 + π′π′π
√π 1 + ππ
(4.5)
Where:
K = Controller gain
a = ratio of pole position to zero positon (a > 1)
T = pole time constant (T > 0)
a’ = ratio of zero position to pole positon (a’ > 1)
T’ = zero time constant (T’ > 0)
Step 1: Sketch the Bode plot of the open-loop system. As shown in Figure 2.0, our open-loop system
will consist of:
πππ = πΌ(π ) β πΆ(π ) β π(π )
Where:
πΆ(π ) = 1
Step 2: If a desired Gain Crossover Frequency πππ is known, adjust the gain K so that the Gain Crossover
Frequency of KβP(s) is equal to the desired Gain Crossover frequency. Accomplish this by trial and error
with Matlab’s margin function or by inspection of the Bode Diagram and convert the value in dB using
75
the following equation:
πΎ = 10
(
ππ΅ π£πππ’π
)
20
Set:
ππ = πππ
OrUsing the Final Value Theorem, calculate the gain K to meet the steady-state error specification and add
a buffer of 10dB in anticipation of the decrease in gain that will result from the Lead Controller.
Set:
ππ = πππ
OrIf no specifications are given that the gain can influence, set:
πΎ = 1 πππ ππ = πππ
Step 3: Determine the Phase Margin of the augmented open-loop system where:
π π¦π = πΌ(π ) β πΎ β π(π )
Step 4: Determine the additional phase lead ππ required to meet the Phase Margin required. Be sure
to add an extra 5° to offset the effects of the Phase Lag Controller. If no Phase Margin has been
specified, use the following approximation to determine the desired Phase Margin for a Second Order
System:
πππ ≈ 100π,
π€βπππ 0 ≤ π ≤ 0.7
Or the rule of thumb of:
πππ ≥ 60°
If the phase lead ππ is greater than 60Μ°, using two Phase Lead Controllers, each contributing ππ /2.
Step 5: Use Equation 4.1 to compute the ratio of the pole position to the zero position.
Step 6: Use Equation 4.2 to compute the pole time constant.
Step 7: Using the Final Value Theorem, determine the extra gain factor that you need to satisfy the
steady-state error for the augmented Plant πΎ β πΆπΏπππ . This is the value of a’. If a’ is greater than 15, use
two Phase Lag Controllers, each contributing a gain factor of √π.
76
Step 8: Use the Gain Crossover Frequency πππ of πΎ β πΆπΏπππ to calculate the zero time constant by:
π′ =
10
πππ
(4.6)
Step 9: Test to see if specifications are met. If not, go back to Step 1.
4.4 Feedforward Design
There seems to be two very different topologies that are considered Feedforward Design. The one
topology attempts to read and react to disturbances in an effort to account for future deviations.
Basically, this topology attempts to control the disturbances. I would consider this a multi input, single
output system and not a true Feedforward system. Instead we’ll consider the following arrangement:
F(s)
R(s)
.
I(s)
E(s)
+
∑
C(s)
+
+
P(s)
∑
.
Y(s)
U(s)
-
H(s)
Figure 4.10 – Typical Feedforward Control Topology
With this topology, a transfer function connects the Reference Input Signal R(s) with the Controller
Output Signal U(s). By adding the Feedforward transfer function in parallel with the Controller, a second
degree of freedom is added to the system, meaning that the Controller and the Feedforward transfer
functions can be designed separately. In comparison, the topology previously discussed in Figure 2.0 is
considered a one degree of freedom system. By adding the second degree of freedom, the Controller
can be designed so that the error transfer function has certain desirable characteristics where the
Feedforward transfer function can be selected to help satisfy the performance requirements with
reference to the input/output relationship. Other benefits to this design are that it unburdens the
Controller feedback loop because, under ideal circumstances, the Feedforward path generates most of
the signal, thereby allowing the Controller to provide only corrections and to respond to disturbances or
77
modelling inaccuracies. Problems with the Feedforward topology include requiring accurate knowledge
of the system to be controlled and extra computation requirements.
By looking at the closed-loop transfer function shown below:
π(π ) =
π(π )
(πΉ(π ) + πΆ(π )) β π(π )
= πΌ(π ) β
π (π )
1 + πΆ(π ) β π(π ) β π»(π )
(4.7)
You’ll notice that the Characteristic Equation is the same as the one degree of system we looked at
earlier. Therefore, our Controller can be designed using the methods outlined earlier. This also means
that our Feedforward transfer function can be non-linear and not affect how we design our Controller.
But how do we design the transfer function for the Feedforward term? Well, that’s only possible for a
process that is well understood. Usually it’s the inverse of the Plant or a portion of the Plant. Let’s
revisit our brushed DC motor system example to see how this works.
4.4.1 Example Continued – Feedforward Controller Design
By combining Equation 2.0 and 2.1, assuming the inductance to be negligible and applying Laplace
transforms assuming initial conditions of zero, we get the following equation:
ππ πΎπ‘ − ππ π ππ π − πΎπ‘ πΎπ ππ π = π½π π π ππ π 2
(4.8)
Now, this is where the art of Feedforward Design begins. We know from Section 2.2.1 where we
identified the system elements that the Controller Output Signal U(s) will be in volts, so let’s rearrange
Equation 4.8 to be in terms of volts.
ππ =
π½π π π
πΎπ‘ πΎπ +ππ π
ππ π 2 +
ππ π
πΎπ‘
πΎπ‘
(4.9)
In general, each of the two terms on the right side of Equation 4.9 could be used independently or
together for our Feedforward transfer function. However, since we’re looking to develop a Controller
for a step input, the first term will attempt to differentiate a step input twice. The first differentiation
will produce an impulse and the second differentiation will result in a doublet, which in this case is
effectively zero, making this option useless. The second term will produce an impulse, giving the system
a boost as the step input is applied but after that it will go back to zero. Since the addition of the
Feedforward term doesn’t affect our Controller design, I’ll reuse the PD Controller designed earlier in
Section 3.2.6. As shown in Figure 4.11, we have the original one degree of freedom design with a PD
Controller and our only viable Feedforward design with the same PD Controller.
As mentioned in
Section 3.2.6, Matlab won’t implement a pure derivative term because it’s an improper transfer
function. To get around this quirk I applied the solution they used for their PID Controller function block
by implementing a normalized high pass filter with a pole at 1000rad/s.
78
Figure 4.11 – Matlab Models of Original One Degree of Freedom Design Compared to Feedforward
Design
Interestingly, both models produce the same result. Why is that? Since our model is in continuous time,
there is no noticeable delay between the application of the step input and an error being produced for
the Controller to react to. And since the Controller has its largest output, basically at the same time as
impulse from the Feedforward term, and both outputs are greater than our physical saturation limit of
±12V, there is no difference in input to the Plant and its output.
Obviously this wasn’t the best example to apply Feedforward design to. My hope was that it would
show you how to apply the technique. Though Feedforward design is not that common, there are a
bunch of examples where it can come in handy. A useful instance is when you have a gravity term
affecting position control. You will be looking at this more in-depth with the inverted pendulum lab.
79
5.0 Controller Validation
Controller Validation is broken into two parts, Physical Testing and Stability Analysis. For Physical
Testing, you’ll implement your Controller on the actual system and run the required tests based on the
Design Specifications in order to determine if the specifications are met. This will also further confirm
the accuracy of your model. If the Physical Testing goes well, you’ll next look at the stability of your
system using your derived model. If your system meets the stability criterion, you can be confident that
your Controller will perform as required.
5.1 Physical Testing
In order to implement your Controller design, program the Arduino Mega 2560 by augmenting the
ControlsLabBaseCode.ino code. Using Mode 3 will allow you to implement a PID Controller and Mode 4
has been left blank for you to write your own code for other Controller types. In order to record your
system’s performance and validate your Controller design, use the Matlab program collect.m created
earlier.
5.1.1 Choosing the Proper Control Loop Frequency
This course only deals with control systems in the continuous time domain that we describe using the
Laplace operator s. This kind of system is generally built using analog electronics but this usually isn’t
the case in practice today. Usually you’ll be dealing with discrete systems implemented on
microcontrollers that operate at a controlled frequency fast enough to emulate analog control. This
kind of analysis uses the Z-transform as a mathematical tool. As a control engineer you’ll need to define
an appropriate Control Loop Frequency. A general rule of thumb is to use a frequency that is a factor of
10 or larger than the -3db cutoff point of the system. Of course, if you can operate at frequencies
greater than that, system performance will improve.
When using the ControlsLabBaseCode.ino code on the Arduino Mega 2560, each Mode has an input for
the Control Loop Frequency by the input variable Period. When setting the input variable Period, you
are selecting the Control Loop Period, which is the inverse of the Control Loop Frequency, in
milliseconds.
5.1.2 Example Continued – Physical Testing of PD Controller
We have 2 Controllers we want to validate, a PD Controller and a Phase Lead Controller, but first, we’ll
implement the PD Controller where:
πΆ(π ) = πΎπ + πΎπ· π = 0.1 + 5.4π₯10−3 π
80
To do so we’ll open the ControlsLabBaseCode.ino file and program the Arduino Mega for PID Closed
Loop Control for a Step Input mode where:
Mode = 3, Kp = 0.1, Ki = 0, Kd = 0.0054, Reference_Input = 1, I_Gain = 318.3, V_In = 12, Time = 5 and
Period 2.
Based on the discussion in Section 5.1.1 about Choosing the Proper Control Loop Frequency, I chose a
Control Loop Frequency of 500Hz. As shown in Figure 5.0, the bandwidth of the closed-loop system with
the PD Controller designed in Section 3.2.7 is 50.95Hz. (This same value can be verified using Matlab’s
bandwidth(sys) function.) Based on the prescribed rule of thumb of a factor of 10, we get a Control
Loop Frequency of 508Hz which we’ll approximate as 500Hz.
-3db
50.95Hz
Figure 5.0 – Bode Diagram of Example Closed-Loop System using PD Controller
Using the collect.m function created in Matlab, I was able to record and plot the response for a unit step
input of our system with the PD Controller devised earlier. As shown in Figure 5.1, the unit step
response looks good. It has a 2.7% overshoot, a rise time of 0.092s and zero steady-state error.
81
Figure 5.1 – Step Response for Example Closed-Loop System using PD Controller
Since we’ve met our Design Specifications, no more tests need to run. However, there is one last thing I
would like to do. I’d like to compare the response of our physical system with our modeled response.
Using the Simulink model I created called base_closed_loop_model_test, I was able to compare both
results. This program is very similar to the program created in Section 2.2.5 to compare open loop
results. As shown in Figure 5.2 our modeled response shown in yellow is very close to the actual
response shown in purple. I’m very confident our model is accurate enough to predict the system’s
stability in the Section 5.2.
5.1.3 Example Continued – Physical Testing of Phase Lead Controller
Using the ControlsLabBaseCode.ino file to program the Arduino Mega for Mode 4 operation, I wrote my
own code to implement the following Phase Lead Controller devised in Section 4.1.4:
πΆ(π ) = 0.25
1 + 0.024π
1 + 0.024π
β
−3
1 + 6.62π₯10 π 1 + 6.62π₯10−3 π
82
Figure 5.2 – Comparison Plot of Unit Step Response of Modeled System vs. Actual System using a PD
Controller
However, to write the code for this Controller requires the Controller Transfer Function to be first
converted from the Laplace domain to the discrete domain and then into a difference equation. To
convert from the Laplace domain to the z-domain, I used the following equation to convert its zeros and
poles:
π§ = π π π
(5.0)
Where T is the Control Loop Period in seconds.
However, before we can go any further, we’ll need to decide on the Control Loop Frequency for this
system using the Phase Lead Controller. Using Matlab’s bode function, the figure shown in Figure 5.3
was plotted and the closed-loop bandwidth was found to be 111.1Hz. Using the rule of thumb of a
factor of 10, we get a Control Loop Frequency of 1111Hz. Unfortunately, as mentioned in the previous
section, our Arduino Mega can only operate up to 1000Hz so we’re stuck with the Control Loop Period
of:
π = 0.001π
We’ll see what affect this has on the system’s performance.
83
-3db
111.1Hz
Stupid Matlab
Figure 5.3 – Bode Diagram of Example Closed-Loop System using Phase Lead Controller
Rearranging our Phase Lead Controller Transfer Function in terms of zeros and poles, we get the
following:
πΆ(π ) =
3.29(π + 41.6667)(π + 41.6667)
(π + 151.0574)(π + 151.0574)
Using Equation 5.0, we can covert our Laplace domain zeros to z-domain zeros as follows:
π§ = π π π = π −41.6667(0.001) = 0.9592
Using Equation 5.0, we can covert our Laplace domain poles to z-domain poles as follows:
π§ = π π π = π −151.0574(0.001) = 0.8598
This leaves us with the following transfer function:
πΆ(π§) =
π(π§ − 0.9592) (π§ − 0.9592)
(π§ − 0.8598)(π§ − 0.8598)
84
To calculate the value of k, the usual method is to equate the DC gain when s = 0 and z = 1. This results
in:
3.29(0 + 41.6667)(0 + 41.6667) π(1 − 0.9592) (1 − 0.9592)
=
(0 + 151.0574)(0 + 151.0574)
(1 − 0.8598)(1 − 0.8598)
Which gives us:
π = 2.96
And the following discrete Controller:
πΆ(π§) =
2.96(π§ − 0.9592) (π§ − 0.9592)
(π§ − 0.8598)(π§ − 0.8598)
Or in normalized form:
πΆ(π§) =
2.96π§ 2 − 5.678π§ + 2.723
π§ 2 − 1.72π§ + 0.7393
Now that our Controller is in the z-domain, our next step is to convert it into a difference equation.
Following the procedure laid out by Silvano Balemi [14], where he converts the general discrete
Controller:
π(π§) ππ β π§ π + ππ−1 β π§ π−1 + ππ−2 β π§ π−2 + β― π1 β π§ + π0
πΆ(π§) =
=
πΈ(π§)
π§ π + ππ−1 β π§ π−1 + ππ−2 β π§ π−2 + β― π1 β π§ + π0
Into the following form:
π’π = −ππ−1 β π’π−1 − β― −π0 β π’π−π + ππ β ππ + β― + π1 β ππ−π+1 + π0 β ππ−π
Where in this case k represents the discrete time step, we get the following Phase Lead Controller in
difference equation:
π’π = 1.72π’π−1 − 0.7393π’π−2 + 2.96ππ − 5.678ππ−1 + 2.723ππ−2
Coding and uploading this equation into the Arduino Mega and using the collect.m function in Matlab to
record and plot the response for a unit step input of our system results in the plot shown in Figure 5.4.
The unit step response looks good as well, with a 3.36% overshoot, a rise time of 0.095s and zero
steady-state error. Interestingly, the Phase Lead Controller did not perform as well on the physical
system as the PD Controller, which does not match our simulation results. Why is that? It’s most likely
because we were not able to implement our Phase Lead Controller at the required Control Loop
Frequency of 1111Hz.
85
Figure 5.4 – Step Response for Example Closed-Loop System using Phase Lead Controller
Since we’ve met our Design Specifications, no more tests need to run. However, again, I’d like to
compare the response of our physical system with our modeled response. As shown in Figure 5.5, the
actual response shown in purple seems to lag noticeably to the modeled response shown in yellow.
Fortunately, this deviation is most likely a result of the Control Loop Frequency implemented on the
Arduino Mega being lower then desired. I’m still very confident our model is accurate enough to predict
the system’s stability.
5.2 Stability Analysis
There are a number of ways to analyse the stability of your system but the best way to determine how
stable your system is, is to determine its Gain and Phase margins. In this course we’ll focus on two
methods. The first method, which I prefer, uses a Bode Diagram of the open-loop system and in Matlab
the margin function will plot the Bode Diagram and calculate the margins for you. The second method
uses a Nyquist Plot of the open-loop system, and I think it was devised by Electrical Engineers to punish
the world. Matlab has a nyquist function that draws the Nyquist Plot but you have to determine the
margins from the plot. Nyquist Plots are preferred when your system has a delay in it.
You might be asking, if our closed-loop poles are in the LHP, aren’t we good? Yes and no. If your system
was able to exist under perfect conditions and not change with time, then yes, it would remain stable.
86
Unfortunately, stupid reality gets in the way. The main culprits are model inaccuracies, aging, noise and
disturbances. Remember, the poles represent physical properties, and as a system ages, the properties
change and so do the locations of the poles. Likewise, noise and disturbances can push a stable pole to
the right of the Imaginary Axis and cause the system to go unstable. As a result, the best way to protect
your system from going unstable is to insure it has a sufficiently large stability margin.
Figure 5.5 – Comparison Plot of Unit Step Response of Modeled System vs. Actual System using a
Phase Lead Controller
5.2.1 Stability Analysis using Bode Diagrams
As discussed in Section 4.1.2, Bode Diagrams can be used to determine the Gain and Phase Margins so I
won’t go into further detail other than reiterating that the conservative rule of thumb for stability
margins are:
πΊπππ ππππππ ≥ 10ππ΅ and
πβππ π ππππππ ≥ 60°
87
5.2.1.1 Example Continued - Stability Analysis using Bode Diagrams for System with PD Controller
Using Matlab’s margin function for an open-loop system with the PD Controller, the following Bode
Diagram was plotted:
Figure 5.6 – Bode Diagram of Example System with a PD Controller
Using this function, Matlab calculates a Gain Margin of infinity and a Phase Margin of 65.5° at 38rad/s.
Both values exceed our conservative rule of thumb for Gain and Phase Margins so I’m confident our PD
Controller will remain stable regardless of aging, noise and/or disturbances.
5.2.1.2 Example Continued – Stability Analysis using Bode Diagrams for System with Phase Lead
Controller
Using Matlab’s margin function for an open-loop system with the PD Controller, the Bode Diagram in
Figure 5.7 was plotted.
88
Figure 5.7 – Bode Diagram of Example System with a Phase Lead Controller
Using this function, Matlab calculates a Gain Margin of infinity and a Phase Margin of 69.9° at 71.4rad/s.
Both values exceed our conservative rule of thumb for Gain and Phase Margins so I’m confident our
Phase Lead Controller will remain stable regardless of aging, noise and/or disturbances.
5.2.1 Stability Analysis using Nyquist Plots
Using Matlab’s nyquist function to draw our Nyquist Plot, we’re left to determine the Gain and Phase
margins ourselves. For Nyquist Plots, the Gain Margin is defined as the amount that the Nyquist Plot
would have to increase to intersect the (-1, 0) point. On a Nyquist Plot, the distance along the negative
real axis is measured between the origin and the intersection of the Nyquist Plot and the negative real
axis. This distance is the inverse of the Gain Factor. The Gain Margin, expressed in decibels, is calculated
using the following:
πΊπππ ππππππ(ππ΅) = 20πππ10 (
1
) = 20πππ10 (πΊπππ πΉπππ‘ππ)
πππ π‘ππππ ππππ π’πππ
(5.1)
89
If the Nyquist Plot intersects the real axis at the origin or on the positive real axis, the Gain Margin is
considered infinite.
Similarly, the Phase Margin is defined as the angle that the Nyquist Plot would have to change to move
to intersect the (-1, 0) point. On a Nyquist Plot, the angle is measured from the negative real axis about
the origin towards the intersection between the Nyquist Plot and the unit circle. If the angle is counterclockwise direction, it is considered positive. If the Nyquist Plot never intersects the unit circle, the
Phase Margin is considered infinite.
As shown below in Figure 5.8, the Sample Nyquist Plot has a Phase Margin of 112°. It also has a Distance
of 0.2, and using Equation 5.1, the Gain Margin is:
πΊπππ ππππππ(ππ΅) = 20πππ10 (
1
) = 20πππ10 (5) = 15ππ΅
0.2
Unit Circle
Distance = 0.2
Phase Margin = 112°
Figure 5.8 – Sample Nyquist Plot
We’ll use the same conservative rule of thumb for Gain and Phase margins that we used stability
analysis using Bode Diagrams.
90
6.0 References
[1] Ogata, Katsuhiko, “Modern Control Engineering”, page 159, Prentice Hall, New Jersey, 5th Edition,
2010.
[2] “Avago Download Page”, Accessed June 1st, 2015, http://www.avagotech.com/docs/AV02-1046EN.
[3] “Avago Download Page”, Accessed June 1st 2015, http://www.avagotech.com/docs/AV02-0096EN.
[4] Franklin, Gene and Powell, J. David and Emami-Naeini, Abbas,”Feedback Control of Dynamic
Systems”, page 48, Prentice Hall, New Jersey, 6th Edition, 2010.
[5] “Chirp”, Wikipedia: The Free Encyclopedia, Wikimedia Foundation Inc., May 5, 2015, Accessed June
12th, 2015, http://en.wikipedia.org/wiki/Chirp.
[6] Ogata, Katsuhiko, “Modern Control Engineering”, page 161, Prentice Hall, New Jersey, 5 th Edition,
2010.
[7]
“Extras:
System
Identification”,
Accessed
http://ctms.engin.umich.edu/CTMS/index.php?aux=Extras_Identification.
13th,
June
[8] “Root Locus”, Wikipedia: The Free Encyclopedia, Wikimedia Foundation Inc., January 24, 2015,
Accessed June 20th, 2015, http://en.wikipedia.org/wiki/Root_locus.
[9] Franklin, Gene and Powell, J. David and Emami-Naeini, Abbas, ”Feedback Control of Dynamic
Systems”, page 120, Prentice Hall, New Jersey, 6th Edition, 2010.
[10] Franklin, Gene and Powell, J. David and Emami-Naeini, Abbas, ”Feedback Control of Dynamic
Systems”, page 119, Prentice Hall, New Jersey, 6th Edition, 2010.
[11] Franklin, Gene and Powell, J. David and Emami-Naeini, Abbas, ”Feedback Control of Dynamic
Systems”, pages 116-119, Prentice Hall, New Jersey, 6th Edition, 2010.
[12] Franklin, Gene and Powell, J. David and Emami-Naeini, Abbas, ”Feedback Control of Dynamic
Systems”, page 129, Prentice Hall, New Jersey, 6th Edition, 2010.
[13] SYDE 352, Introduction to Control Systems, Course Notes, Package 2 of 2, Winter 2006, Prof. Dan
Davison, Dept. of Electrical and Computer Engineering, University of Waterloo.
[14] Balemi, Silvano, “Advanced Control”, June
http://www.dti.supsi.ch/~smt/courses/DigImpl.pdf.
3,
2011,
Accessed
August
13,
2015,
91
