Things to memorize from MAE 318

This course involves a large number of concepts to be integrated together. Controller design
problems, the end goal of this course, often involve multitude of steps and concepts applied
simultaneously. The only way to make things easier is to remember the following very basic
formulae/ideas/concepts at ALL the times.

Please review this page every week: before every HW and every exam or quiz.

1. Diff eq TF
Example:

A linear time invariant (LTI) differential equation in time domain, is equivalent to a transfer function
(TF) in s-domain.
E.g.: The diff eq. relating the input function u(t) to the output function
y(t) in time domain is equivalent to TF from U to Y: relating
input and output functions in the s-domain. If initial conditions are ignored: Y(s) = G(s)*U(s). Note
how numerator represents the input side and its derivatives, denominator represents the output
side and its derivatives, and each dot is equivalent to an s.
Differentiation in time domain is equivalent to multiplication by s in s-domain. This is one of the
most important property of the Laplace Transforms. Similarly, integration is multiplication by
1/s.

2. A TF is uniquely specified by its poles, zeros, and gain.

Example: For , we have
poles: -1+i and -1-i
zeros: -1 and -1.5
gain: 2
dc gain: 1.5 (This is )
Poles are the solutions of denominator polynomial. Zeros are the solutions of numerator
polynomial. Gain is the ratio of coefficients of leading powers of numerator and denominator. Dc
gain is the ratio of constant terms of numerator and denominator.
A transfer function can be written in various formats e.g., polynomial/polynomial, gain-pole-zero
format (where every polynomial is factored and coefficient of s is 1 in each first order factor) and
my favorite "dc gain format" (where everything is factored and constant terms in each factor (if

any) is 1). These are:

3. Algorithm to roughly plot a TF's response for some input u(t)

Steps: If all poles have negative real parts (i.e. stable), the solution starts from initial conditions
 and exponentially approach the particular solution that usually looks like the delayed version of
the input u(t).
1. This algorithm is based on the idea that the solution of LTI system has the format:

2. The coefficients in front of the exponential terms are chosen based on initial conditions such
that solution always has the correct initial value y(0) (or initial slope ydot(0) etc.). Hence, the
solution starts from the initial conditions.
3. If ALL the poles have negative real parts then all the exponential terms will approach zero
eventually, hence the solution will just exponentially approach the particular solution.
4. Particular solution (PS) usually looks like the delayed version of the input u(t). So, if the input
is a constant (step) the PS is a (different) constant too, if the input is linear (ramp) then the PS
is linear too (different slope and intercept), if the input is sine then the PS is a sine too (same
frequency but different amplitude and phase).
5. If the poles are complex numbers then it leads to the oscillations in the solution graph whose
frequency is the value of imaginary part of the pole and amplitude is proportional to
exponential of the real part. This is because
.

4. For dc (i.e., constant) inputs: Steady state response = dc gain * dc input

Example: If you give input u(t) = 2 to , the solution will reach 2 *
(3/2) = 3 in the steady state.
This is only true if the input to the TF (i.e., diff eq) is a constant and the differential equation is
stable. Dc input, step input, constant input, zero-frequency input, all mean the same thing.
This is not true if you give sinusoidal or any other input to the TF.

5. Settling time and % overshoot formulae for step response of the simple systems (1 pole or
2 complex poles, no zeros)
Formulae: and
Here is the real part of the pole and is the imaginary part.
These formulae are only true when you give step input to a TF with one pole (1st order) with no
zeros, or for a TF with two complex poles (2nd order underdamped) with no zeros.
Please also remember the plots of the responses.
 More formulae for the responses above:
Time constant of 1st order system: is . It's the time taken to reach 63.2% of the steady
value.
Peak time for 2nd order system: . It's time taken to go from zero to the maximum
value (assuming zero initial conditions).
Oscillation time period: . It's the time between two peaks or two valleys.
Oscillation frequency: rad/s. This is also called damped frequency, hence .
Natural frequency is the oscillation frequency where there is no damping i.e., damping ratio
. Otherwise: .
Oscillation decay rate is . It's the factor by which amplitude becomes smaller after every
oscillation time period. Note: .

6. Extra Zeros increase overshoot and make the response faster. Extra poles do the
opposite.
Example: The step response of 1/(s^2 + 2s + 2) has Ts of about 1s and %OS about 4.32%. But
(s+2)/(s^2 + 2s + 2) will have lower Ts and higher %OS. Ans 1/((s^2 + 2s + 2)(s+2)) will have
higher Ts and lower %OS.
The formulae and are only true for system with 1 pole (1st
order) or 2 complex poles (2nd order underdamped) and with no zeros. If you add (an extra) zero
to the TF you can expect overshoot more than what this formula says, and expect a smaller
settling time (more specifically smaller rise time) compared to what the formula says. If you add
an extra pole to the TF you can expect a lower overshoot and larger settling time, compared to
what these formulae say.
If a pole is close to a zero they cancel each other's effect: (s+2)/((s^2 + 2s + 2)(s+2.1)) has
similar response to 1/(s^2 + 2s + 2).
7. Poles/Zeros that have very negative real parts are not dominant. They are less effective in
changing %OS and Ts.
Example: (s+2)/(s^2 + 2s + 2) has higher overshoot than 1/(s^2 + 2s + 2) but lower overshoot
than (s+1)/(s^2 + 2s + 2).
This is because the solution is of the form:
Hence, if a pole has a really negative
real part, it's corresponding exponential term will decay really fast, and it won't have much effect.
Thus, the 'least negative' poles/zeros dominate the response. As a general rule of thumb, if a
pole/zero's real part is 5 times than the other, it can be ignored compared to the other. All these
facts can be used to approximate complicated TFs to simpler ones. Hence, (s+2)(s+3.01)
(s+10)/(s+1)(s+3)(s+20) behaves roughly the same as 0.50167(s+2)/(s+1). Note, how I kept the
dc gain the same, so that the step response reaches the same final value.

8. Mason's rule: TF from signal A to B = TFs in the forward path from A to B / (1 + Loop
TF)
Assumptions: This is Mason's rule for systems with one negative feedback loop (i.e., the signal is
fed back with a negative sign). Both the signals A and B should be available in the block diagrams
(as the wires / lines). The forward path should intersect with the loop e.g., TF from r to rf in the
general block diagram below is just F not F/(1 + GKH), because this path from r to rf doesn't
touch the loop at all.

9. Simple controller architecture and terminology

Description: The plant G is given, the controller C is to be found, with an aim that output y
reaches the reference r despite the presence of disturbance du. We call this system unity-
feedback (because there is no block in the feedback path) and 1 degree-of-freedom (because you
only get to design 1 block, which is C).

Definitions (special case of general ones below with F = H = 1)

Loop TF (aka Open-loop TF): GC
OLZs (open-loop zeros): zeros of G and C
OLPs (open-loop poles): poles of G and C

CLTF (closed-loop TF from r to y): (Note the mason's rule)

CLZs (closed-loop zeros): zeros of G and C (same as OLZs)
CLPs (closed-loop poles): solutions of 1+GC=0 (Not the same poles of G and C) (These
 CLPs are given by root locus of GC)

Y= *R + * Du (Note: the mason's rule to get TF from R to Y and TF from

Du to Y)
U= *R + * Du (Note: the mason's rule to get TF from R to U and TF from
Du to U)
E = R- Y = R - Y from above = *R + * Du

10. General controller architecture and terminology

Description: The plant G and sensor H are given, the controller C and pre-filter F are to be found,
with an aim that output y reaches the reference r despite the presence of disturbance du. We call
this system non-unity-feedback (because there is H in the feedback path) and 2 degree-of-
freedom (because you get to design 2 blocks, which are C and F). For system with single-input
single-output (siso) blocks, this is the most general you can go. This is because a control system
takes take in two things: sensor output ym and reference r and produces one thing: input to the
plant u. Thus, any control system choice can be reduced to two independent transfer functions
(blocks) relating U to Ym and R.

Definitions:
Loop TF (aka Open-loop TF): GCH
OLZs: zeros of G, C and H
OLPs: poles of G, C and H

CLTF: FGC/(1 + GCH) (Note the mason's rule)

CLZs: zeros of F, G, C and poles of H
CLPs: poles of F and solutions of 1+GCH=0 (These are given by root locus of GCH)

Y= *R + * Du (Note: the mason's rule to get TF from R to Y and TF

from Du to Y)
U= *R + * Du (Note: the mason's rule to get TF from R to U and TF
from Du to U)
 E = R- Y = R - Y from above = *R + * Du

11. Three main error formulae and conclusions

Proof (by final value theorem): error in steady state,

Error due to step reference:

If GCH has no 1/s then the error is finite.
If GCH has one or more 1/s then error will be zero.

Error due to ramp reference:

If GCH has no 1/s then the error is infinite.
If GCH has one 1/s then error will be finite.
If GCG has two ore more 1/s then error will be zero.

Error due to step disturbance du:

If CH has no 1/s (or G has no s) then the error is finite.

If CH has one or more 1/s (or G has one or more s) then error will be zero.

Note: All errors get smaller when the controller's dc gain (limit as s goes to zero) becomes larger.

12. Root locus of open-loop TF shows how CLPs will change if you change controller gain
Definition: Rlocus of GCH gives you solutions of 1 + kGCH= 0 (i.e., CLPs) as the gain of
controller C changes by a factor k from 0 to infinity.
Steps: First mark the zeros of GCH as o's and poles of GCH as x's in the complex plane. These
x's and o's divide the real axis into segments. Mark the segments which are part of the rlocus.
These are 2nd, 4th, 6th, etc. segments from the right. (These would be 1st, 3rd, 5th etc. if the
gain went from 0 to -infinity). Then, mark the asymptotes as dashed lines. Number of asymptotes
N = number of x's - number of o's). All the asymptotes start from the same point on real axis
which is (sum of x's - sum of o's)/N. The angles of asymptotes depend of their number N. For
N=1, the angle is -180. For N=2, the angles are +90 and -90. For N=3, the angles are +60, -60
and -180. For N=4, the angles are +45, -45, +135 and -135. The angles would be different if the
gain went from 0 to -infinity.
Now finally draw the rlocus lines, which are the paths of closed loop poles as the gain factor k
changes from 0 to infinity. These paths start from x's and go towards o's OR approach (not
directly follow) the asymptote lines. The paths are unique and they are symmetric about the real
axis. Make sure to fully utilize all the real-axis segments that you marked earlier.
Basic rloci shapes to memorize, as gain goes from 0 to infinity.
 Most important note: Zeros pull the root locus to the left.

13. Control design via rlocus for step/ramp inputs

Steps:
1. First perform the error calculations. They will always boil down to having the controller gain
beyond a particular value and/or having integrator(s) in the K.
2. Then mark the region where the CLPs should be, for getting the right settling time and
overshoot. You may use and , but these formulae are only
true if CLTF has one/two poles with no zeros.
3. Now assume the simplest controller (proportional as default or integral if the error calculations
want it) and draw the rlocus of OLTF. See if the rlocus lines pass through the correct regions,
thus indicating that there exists a controller gain that get the CLPs in the correct region.
4. Otherwise, iteratively add poles and zeros in the controller, as necessary, to get the rlocus
(and CLPs) in the correct region. Remember, adding zero(s) pull the rlocus to the left.
5. Always be aware of CLPs and CLZs at each step. If you have more than two CLPs and any
CLZs the settling time and overshoot regions are not correct. A CLZ will increase overshoot
and reduce settling time and a third (or more) CLP will decrease overshoot and increase
settling time.
6. I often use pole-zero cancellation to keep CLTF simple. E.g., make a controller pole/zero
cancel the plant zero/pole, or add a pole in the prefilter F to cancel any unwanted CLZs.
Never do pole-zero cancellation for the unstable poles (because we never know our TFs
exactly in the real-life, and inexactly cancelled unstable pole will lead to instability).
7. The tips to reduce the value of input u(t) that the controller wants to be given to the plant are
1) reduce the controller gain 2) add pole to the prefilter (to make the controller more proper)
and 3) add a pole to the pre-filter (to smoothen the reference command).
8. The rlocus analysis will give you the (general/variable) location of poles/zeros needed in the
controller (and pre-filter). To find the exact numerical controller gain/poles/zeros, first write the
CLTF = FGC/(1 + GCH) and then find CLPs (as variables) and set them equal to the
 numerical values of your choice (hopefully in the correct region). Now solve/find the variables
in the controller (gain, zero, poles, etc.). All these calculations are automatically done for you,
if you use sisotool, and in there you don't even have to worry if settling time/overshoot
formulae are correct or not, because it will show you the exact responses.

14. Basic controller types

A controller is a combination of poles and zeros and gain. But certain combinations have special
names.
1. Proportional controller (P) : k (no poles/zeros, just gain)
It's the default and the simplest!
2. Proportional-derivative controller (PD): k(s+z) = kp + kd*s (one zero)
Make the response faster due to the zero, but can make overshoot and u(t) values worse.
3. Proportional-integral controller (PI): k(s+z)/s = kp + ki/s (one zero and a pole at origin)
The integrator (pole at origin) helps with errors, but can worsen (increase) settling time and
worsen (increase) overshoot due to the zero.
4. Proportional-integral-derivative controller (PID): k(s^2 + as + b)/s = kp + ki/s + kd*s (two
zeros and a pole at origin)
Combination of PI and PD effects.
5. Lead controller: k(s+z)/(s+p) (zero is less negative than pole, it's dominant)
Same effects as PD, but u(t) and overshoot would not be as bad.
6. Lag controller: k(s+z)/(s+p) (pole is less negative than zero, it's dominant)
Same effects as PI, but settling time and overshoot would not be as bad.
7. Lead-Lag controller: k(s+z1)(s+z2)/(s+p1)(s+p2) (combination of lead and lag)
Combination of lead and lag effects.

Comments

You'll see all these concepts as you go through the videos. Please take notes and commit to
memory as you see them.
Humans usually are good with problems that involve 1-2 steps. Problems in this class (especially
toward the end) will easily involve 7-10 steps, so the only way for you to understand/do those in
short time is if you have the basics things/formulae in your working memory and not just in your
notes/cheat sheets.
If the above items are not absolutely committed to (rote) memory it becomes really really hard for
people. Please trust me on this!! I have been doing this for years and diagnosing the issues
people face.
Thinking that you don't need to remember these, and you can just look them up in the cheat sheet
of the exams is the biggest fallacy which I hope you don't learn the hard way.