Introducción A La Ingenieria de Control

SYSTEM
Introduction: System Modeling

The first step in the control design process is to develop appropriate mathematical models of the system derived either from physical
laws or experimental data. In this section, we introduce the state-space and transfer function representations of dynamic systems. We
then review some basic approaches to modeling mechanical and electrical systems and show how to enter these models into MATLAB
for further analysis.
Key MATLAB commands used in this tutorial are: ss , tf
Contents
Dynamic Systems
State-Space Representation
Transfer Function Representation
Mechanical Systems
Example: Mass-Spring-Damper System
Entering State-Space Models into MATLAB
Entering Transfer Function Models into MATLAB
Electrical Systems
Example: RLC Circuit
System Identification
System Conversions
Dynamic Systems
Dynamic systems are systems that change or evolve in time according to a fixed rule. For many physical systems, this rule can be
stated as a set of first-order differential equations:
(1)
In the above equation,
is the state vector, a set of variables representing the configuration of the system at time . For instance in a
simple mechanical mass-spring-damper system, the two state variables could be the position and velocity of the mass.
is the vector
of control inputs at time , representing the externally applied "forces" on the system, and is a possibly nonlinear function giving the
time derivative (rate of change) of the state vector,
for a particular state, input, and time.
The state at any future time,
, may be determined exactly given knowledge of the initial state,
, and the time history of the
inputs,
, between and by integrating Eq.(1). Though the state variables themselves are not unique, there is a minimum number of
state variables, , required in a given system for the above to hold true. is referred to as the system order and determines the
dimensionality of the state-space. The system order usually corresponds to the number of independent energy storage elements in the
system.
The relationship given in Eq.(1) is very general and can be used to describe a wide variety of different systems; unfortunately, it may
be very difficult to analyze. There are two common simplifications which make the problem more tractable. First, if the function, ,
does not depend explicitly on time, i.e.
, then the system is said to be time invariant. This is often a very reasonable
assumption, since the underlying physical laws themselves do not typically depend on time. For time invariant systems, the parameters
or coefficients of the function, , are constant. The control input, however, may still be time dependent,
.
The second common assumption concerns the linearity of the system. In reality, nearly every physical system is nonlinear. In other
words, is typically some complicated function of the state and inputs. These nonlinearities arise in many different ways, one of the
most common in control systems being "saturation" in which an element of the system reaches a hard physical limit to its operation.
Fortunately, over a sufficiently small operating range (think tangent line near a curve), the dynamics of most systems are
approximately linear, that is
.
Until the advent of digital computers (and to a large extent thereafter), it was only practical to analyze linear time invariant (LTI)
systems. Consequently, most of the results of control theory are based on these assumptions. Fortunately, as we shall see, these results
have proven to be remarkably effective and many significant engineering challenges have been solved using LTI techniques. In fact,
the true power of feedback control systems are that they work (are robust) in the presence of the unavoidable modeling uncertainty.
State-Space Representation
For continuous linear time invariant (LTI) systems, the standard state-space representation is given below:
(2)
(3)
where is the vector of state variables (nx1), is the time derivative of state vector (nx1), is the input or control vector (px1), is the
output vector (qx1), is the system matrix (nxn), is the input matrix (nxp), is the output matrix (qxn), is the feedforward matrix
(qxp).
The output equation, Eq.(3), is necessary because often there are state variables which are not directly observed or are otherwise not of
interest. The output matrix, , is used to specify which state variables (or combinations thereof) are available for use by the controller.
Also often there is no direct feedforward in which case is the zero matrix.
The state-space representation, also referred to as the time-domain representation, can easily handle multi-input/multi-output
(MIMO) systems, systems with non-zero initial conditions, and nonlinear systems via Eq.(1). Consequently, the state-space
representation is used extensively in "modern" control theory.
Transfer Function Representation

LTI systems have the extremely important property that if the input to the system is sinusoidal, then the output will also be sinusoidal
at the same frequency but in general with different magnitude and phase. These magnitude and phase differences as a function of
frequency are known as the frequency response of the system.
Using the Laplace transform, it is possible to convert a system's time-domain representation into a frequency-domain output/input
representation, known as the transfer function. In so doing, it also transforms the governing differential equation into an algebraic
equation which is often easier to analyze.
The Laplace transform of a time domain function,
, is defined below:
(4)
where the parameter
is a complex frequency variable. It is very rare in practice that you will have to directly evaluate a
Laplace transform (though you should certainly know how). It is much more common to look up the transform of the function you are
interested in in a table such as the one found here: Laplace Transform Table
The Laplace transform of the nth derivative of a function is particularly important:
(5)
Frequency-domain methods are most often used for analyzing LTI single-input/single-output (SISO) systems, e.g. those governed by
a constant coefficient differential equation as follows:
(6)
The Laplace transform of this equation is given below:
(7)
where
and
are the Laplace Transforms of
assume that the each of the initial conditions,
,
therefore:
and
,
respectively. Note that when finding transfer functions, we always

, etc. is zero. The transfer function from input
to output
is
(8)
It is useful to factor the numerator and denominator of the transfer function into the so called zero-pole-gain form:
(9)
The zeros of the transfer function,
, are the roots of the numerator polynomial, i.e. the values of s such that
. The poles
of the transfer function,
, are the roots of the denominator polynomial, i.e. the values of s such that
. Both the zeros and
poles may be complex valued (have both real and imaginary parts). The system Gain is
.
Note that we can also determine the transfer function directly form the state-space representation as follows:
(10)
Mechanical Systems
Newton's laws of motion form the basis for analyzing mechanical systems. Newtons second law, Eq. (11), states that the sum of the
forces acting on a body equals its mass times acceleration. Newton's third law, for our purposes, states that if two bodies are
connected, then they experience the same magnitude force acting in opposite directions.
(11)
When applying this equation, it is best to construct a free body diagram (FBD) of the sysetm showing all applied forces.
Example: Mass-Spring-Damper System
The free body diagram for this system is shown below. The spring force is proportional to the displacement of the mass, , and the
viscous damping force is proportional to the velocity of the mass,
. Both forces oppose the motion of the mass and are therefore
shown in the negative -direction. Note also, that
corresponds to the position of the mass when the spring is unstretched.
Now we proceed by summing the forces and applying Newtons second law, Eq. (11), in each direction of the problem. In this case,
there are no forces acting in the -direction; however, in the -direction we have:
(12)
This equation, known as the governing equation, completely characterizes the dynamic state of the system. Later, we will see how to
use this to calculate the response of the system to any external input,
, as well as analyze system properties such as stability and
performance.
To determine the state-space representation of the mass-spring-damper system, we must reduce the second order governing equation to
a set of two first order differential equations. To this end, we choose the position and velocity as our state variables.
(13)
Note also that these state variables correspond to the potential energy in the spring and the kinetic energy of the mass respectively.
Often when choosing state variables it is helpful to consider the independent energy storage elements in the system.
The state equation in this case is as follows:
(14)
If, for instance, we are interested in controlling the position of the mass, then the output equation is as follows:
(15)
Entering State-Space Models into MATLAB

Now we will show you how to enter the equations derived above into a m-file for MATLAB. Let's assign numerical values to each of
the variables.
m
k
b
F
mass
spring constant
damping constant
input force
Create a new m-file and enter the following commands.

m
k
b
F
=
=
=
=
1;
1;
0.2;
1;
A
B
C
D
=
=
=
=
[0 1; -k/m -b/m];
[0 1/m]';
[1 0];
[0];
sys = ss(A,B,C,D)
sys =
a =
x1
0
-1
x1
x2
b =
x1
x2
c =
u1
0
1
x2
1
-0.2
1.0
1.0
0.2
1.0
kg
N/m
Ns/m
N
y1
x1
1
x2
0
d =
y1
u1
0
Continuous-time state-space model.
The Laplace transform for this system assuming zero initial conditions is
(16)
and therefore the transfer function from force input to displacement output is
(17)
Entering Transfer Function Models into MATLAB

Now we will show how to enter the transfer function derived above into MATLAB. Enter the following commands into the m-file in
which you defined the system parameters.
s = tf('s');
sys = 1/(m*s^2+b*s+k)
sys =
1
--------------s^2 + 0.2 s + 1
Continuous-time transfer function.
Note that we have used the symbolic s variable here to define our transfer function model. We recommend using this method most of
the time; however, in some circumstances, for instance in older versions of MATLAB or when interfacing with SIMULINK, you may
need to define the transfer function model using the numerator and denominator polynomial coefficients directly. In these cases, use
the following commands:
num
den
sys
sys
= [1];
= [m b k];
= tf(num,den)
=
1
--------------s^2 + 0.2 s + 1
Electrical Systems
Like Newtons laws in mechanical systems, Kirchoffs circuit laws are the basic analytical tool in electrical systems. Kirchoffs
current law (KCL) states that the sum of the electrical currents entering and exiting a node in a circuit must be equal. Kirchoffs
voltage law (KVL) states that the sum of voltage differences around any closed loop in the circuit is zero. When applying KVL, the
source voltages are typically taken as positive and the load voltages taken as negative.
Example: RLC Circuit

We will now consider a simple series combination of three passive electrical elements: a resistor, an inductor, and a capacitor, known
as an RLC Circuit.
Since this circuit is a single loop, each node only has one input and output; therefore, application of KCL simply shows that the current
is the same throughout the circuit at any given time,
. Now applying KVL around the loop and using the sign conventions indicated
in the diagram, we arrive at the following governing equation.
(18)
We note that that the governing equation for the RLC circuit has an analogous form to the mass-spring-damper mechanical system. In
particular, they are both second order systems where the charge (integral of current) corresponds to displacement, the inductance to
mass, the resistance to viscous damping, and the inverse capacitance to the spring stiffness. These analogies and others like them turn
out to be quite useful conceptually in understanding the behavior of dynamical systems.
The state-space representation is found by choosing the charge and current as the state variables.
(19)
where,
(20)
The state equation is therefore:
(21)
We choose the current as ouput as follows:
(22)
The transfer function representation may be found by taking the Laplace transform as we did for the mass-spring-damper or from the
state-space equation as follows:
(23)
(24)
The RLC state-space and transfer fcuntion models can be entered into MATLAB using the same procedure as discussed for the massspring-damper system above.
System Identification
In this section, we have seen how to model systems using basic physical principles; however, often this is not possible either because
the parameters of the system are uncertain, or the underlying processes are simply not known. In these cases, we must rely on
experimental measurements and statistical techniques to develop a system model, a process known as system identification.
System identification may be performed using either time-domain or frequency-domain data, see the Introduction: System
Identification page.
Also refer to MATLABs System Identification Toolbox for more information on this subject.
Introduction: System Analysis

Once appropriate mathematical models of a system have been obtained, either in state-space or transfer function form, we may then
analyze these models to predict how the system will respond in both the time and frequency domains. To put this in context, control
systems are often designed to improve stability, speed of response, steady-state error, or prevent oscillations. In this section, we will
show how to determine these dynamic properties from the system models.
Key MATLAB commands used in this tutorial are: tf , ssdata , pole , eig , step , pzmap , bode , ltiview
Contents
Time Response Overview

Frequency Response Overview
Stability
System Order
First Order Systems
Second Order Systems
Time Response Overview

The time response represents how the state of a dynamic system changes in time when subjected to a particular input. Since the
models we have derived consist of differential equations, some integration must be performed in order to determine the time response
of the system. For some simple systems, a closed-form analytical solution may be available. However, for most systems, especially
nonlinear systems or those subject to complicated input forces, this integration must be carried out numerically. Fortunately,
MATLAB provides many useful resources for calculating time responses for many types of inputs, as we shall see in the following
sections.
The time response of a linear dynamic system consists of the sum of the transient response which depends on the initial conditions
and the steady-state response which depends on the system input. These correspond to the free (homogeneous or zero input) and the
forced (inhomogeneous or non-zero input) solutions of the governing differential equations respectively.
Frequency Response Overview

All the examples presented in this tutorial are modeled by linear constant coefficient differential equations and are thus linear timeinvariant (LTI). LTI systems have the extremely important property that if the input to the system is sinusoidal, then the steady-state
output will also be sinusoidal at the same frequency but in general with different magnitude and phase. These magnitude and phase
differences as a function of frequency comprise the frequency response of the system.
The frequency response of a system can be found from the transfer function in the following way: create a vector of frequencies
(varying between zero or "DC" to infinity) and compute the value of the plant transfer function at those frequencies. If
is the openloop transfer function of a system and is the frequency vector, we then plot
versus . Since
is a complex number, we can
plot both its magnitude and phase (the Bode Plot) or its position in the complex plane (the Nyquist Diagram). Both methods display
the same information in different ways.
Stability
For our purposes, we will use the Bounded Input Bounded Output (BIBO) definition of stability which states that a system is stable
if the output remains bounded for all bounded (finite) inputs. Practically, this means that the system will not blow up while in
operation.
The transfer function representation is especially useful when analyzing system stability. If all poles of the transfer function (values of
s at which the denominator equals zero) have negative real parts, then the system is stable. If any pole has a positive real part, then the
system is unstable. If we view the poles on the complex s-plane, then all poles must be in the left half plane (LHP) to ensure stability.
If any pair of poles is on the imaginary axis, then the system is marginally stable and the system will oscillate. The poles of a LTI
system model can easily be found in MATLAB using the pole command, an example if which is shown below:
s = tf('s');
G = 1/(s^2+2*s+5)
pole(G)
G =
1
------------s^2 + 2 s + 5
ans =
-1.0000 + 2.0000i
-1.0000 - 2.0000i
Thus this system is stable since the real parts of the poles are both negative. The stability of a system may also be found from the statespace representation. In fact, the poles of the transfer function are the eigenvalues of the system matrix A. We can use the eig
command to calculate the eigenvalues using either the LTI system model directly, eig(G) or the system matrix as shown below.
[A,B,C,D] = ssdata(G);
eig(A)
ans =
-1.0000 + 2.0000i
-1.0000 - 2.0000i
System Order
The order of a dynamic system is the order of the highest derivative of its governing differential equation. Equivalently, it is the
highest power of s in the denominator of its transfer function. The important properties of first, second, and higher order systems will
be reviewed in this section.
First Order Systems

First order systems are the simplest dynamic systems to analyze. Some common examples include cruise control systems and RC
circuits.
The general form of the first order differential equation is as follows
(1)
The first order transfer function is
(2)
DC Gain
The DC gain, , is the ratio of the magnitude of the steady-state step response to the magnitude of the step input. From the Final
Value Theorem, for stable transfer functions the DC gain is the value of the transfer function when s=0. For first order systems equal
to
.
Time Constant
The time constant

is the time it takes for the system to reach 63% of the steady-state value for a step response or to
decrease to 37% of the inital value for an impulse response. More generally, it represents the time scale for which the dynamics of the
system are significant.
Poles/Zeros
There is a single real pole at
. Therefore, the system is stable if is positive and unstable if is negative. There are no zeros.
Step Response
We can calculate the system time response to a step input of magnitude u using the MATLAB following commands:
k_dc = 5;
Tc = 10;
u = 2;
s = tf('s');
G = k_dc/(Tc*s+1)
step(u*G)
G =
5
-------10 s + 1
Note: MATLAB also provides a powerful GUI (LTI Viewer) for analyzing LTI systems which can be accessed using,
ltiview('step',G).
If you right click on the step response graph and select Characteristics, you can choose to have several system metrics overlaid on the
response: peak response, settling time, rise time, and steady-state.
Settling Time
The settling time, , is the time required for the system ouput to fall within a certain percentage (i.e. 2%) of the steady state value for a
step input or equivalently to decrease to a certain percentage of the initial value for an impulse input. The settling times for first order
system for the most common tolerances are provided in the table below. Note that the tighter the tolerance, the longer the system
response takes to settle to within this tolerance, as expected.
10%
5%
2%
1%
Ts=2.3/a=2.3Tc Ts=3/a=3Tc Ts=3.9/a=3.9Tc Ts=4.6/a=4.6Tc
Rise Time
The rise time, , is the time required for the system output to rise from some lower level x% to some higher level y% of the final
steady-state value. For first order systems, the typical range is 10% - 90%.
Bode Plots
The Bode Plots show the magnitude and phase of the system frequency response,
using the bode(G) command.
bode(G)
. We can generate the Bode plots in MATLAB
Again the same results could be obtained using the LTI viewer GUI, ltiview('bode',G)
The Bode plots use a logarithmic frequency scale, so that a larger range of frequencies are visible. Also, the magnitude is represented
using the logarithmic decibel unit (dB) defined as:
(3)
Like frequency, the decibel scale allows us to view a much larger range of magnitudes on a single plot. Also, as we shall see in
subsequent tutorials, when systems are combined or controllers are added, transfer functions are often multiplied together. Using the
dB scale, we may simply add the magnitudes of the transfer functions. Note, we may also add the phase angles though these are not
shown on a log scale.
The low frequency magnitude of the first order bode plot is
. The magnitude plot has a bend at the frequency equal to the
absolute value of the pole (ie.
), and then decreases at 20dB for every factor of ten increase in frequency (-20dB/decade). The
phase plot is asymptotic to 0 degrees at low frequency, and asymptotic to -90 degrees at high frequency. Between frequency 0.1a and
10a, the phase changes by approximately -45 degrees for every factor of ten increase in frequency (-45 degrees/decade).
We will see in the Frequency Methods for Controller Design Section how to use Bode Plots to calculate closed loop stability and
performance of feedback systems.
Second Order Systems

Second order systems are commonly encountered in practice, and are the simplest type of dynamic system to exhibit oscillations. In
fact many real higher order systems are modeled as second order to facilitate analysis. Examples include mass-spring-damper systems
and RLC circuits.
The general form of the first order differential equation is as follows
(4)
The first order transfer function is
(5)
DC Gain
The DC gain, , again is the ratio of the magnitude of the steady-state step response to the magnitude of the step input, and for stable
systems it is the value of the transfer function when
. For second order systems,
(6)
Damping Ratio
The damping ratio is a dimensionless quantity charaterizing the energy losses in the system due to such effects as viscous friction or
electrical resistance. From the above definitions,
(7)
Natural Frequency
The natural frequency is the frequency (in rad/s) that the system will oscillate at when there is no damping,
(8)
Poles/Zeros
The second order transfer function has two poles at:
(9)
Under Damped System
If
, then the system is under damped. Both poles are complex valued with negative real parts; therefore the system is stable but
oscillates while approaching the steady-state value.
k_dc = 1;
w_n = 10;
zeta = 0.2;
s = tf('s');
G1 = k_dc*w_n^2/(s^2 + 2*zeta*w_n*s + w_n^2);
pzmap(G1)
axis([-3 1 -15 15])
step(G1)
axis([0 3 0 2])
Settling Time
The settling time, , is the time required for the system ouput to fall within a certain percentage of the steady state value for a step
input or equivalently to decrease to a certain percentage of the initial value for an impulse input. For a second order, underdamped
system, the settling time can be approximated by the following equation:
(10)
The settling times for the most common tolerances are presented in the following table:
10%
5%
2%
1%
Ts=2.3/(zeta*wn) Ts=3/(zeta*w_n) Ts=3.9/(zeta*w_n) Ts=4.6/(zeta*w_n)
Percent Overshoot
The percent overshoot is the percent by which a system exceeds its final steady-state value. For a second order under damped system,
the percent overshoot is diretly related to the damping ratio by the following equation:
(11)
For second order under damped systems, the 2% settling time,
and natural frequency as shown below.
, rise time,
, and percent overshoot, %OS, are related to the damping
(12)
(13)
(14)
Over Damped Systems
If
, then the system is over damped. Both poles are real and negative; therefore the system is stable and does not oscillate. The
step response and a pole-zero map of an over damped system are calculated below:
zeta = 1.2;
pzmap(G2)
axis([-20 1 -1 1])
step(G2)
axis([0 1.5 0 1.5])
Critically Damped Systems

If
, then the system is critically damped. Both poles are real and have the same magnitude,
. Critically damped
systems approach steady-state quickest without oscillating. Now change the value of the damping to 1, and replot the step response and
pole-zero map.
zeta = 1;

pzmap(G3)
axis([-11 1 -1 1])
step(G3)
axis([0 1.5 0 1.5])
Undamped Systems
If
, then the system is undamped. In this case, the poles are purely imaginary; therefore the system is marginally stable and
oscillates indefinitely.
zeta = 0;
pzmap(G4)
axis([-1 1 -15 15])
step(G4)
axis([0 5 -0.5 2.5])
Bode Plot
We show the Bode Magnitude and Phase Plots for all damping conditions of a second order system below:
bode(G1,G2,G3,G4)
legend('under damped: zeta < 1','over damped: zeta > 1','critically damped: zeta = 1','undamped: zeta = 0')
The magnitude of the bode plot of a second order system drops off at -40dB per decade, while the relative phase changes from 0 to 180 degrees at -90 degrees per decade. For the under damped systems, we also see a resonance peak near the natural frequency, = 10
rad/s. The sharpness of the peak depends on the damping in the system, and is charaterized by the quality factor, or Q-Factor, defined
below. The Q-factor is an important property in signal processing.
(15)
CONTROL
Introduction: PID Controller Design
In this tutorial we will introduce a simple yet versatile feedback compensator structure, the Proportional-Integral-Derivative (PID)
controller. We will discuss the effect of each of the pid parameters on the closed-loop dynamics and demonstrate how to use a PID
controller to improve the system performance.
Key MATLAB commands used in this tutorial are: tf , step , pid , feedback , pidtool , pidtune
Contents
PID Overview
The Characteristics of P, I, and D Controllers
Example Problem
Open-Loop Step Response
Proportional Control
Proportional-Derivative Control
Proportional-Integral Control
Proportional-Integral-Derivative Control
General Tips for Designing a PID Controller
Automatic PID Tuning
PID Overview
In this tutorial, we will consider the following unity feedback system:
The output of a PID controller, equal to the control input to the plant, in the time-domain is as follows:
(1)
First, let's take a look at how the PID controller works in a closed-loop system using the schematic shown above. The variable ( )
represents the tracking error, the difference between the desired input value ( ) and the actual output ( ). This error signal ( ) will be
sent to the PID controller, and the controller computes both the derivative and the integral of this error signal. The control signal ( ) to
the plant is equal to the proportional gain ( ) times the magnitude of the error plus the integral gain ( ) times the integral of the error
plus the derivative gain ( ) times the derivative of the error.
This control signal ( ) is sent to the plant, and the new output ( ) is obtained. The new output ( ) is then fed back and compared to the
reference to find the new error signal ( ). The controller takes this new error signal and computes its derivative and its integral again,
ad infinitum.
The transfer function of a PID controller is found by taking the Laplace transform of Eq.(1).
(2)
= Proportional gain
= Integral gain
= Derivative gain
We can define a PID controller in MATLAB using the transfer function directly, for example:
Kp = 1;
Ki = 1;
Kd = 1;
s = tf('s');
C = Kp + Ki/s + Kd*s
C =
s^2 + s + 1
----------s
Alternatively, we may use MATLAB's pid controller object to generate an equivalent continuous-time controller as follows:
C = pid(Kp,Ki,Kd)
C =
1
Kp + Ki * --- + Kd * s
s
with Kp = 1, Ki = 1, Kd = 1
Continuous-time PID controller in parallel form.
Let's convert the pid object to a transfer function to see that it yields the same result as above:
tf(C)
ans =
s^2 + s + 1
----------s
The Characteristics of P, I, and D Controllers

A proportional controller ( ) will have the effect of reducing the rise time and will reduce but never eliminate the steady-state error.
An integral control ( ) will have the effect of eliminating the steady-state error for a constant or step input, but it may make the
transient response slower. A derivative control ( ) will have the effect of increasing the stability of the system, reducing the
overshoot, and improving the transient response.
The effects of each of controller parameters,
, and
on a closed-loop system are summarized in the table below.
CL RESPONSE RISE TIME OVERSHOOT SETTLING TIME S-S ERROR

Kp
Decrease
Increase
Small Change
Decrease
Ki
Decrease
Increase
Increase
Eliminate
Kd
Small Change
Decrease
Decrease
No Change
Note that these correlations may not be exactly accurate, because , , and are dependent on each other. In fact, changing one of
these variables can change the effect of the other two. For this reason, the table should only be used as a reference when you are
determining the values for , and .
Example Problem
Suppose we have a simple mass, spring, and damper problem.
The modeling equation of this system is

(3)
Taking the Laplace transform of the modeling equation, we get
(4)
The transfer function between the displacement
and the input
then becomes
(5)
Let
M
b
k
F
=
=
=
=
1 kg
10 N s/m
20 N/m
1 N
Plug these values into the above transfer function
(6)
The goal of this problem is to show you how each of
and
contributes to obtain
Fast rise time

Minimum overshoot
No steady-state error
Open-Loop Step Response

Let's first view the open-loop step response. Create a new m-file and run the following code:
s = tf('s');
P = 1/(s^2 + 10*s + 20);
step(P)
The DC gain of the plant transfer function is 1/20, so 0.05 is the final value of the output to an unit step input. This corresponds to the
steady-state error of 0.95, quite large indeed. Furthermore, the rise time is about one second, and the settling time is about 1.5 seconds.
Let's design a controller that will reduce the rise time, reduce the settling time, and eliminate the steady-state error.
Proportional Control
From the table shown above, we see that the proportional controller (Kp) reduces the rise time, increases the overshoot, and reduces
the steady-state error.
The closed-loop transfer function of the above system with a proportional controller is:
(7)
Let the proportional gain (
) equal 300 and change the m-file to the following:
Kp = 300;
C = pid(Kp)
T = feedback(C*P,1)
t = 0:0.01:2;
step(T,t)
C =
Kp = 300
P-only controller.
T =
300
---------------s^2 + 10 s + 320
The above plot shows that the proportional controller reduced both the rise time and the steady-state error, increased the overshoot, and
decreased the settling time by small amount.
Proportional-Derivative Control
Now, let's take a look at a PD control. From the table shown above, we see that the derivative controller (Kd) reduces both the
overshoot and the settling time. The closed-loop transfer function of the given system with a PD controller is:
(8)
Let equal 300 as before and let
window.
equal 10. Enter the following commands into an m-file and run it in the MATLAB command
Kp = 300;
Kd = 10;
C = pid(Kp,0,Kd)
T = feedback(C*P,1)
t = 0:0.01:2;
step(T,t)
C =
Kp + Kd * s
with Kp = 300, Kd = 10
Continuous-time PD controller in parallel form.
T =
10 s + 300
---------------s^2 + 20 s + 320
This plot shows that the derivative controller reduced both the overshoot and the settling time, and had a small effect on the rise time
and the steady-state error.
Proportional-Integral Control
Before going into a PID control, let's take a look at a PI control. From the table, we see that an integral controller (Ki) decreases the
rise time, increases both the overshoot and the settling time, and eliminates the steady-state error. For the given system, the closed-loop
transfer function with a PI control is:
(9)
Let's reduce the
to 30, and let
equal 70. Create an new m-file and enter the following commands.
Kp = 30;
Ki = 70;
C = pid(Kp,Ki)
T = feedback(C*P,1)
t = 0:0.01:2;
step(T,t)
C =
1
Kp + Ki * --s
with Kp = 30, Ki = 70
Continuous-time PI controller in parallel form.
T =
30 s + 70
-----------------------s^3 + 10 s^2 + 50 s + 70
Run this m-file in the MATLAB command window, and you should get the following plot. We have reduced the proportional gain
(Kp) because the integral controller also reduces the rise time and increases the overshoot as the proportional controller does (double
effect). The above response shows that the integral controller eliminated the steady-state error.
Proportional-Integral-Derivative Control
Now, let's take a look at a PID controller. The closed-loop transfer function of the given system with a PID controller is:
(10)
After several trial and error runs, the gains = 350, = 300, and = 50 provided the desired response. To confirm, enter the
following commands to an m-file and run it in the command window. You should get the following step response.
Kp = 350;
Ki = 300;
Kd = 50;
C = pid(Kp,Ki,Kd)
T = feedback(C*P,1);
t = 0:0.01:2;
step(T,t)
C =
1
Kp + Ki * --- + Kd * s
s
with Kp = 350, Ki = 300, Kd = 50
Now, we have obtained a closed-loop system with no overshoot, fast rise time, and no steady-state error.
General Tips for Designing a PID Controller

When you are designing a PID controller for a given system, follow the steps shown below to obtain a desired response.
1. Obtain an open-loop response and determine what needs to be improved
2.
3.
4.
5.
Add a proportional control to improve the rise time

Add a derivative control to improve the overshoot
Add an integral control to eliminate the steady-state error
Adjust each of Kp, Ki, and Kd until you obtain a desired overall response. You can always refer to the table shown in this "PID Tutorial"
page to find out which controller controls what characteristics.
Lastly, please keep in mind that you do not need to implement all three controllers (proportional, derivative, and integral) into a single
system, if not necessary. For example, if a PI controller gives a good enough response (like the above example), then you don't need to
implement a derivative controller on the system. Keep the controller as simple as possible.
Automatic PID Tuning

MATLAB provides tools for automatically choosing optimal PID gains which makes the trial and error process described above
unnecessary. You can access the tuning algorithm directly using pidtune or through a nice graphical user interface (GUI) using
pidtool.
The MATLAB automated tuning algorithm chooses PID gains to balance performance (response time, bandwidth) and robustness
(stability margins). By default the algorthm designs for a 60 degree phase margin.
Let's explore these automated tools by first generating a proportional controller for the mass-spring-damper system by entering the
following commands:
pidtool(P,'p')
The pidtool GUI window, like that shown below, should appear.
Notice that the step response shown is slower than the proportional controller we designed by hand. Now click on the Show
Parameters button on the top right. As expected the proportional gain constant, Kp, is lower than the one we used, Kp = 94.85 < 300.
We can now interactively tune the controller parameters and immediately see the resulting response int he GUI window. Try dragging
the resposne time slider to the right to 0.14s, as shown in the figure below. The response does indeeed speed up, and we can see Kp is
now closer to the manual value. We can also see all the other performance and robustness parameters for the system. Note that the
phase margin is 60 degrees, the default for pidtool and generally a good balance of robustness and performance.
Now let's try designing a PID controller for our system. By specifying the previously designed or (baseline) controller, C, as the
second parameter, pidtool will design another PID controller (instead of P or PI) and will compare the response of the system with the
automated controller with that of the baseline.
pidtool(P,C)
We see in the output window that the automated controller responds slower and exhibits more overshoot than the baseline. Now
choose the Design Mode: Extended option at the top, which reveals more tuning parameters.
Now type in Bandwidth: 32 rad/s and Phase Margin: 90 deg to generate a controller similar in performance to the baseline. Keep in
mind that a higher bandwidth (0 dB crossover of the open-loop) results in a faster rise time, and a higher phase margin reduces the
overshoot and improves the system stability.
Finally we note that we can generate the same controller using the command line tool pidtune instead of the pidtool GUI
opts = pidtuneOptions('CrossoverFrequency',32,'PhaseMargin',90);
[C, info] = pidtune(P, 'pid', opts)
C =
1
Kp + Ki * --- + Kd * s
s
with Kp = 320, Ki = 169, Kd = 31.5
info =
Stable: 1
CrossoverFrequency: 32
PhaseMargin: 90
Introduction: Root Locus Controller Design

In this tutorial we will introduce the root locus, show how to create it using MATlAB, and demonstrate how to design feedback
controllers using the root locus that satisfy certain performance criteria.
Key MATLAB commands used in this tutorial are: feedback , rlocus , step , sisotool
Contents
Closed-Loop Poles
Plotting the Root Locus of a Transfer Function
Choosing a Value of K from the Root Locus
Closed-Loop Response
Using SISOTOOL for Root Locus Design
Closed-Loop Poles
The root locus of an (open-loop) transfer function
proportional gain K and unity feedback.
is a plot of the locations (locus) of all possible closed-loop poles with
The closed-loop transfer function is:
(1)
and thus the poles of the closed-loop poles of the closed-loop system are values of such that
If we write
, then this equation has the form:
(2)
(3)
Let = order of
and
= order of
(the order of a polynomial is the highest power of that appears in it).
We will consider all positive values of K. In the limit as

the limit as
, the poles of the closed-loop system are
, the poles of the closed-loop system are

or the zeros of
.
or the poles of
. In
No matter what we pick K to be, the closed-loop system must always have poles, where is the number of poles of
. The root
locus must have branches, each branch starts at a pole of
and goes to a zero of
. If
has more poles than zeros (as is
often the case),
and we say that
has zeros at infinity. In this case, the limit of
as
is zero. The number of zeros at
infinity is
, the number of poles minus the number of zeros, and is the number of branches of the root locus that go to infinity
(asymptotes).
Since the root locus is actually the locations of all possible closed-loop poles, from the root locus we can select a gain such that our
closed-loop system will perform the way we want. If any of the selected poles are on the right half plane, the closed-loop system will
be unstable. The poles that are closest to the imaginary axis have the greatest influence on the closed-loop response, so even though the
system has three or four poles, it may still act like a second or even first order system depending on the location(s) of the dominant
pole(s).
Plotting the Root Locus of a Transfer Function

Consider an open-loop system which has a transfer function of
(4)
How do we design a feedback controller for the system by using the root locus method? Say our design criteria are 5% overshoot and 1
second rise time. Make a MATLAB file called rl.m. Enter the transfer function, and the command to plot the root locus:
s = tf('s');
sys = (s + 7)/(s*(s + 5)*(s + 15)*(s + 20));
rlocus(sys)
axis([-22 3 -15 15])
Choosing a Value of K from the Root Locus
The plot above shows all possible closed-loop pole locations for a pure proportional controller. Obviously not all of those closed-loop
poles will satisfy our design criteria, To determine what part of the locus is acceptable, we can use the command sgrid(Zeta,Wn) to
plot lines of constant damping ratio and natural frequency. Its two arguments are the damping ratio ( ) and natural frequency ( )
[these may be vectors if you want to look at a range of acceptable values]. In our problem, we need an overshoot less than 5% (which
means a damping ratio of greater than 0.7) and a rise time of 1 second (which means a natural frequency greater than 1.8). Enter the
following in the MATLAB command window:
Zeta = 0.7;
Wn = 1.8;
sgrid(Zeta,Wn)
On the plot above, the two dotted lines at about a 45 degree angle indicate pole locations with = 0.7; in between these lines, the poles
will have > 0.7 and outside of the lines < 0.7. The semicircle indicates pole locations with a natural frequency = 1.8; inside the
circle, < 1.8 and outside the circle > 1.8.
Going back to our problem, to make the overshoot less than 5%, the poles have to be in between the two white dotted lines, and to
make the rise time shorter than 1 second, the poles have to be outside of the white dotted semicircle. So now we know only the part of
the locus outside of the semicircle and in betwen the two lines are acceptable. All the poles in this location are in the left-half plane, so
the closed-loop system will be stable.
From the plot above we see that there is part of the root locus inside the desired region. So in this case, we need only a proportional
controller to move the poles to the desired region. You can use the rlocfind command in MATLAB to choose the desired poles on
the locus:
[k,poles] = rlocfind(sys)
Click on the plot the point where you want the closed-loop pole to be. You may want to select the points indicated in the plot below to
satisfy the design criteria.
Note that since the root locus may have more than one branch, when you select a pole, you may want to find out where the other pole
(poles) are. Remember they will affect the response too. From the plot above, we see that all the poles selected (all the "+" signs) are at
reasonable positions. We can go ahead and use the chosen K as our proportional controller.
Closed-Loop Response
In order to find the step response, you need to know the closed-loop transfer function. You could compute this using the rules of block
diagrams, or let MATLAB do it for you (there is no need to enter a value for K if the rlocfind command was used):
K = 350;
sys_cl = feedback(K*sys,1)
sys_cl =
350 s + 2450
-------------------------------------s^4 + 40 s^3 + 475 s^2 + 1850 s + 2450
The two arguments to the function feedback are the numerator and denominator of the open-loop system. You need to include the
proportional gain that you have chosen. Unity feedback is assumed.
If you have a non-unity feedback situation, look at the help file for the MATLAB function feedback, which can find the closed-loop
transfer function with a gain in the feedback loop.
Check out the step response of your closed-loop system:
step(sys_cl)
As we expected, this response has an overshoot less than 5% and a rise time less than 1 second.
Using SISOTOOL for Root Locus Design

Another way to complete what was done above is to use the interactive MATLAB GUI called sisotool. Using the same model as
above, first define the plant,
.
s = tf('s');
plant = (s + 7)/(s*(s + 5)*(s + 15)*(s + 20));
The sisotool function can be used for analysis and design. In this case, we will focus on using the Root Locus as the design method
to improve the step response of the plant. To begin, type the following into the MATLAB command window:
sisotool(plant)
The following window should appear. To start, select the tab labeled Graphical Tuning. Within this window, turn off Plot 2 and make
sure Plot 1 is the Root Locus and verify that Open Loop 1 is selected. Finally, click the button labeled Show Design Plot to bring up
the tunable Root Locus plot.
In the same fashion, select the tab labeled Analysis Plots. Within this window, for Plot 1, select Step. In the Contents of Plots
subwindow, select Closed Loop r to y for Plot 1. If the window does not automatically pop up, click the button labeled Show
Analysis Plot.
The next thing to do is to add the design requirements to the Root Locus plot. This is done directly on the plot by right-clicking and
selecting Design Requirements, New. Design requirements can be set for the Settling Time, the Percent Overshoot, the Damping
Ratio, the Natural Frequency, or a Region Constraint. There is no direct requirement for Rise Time, but the natural frequency can be
used for this.
Here, we will set the design requirements for the damping ratio and the natural frequency just like was done with sgrid. Recall that
the requirements call for = 0.7 and = 1.8. Set these within the design requirements. On the plot, any area which is still white, is an
acceptable region for the poles.
Zoom into the Root Locus by right-clicking on the axis and select Properties, then click the label Limits. Change the real axis to -25
to 5 and the imaginary to -2.5 to 2.5.
Also, we can see the current values of some key parameters in the response. In the Step response, right-click on the plot and go to
Characteristics and select Peak Response. Do the same for the Rise Time. There should now be two large dots on the screen
indicating the location of these parameters. Click each of these dots to bring up a screen with information.
Both plots should appear as shown here:
As the characteristics show on the Step response, the overshoot is acceptable, but the rise time is incredibly off.
To fix this, we need to choose a new value for the gain K. Similarly to the rlocfind command, the gain of the controller can be
changed directly on the root locus plot. Click and drag the pink box on the origin to the acceptable area where the poles have an
imaginary component as shown below.
At the bottom of the plot, it can be seen that the loop gain has been changed to 361. Looking at the Step response, both of the values
are acceptable for our requirements.
Published with MATLAB 7.14
Introduction: Frequency Domain Methods for Controller

Design
The frequency response method of controller design may be less intuitive than other methods you have studied previously. However, it
has certain advantages, especially in real-life situations such as modeling transfer functions from physical data. In this tutorial, we will
see how we can use the open-loop frequency response of a system to predict its behavior in closed-loop.
Key MATLAB commands used in this tutorial are: bode , nyquist , margin , lsim , step , feedback , sisotool
Contents
Gain and Phase Margin

Nyquist Diagram
The Cauchy Criterion
Closed-Loop Performance from Bode Plots
Closed-Loop Stability from the Nyquist Diagram
Gain and Phase Margin

Consider the following unity feedback system:
where is a variable (constant) gain and

is the plant under consideration. The gain margin is defined as the change in open-loop
gain required to make the system unstable. Systems with greater gain margins can withstand greater changes in system parameters
before becoming unstable in closed-loop.
The phase margin is defined as the change in open-loop phase shift required to make a closed-loop system unstable.
The phase margin also measures the system's tolerance to time delay. If there is a time delay greater than
in the loop (where
is the frequency where the phase shift is 180 deg), the system will become unstable in closed-loop. The time delay, can be thought
of as an extra block in the forward path of the block diagram that adds phase to the system but has no effect on the gain. That is, a time
delay can be represented as a block with magnitude of 1 and phase
(in radians/second).
For now, we won't worry about where all this comes from and will concentrate on identifying the gain and phase margins on a Bode
plot.
The phase margin is the difference in phase between the phase curve and -180 degrees at the point corresponding to the frequency that
gives us a gain of 0 dB (the gain crossover frequency,
). Likewise, the gain margin is the difference between the magnitude curve
and 0 dB at the point corresponding to the frequency that gives us a phase of -180 degrees (the phase crossover frequency,
).
One nice thing about the phase margin is that you don't need to replot the Bode in order to find the new phase margin when changing
the gains. If you recall, adding gain only shifts the magnitude plot up. This is equivalent to changing the y-axis on the magnitude plot.
Finding the phase margin is simply a matter of finding the new cross-over frequency and reading off the phase margin. For example,
suppose you entered the command bode(sys). You will get the following bode plot:
s = tf('s');
sys = 50/(s^3 + 9*s^2 + 30*s +40);
bode(sys)
grid on
title('Bode Plot with No Gain')
You should see that the phase margin is about 100 degrees. Now suppose you added a gain of 100, by entering the command
bode(100*sys). You should get the following plot:
bode(100*sys)
grid on
title('Bode Plot with Gain = 100')
As you can see the phase plot is exactly the same as before, and the magnitude plot is shifted up by 40 dB (gain of 100). The phase
margin is now about -60 degrees. This same result could be achieved if the y-axis of the magnitude plot was shifted down 40 dB. Try
this, look at the first Bode plot, find where the curve crosses the -40 dB line, and read off the phase margin. It should be about 90
degrees, the same as the second Bode plot.
We can have MATLAB calculate and display the gain and phase margins using the margin(sys) command. This command returns
the gain and phase margins, the gain and phase cross over frequencies, and a graphical representation of these on the Bode plot. Let's
check it out:
margin(100*sys)
Bandwidth Frequency
The bandwidth frequency is defined as the frequency at which the closed-loop magnitude response is equal to -3 dB. However, when
we design via frequency response, we are interested in predicting the closed-loop behavior from the open-loop response. Therefore, we
will use a second-order system approximation and say that the bandwidth frequency equals the frequency at which the open-loop
magnitude response is between -6 and -7.5 dB, assuming the open-loop phase response is between -135 deg and -225 deg. For a
complete derivation of this approximation, consult your textbook.
In order to illustrate the importance of the bandwidth frequency, we will show how the output changes with different input frequencies.
We will find that sinusoidal inputs with frequency less than Wbw (the bandwidth frequency) are tracked "reasonably well" by the
system. Sinusoidal inputs with frequency greater than Wbw are attenuated (in magnitude) by a factor of 0.707 or greater (and are also
shifted in phase).
Let's say we have the following closed-loop transfer function representing a system:
(1)
sys = 1/(s^2 + 0.5*s + 1);
bode(sys)
Since this is the closed-loop transfer function, our bandwidth frequency will be the frequency corresponding to a gain of -3 dB.
Looking at the plot, we find that it is approximately 1.4 rad/s. We can also read off the plot that for an input frequency of 0.3 radians,
the output sinusoid should have a magnitude about one and the phase should be shifted by perhaps a few degrees (behind the input).
For an input frequency of 3 rad/sec, the output magnitude should be about -20 dB (or 1/10 as large as the input) and the phase should
be nearly -180 (almost exactly out-of-phase). We can use the lsim command to simulate the response of the system to sinusoidal
inputs.
First, consider a sinusoidal input with a frequency lower than Wbw. We must also keep in mind that we want to view the steady state
response. Therefore, we will modify the axes in order to see the steady state response clearly (ignoring the transient response).
sys = 1/(s^2 + 0.5*s + 1);
w = 0.3;
t = 0:0.1:100;
u = sin(w*t);
[y,t] = lsim(sys,u,t);
plot(t,y,t,u)
axis([50 100 -2 2])
Note that the output (blue) tracks the input (green) fairly well; it is perhaps a few degrees behind the input as expected. However, if we
set the frequency of the input higher than the bandwidth frequency for the system, we get a very distorted response (with respect to
the input):
sys = 1/(s^2 + 0.5*s + 1);
w = 3;
t = 0:0.1:100;
u = sin(w*t);
[y,t] = lsim(sys,u,t);
plot(t,y,t,u)
axis([90 100 -1 1])
Again, note that the magnitude is about 1/10 that of the input, as predicted, and that it is almost exactly out of phase (180 degrees
behind) the input. Feel free to experiment and view the response for several different frequencies , and see if they match the Bode
plot.
Nyquist Diagram
The Nyquist plot allows us to predict the stability and performance of a closed-loop system by observing its open-loop behavior. The
Nyquist criterion can be used for design purposes regardless of open-loop stability (remember that the Bode design methods assume
that the system is stable in open-loop). Therefore, we use this criterion to determine closed-loop stability when the Bode plots display
confusing information.
Note: The MATLAB nyquist command does not provide an adequate representation for systems that have open-loop poles in
the jw-axis. Therefore, we suggest that you copy the nyquist1.m file as a new m-file. This m-file creates more accurate Nyquist
plots, since it correctly deals with poles and zeros on the jw-axis.
The Nyquist diagram is basically a plot of
where
is the open-loop transfer function and is a vector of frequencies which
encloses the entire right-half plane. In drawing the Nyquist diagram, both positive and negative frequencies (from zero to infinity) are
taken into account. We will represent positive frequencies in red and negative frequencies in green. The frequency vector used in
plotting the Nyquist diagram usually looks like this (if you can imagine the plot stretching out to infinity):
However, if we have open-loop poles or zeros on the jw axis,

will not be defined at those points, and we must loop around them
when we are plotting the contour. Such a contour would look as follows:
Please note that the contour loops around the pole on the jw axis. As we mentioned before, the MATLAB nyquist command does not
take poles or zeros on the jw axis into account and therefore produces an incorrect plot. To correct this, please download and use
nyquist1.m. If we have a pole on the jw axis, we have to use nyquist1. If there are no poles or zeros on the jw-axis, or if we have
pole-zero cancellation, we can use either the nyquist command or nyquist1.m.
The Cauchy Criterion

The Cauchy criterion (from complex analysis) states that when taking a closed contour in the complex plane, and mapping it through a
complex function
, the number of times that the plot of
encircles the origin is equal to the number of zeros of
enclosed by
the frequency contour minus the number of poles of
enclosed by the frequency contour. Encirclements of the origin are counted as
positive if they are in the same direction as the original closed contour or negative if they are in the opposite direction.
When studying feedback controls, we are not as interested in
as in the closed-loop transfer function:
(2)
If
encircles the origin, then
will enclose the point -1. Since we are interested in the closed-loop stability, we want to know
if there are any closed-loop poles (zeros of
) in the right-half plane. More details on how to determine this will come later.
Therefore, the behavior of the Nyquist diagram around the -1 point in the real axis is very important; however, the axis on the standard
nyquist diagram might make it hard to see what's happening around this point. To correct this, you can add the lnyquist.m function to
your files. The lnyquist.m command plots the Nyquist diagram using a logarithmic scale and preserves the characteristics of the -1
point.
To view a simple Nyquist plot using MATLAB, we will define the following transfer function and view the Nyquist plot:
(3)
s = tf('s');
sys = 0.5/(s - 0.5);
nyquist(sys)
axis([-1 0 -1 1])
Now we will look at the Nyquist diagram for the following transfer function:
(4)
Note that this function has a pole at the origin. We will see the difference between using the nyquist, nyquist1, and lnyquist
commands with this particular function.
sys = (s + 2)/(s^2);
nyquist(sys)
nyquist1(sys)
lnyquist(sys)
Note that the nyquist plot is not the correct one, the nyquist1 plot is correct, but it's hard to see what happens close to the -1 point,
and the lnyquist plot is correct and has an appropriate scale.
Closed-Loop Performance from Bode Plots

In order to predict closed-loop performance from open-loop frequency response, we need to have several concepts clear:
The system must be stable in open-loop if we are going to design via Bode plots.
If the gain crossover frequency is less than the phase crossover frequency (i.e.
), then the closed-loop system will be stable.
For second-order systems, the closed-loop damping ratio is approximately equal to the phase margin divided by 100 if the phase margin
is between 0 and 60 degrees. We can use this concept with caution if the phase margin is greater than 60 degrees.
For second-order systems, a relationship between damping ratio, bandwidth frequency, and settling time is given by an equation
described on the Extras: Bandwidth page.
A very rough estimate that you can use is that the bandwidth is approximately equal to the natural frequency.
Let's use these concepts to design a controller for the following system:
Where
is the controller and
is:
(5)
The design must meet the following specifications:
Zero steady state error.

Maximum overshoot must be less than 40%.
Settling time must be less than 2 seconds.
There are two ways of solving this problem: one is graphical and the other is numerical. Within MATLAB, the graphical approach is
best, so that is the approach we will use. First, let's look at the Bode plot. Create a m-file with the following code:
sys = 10/(1.25*s + 1);
bode(sys)
There are several characteristics of the system that can be read directly from this Bode plot. First of all, we can see that the bandwidth
frequency is around 10 rad/sec. Since the bandwidth frequency is roughly the same as the natural frequency (for a first order system of
this type), the rise time is 1.8/BW = 1.8/10 = 1.8 seconds. This is a rough estimate, so we will say the rise time is about 2 seconds.
The phase margin for this system is approximately 95 degrees. The relation damping ratio = PM/100 only holds for PM < 60. Since
the system is first-order, there should be no overshoot.
The last major point of interest is steady-state error. The steady-state error can be read directly off the Bode plot as well. The constant
( , , or ) is found from the intersection of the low frequency asymptote with the w = 1 line. Just extend the low frequency line
to the w = 1 line. The magnitude at this point is the constant. Since the Bode plot of this system is a horizontal line at low frequencies
(slope = 0), we know this system is of type zero. Therefore, the intersection is easy to find. The gain is 20 dB (magnitude 10). What
this means is that the constant for the error function is 10. The steady-state error is 1/(1+Kp) = 1/(1+10) = 0.091.
If our system was type one instead of type zero, the constant for the steady-state error would be found in a manner similar to the
following.
Let's check our predictions by looking at a step response plot. This can be done by adding the following two lines of code into the
MATLAB command window.
sys_cl = feedback(sys,1);
step(sys_cl)
title('Closed-Loop Step Response, No Controller')
As you can see, our predictions were very good. The system has a rise time of about 2 seconds, has no overshoot, and has a steadystate error of about 9%. Now we need to choose a controller that will allow us to meet the design criteria. We choose a PI controller
because it will yield zero steady-state error for a step input. Also, the PI controller has a zero, which we can place. This gives us
additional design flexibility to help us meet our criteria. Recall that a PI controller is given by:
(6)
The first thing we need to find is the damping ratio corresponding to a percent overshoot of 40%. Plugging in this value into the
equation relating overshoot and damping ratio (or consulting a plot of this relation), we find that the damping ratio corresponding to
this overshoot is approximately 0.28. Therefore, our phase margin should be at least 30 degrees. We must have a bandwidth frequency
greater than or equal to 12 if we want our settling time to be less than 1.75 seconds which meets the design specs.
Now that we know our desired phase margin and bandwidth frequency, we can start our design. Remember that we are looking at the
open-loop Bode plots. Therefore, our bandwidth frequency will be the frequency corresponding to a gain of approximately -7 dB.
Let's see how the integrator portion of the PI or affects our response. Change your m-file to look like the following (this adds an
integral term but no proportional term):
plant = 10/(1.25*s + 1);
contr = 1/s;
bode(contr*plant, logspace(0,2))
Our phase margin and bandwidth frequency are too small. We will add gain and phase with a zero. Let's place the zero at 1 for now
and see what happens. Change your m-file to look like the following:
plant = 10/(1.25*s + 1);
contr = (s + 1)/s;
It turns out that the zero at 1 with a unit gain gives us a satisfactory answer. Our phase margin is greater than 60 degrees (even less
overshoot than expected) and our bandwidth frequency is approximately 11 rad/s, which will give us a satisfactory response. Although
satisfactory, the response is not quite as good as we would like. Therefore, let's try to get a higher bandwidth frequency without
changing the phase margin too much. Let's try to increase the gain to 5 and see what happens. This will make the gain shift and the
phase will remain the same.
plant = 10/(1.25*s + 1);
contr = 5 * ((s + 1)/s);
That looks really good. Let's look at our step response and verify our results. Add the following two lines to your m-file:
sys_cl = feedback(contr*plant,1);
step(sys_cl)
As you can see, our response is better than we had hoped for. However, we are not always quite as lucky and usually have to play
around with the gain and the position of the poles and/or zeros in order to achieve our design requirements.
Closed-Loop Stability from the Nyquist Diagram

Consider the negative feedback system:
Remember from the Cauchy criterion that the number N of times that the plot of G(s)H(s) encircles -1 is equal to the number Z of
zeros of 1 + G(s)H(s) enclosed by the frequency contour minus the number P of poles of 1 + G(s)H(s) enclosed by the frequency
contour (N = Z - P). Keeping careful track of open- and closed-loop transfer functions, as well as numerators and denominators, you
should convince yourself that:
The zeros of 1 + G(s)H(s) are the poles of the closed-loop transfer function.
The poles of 1 + G(s)H(s) are the poles of the open-loop transfer function.
The Nyquist criterion then states that:
P = the number of open-loop (unstable) poles of G(s)H(s).

N = the number of times the Nyquist diagram encircles -1.
clockwise encirclements of -1 count as positive encirclements.

counter-clockwise encirclements of -1 count as negative encirclements.
Z = the number of right-half-plane (positive, real) poles of the closed-loop system.
The important equation whih relates these three quantities is:

(7)
Note: This is only one convention for the Nyquist criterion. Another convention states that a positive N counts the counterclockwise or anti-clockwise encirclements of -1. The P and Z variables remain the same. In this case the equation becomes Z =
P - N. Throughout these tutorials, we will use a positive sign for clockwise encirclements.
It is very important (and somewhat tricky) to learn how to count the number of times that the diagram encircles -1. Therefore, we will
go into some detail to help you visualize this. You can view this movie as an example.
Another way of looking at it is to imagine you are standing on top of the -1 point and are following the diagram from beginning to end.
Now ask yourself: How many times did I turn my head a full 360 degrees? Again, if the motion was clockwise, N is positive, and if the
motion is anti-clockwise, N is negative.
Knowing the number of right-half plane (unstable) poles in open loop (P), and the number of encirclements of -1 made by the Nyquist
diagram (N), we can determine the closed-loop stability of the system. If Z = P + N is a positive, nonzero number, the closed-loop
system is unstable.
We can also use the Nyquist diagram to find the range of gains for a closed-loop unity feedback system to be stable. The system we
will test looks like this:
where G(s) is:
(8)
This system has a gain K which can be varied in order to modify the response of the closed-loop system. However, we will see that we
can only vary this gain within certain limits, since we have to make sure that our closed-loop system will be stable. This is what we
will be looking for: the range of gains that will make this system stable in the closed-loop.
The first thing we need to do is find the number of positive real poles in our open-loop transfer function:
roots([1 -8 15])
ans =
5
3
The poles of the open-loop transfer function are both positive. Therefore, we need two anti-clockwise (N = -2) encirclements of the
Nyquist diagram in order to have a stable closed-loop system (Z = P + N). If the number of encirclements is less than two or the
encirclements are not anti-clockwise, our system will be unstable.
Let's look at our Nyquist diagram for a gain of 1:
sys = (s^2 + 10*s + 24)/(s^2 - 8*s + 15);
nyquist(sys)
There are two anti-clockwise encirclements of -1. Therefore, the system is stable for a gain of 1. Now we will see how the system
behaves if we increase the gain to 20:
nyquist(20*sys)
The diagram expanded. Therefore, we know that the system will be stable no matter how much we increase the gain. However, if we
decrease the gain, the diagram will contract and the system might become unstable. Let's see what happens for a gain of 0.5:
nyquist(0.5*sys)
The system is now unstable. By trial and error we find that this system will become unstable for gains less than 0.80. We can verify
our answers by zooming in on the Nyquist plots as well as by looking at the closed-loop steps responses for gains of 0.79, 0.80, and
0.81.
Gain Margin
We already defined the gain margin as the change in open-loop gain expressed in decibels (dB), required at 180 degrees of phase shift
to make the system unstable. Now we are going to find out where this comes from. First of all, let's say that we have a system that is
stable if there are no Nyquist encirclements of -1, such as:
(9)
Looking at the roots, we find that we have no open loop poles in the right half plane and therefore no closed-loop poles in the righthalf-plane if there are no Nyquist encirclements of -1. Now, how much can we vary the gain before this system becomes unstable in
closed-loop? Let's look at the following figure:
The open-loop system represented by this plot will become unstable in closed loop if the gain is increased past a certain boundary. The
negative real axis area between -1/a (defined as the point where the 180 degree phase shift occurs...that is, where the diagram crosses
the real axis) and -1 represents the amount of increase in gain that can be tolerated before closed-loop instability.
If we think about it, we realize that if the gain is equal to a, the diagram will touch the -1 point:
(10)
or
(11)
Therefore, we say that the gain margin is a units. However, we mentioned before that the gain margin is usually measured in decibels.
Hence, the gain margin is:
(12)
We will now find the gain margin of the stable, open-loop transfer function we viewed before. Recall that the function is:
(13)
and that the Nyquist diagram can be viewed by typing:
sys = 50/(s^3 + 9*s^2 + 30*s + 20);
nyquist(sys)
As we discussed before, all that we need to do to find the gain margin is find a, as defined in the preceding figure. To do this, we need
to find the point where there is exactly 180 degrees of phase shift. This means that the transfer function at this point is real (has no
imaginary part). The numerator is already real, so we just need to look at the denominator. When s = jw, the only terms in the
denominator that will have imaginary parts are those which are odd powers of s. Therefore, for G(jw) to be real, we must have:
(14)
which means w = 0 (this is the rightmost point in the Nyquist diagram) or w = sqrt(30). We can then find the value of G(jw) at this
point using polyval:
w = sqrt(30);
polyval(50,j*w)/polyval([1 9 30 40],j*w)
ans =
-0.2174
The answer is: -0.2174 + 0i. The imaginary part is zero, so we know that our answer is correct. We can also verify by looking at the
Nyquist plot again. The real part also makes sense. Now we can proceed to find the gain margin.
We found that the 180 degrees phase shift occurs at -0.2174 + 0i. This point was previously defined as -1/a. Therefore, we now
have a, which is the gain margin. However, we need to express the gain margin in decibels:
(15)
(16)
(17)
We now have our gain margin. Let's see how accurate it is by using a gain of a = 4.6 and zooming in on the Nyquist plot:
a = 4.6;
nyquist(a*sys)
The plot appears to go right through the -1 point. We will now verify the accuracy of our results by viewing the zoomed Nyquist
diagrams and step responses for gains of 4.5, 4.6, and 4.7.
Phase Margin
We have already discussed the importance of the phase margin. Therefore, we will only talk about where this concept comes from. We
have defined the phase margin as the change in open-loop phase shift required at unity gain to make a closed-loop system unstable.
Let's look at the following graphical definition of this concept to get a better idea of what we are talking about.
Let's analyze the previous plot and think about what is happening. From our previous example we know that this particular system will
be unstable in closed-loop if the Nyquist diagram encircles the -1 point. However, we must also realize that if the diagram is shifted by
theta degrees, it will then touch the -1 point at the negative real axis, making the system marginally stable in closed-loop. Therefore,
the angle required to make this system marginally stable in closed-loop is called the phase margin (measured in degrees). In order to
find the point we measure this angle from, we draw a circle with radius of 1, find the point in the Nyquist diagram with a magnitude of
1 (gain of zero dB), and measure the phase shift needed for this point to be at an angle of 180 degrees.
Introduction: State-Space Methods for Controller Design

In this section, we will show how to design controllers and observers using state-space (or time-domain) methods.
Key MATLAB commands used in this tutorial are: eig , ss , lsim , place , acker
Contents
Modeling
Stability
Controllability and Observability
Control Design Using Pole Placement
Introducing the Reference Input
Observer Design
Modeling
There are several different ways to describe a system of linear differential equations. The state-space representation was introduced
in the Introduction: System Modeling section. For a SISO LTI system, the state-space form is given below:
(1)
(2)
where x is a n by 1 vector representing the state (commonly position and velocity variable in mechanical systems), u is a scalar
representing the input (commonly a force or torque in mechanical systems), and y is a scalar representing the output. The matrices A (n
by n), B (n by 1), and C (1 by n) determine the relationships between the state and input and output variables. Note that there are n
first-order differential equations. State space representation can also be used for systems with multiple inputs and outputs (MIMO), but
we will only use single-input, single-output (SISO) systems in these tutorials.
To introduce the state space design method, we will use the magnetically suspended ball as an example. The current through the coils
induces a magnetic force which can balance the force of gravity and cause the ball (which is made of a magnetic material) to be
suspended in midair. The modeling of this system has been established in many control text books (including Automatic Control
Systems by B. C. Kuo, the seventh edition).
The equations for the system are given by:

(3)
(4)
where h is the vertical position of the ball, i is the current through the electromagnet, V is the applied voltage, M is the mass of the ball,
g is gravity, L is the inductance, R is the resistance, and K is a coefficient that determines the magnetic force exerted on the ball. For
simplicity, we will choose values M = 0.05 Kg, K = 0.0001, L = 0.01 H, R = 1 Ohm, g = 9.81 m/sec^2. The system is at
equilibrium (the ball is suspended in midair) whenever h = K i^2/Mg (at which point dh/dt = 0). We linearize the equations about
the point h = 0.01 m (where the nominal current is about 7 amp) and get the state space equations:
(5)
(6)
where:
(7)
is the set of state variables for the system (a 3x1 vector), u is the input voltage (delta V), and y (the output), is delta h. Enter the system
matricies into a m-file.
A = [ 0
980
0
1
0
0
0
-2.8
-100 ];
B = [ 0
0
100 ];
C = [ 1 0 0 ];
Stability
One of the first things we want to do is analyze whether the open-loop system (without any control) is stable. As discussed in the
Introduction: System Analysis section, the eigenvalues of the system matrix, A, (equivalent to the poles of the transfer fucntion)
determine the stability. The eigenvalues of the A matrix are the values of s where det(sI - A) = 0.
poles = eig(A)
poles =
31.3050
-31.3050
-100.0000
One of the poles is in the right-half plane, (i.e. has positive real part which means that the system is unstable in open-loop.
To check out what happens to this unstable system when there is a nonzero initial condition, add the following lines to your m-file
and it again:
t = 0:0.01:2;
u = zeros(size(t));
x0 = [0.01 0 0];
sys = ss(A,B,C,0);
[y,t,x] = lsim(sys,u,t,x0);
plot(t,y)
title('Open-Loop Response to Non-Zero Initial Condition')
xlabel('Time (sec)')
ylabel('Ball Position (m)')
It looks like the distance between the ball and the electromagnet will go to infinity, but probably the ball hits the table or the floor first
(and also probably goes out of the range where our linearization is valid).
Controllability and Observability

A system is controllable if there exists a control input, u(t), that transfers any state of the system to zero in finite time. It can be shown
that an LTI system is controllable if and only if its controllabilty matrix, CO, has full rank (i.e. if rank(CO) = n where n is the number
of states ). The rank of the controllability matrix of an LTI model can be determined in MATLAB using the commands
rank(ctrb(A,B)) or rank(ctrb(sys)).
(8)
All the state variables of a system may not be directly measurable, for instance if the component is in an inaccessible location. In these
cases it is neccesary to estimate the values of the unknown internal state variables using only the available system outputs. A system is
observable if the initial state, x(t_0), can be determined from the system output, y(t), over some finite time t_0 < t < t_f. For LTI
systems, the system is observable if and only if the observability matrix, OB, has full rank (i.e. if rank(OB) = n where n is the number
of states). The observability of an LTI model can be determined in MATLAB using the command rank(obsv(A,C)) or
rank(obsv(sys)).
(9)
Controllability and observability are dual concepts. A system (A,B) is controllable if and only if a system (A',C,B',D) is observable.
This fact will be useful when designing an observer, as we shall see below.
Control Design Using Pole Placement

Let's build a controller for this system using pole placement. The schematic of a full-state feedback system is shown below. By fullstate, we mean that all state variables are known to the controller at all times. For instance in this system, we would need a sensor
measuring the ball position, another measuring velocity, and a third measuring current in the electro-magnet.
For simplicity, let's assume the reference is zero, R=0. The input is then
(10)
The state-space equations for the closed-loop feedback system are therefore
(11)
(12)
The stability and time domain performance of the closed-loop feedback system are determined primarily by the location of the poles
(eigenvalues) of the matrix (A-BK). Since the matrices A and B*K are both 3 by 3 matrices, there will be 3 poles for the system. By
choosing an appropriate K matrix we can place these closed-loop poles anywhere we want. We can use the MATLAB function place
to find the control matrix, K, which will give the desired poles.
Before attempting this method, we have to decide where we want the closed-loop poles to be. Suppose the criteria for the controller
were settling time < 0.5 sec and overshoot < 5%, then we might try to place the two dominant poles at -10 +/- 10i (at zeta = 0.7 or 45
degrees with sigma = 10 > 4.6*2). The third pole we might place at -50 to start, and we can change it later depending on what the
closed-loop behavior is. Remove the lsim command from your m-file and everything after it, then add the following lines to your mfile:
p1 = -10 + 10i;
p2 = -10 - 10i;
p3 = -50;
K = place(A,B,[p1 p2 p3]);
sys_cl = ss(A-B*K,B,C,0);
lsim(sys_cl,u,t,x0);
The overshoot is too large (there are also zeros in the transfer function which can increase the overshoot; you do not see the zeros in
the state-space formulation). Try placing the poles further to the left to see if the transient response improves (this should also make the
response faster).
p1 = -20 + 20i;
p2 = -20 - 20i;
p3 = -100;
K = place(A,B,[p1 p2 p3]);
lsim(sys_cl,u,t,x0);
This time the overshoot is smaller. Consult your textbook for further suggestions on choosing the desired closed-loop poles.
Compare the control effort required (K) in both cases. In general, the farther you move the poles, the more control effort it takes.
Note: If you want to place two or more poles at the same position, place will not work. You can use a function called acker which
works similarly to place:
K = acker(A,B,[p1 p2 p3])
Introducing the Reference Input

Now, we will take the control system as defined above and apply a step input (we choose a small value for the step, so we remain in
the region where our linearization is valid). Replace t,|u|, and lsim in your m-file with the following:
t = 0:0.01:2;
u = 0.001*ones(size(t));
lsim(sys_cl,u,t);
axis([0 2 -4E-6 0])
The system does not track the step well at all; not only is the magnitude not one, but it is negative instead of positive!
Recall the schematic above, we don't compare the output to the reference; instead we measure all the states, multiply by the gain vector
K, and then subtract this result from the reference. There is no reason to expect that K*x will be equal to the desired output. To
eliminate this problem, we can scale the reference input to make it equal to K*x steadystate. This scale factor is often called Nbar; it is
introduced as shown in the following schematic:
We can get Nbar from MATLAB by using the function rscale (place the following line of code after K = ...).
Nbar = rscale(sys,K)
Nbar =
-285.7143
Note that this function is not standard in MATLAB. You will need download it here, rscale.m, and save it to your current workspace.
Now, if we want to find the response of the system under state feedback with this introduction of the reference, we simply note the fact
that the input is multiplied by this new factor, Nbar:
lsim(sys_cl,Nbar*u,t)
title('Linear Simulation Results (with Nbar)')
axis([0 2 0 1.2*10^-3])
and now a step can be tracked reasonably well.
Observer Design
When we can't measure all the states x (often the case in practice), we can build an observer to estimate them, while measuring only
the output y = C x. For the magnetic ball example, we will add three new, estimated states to the system. The schematic is as follows:
The observer is basically a copy of the plant; it has the same input and almost the same differential equation. An extra term compares
the actual measured output y to the estimated output y_hat; this will cause the estimated states \hat{x} to approach the values of the
actual states x. The error dynamics of the observer are given by the poles of (A-LC).
First, we need to choose the observer gain L. Since we want the dynamics of the observer to be much faster than the system itself, we
need to place the poles at least five times farther to the left than the dominant poles of the system. If we want to use place, we need to
put the three observer poles at different locations.
op1 = -100;
op2 = -101;
op3 = -102;
Because of the duality between controllability and observability, we can use the same technique used to find the control matrix, but
replacing the matrix B by the matrix C and taking the transposes of each matrix
L = place(A',C',[op1 op2 op3])';
The equations in the block diagram above are given for \hat{x}. It is conventional to write the combined equations for the system plus
observer using the original state x plus the error state: e = x - \hat{x}. We use as state feedback u = -K \hat{x}. After a little bit
of algebra (consult your textbook for more details), we arrive at the combined state and error equations with the full-state feedback and
an observer.
At = [ A-B*K
zeros(size(A))
Bt = [
B*K
A-L*C ];
B*Nbar
zeros(size(B)) ];
Ct = [ C
zeros(size(C)) ];
To see how the response looks to a nonzero initial condition with no reference input, add the following lines into your m-file. We
typically assume that the observer begins with zero initial condition, \hat{x} = 0. This gives us that the initial condition for the error is
equal to the initial condition of the state.
sys = ss(At,Bt,Ct,0);
lsim(sys,zeros(size(t)),t,[x0 x0]);
title('Linear Simulation Results (with observer)')
Responses of all the states are plotted below. Recall that lsim gives us x and e; to get \hat{x}, we need to compute x - e.
t = 0:1E-6:0.1;
x0 = [0.01 0.5 -5];
[y,t,x] = lsim(sys,zeros(size(t)),t,[x0 x0]);
n = 3;
e = x(:,n+1:end);
x = x(:,1:n);
x_est = x - e;
% Save state variables explicitly to aid in plotting
h = x(:,1); h_dot = x(:,2); i = x(:,3);
h_est = x_est(:,1); h_dot_est = x_est(:,2); i_est = x_est(:,3);
plot(t,h,'-r',t,h_est,':r',t,h_dot,'-b',t,h_dot_est,':b',t,i,'-g',t,i_est,':g')
We can see that the observer estimates the states quickly and tracks the states well in the steady-state.
Introduction: Digital Controller Design

In this section we will discuss converting continuous time models into discrete time (or difference equation) models. We will also
introduce the z-transform and show how to use it to analyze and design controllers for discrete time systems.
Key MATLAB commands used in this tutorial are: c2d , pzmap , zgrid , step , rlocus
Contents
Introduction
Zero-Hold Equivalence
Conversion Using c2d
Example: Mass-Spring-Damper
Stability and Transient Response
Discrete Root Locus
Introduction
The figure below shows the typical continuous feedback system that we have been considering so far in this tutorial. Almost all of the
continuous controllers can be built using analog electronics.
The continuous controller, enclosed in the dashed square, can be replaced by a digital controller, shown below, that performs same
control task as the continuous controller. The basic difference between these controllers is that the digital system operates on discrete
signals (or samples of the sensed signal) rather than on continuous signals.
Different types of signals in the above digital schematic can be represented by the following plots.
The purpose of this Digital Control Tutorial is to show you how to use MATLAB to work with discrete functions either in transfer
function or state-space form to design digital control systems.
Zero-Hold Equivalence
In the above schematic of the digital control system, we see that the digital control system contains both discrete and the continuous
portions. When designing a digital control system, we need to find the discrete equivalent of the continuous portion so that we only
need to deal with discrete functions.
For this technique, we will consider the following portion of the digital control system and rearrange as follows.
The clock connected to the D/A and A/D converters supplies a pulse every T seconds and each D/A and A/D sends a signal only
when the pulse arrives. The purpose of having this pulse is to require that Hzoh(z) have only samples u(k) to work on and produce only
samples of output y(k); thus, Hzoh(z) can be realized as a discrete function.
The philosophy of the design is the following. We want to find a discrete function Hzoh(z) so that for a piecewise constant input to the
continuous system H(s), the sampled output of the continuous system equals the discrete output. Suppose the signal u(k) represents a
sample of the input signal. There are techniques for taking this sample u(k) and holding it to produce a continuous signal uhat(t). The
sketch below shows that the uhat(t) is held constant at u(k) over the interval kT to (k+1)T. This operation of holding uhat(t) constant
over the sampling time is called zero-order hold.
The zero-order held signal uhat(t) goes through H2(s) and A/D to produce the output y(k) that will be the piecewise same signal as if
the discrete signal u(k) goes through Hzoh(z) to produce the discrete output y(k).
Now we will redraw the schematic, placing Hzoh(z) in place of the continuous portion.
By placing Hzoh(z), we can design digital control systems dealing with only discrete functions.
Note: There are certain cases where the discrete response does not match the continuous response due to a hold circuit implemented in
digital control systems. For information, see Lagging effect associated with the hold.
Conversion Using c2d

There is a MATLAB function called c2d that converts a given continuous system (either in transfer function or state-space form) to a
discrete system using the zero-order hold operation explained above. The basic command for this in MATLAB is sys_d =
c2d(sys,Ts,'zoh')
The sampling time (Ts in sec/sample) should be smaller than 1/(30*BW), where BW is the closed-loop bandwidth frequency.
Example: Mass-Spring-Damper
Transfer Function
Suppose you have the following continuous transfer function
(1)
Assuming the closed-loop bandwidth frequency is greater than 1 rad/sec, we will choose the sampling time (Ts) equal to 1/100 sec.
Now, create an new m-file and enter the following commands.
M = 1;
b = 10;
k = 20;
s = tf('s');
sys = 1/(M*s^2+b*s+k);
Ts = 1/100;
sys_d = c2d(sys,Ts,'zoh')
sys_d =
4.837e-05 z + 4.678e-05
----------------------z^2 - 1.903 z + 0.9048
Sample time: 0.01 seconds
Discrete-time transfer function.
State-Space
The continuous time state-space model is as follows:
(2)
(3)
All constants are the same as before. The following m-file converts the above continuous state-space to discrete state-space.
A = [0
1;
-k/M
-b/M];
B = [ 0;
1/M];
C = [1 0];
D = [0];
Ts = 1/100;
sys = ss(A,B,C,D);
sys_d = c2d(sys,Ts,'zoh')
sys_d =
a =
x1
x2
x1
0.999
-0.1903
x2
0.009513
0.9039
b =
x1
x2
u1
4.837e-05
0.009513
c =
y1
x1
1
x2
0
d =
y1
u1
0
Sample time: 0.01 seconds

Discrete-time state-space model.
From these matrices, the discrete state-space can be written as
(4)
(5)
Now you have the discrete time state-space model.
Stability and Transient Response

For continuous systems, we know that certain behaviors results from different pole locations in the s-plane. For instance, a system is
unstable when any pole is located to the right of the imaginary axis. For discrete systems, we can analyze the system behaviors from
different pole locations in the z-plane. The characteristics in the z-plane can be related to those in the s-plane by the expression
(6)
T = Sampling time (sec/sample)

s = Location in the s-plane
z = Location in the z-plane
The figure below shows the mapping of lines of constant damping ratio (zeta) and natural frequency (Wn) from the s-plane to the zplane using the expression shown above.
If you noticed in the z-plane, the stability boundary is no longer imaginary axis, but is the unit circle z=1. The system is stable when all
poles are located inside the unit circle and unstable when any pole is located outside.
For analyzing the transient response from pole locations in the z-plane, the following three equations used in continuous system
designs are still applicable.
(7)
(8)
(9)
where,
zeta = Damping ratio

Wn = Natural frequency (rad/sec)
Ts = Settling time
Tr = Rise time
Mp = Maximum overshoot
Important: The natural frequency (Wn) in z-plane has the unit of rad/sample, but when you use the equations shown above, the Wn
must be in the unit of rad/sec.
Suppose we have the following discrete transfer function
(10)
Create an new m-file and enter the following commands. Running this m-file in the command window gives you the following plot
with the lines of constant damping ratio and natural frequency.
numDz = 1;
denDz = [1 -0.3 0.5];
sys = tf(numDz,denDz,-1); % the -1 indicates that the sample time is undetermined
pzmap(sys)
axis([-1 1 -1 1])
zgrid
From this plot, we see poles are located approximately at the natural frequency of 9pi/20T (rad/sample) and the damping ratio of 0.25.
Assuming that we have a sampling time of 1/20 sec (which leads to Wn = 28.2 rad/sec) and using three equations shown above, we can
determine that this system should have the rise time of 0.06 sec, a settling time of 0.65 sec and a maximum overshoot of 45% (0.45
more than the steady-state value). Let's obtain the step response and see if these are correct. Add the following commands to the above
m-file and rerun it in the command window. You should get the following step response.
sys = tf(numDz,denDz,1/20);
step(sys,2.5);
As you can see from the plot, the rise time, settling time and overshoot came out to be what we expected. This shows how you can use
the locations of poles and the above three equations to analyze the transient response of the system.
Discrete Root Locus

The root-locus is the locus of points where roots of characteristic equation can be found as a single gain is varied from zero to infinity.
The characteristic equation of an unity feedback system is
(11)
where G(z) is the compensator implemented in the digital controller and Hzoh(z) is the plant transfer function in z.
The mechanics of drawing the root-loci are exactly the same in the z-plane as in the s-plane. Recall from the continuous Root-Locus
Tutorial, we used the MATLAB function called sgrid to find the root-locus region that gives an acceptable gain (K). For the discrete
root-locus analysis, we will use the function zgrid that has the same characteristics as sgrid. The command zgrid(zeta, Wn) draws lines
of constant damping ratio (zeta) and natural frequency (Wn).
Suppose we have the following discrete transfer function
(12)
and the requirements are a damping ratio greater than 0.6 and a natural frequency greater than 0.4 rad/sample (these can be found from
design requirements, sampling time (sec/sample) and three equations shown in the previous section). The following commands draw
the root-locus with the lines of constant damping ratio and natural frequency. Create an new m-file and enter the following commands.
Running this m-file should give you the following root-locus plot.
numDz = [1 -0.3];
denDz = [1 -1.6 0.7];
sys = tf(numDz,denDz,-1);
rlocus(sys)
axis([-1 1 -1 1])
zeta = 0.4;
Wn = 0.3;
zgrid(zeta,Wn)
From this plot, you should realize that the system is stable because all poles are located inside the unit circle. Also, you see two dotted
lines of constant damping ratio and natural frequency. The natural frequency is greater than 0.3 outside the constant-Wn line, and the
damping ratio is greater than 0.4 inside the constant-zeta line. In this example, we do have the root-locus drawn in the desired region.
Therefore, a gain (K) chosen from one of the loci in the desired region should give you the response that satisfies design requirements.
SIMULINK
Introduction: Simulink Modeling
In Simulink, it is very straightforward to represent and then simulate a mathematical model representing a physical system. Models are
represented graphically in Simulink as block diagrams. A wide array of blocks are available to the user in provided libraries for
representing various phenomena and models in a range of formats. One of the primary advantages of employing Simulink (and
simulation in general) for the analysis of dynamic systems is that it allows us to quickly analyze the response of complicated systems
that may be prohibitively difficult to analyze analytically. Simulink is able to numerically approximate the solutions to mathematical
models that we are unable to, or don't wish to, solve "by hand."
In general, the mathematical equations representing a given system that serve as the basis for a Simulink model can be derived from
physical laws. In this page we will demonstrate how to derive a mathematical model and then implement that model in Simulink. This
model is then employed in the Introduction: Simulink Control page in order to demonstrate how to employ Simulink to design and
simulate the control for a system.
Contents
Train system
Free-body diagram and Newton's second law
Constructing the Simulink model
Running the model
Train system
In this example, we will consider a toy train consisting of an engine and a car. Assuming that the train only travels in one dimension
(along the track), we want to apply control to the train so that it starts and comes to rest smoothly, and so that it can track a constant
speed command with minimal error in steady state.
The mass of the engine and the car will be represented by and , respectively. Furthermore, the engine and car are connected via a
coupling with stiffness . In other words, the coupling is modeled as a spring with a spring constant . The force represents the force
generated between the wheels of the engine and the track, while represents the coefficient of rolling friction.
Free-body diagram and Newton's second law

The first step in deriving the mathematical equations that govern a physical system is to draw the free-body diagram(s) representing
the system. This is done below for our train system.
From Newton's second law, we know that the sum of the forces acting on a body is equal to the product of the mass of the body and its
acceleration. In this case, the forces acting on the engine
in the horizontal direction are the spring force, the rolling resistance, and
the force generated at the wheel/track interface. The forces acting on the train car
in the horizontal direction are the spring force
and the rolling resistance. In the vertical direction, the weight forces are balanced by the normal forces applied by the ground
. Therefore, there will be no acceleration in the vertical direction.
We will model the spring as generating a force that is linearly proportional to the deformation of the spring,
, where and
are the displacements of the engine and car, respectively. Here it is assumed that the spring is undeformed when and equal zero.
The rolling resistance forces are modeled as being linearly proportional to the product of the corresponding velocities and normal
forces (which are equal to the weight forces).
Applying Newton's second law in the horizontal direction based on the above free-body diagrams leads to the following governing
equations for the train system.
(1)
(2)
Constructing the Simulink model

This set of system equations can now be represented graphically without further manipulation. Specifically, we will construct two
copies (one for each mass) of the general expression
or
. First, open Simulink and open a new model window.
Then drag two Sum blocks (from the Math Operations library) into your model window and place them approximately as shown in the
figure below.
The outputs of each of these Sum blocks represents the sum of the forces acting on each mass. Multiplying each output signal by
will give us the corresponding acceleration of each mass. Now drag two Gain blocks (from the Math Operations Library) into your
model and attach each one with a line from the output of one of the Sum blocks. Label these two signals as "Sum_F1" and "Sum_F2"
in order to make your model more clear. This is accomplished by double-clicking in the space above each of the two signal lines and
entering the desired label.
These Gain blocks should contain

for each of the masses. We will define the variables M1 and M2 in the MATLAB workspace, so
we can just enter the corresponding variable names in each of the Gain blocks. Double-click on the upper Gain block and enter "1/M1"
into the Gain field. Similarly, enter "1/M2" in the Gain field of the second Gain block.
You will notice that the gains did not appear in the image of the Gain blocks, rather the blocks display a value of -K-. This is because
the blocks are too small on the screen to show the full variable name inside the triangle. The blocks can be resized so that the actual
gain value can be seen. To resize a block, select it by clicking on it once. Small squares will appear at the corners. Drag one of these
squares to stretch the block. Your model should appear as below.
The outputs of these gain blocks are the accelerations of each of the masses (the train engine and car). The governing equations we
derived above depend on the velocities and displacements of the masses. Since velocity can be determined by integrating acceleration,
and position can be determined by integrating velocity, we can generate these signals employing integrator blocks. Drag a total of four
Integrator blocks from the Continuous library into your model, two for each of our two accelerations. Connect these blocks and label
the signals as shown below. Specifically, the first inegrator takes the acceleration of mass 1 ("x1_ddot") as an input and generates the
velocity of mass 1 ("x1_dot"). The second integrator then takes this velocity and outputs the displacement of the first mass ("x1"). The
same pattern holds for the integrators for the second mass.
Now, drag two Scopes from the Sinks library into your model and connect them to the outputs of these integrators. Label them "x1"
and "x2".
Now we are ready to add the forces acting on each mass. First, we need to adjust the inputs on each Sum block to represent the proper
number of forces (we will worry about the signs later). Since there is a total of three forces acting on mass 1, double-click on the
corresponding Sum block and change the List of signs field to "|+++". The symbol "|" serves as a spacer. There are only 2 forces
acting on mass 2, therefore, we can leave that Sum block alone for now.
The first force acting on mass 1 is just the input force, . Drag a Signal Generator block from the Sources library and connect it to the
uppermost input of the corresponding Sum block. Label this signal as "F".
The next force acting on mass 1 is the rolling resistance force. Recall that this force is modeled as follows.
(3)
To generate this force, we can tap off the velocity signal and multiply by an appropriate gain. Drag a Gain block into your model
window. Tap off the "x1_dot" signal and connect it to the input of this new Gain block (draw this line in several steps if necessary).
Connect the output of the Gain block to the second input of the Sum block. Double-click the Gain block and enter "mu*g*M1" into the
Gain field. The rolling resistance force, however, acts in the negative direction. Therefore, change the list of signs of the Sum block to
"|+-+". Next, resize the Gain block to display the full gain and label the output of the Gain block "Frr1". Your model should now
appear as follows.
The last force acting on mass 1 is the spring force. Recall that this force is equal to the following.
(4)
Therefore, we need to generate a signal

which we can then be multiplied by a gain to create the force. Drag a Subtraction
block (or a Sum block or an Addition block) below the rest of your model. In order to change the direction of this block, right-click on
the block and choose Format > Flip block from the resulting menu. Alternatively, you can select the block then hit Ctrl-I. Now, tap
off the "x2" signal and connect it to the negative input of the Subtract block. Also, tap off the "x1" signal and connect it to the positive
input. This will cause signal lines to cross. Lines may cross, but they are only actually connected where a small block appears (such as
at a tap point).
Now, we can multiply this difference by the spring constant to generate the spring force. Drag a Gain block into your model to the left
of the Subtraction block. Change the value of the Gain block to "k" and connect the output of the Subtract block to its input. Then
connect the output of the Gain block to the third input of the Sum block for mass 1 and label the signal "Fs". Since the spring force acts
on mass 1 in the negative direction, it is necessary to again change the list of signs of the Sum block to "|+--". Your model should
appear as follows.
We can now apply forces to mass 2. For the first force, we will use the same spring force we just generated, except that it is applied to
mass 2 in the positive direction. Simply tap off the spring force signal "Fs" and connect it to the first input of the Sum block for mass
2.
The last force applied to mass 2 is its rolling resistance force. This force is generated in an analogous manner to the rolling resistance
force applied to mass 1. Tap off the signal "x2_dot" and multiply it by a Gain block with value "mu*g*M2". Then connect the output
of the Gain block to the second input of the corresponding Sum block and label the signal "Frr2". Changing the second input of the
Sum block to be negative will lead to the following model.
Now the model is complete. We simply need to supply the proper input and define the output of interest. The input to the system is the
force generated by the engine. Within the Simulink model, we have already defined the force to be the output of a Signal Generator
block. The output of the system, which we will observe and ultimately try to control, will be the velocity of the train engine. Add
another Scope block to your model from the Sinks library. Tap a line from the "x1_dot" signal and connect it to the Scope block. Label
this scope as "x1_dot" and your model should appear as in the following.
Now, the model is complete and should be saved. You can also download the completed model here.
Running the model
Before running the model, we need to assign numerical values to each of the variables used in the model. For the train system, we will
employ the following values.
= 1 kg
= 0.5 kg
= 1 N/sec
=1N
= 0.02 sec/m
= 9.8 m/s^2

M1
M2
k
F
mu
g
=
=
=
=
=
=
1;
0.5;
1;
1;
0.02;
9.8;
Execute your m-file in the MATLAB command window to define these values. Simulink will recognize these MATLAB variables for
use in the model.
Now, we need to give an appropriate input to the engine. Double-click on the Signal Generator block (outputs "F"). Select square
from the Wave form drop-down menu and set the Frequency field to equal "0.001". You may leave the Units as the default Hertz.
Also enter "-1" into the Amplitude field (positive amplitude steps negative before stepping positive).
The last step before running the simulation is to select an appropriate simulation time. To view one cycle of the 0.001 Hz square wave,
we should simulate the model for 1000 seconds. Select Parameters from the Simulation menu at the top of the model window and
change the Stop Time field to "1000". Close the dialog box.
Now, run the simulation and open the "x1_dot" scope to examine the velocity output (hit autoscale). The input was a square wave with
two steps, one positive and one negative. Physically, this means that the engine first went forward, then backward. The velocity output
reflects this.
In this page we derived the mathematical model for the train system from first principles and then represented the derived equations
within Simulink. An alternative option that is now available is to represent a dynamic system employing the physical modeling tool
Simscape. Simscape is an addition to Simulink that allows a user to model a system employing blocks that represent physical
quantities (and objects) such as inertias and joints, or resistances and inductors. Employing Simscape allows the user to simulate a
physical system without deriving the governing mathematical equations.
Continuing on to the Introduction: Simulink Control page, we will employ the model derived in this page to demonstrate how to use
Simulink to design the control for our train system.
Introduction: Simulink Control

Contents
The open-loop plant model

Implementing a PID controller in Simulink
Running the closed-loop model
Extracting a model into MATLAB
Controller design within Simulink
The open-loop plant model

In the Introduction: Simulink Modeling page we demonstrated how Simulink can be employed to simulate a physical system. More
generally, Simulink can also simulate the complete control system, including the control algorithm in addition to the physical plant. As
mentioned previously, Simulink is especially useful for generating the approximate solutions of mathematical models that may be
prohibitively difficult to solve "by hand." For example, consider that you have a nonlinear plant. A common approach is to generate a
linear approximation of the plant and then use the linearized model to design a controller using analytical techniques. Simulink can
then be employed to simulate the performance of your controller when applied to the full nonlinear model. Simulink can be employed
for generating the linearized model and MATLAB can be employed for designing the controller as described in the other Introduction
pages. Various control design facilities of MATLAB can also be accessed directly from within Simulink. We will demonstrate both
approaches in this page.
Recall the Simulink model of the toy train system derived in the Introduction: Simulink Modeling page and pictured below.
You can generate this model yourself, or you can download the completed model here. Assuming that the train only travels in one
dimension (along the track), we want to apply control to the train engine so that it starts and comes to rest smoothly, and so that it can
track a constant speed command with minimal error in steady state.
Implementing a PID controller in Simulink

Let us first create the structure for simulating the train system in unity feedback with a PID controller. In order to make our Simulink
model more understandable, we will first save the train model into its own subsystem block. To accomplish this, delete the three scope
blocks and replace each one by an Out1 block from the Sinks library. Label each Out1 block with the corresponding variable name,
"x1_dot", "x1", and "x2". Then delete the Signal Generator block and replace it with an In1 block from the Sources library. Label this
input "F" for the force generated between the train engine and the railroad track. Your model should now appear as follows.
Next select all of the blocks in your model (Ctrl A) and select Create Subsystem from the Edit menu at the top of the model window.
With a little rearranging and relabeling, your model will appear as shown below.
Now we can add a controller to our system. We will employ a PID controller which can be implemented using a PID Controller block
from the Continuous library. Placing this block in series with the train subsystem, your model will appear as follows. In the following,
we model the controller as generating the force "F" directly. This neglects the dynamics with which the train engine generates the
torque applied to the wheels, and subsequently neglects the dynamics of how the force is generated at the wheel/track interface. This
simplified approach is taken at this point since we only wish to introduce the basic functionality of Simulink for controller design and
analysis.
Double-clicking on the PID Controller block, we will initially set the Integral (I) gain field equal to 0 and will leave the Proportional
(P) and Derivative (D) gains as their defaults of 1 and 0, respectively. Next add a Sum block from the Math Operations library.
Double-click on this block and modify the List of signs field to "|+-". Since we wish to control the velocity of the toy train engine, we
will feedback the engine's velocity. This is accomplished by 4ring a line off of the "x1_dot" signal and connecting it to the negative
sign of the Sum block. The output of the Sum block will be the velocity error for the train engine and should be connected to the input
of the PID Controller block. Connecting the blocks as described and adding labels, your model should appear as follows.
Next add a Signal Builder block from the Sources library to represent the velocity commanded to the train. Since we wish to design a
controller to bring the train smoothly up to speed and smoothly to rest, we will test the system with a velocity command that steps up
to 1 m/s followed by a step back down to 0 m/s (recall that our system is a toy train). To generate this type of command signal, doubleclick on the Signal Builder block. Then choose Change time range from the Axes menu at the top of the block's dialog window. Set
the Max time field to "300" seconds. Next, set the step up to occur at 10 seconds and the step down to occur at 150 seconds. This is
accomplished by clicking on the corresponding portions of the signal graph (left and right vertical lines) and either dragging the line to
the desired position, or entering the desired time in the T field at the bottom of the window. When done, your signal should appear as
follows.
Also add a Scope block from the Sinks library and use it to replace the Out1 block for the train's velocity. Relabeling the blocks, your
model will appear as follows.
We are now ready to run the closed-loop simulation. If you wish to skip the above steps, you may download the completed model with
control here.
Running the closed-loop model

Before running the model, we need to assign numerical values to each of the variables used in the model. For the train system, we will
employ the following values.
= 1 kg
= 0.5 kg
= 1 N/sec
=1N
= 0.02 sec/m
= 9.8 m/s^2

M1
M2
k
F
mu
g
=
=
=
=
=
=
1;
0.5;
1;
1;
0.02;
9.8;
Execute your m-file in the MATLAB command window to define these values. Simulink will recognize these MATLAB variables for
use in the model. Next we need to set the time for which our simulation will run to match the time range of the command from the
Signal Builder block. This is accomplished by selecting Parameters from the Simulation menu at the top of the model window and
changing the Stop Time field to "300". Now, run the simulation and open the "x1_dot" scope to examine the velocity output (hit
autoscale). The result as shown below demonstrates that the closed-loop system is unstable for this controller.
Since the performance achieved above is unsatisfactory, we need to redesign our controller. We will first demonstrate how to extract a
model from Simulink into MATLAB for analysis and design. Then we will demonstrate how to design the control from directly within
Simulink.
Extracting a model into MATLAB

The Simulink Control Design toolbox offers the functionality to extract a model from Simulink into the MATLAB workspace. This is
especially useful for complicated, or nonlinear simulation models. This is also useful for generating discrete-time (sampled) models.
For this example, let us extract a continous-time model of our train subsystem. First we need to identify the inputs and outputs of the
model we wish to extract. The input to the train system is the force . We can designate this fact by right-clicking on the signal
representing "F" (output of the PID block) and choosing Linearization Points > Input Point from the resulting menu. Likewise, we
can designate the output of the train system by right-clicking on the "x1_dot" signal and choosing Linearization Points > Output
Point from the resulting menu. These inputs and outputs will now be indicated by small arrow symbols as shown in the following
figure. Since we wish to extract a model of the train by itself, without control, we need to further delete the feedback signal, otherwise
we will extract the closed-loop model from to . Your model should now appear as follows.
We can now extract the model by opening the Linear Analysis Tool. This is accomplished by selecting Control Design > Linear
Analysis from under the Tools menu at the top of the model window. Following these steps will open the window shown below.
This tool generates an LTI object from a (possibly nonlinear) Simulink model and allows you to specify the point about which the
linearization is performed. Since our Simulink model is already linear, our choice of operating point will have no effect and we can
leave it as the default Model Initial Condition. In order to generate the linearized model, select the Linearize button in the above
figure, which is indicated by the green triangle. The Linear Analysis Tool window should now appear as shown below.
Inspecting the above, the step response of the linearized model was automatically generated. Comparing this step response to the one
generated by the simulation of the open-loop train system in the Introduction: Simulink Modeling page, you can see that the responses
are identical. This makes sense since the simulation model was already linear. Additionally, the linearization process generated the
object linsys1 shown in the Linear Analysis Workspace above. This LTI object can be exported for use within MATLAB by simply
dragging the object into the MATLAB Workspace window.
Having extracted this model, we can now employ all of the facilities that MATLAB offers for controller design. For example, let us
employ the following commands to generate and analyze the closed-loop system reflecting the Simulink model created above.
sys_cl = feedback(linsys1,1);
pole(sys_cl)
ans =
-1.5261
0.0000
0.0670 + 1.1977i
0.0670 - 1.1977i
Examination of the above demonstrates that the closed-loop system in its current state has poles with positive real part and, therefore,
is unstable. This agrees with the result of our closed-loop simulation from above. We can then employ MATLAB to design a new
controller. Instead, we will demonstrate how to access some of MATLAB's functionality from directly within Simulink.
Controller design within Simulink

Rather than performing the controller design in MATLAB, we can also launch interactive tools to tune our controller from within
Simulink. One manner in which this can be done is to double-click on the PID Controller in the model and select the Tune button to
launch the PID Tuner GUI. Rather than do this, will launch the more general Simulink Control Design GUI by selecting Linear
Analysis > Compensator Design from under the Tools menu located at the top of the model window. Following these steps will open
the Control and Estimation Tools Manager window shown below.
The first thing that needs to be done is to identify the controller block that is to be tuned. This is accomplished by first clicking on the
Select Blocks button, and then selecting the PID Controller block from the resulting window as shown below. Next click the OK
button. Note that controllers represented in other types of blocks (Transfer Function, State Space, etc.) can also be tuned.
Before we proceed to tune our controller, we must first identify the inputs and outputs of the closed-loop system we wish to analyze.
This is done in the same manner we did when extracting a model into MATLAB. Specifically, right-click on the velocity command
signal (output of the Signal Builder block) and choose Linearization Points > Input Point from the resulting menu to identify the
input of our closed-loop system. Similarly, right-click on the train engine velocity signal ("x1_dot") and select Linearization Points >
Output Point from the menu to choose the output of our system. Your model should now appear as follows where the small arrow
symbols identify the input and output of the model.
Now that we have identified the block to tune and our input and output signals, we can now commence with tuning the controller.
Select the Tune Blocks button in the Control and Estimation Tools Manager window. This will open the Design Configuration
Window shown below which provides some introduction on how to employ the interactive design tool. In essence, this GUI is the
SISO Design Tool that is available from within MATLAB as well.
Clicking the Next button, we will choose the design plots we wish to employ for designing our controller. In this example, we will
employ a root locus design approach and hence will choose a Plot Type of Root Locus for Plot 1 as shown below. Since the root
locus approach to design employs a plot from the open-loop system for placing the closed-loop poles, we will leave the choice of
Open/Closed Loops as Open Loop 1 (this is our only choice!).
Clicking the Next button again will allow us to choose our analysis plots. We use the step response plot to assess how well we are able
to meet our goal of bringing the train up to speed smoothly with minimal steady-state error to a constant speed command. Therefore,
we will choose a Plot Type of Step from the drop-down menu under Plot 1 as shown below. We will also select Plot 1 under the Plot
Contents portion of the window for the only system that is defined. There is only one system available because we have defined only a
single input and single output for our system.
Selecting the Next Button will then open the SISO Design Tool with a root locus plot and a step response plot. The root locus plot
shown below displays the closed-loop pole locations of the train system plant under simple proportional control. Examining the plot,
one can see that many values of loop gain will place closed-loop poles in the right-half plane leading to an unstable response.
If we decrease the loop gain sufficiently, we can move the closed-loop poles into the left-half plane and we can stabilize our system.
This can be accomplished graphically by "grabbing" the pink boxes marking the closed-loop pole locations and dragging them toward
the open-loop pole locations (marked by x's). A loop gain of approximately 0.1 will stabilize the system. Examining the corresponding
step response, which will change automatically in response to the gain change if the Real-Time Update box is checked in the LTI
Viewer window, you can see that while the response is stable its steady-state error is quite large.
Recall that adding integral control is one way to reduce the steady-state error for a system. In this case, adding an integrator via the
controller will make the system type 1, where type 1 systems can track step references with zero steady-state error. Recall the
following form of a PI controller.
(1)
Therefore, a PI controller will add an integrator and a zero to our open-loop system. The integrator can be added to the system by
right-clicking in the field of the root locus plot and selecting Add Pole/Zero > Integrator from the resulting menu. Similarly, the zero
can be added by right-clicking on the root locus plot and selecting Add Pole/Zero > Real zero from the resulting menu. Then click
where along the real axis you wish to place the zero. We will place the zero just to the right of the plant pole on the real axis. You can
move the zero by clicking on it and dragging it to a new location. Once you have placed the zero, then grab the pink boxes representing
the closed-loop poles and attempt to line the three dominant poles up so that they have the same real part. There also will be a real
closed-loop pole to the left that is "faster" than the rest, and a closed-loop pole at the origin that is cancelled by a closed-loop zero at
the origin. The resulting root locus plot is shown below.
The compensator can also be edited by directly typing in pole and zero locations. This can be done by choosing Edit Compensator
from the Design menu located at the top of the SISO Design Task window. The window that opens is shown below. We will more
precisely place the zero at -0.15 and will choose a loop gain equal to 0.01.
The resulting closed-loop step response plot is shown below demonstrating that the train engine is brought to speed smoothly and with
zero steady-state error for a constant speed command.
The control gains that have been chosen can then be applied to the Simulink model by clicking the Update Simulink Block
Parameters button under the Compensator Editor tab of the Control and Estimation Tools Manager window (see above). The
simulation can then be run with this newly tuned controller. Clicking on the Scope block for the train engine's velocity and selecting
autoscale will produce a plot like the one shown below.
Overall this response seems to meet our goals of bringing the train up to speed and to rest smoothly, while maintaining minimal
steady-state error. This response matches the result generated with the SISO Design Tool above because that analysis and the
Simulink model used the exact same linear model.

Introducción A La Ingenieria de Control

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Introducción A La Ingenieria de Control

Загружено:

Авторское право:

Доступные форматы

SYSTEM

Introduction: System Modeling

Transfer Function Representation

respectively. Note that when finding transfer functions, we always

Example: Mass-Spring-Damper System

Entering State-Space Models into MATLAB

Create a new m-file and enter the following commands.

Continuous-time state-space model.

Entering Transfer Function Models into MATLAB

Example: RLC Circuit

Introduction: System Analysis

Time Response Overview

Second Order Systems

Time Response Overview

Frequency Response Overview

First Order Systems

The time constant

. We can generate the Bode plots in MATLAB

Second Order Systems

, and percent overshoot, %OS, are related to the damping

Critically Damped Systems

G3 = k_dc*w_n^2/(s^2 + 2*zeta*w_n*s + w_n^2);

The Characteristics of P, I, and D Controllers

on a closed-loop system are summarized in the table below.

CL RESPONSE RISE TIME OVERSHOOT SETTLING TIME S-S ERROR

The modeling equation of this system is

and the input

Plug these values into the above transfer function

Fast rise time

Open-Loop Step Response

) equal 300 and change the m-file to the following:

to 30, and let

General Tips for Designing a PID Controller

Add a proportional control to improve the rise time

Automatic PID Tuning

Introduction: Root Locus Controller Design

is a plot of the locations (locus) of all possible closed-loop poles with

The closed-loop transfer function is:

, then this equation has the form:

(the order of a polynomial is the highest power of that appears in it).

We will consider all positive values of K. In the limit as

, the poles of the closed-loop system are

Plotting the Root Locus of a Transfer Function

Choosing a Value of K from the Root Locus

Using SISOTOOL for Root Locus Design

Published with MATLAB 7.14

Introduction: Frequency Domain Methods for Controller

Gain and Phase Margin

Gain and Phase Margin

where is a variable (constant) gain and

However, if we have open-loop poles or zeros on the jw axis,

The Cauchy Criterion

as in the closed-loop transfer function:

Closed-Loop Performance from Bode Plots

is the controller and

Zero steady state error.

Closed-Loop Stability from the Nyquist Diagram

The Nyquist criterion then states that:

P = the number of open-loop (unstable) poles of G(s)H(s).

clockwise encirclements of -1 count as positive encirclements.

The important equation whih relates these three quantities is:

where G(s) is:

Published with MATLAB 7.14

G3 = k_dcw_n^2/(s^2 + 2zetaw_ns + w_n^2);