Beruflich Dokumente
Kultur Dokumente
Lab Report
Apparatus
MATLAB Software
Introduction
In this lab session we discuss the compensation of control systems using frequency response methods. We
examine both the compensator. Let us consider the rotor winder control system shown in Figure
The design objective is to achieve high steady-state accuracy to a ramp input. The steady state error to a
unit ramp input R(s) = 1⁄𝑠 2 is
1
𝑒𝑠𝑠 =
𝑘𝑣
Where
𝐺𝑐 (𝑠)
𝐾𝑣 = lim
𝑠→0 50
The performance specification of overshoot and settling time must be considered, as must the steady-state
tracking error. In all likelihood, a simple gain will not be satisfactory, so we will also consider compensation
utilizing lead compensator, using both Bode diagram method. Our approach is to develop a series of m-file
scripts to aid in the compensator designs.
Lead Compensator
The general transfer function of lead compensator is given below
𝐾(𝑠 + 𝑧)
𝐺𝑐 (𝑠) =
(𝑠 + 𝑝)
Where | z | < | p |. The lead compensator will give us the capability to improve the transient response. We
will use a frequency-domain approach to design the lead compensator.
We want a steady-state error of less than 10% to a ramp input and 𝐾𝑣 = 10. In addition to the steady-state
specifications, we want to meet certain performance specifications
yields 𝜁 = 0.59 and 𝜔𝑛 = 2.26. We thus obtain the phase margin requirement:
The steps leading to the final design are as follows:
1. Obtain the uncompensated system Bode diagram with K = 500, and compute the phase
margin.
2. Determine the amount of necessary phase lead ∅𝑚
3. Evaluate α from sin ∅𝑚 = (α − 1)⁄(α + 1)
4. Compute 10 log α and find the frequency 𝜔𝑚 on the uncompensated Bode diagram where
the magnitude curve is equal to -10 log α.
5. In the neighborhood of 𝜔𝑚 on the uncompensated Bode diagram, draw a line through the
0-dB point at 𝜔𝑚 with slope equal to the current slope plus 20 dB/decade. Locate the
intersection of the line with the uncompensated Bode diagram to determine the lead
compensation zero location. Then calculate the lead compensator pole location as p = αz
6. Obtain the compensated Bode diagram and check the phase margin. Repeat any steps if
necessary.
7. Raise the gain to account for the attenuation 1/ α.
8. Verify the final design with simulation using step function inputs, and repeat any design
steps if necessary.
We use three m-file in the design. The m-files are given below
Bode diagram of the uncompensated System
K=500;
numg=[1]; deng=[1 15 50 0]; sysg=tf(numg,deng);
sys=K*sysg;
[Gm,Pm,Wcg,Wcp]=margin(sys);
Phi=(60-Pm)*pi/180;
alpha=(1+sin(Phi))/(1-sin(Phi))
[mag,phase,w]=bode(sys);
mag_save(1,:)=mag(:,1,:);
M=-10*log10(alpha)*ones(length(w),1);
semilogx(w,20*log10(mag_save),w,M),
grid
xlabel('Frequency (rad/s)'),
ylabel('Magnitude (dB)')
title('Uncompensated Bode Plot')
hold on
semilogx([0.93462 9.3462 93.462
934.62],[20 0 -20 -40],'--')
Detailed Bode diagram of the compensated system
K=1800;
numg=[1]; deng=[1 15 50 0];
numgc=K*[1 3.5]; dengc=[1 25];
sysg=tf(numg,deng);
sysgc=tf(numgc,dengc);
sys=series(sysgc,sysg);
margin(sys)
where K = 1800 was selected after iteratively using the MATLAB script.
K=1800;
numg=[1]; deng=[1 15 50 0];
sysg=tf(numg,deng);
numgc=K*[1 3.5]; dengc=[1 25];
sysgc=tf(numgc,dengc);
syso=series(sysgc,sysg);
sys=feedback(syso,[1]);
t=[0:0.01:2];
step(sys,t)
ylabel ('y(t)')
Observations
MATLAB Code:
K=500;
numg1=[-10]; deng1=[1 10];
sysg1=tf(numg1,deng1);
numg2=[-10 -10.1 -0.1]; deng2=[1 2.02 2.0501
0.0602 0.0202]; sysg2=tf(numg2,deng2);
sys=K*series(sysg1,sysg2);
[Gm,Pm,Wcg,Wcp]=margin(sys);
Phi=(60-Pm)*pi/180;
alpha=(1+sin(Phi))/(1-sin(Phi));
[mag,phase,w]=bode(sys);
mag_save(1,:)=mag(:,1,:);
M=-10*log10(alpha)*ones(length(w),1);
semilogx(w,20*log10(mag_save),w,M), grid
xlabel('Frequency (rad/s)'), ylabel('Magnitude
(dB)')
title('Uncompensated Bode Plot')
hold on
semilogx([0.93462 9.3462 93.462 934.62],[20
0 -20 -40],'--')
MATLAB Plot:
Lab Session 2
Title
1. To study the compensation of control systems using s plane Method
2. To study the lag compensator design
Apparatus
MATLAB Software
Introduction
In this lab session we discuss the compensation of control systems using s-plane method. We examine lag
compensator. Let us consider the rotor winder control system shown in Figure
The design objective is to achieve high steady-state accuracy to a ramp input. The steady state error to a
unit ramp input R(s) = 1⁄𝑠 2 is
1
𝑒𝑠𝑠 =
𝑘𝑣
Where
𝐺𝑐 (𝑠)
𝐾𝑣 = lim
𝑠→0 50
The performance specification of overshoot and settling time must be considered, as must the steady-state
tracking error. In all likelihood, a simple gain will not be satisfactory, so we will also consider compensation
utilizing lag compensator, using root locus plot design method. Our approach is to develop a series of m-
file scripts to aid in the compensator designs
Lag compensator
The lag compensator which has the form
𝐾(𝑠 + 𝑧)
𝐺𝑐 (𝑠) =
(𝑠 + 𝑝)
Where | p | < | z |. We will use a root locus approach to design the lag compensator, although it can be done
using a Bode diagram as well. The desired root location region of the dominant roots is specified by
𝜁 = 0.59 𝑎𝑛𝑑 𝜔𝑛 = 2.26
The steps in the design are as follows:
The design methodology is illustrated in given m files using the rlocfind function, we can compute the gain
K associated with the roots of our choice on the uncompensated root locus that lie in the performance region.
We then compute α to ensure that we achieve
the desired 𝐾𝑣 . We place the lag compensator
pole and zero to avoid affecting the
uncompensated root locus.
Uncompensated root locus
K=100;
numg=[1]; deng=[1 15 50 0]; sysg=tf(numg,deng);
numgc=K*[1 0.1]; dengc=[1 0.01]; sysgc=tf(numgc,dengc);
syso=series(sysgc,sysg);
sys=feedback(syso,[1]);
step(sys)
The settling time and overshoot specifications are not satisfied, but 𝐾𝑣 = 10, as desired. It is possible to
continue the design iteration and refine the compensator somewhat, although it should be clear that the lag
compensator has improved the steady-state errors to a ramp input relative to the lead compensator design.
The final lag compensator design is
100(𝑠 + 0.1)
𝐺𝑠 (𝑠) =
𝑠 + 0.01
The resulting performance is summarized in Table
Task
Consider the control system shown in Figure.
a) Design a lag compensator using root locus methods to meet the following specifications:
1. steady state error less than 10% for a step input,
2. phase margin greater than 45°, and
3. settling time (with a 2% criterion) less than 5 seconds for a unit step input.
b) Test the controller developed in part (a) by simulating the closed-loop system response to
unit step input. Provide the time histories of the output y(t).
c) Compute the phase margin using the margin function.
Observations
MATLAB codes:
%% Lab Task
% uncompensated
clear all
numg=[1 10]; deng=[1 2 20];
sysg=tf(numg,deng);
clf; rlocus(sysg); hold on
zeta=0.5912; wn=2.2555;
x=[-20:0.1 :-zeta*wn]; y=-(sqrt(1-zeta^2)/zeta)*x;
plot(x,y,':',x,-y,':')
rlocfind(sysg)
axis([-25,1,-20,20]);
%compensated
clear all
numg=[1 10]; deng=[1 2 20]; sysg=tf(numg,deng);
numgc=10*[1 .6]; dengc=[1 .3]; sysgc=tf(numgc,dengc);
sys=series(sysgc,sysg);
sys1=feedback(sys,1);
step(sys1)
clf; rlocus(sys);
hold on
zeta=0.5912; wn=2.2555;
x=[-10:0.1 :-zeta*wn]; y=-(sqrt(1-zeta^2)/zeta)*x;
xc=[-10:0.1 :-zeta*wn];c=sqrt(wn^2-xc.^2);
plot(x,y,':',x,-y,':',xc,c,':',xc,-c,':')
axis([-15,1,-10,10]);
MATLAB Plots:
Apparatus
MATLAB Software
Introduction
Controllable system: A linear system is (completely) controllable if and only if the controllability matrix
𝐏𝐜 = [𝐁 𝐀𝐁 𝐀𝟐 𝐁 … . 𝐀𝐧−𝟏 𝐁] has full rank, where A is an n x n matrix. For single-input, single-output linear
systems, the system is controllable if and only if the determinant of the n x n controllability matrix is nonzero
Observable: A linear system is (completely) observable if and only if the observability matrix 𝐏𝟎 =
[𝐂 ; 𝐂𝐀 ; 𝐂𝐀𝟐 … . 𝐂𝐀𝐧−𝟏 ] has full rank, where A is an n x n matrix. For single-input, single-output linear
systems, the system is observable if and only if the determinant of the n x n observability matrix P() is
nonzero.
Full-state feedback control law: A control law of the form u = -Kx where x is the state of the system
assumed known at all times.
In the state variable feedback form controllability and observability can be checked using the functions
“ctrb” and” obsv”, respectively. The inputs to the ctrb function are the system matrix A and the input matrix
B; the output of ctrb is the controllability matrix Pc. Similarly, the input to the obsv function, shown in
Figure, is the system matrix A and the output matrix C; the output of obsv is the observability matrix Po.
The controllability matrix Pc is a function only of A and B, while the observability matrix Po is a function
only of A and C.
Example: Consider the system given below check the controllability and observability of the system.
−6 2 0 5
𝑥̇ = [ 4 0 7 ] 𝑥 + [0] 𝑢
−10 1 11 1
𝑦 = [1 2 1]𝑥
Solution:
clear all,clc
A=[-6 2 0;4 0 7;-10 1 11];
B=[5;0;1];
C=[1 2 1];
Pc=ctrb(A,B);
Po=obsv(A,C)
detPc=det(Pc)
detPo=det(Po)
if detPc==0
disp('system is not controllable')
else
disp('system is controllable')
end
if detPo==0
disp('system is not observable')
else
disp('system is observable')
end
MATLAB Result:
Po =
1 2 1
-8 3 25
-190 9 296
detPc =
-84933
detPo =
-3.6030e+03
system is controllable
system is observable
Now we discussed Ackermann's formula to place the poles of the system at desired locations. The function
acker calculates the gain matrix K to placle the closed-loop poles at the desired locations. The acker function
is illustrated in Figure
𝑑3 𝑦 𝑑2 𝑦 𝑑1 𝑦
+ 5 + 3 + 2𝑦 = 𝑢
dt 3 dt 2 dt
The state space form is
0 1 0 0
𝑥̇ = [ 0 0 1 ] 𝑥 + [0] 𝑢
−2 −3 −5 1
𝑦 = [1 0 0]𝑥
Solution:
MATLAB Result
Po =
1 0 0
0 1 0
0 0 1
detPc =
-1
detPo =
1
K =
8 9 2
Using Simulink
Or you can use ODE45 or ODE23 for simulation of system.
Step 1: Define the differential equation as a MATLAB function (mydiff.m):
function ydot=mydiff(t,y)
ydot=zeros(3,1);
ydot(1)=y(2);
ydot(2)=y(3)
ydot(3)= -7*y(3)-12*y(2)-10*y(1);
end
Step 2: Use one of the built-in ODE solver (ode23, ode45, ...) in a Script
clear all,clc
xo=[5 0 0];
tspan = [0 20];
[t y]=ode45('mydiff',tspan,xo);
plot(t,y(:,1),'g',t,y(:,2),'r',t,y(:,3),'b')
Task:
Design the Full-State Feedback Control Law for Inverted Pendulum for settling
time half second.
The system matrices are given below
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
• l = 0.098 m
• g=9.8 m/𝑠 2
• m=0.825 kg
• M=8.085 kg
Observations
MATLAB Code:
%% Task
clear all
clc
g=9.8; l=.098; m=.825; M=8.085;
s=tf('s');
wn=sqrt(g/l);
z=8/wn;
a=30; b=180;
A=[0 1 0 0;0 0 -m*g/M 0; 0 0 0 1;0 0 g/l 0];
B=[0;1/M;0;-1/(M*l)]; C=[1 0 0 0]; D=[0];
eq=(s^2+2*z*wn*s+wn^2)*(s^2+a*s+b)
r=roots([1 46 760 5880 18000]);
k=place(A,B,r);
A1=A-B*k;
system= ss(A1,B,C,D);
% step(system)
stepinfo(system)
MATLAB Plot:
Conclusion
As it can be seen, using the Ackermann’s formula available in MATLAB, full state feedback controller is
designed, which helps stabilize the system in given time. Stepinfo gives the exact transient response
values for the system.
Lab Session 4
Objective
The objective of this Lab is to learn the estimator design and implement it with full state feedback
control for regulator.
Apparatus
MATLAB Software
Introduction
The basic estimator design involves the creating the states using the output of the system. The simplest
form of observer is the Luenberger Observer which uses the system mathematical model and compare the
output of the system and the mathematical model and the difference is amplified and fed back to estimate
the correct value of the state.
The differential equation of the observer is
𝑋̂̇ = 𝐴𝑋̂ + 𝐵𝑈 + 𝐿(𝑌 − 𝑌̂)
Here 𝑋̂ 𝑎𝑛𝑑 𝑌̂ represent estimated states and L is the observer gain. The gain is decided on the basis of
poles of the observer and how fast the error needs to be eliminated.
The goal of the observer is to provide an estimate x so that 𝑥 → 𝑥̂ as 𝑡 → ∞ Remember that we do not know
𝑥(𝑡0 ) precisely; therefore, we must provide an initial estimate 𝑥̂(𝑡0 ) to the observer. Define the observer
estimation error as
𝑒(𝑡) = 𝑥(𝑡) − 𝑥̂(𝑡)
The observer design should produce an observer with the property that 𝑒(𝑡) → 0 as 𝑡 → 0. One of the
main results of systems theory is that if the system is completely observable, we can always find L so that
the tracking error is asymptotically stable as desired. Taking the time-derivative of the estimation error
yields
𝑒̇ = 𝑥̇ − 𝑥̂̇
and using the system model and the observer we obtain
𝑒̇ = 𝐴𝑥 + 𝐵𝑢 − 𝐴𝑥̂ − 𝐵𝑢_𝐿(𝑦 − 𝐶𝑥̂)
𝑒̇ (𝑡) = (𝐴 − 𝐿𝐶)𝑒(𝑡)
The characteristic equation is
det(𝜆𝐼 − (𝐴 − 𝐿𝐶)) = 0
the observer design process reduces to finding the matrix L such that the roots of the characteristic equation
lie in the left half-plane. This can always be accomplished if the system is completely observable.
Example:
Consider the Inverted pendulum the system matrix is
• l = 0.098 m
• g=9.8 m/𝑠 2
• m=0.825 kg
• M=8.085 kg
B=[0;0.1237;0;-1.2621];
C=[1 0 0 0];
D=[0;0;0;0];
Pc=ctrb(A,B);
Po=obsv(A,C);
detPc=det(Pc)
detPo=det(Po)
P=[-3+2i;-3-2i;-5;-6]
Q=[-30+20i,-30-20i,-50,-60];
K=acker(A,B,P)
L=acker(A',C',Q)
MATLAB Result
detPc =
196.5402
detPo =
P =
-3.0000 + 2.0000i
-3.0000 - 2.0000i
-5.0000 + 0.0000i
-6.0000 + 0.0000i
K =
L =
Observations
The given Simulink model was recreated in the environment and the values of K and L were implemented
in the gain matrices, which helps get the desired response.
Conclusion
The given Simulink model was recreated in the environment and the values of K and L were implemented
in the gain matrices, which helps get the desired response.
Lab Session 05
Objective
Implement Compensator Design by pole placement using SISO tool in MATLAB.
Apparatus
MATLAB
Introduction to Compensator
In redesigning a control system to alter the system response, an additional component is inserted
within the structure of the feedback system. It is this additional component or device that equalizes
or compensates for the performance deficiency. The compensating device may be electric,
mechanical, hydraulic, pneumatic, or some other type of device or network and is often called a
compensator.
Types of Compensation
Cascade Compensation
Feedback Compensation
Output, or Load Compensation
Input Compensation
Procedure
Let us consider Lead-compensator example, where the uncompensated loop transfer function is
1
G(s)
s2
You can select control architecture based on controller position and number of feedback loops
as shown in figure 1. Here we select basic control architecture i.e. Cascade compensation (C)
with pre-filter (F).
Click ‘System data’ to import data for compensation. Following window appear as shown
in figure 2
o G represent Plant TF
o H represent Feedback TF
o C represent Compensator TF
o F represent Pre-Filter TF
By selecting ‘Browser’ option, you can import system TF as shown in figure 2 < sys >.
Multiple plots can be shown at a time as we select root locus and bode plot only. We can
also plot Nichlos graph.
Now place zero and pole in LHP in such a way that root locus pass through desired
location. In case of lead compensator, |zero| < |pole|.
By adding pole and zero, root locus pass through desired location as shown by circle in
figure 6.
Step response to compensated system can be plot by selecting ‘Analysis Plot’ option and
Tick step response
Design specs:
Velocity Constant Kv should be equal to 20
ζ = 0.45
Observations
Conclusions
Using SISO tool for designing a compensator is easier than the conventional method of
calculating the locations of the poles and zeroes. Using this tool, a lag compensator can be
designed, which falls under the requirements.
Lab Session 06
Objective
Linear quadratic regulator design and analysis
Introduction
The theory of optimal control is concerned with operating a dynamic system at minimum cost.
The case where the system dynamics are described by a set of linear differential equations and the cost is
described by a quadratic function is called the LQ problem. One of the main results in the theory is that
the solution is provided by the linear–quadratic regulator (LQR), a feedback controller whose equations
are given below. The LQR is an important part of the solution to the LQG (linear–quadratic–Gaussian)
problem. Like the LQR problem itself, the LQG problem is one of the most fundamental problems in
control theory.
The LQR algorithm reduces the amount of work done by the control systems engineer to optimize
the controller. However, the engineer still needs to specify the cost function parameters and compare the
results with the specified design goals. Often this means that controller construction will be an iterative
process in which the engineer judges the "optimal" controllers produced through simulation and then
adjusts the parameters to produce a controller more consistent with design goals.
From the main problem, the dynamic equations of the inverted pendulum system in state-space form are
the following
𝑥̇ 0 1 0 0 𝑥 0
𝑥̈ 0 −0.1818 2.6727 0 𝑥̇ 1.8181
[ ̇] = [ ] [∅] + [ ]𝑢
∅ 0 0 0 1 0
∅̈ 0 −0.4545 31.1818 0 ∅̇ 4.5455
To see how this problem was originally set up and the system equations were derived, consult the
Inverted Pendulum: System Modeling page. For this problem the outputs are the cart's displacement (x in
meters) and the pendulum angle ( 𝜋 in radians) where 𝜋 represents the deviation of the pedulum's position
from equilibrium, that is, 𝜃 = 𝜋 + ∅.
The design criteria for this system for a 0.2-m step in desired cart position $x$ are as follows:
Open-loop poles
The first step in designing a full-state feedback controller is to determine the open-loop poles of the
system. Enter the following lines of code into an m-file. After execution in the MATLAB command
window, the output will list the open-loop poles (eigenvalues of A) as shown below.
M = 0.5;
m = 0.2;
b = 0.1;
I = 0.006;
g = 9.8;
l = 0.3;
p = I*(M+m)+M*m*l^2; %denominator for the A and B matrices
A = [0 1 0 0;
0 -(I+m*l^2)*b/p (m^2*g*l^2)/p 0;
0 0 0 1;
0 -(m*l*b)/p m*g*l*(M+m)/p 0];
B=[ 0;
(I+m*l^2)/p;
0;
m*l/p];
C = [1 0 0 0;
0 0 1 0];
D = [0;
0];
states = {'x' 'x_dot' 'phi' 'phi_dot'};
inputs = {'u'};
outputs = {'x'; 'phi'};
sys_ss = ss(A,B,C,D,'statename',states,'inputname',inputs,'outputname',outputs);
poles = eig(A)
poles =
0
-0.1428
-5.6041
5.5651
As you can see, there is one right-half plane pole at 5.5651. This should confirm your intuition that the
system is unstable in open loop.
Linear Quadratic Regulation (LQR)
The next step in the design process is to find the vector of state-feedback control gains K
assuming that we have access (i.e. can measure) all four of the state variables. This can be accomplished
in a number of ways. If you know the desired closed-loop pole locations, you can use the MATLAB
commands place or acker. Another option is to use the lqr command which returns the optimal controller
gain assuming a linear plant, quadratic cost function, and reference equal to zero (consult your textbook
for more details).
Before we design our controller, we will first verify that the system is controllable. Satisfaction of
this property means that we can drive the state of the system anywhere we like in finite time (under the
physical constraints of the system). For the system to be completely state controllable, the controllability
matrix must have rank n where the rank of a matrix is the number of linearly independent rows (or
columns). The controllability matrix of the system takes the form shown below. The number n
corresponds to the number of state variables of the system. Adding additional terms to the controllability
matrix with higher powers of the matrix A will not increase the rank of the controllability matrix since
these additional terms will just be linear combinations of the earlier terms.
Since our controllability matrix is 4x4, the rank of the matrix must be 4. We will use the
MATLAB command ctrb to generate the controllability matrix and the MATLAB command rank to test
the rank of the matrix. Adding the following additional commands to your m-file and running in the
MATLAB command window will produce the following output.
co = ctrb(sys_ss);
controllability = rank(co)
controllability =
4
Therefore, we have verified that our system is controllable and thus we should be able to design a
controller that achieves the given requirements. Specifically, we will use the linear quadratic regulation
method for determining our state-feedback control gain matrix $K$. The MATLAB function lqr allows
you to choose two parameters, R and Q, which will balance the relative importance of the control effort
(u) and error (deviation from 0), respectively, in the cost function that you are trying to optimize. The
simplest case is to assume R=1, and Q = C'C. The cost function corresponding to this R and Q places
equal importance on the control and the state variables which are outputs (the pendulum's angle and the
cart's position). Essentially, the lqr method allows for the control of both outputs. In this case, it is pretty
easy to do. The controller can be tuned by changing the nonzero elements in the Q matrix to achieve a
desirable response. To observe the structure of Q, enter the following into the MATLAB command
window to see the output given below.
Q = C'*C
Q=
1 0 0 0
0 0 0 0
0 0 1 0
0 0 0 0
The element in the (1,1) position of represents the weight on the cart's position and the element in the
(3,3) position represents the weight on the pendulum's angle. The input weighting will remain at 1.
Ultimately what matters is the relative value of and , not their absolute values. Now that we know
how to interpret the matrix, we can experiment to find the matrix that will give us a "good"
controller. We will go ahead and find the matrix and plot the response all in one step so that changes
can be made in the control and seen automatically in the response. Add the following commands to the
end of your m-file and run in the MATLAB command window to get the following value for and the
response plot shown below.
Q = C'*C;
R = 1;
K = lqr(A,B,Q,R)
Ac = [(A-B*K)];
Bc = [B];
Cc = [C];
Dc = [D];
states = {'x' 'x_dot' 'phi' 'phi_dot'};
inputs = {'r'};
outputs = {'x'; 'phi'};
sys_cl = ss(Ac,Bc,Cc,Dc,'statename',states,'inputname',inputs,'outputname',outputs);
t = 0:0.01:5;
r =0.2*ones(size(t));
[y,t,x]=lsim(sys_cl,r,t);
[AX,H1,H2] = plotyy(t,y(:,1),t,y(:,2),'plot');
set(get(AX(1),'Ylabel'),'String','cart position (m)')
set(get(AX(2),'Ylabel'),'String','pendulum angle (radians)')
title('Step Response with LQR Control')
K=
-1.0000 -1.6567 18.6854 3.4594
The curve in red represents the pendulum's angle in radians, and the curve in blue represents the cart's
position in meters.
You may have noted that if you increased the values of the elements of even higher, you could improve
the response even more. The reason this weighting was chosen was because it just satisfies the transient
design requirements. Increasing the magnitude of more would make the tracking error smaller but
would require greater control force . More control effort generally corresponds to greater cost (more
energy, larger actuator, etc.).
Task
Improve the response by increasing value of element Q further to achieve fast response.
Observations
By changing the values of the Q and R matrices, it can be seen that the performance parameters of
the system are changed. For example, state accuracy is attained by improving the value of Q, while
fuel cost is effectively reduced by increasing the value of R. This is the beauty of the LQR
controller.
Conclusion
LQR is an effective technique for controller design in the modern control theory.
Lab Session 07
Objective
To study the PID controller and its effects on the feedback loop response
Apparatus
MATLAB Software
Introduction
Consider the following unity feedback system
A system to be controlled is called plant and controller provides excitation for the plant; Designed to control
the overall system behavior.
The transfer function of the PID controller looks like the following:
KI KDs2 K ps KI
Gc ( s) K p KDs
s s
KP = Proportional gain
KI = Integral gain
KD = Derivative gain
First, let's take a look at how the PID controller works in a closed-loop system using the schematic shown
above. The variable (e) represents the tracking error, the difference between the desired input value (R) and
the actual output (Y). This error signal (e) will be sent to the PID controller, and the controller computes
both the derivative and the integral of this error signal. The signal (u) just past the controller is now equal
to the proportional gain (KP) times the magnitude of the error plus the integral gain (KI) times the integral
of the error plus the derivative gain (KD) times the derivative of the error.
de(t )
u K p e(t ) K I e(t )dt K D
dt
This signal (u) will be sent to the plant, and the new output (Y) will be obtained. This new output (Y) will
be sent back to the sensor again to find the new error signal (e). The controller takes this new error signal
and computes its derivatives and its internal again. The process goes on and on.
Example
Suppose we have a simple mass, spring, and damper system
X ( s) 1
F ( s) Ms bs k
2
Let suppose,
M = 1kg
b = 10 N.s/m
k = 20 N/m
F(s) = 1
X ( s) 1
G ( s) 2
F ( s) s 10s 20
To study the effect of Proportional, Differential and Integral Controller on
The DC gain of the plant transfer function is 1/20, so 0.05 is the final value of the output to a 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 eliminates the steady-state error.
Proportional Control
The closed-loop transfer function of the above system with a proportional controller is
X ( s) Kp
2
F ( s) s 10s (20 K p )
The above 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
The closed-loop transfer function of the given system with a PD controller is
X ( s) KDs K p
2
F ( s) s (10 K D ) s (20 K p )
This 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. For the given system, the closed-loop
transfer function with a PI control is
X ( s) K ps KI
3
F ( s) s 10s (20 K p s) K I
2
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
X ( s) KDs2 K ps KI
F ( s) s 3 (10 K D ) s 2 (20 K p ) s K I
After several trial and error runs, the gains Kp=350, Ki=300, and Kd=22 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.
MATLAB CODE:
Kp=350;
Ki=300;
Kd=22;
contr=tf([Kd Kp Ki],[1 0]);
sys_cl=feedback(contr*plant,1);
t=0:0.01:2;
step(sys_cl,t)
Now, we have obtained a closed-loop system with no overshoot, fast rise time, and no steady-state error.
The characteristics of P, I, and D controllers
The proportional controller (KP) will have the effect of reducing the rise time and will reduce, but never
eliminate, the steady state error. An integral controller (K I) will have the effect of eliminating the steady
state error, but it may make the transient response worse. A derivative control (KD) will have the effect of
increasing the stability of the system, reducing the overshoot and improving the transient response.
Effect of each controller KP, KI and KD on the closed-loop system are summarized below
Task 1
Consider a process given below to be controlled by a PID controller
400
𝐺𝑝 (𝑠) =
𝑠(𝑠 + 48.5)
Based on your results in parts b) and c) above what do you conclude as a suitable PID controller for this
process and give your justification.
Observations
MATLAB Code:
s= tf('s');
sys= 400/(s*(s+48.5));
% kp=2;
% kp=10;
% kp=100;
% ki=kp/10;
% sys1= (kp*s+ki)/s;
% syst=
series(sys,sys1);
% system=
feedback(syst,1);
kp=100;
ki=kp/10;
% kd=15;
% kd=5;
kd=2;
sys1=
(kp*s+ki+kd*s^2)/s;
syst=
series(sys,sys1);
system=
feedback(syst,1);
step(system)
Conclusion
It can be seen from the figures, as well as the table above, the PID controller can be used to
manipulate the transient response characteristics of the system. The initially unstable system was
made stable by incorporating the controller. Kd, Kp, Ki all have specific functions, which can be
seen in the aforementioned table.
Lab Session 08
Objective
To Design Robust PID Controller
Apparatus
MATLAB
Introduction
Physical systems and the external environment in which they operate cannot be modeled precisely,
may change in an unpredictable manner, and may be subject to significant disturbances. The design
of control systems in the presence of significant uncertainty requires the designer to seek a robust
system.
“A robust control system exhibits the desired performance despite the presence of significant
process uncertainty”
The process model will always be an inaccurate representation of the actual physical system
because of
Parameter changes
Un-modeled dynamics
Un-modeled time delays
Changes in equilibrium point (operating point)
Sensor noise
Unpredicted disturbance inputs
Multiple methods are available for robust design, including root locus, frequency response, ITAE
methods for a robust PID systems, internal model control, and pseudo-quantitative feedback
method. Here we used Integral time-weighted absolute error method to design robust PID
controller. Let consider a plant transfer function with un-certain parameters
K
G p ( s)
(s 1) 2
Step Response
As we can see from step response that there have multiple response corresponding to uncertain
parameter k and τ. We wish to design robust PID controller to eliminate disturbance effect or
parameter variation on system response.
Design specification
Percent overshoot should be less than 2 %
Settling time should be less than 2 sec ( 2 % criteria)
The transfer function of the PID controller is
KI KDs2 K ps KI
Gc ( s) K p KDs
s s
Therefore, the closed-loop transfer function without pre-filtering i.e. 𝐺𝑝(𝑠) = 1
We assume for simplicity K=1 and τ=1, closed loop Transfer function become
Gc ( s )G ( s ) KDs2 K ps KI
T ( s) 3
1 Gc ( s )G ( s ) s (2 K D ) s 2 (1 K p ) s K I
Using integral time-weighted absolute error method to find robust gains values to achieve desired
response irrespective of uncertain parameter variation. Closed loop transfer function are of 3rd
order, we choose the optimum coefficients of the characteristic equation for ITAE
s 3 1.75 n s 2 2.15 n2 s n3
2 K D 14 => K D 12
K I 512
These are the PID gains values which are robust to uncertain parameter variation, closed loop
transfer function become
K=1 and τ =1
Step Response
K=2 and τ =1
Step Response
Km
G( s)
(s p1 )( s p2 )
Observations
Matlab Code
s= tf('s');
% km=ureal('km',4,'Plusminus',1);
% p1=ureal('p1',1,'Plusminus',0.5);
% p2=ureal('p2',4,'Plusminus',0.5);
km=4; p1=1; p2=4;
sys= km/((s+p1)*(s+p2));
% step(sys,getNominal(sys),6)
% legend('Sampled
uncertainty','Nominal')
kd= 0.71875; kp=9.8844; ki=22.78125;
gc= ((kd*s^2)+(kp*s)+ki)/s;
system= series(sys,gc);
system= feedback(system,1)
% prefilter=
42.88/(1.125*s^2+22.34*s+42.88);
prefilter= 91.13/(s^2+39.54*s+91.13);
system1= prefilter*system;
stepinfo(system1)
Conclusions
Robust controller design is useful in the environments where the plant parameters are susceptible
to change. These controllers help maintain the required parameters of the system. Using the
ITAE standard equation, a robust PID controller can be designed.
Lab Session 09
Objective
To study the digital control system and compensator design in digital systems.
Apparatus
MATLAB
Introduction
The figure below shows the typical continuous-time feedback system. Almost all continuous-time
controllers can be implemented employing analog electronics
The continuous controller, enclosed in the shaded rectangle, can be replaced by a digital controller, shown
below, that performs the same control task as the continuous controller. The basic difference between
these controllers is that the digital system operates on discrete signals (samples of the sensed signals)
rather than on continuous signals. Such a change may be necessary if we wish to implement our control
algorithm in software on a digital computer, which is frequently the case.
The purpose of this lab is to demonstrate how to use MATLAB to work with discrete functions, either in
transfer function or state-space form, to design digital control systems.
In the above schematic of the digital control system, we see that the system contains both discrete and
continuous portions. Typically, the system being controlled is in the physical world and generates and
responds to continuous-time signals, while the control algorithm may be implemented on a digital
computer. When designing a digital control system, we first need to find the discrete equivalent of the
continuous portion of the system. There are multiple method of discretization
Continuous
Time Plant
DT Controller
Graph
Figure 21: Step Response of CT and DT system with different sampling time
From graphs, ZOH method is suitable for lower sampling time as compared to system closed loop
bandwidth or time constant. While for higher sampling period, bilinear transformation is suitable.
For designing controller in DT, we use following MATLAB ‘c2d’ command
We can also use PID Tuner app for designing PID controller in discrete domain,
>> C
C=
Ts z-1
Kp + Ki * ------ + Kd * ------
z-1 Ts
PID(z) block explain below, its show discrete time controller while plant is in CT domain, we can tune
PID gains values manually or can be tune automatically by select Tune option in PID Simulink block.
1
G p (s)
s 10s 20
2
Observations
MATLAB Code:
%% Manual
s= tf('s');
sys= 1/(s^2+10*s+20);
sys1=c2d(sys,0.01,'tustin');
kp=600.0478; ki=1734.7763; kd=49.207; Tf=0.00017681; Ts=0.01;
C=pid(kp,ki,kd,Tf,Ts,'IFormula','Trapezoidal','Dformula','Trapez
oidal');
Gp = series(C,sys1);
clos=feedback(Gp,1);
step(clos)
stepinfo(clos)
%% Auto
s= tf('s');
sys= 1/(s^2+10*s+20);
sys1=c2d(sys,0.001,'tustin');
kp=428.386; ki=745.76135; kd=41.17381; Tf=0.00017681; Ts=0.001;
C=pid(kp,ki,kd,Tf,Ts,'IFormula','Trapezoidal','Dformula','Trapez
oidal');
Gp = series(C,sys1);
clos=feedback(Gp,1);
step(clos)
stepinfo(clos)
MATLAB Plots:
Discretization by ZOH:
Conclusions
Discretization of the time-based systems helps with the implementation of a discrete controller,
which is able to effectively control the system. This process is useful since most of the controllers
are computer based and run on discrete values.
Lab Session 10
Fuzzy controller (for inverted pendulum)
III. Defuzzification: In this phase we will get a real number for the output.
[Input1]
Name='theta'
Range=[-5 5]
NumMFs=5
MF1='NL':'trimf',[-7.5 -5 -2.5]
MF2='NS':'trimf',[-5 -2.5 0]
MF3='Z':'trimf',[-2.5 0 2.5]
MF4='PS':'trimf',[0 2.5 5]
MF5='PL':'trimf',[2.5 5 7.5]
[Input2]
Name='thetad'
Range=[-1.5 1.5]
NumMFs=5
MF1='NL':'trimf',[-2.25 -1.5 -0.75]
MF2='NS':'trimf',[-1.5 -0.75 0]
MF3='Z':'trimf',[-0.75 0 0.75]
MF4='PS':'trimf',[0 0.75 1.5]
MF5='PL':'trimf',[0.75 1.5 2.25]
[Output1]
Name='output1'
Range=[-40 40]
NumMFs=5
MF1='NL':'trimf',[-60 -40 -20]
MF2='NS':'trimf',[-40 -20 0]
MF3='Z':'trimf',[-20 0 20]
MF4='PS':'trimf',[0 20 40]
MF5='PL':'trimf',[20 40 60]
Simulink:
Fx=
( g*sin(u(2)) - m*l*(u(3)^2)*cos(u(2))*sin(u(2))/(mc + m) ) / ( l*(4/3 -
m*cos(u(2))^2/(mc + m)) ) + (cos(u(2))/(mc + m))*(-1)*u(1) / (l*(4/3 -
m*(cos(u(2))^2)/(mc+m)))
Function rules:
[Rules]
1 1, 1 (1) : 1
1 2, 1 (1) : 1
1 3, 1 (1) : 1
1 4, 2 (1) : 1
1 5, 3 (1) : 1
2 1, 1 (1) : 1
2 2, 1 (1) : 1
2 3, 2 (1) : 1
2 4, 3 (1) : 1
2 5, 4 (1) : 1
3 1, 1 (1) : 1
3 2, 2 (1) : 1
3 3, 3 (1) : 1
3 4, 4 (1) : 1
3 5, 5 (1) : 1
4 1, 2 (1) : 1
4 2, 3 (1) : 1
4 3, 4 (1) : 1
4 4, 5 (1) : 1
4 5, 5 (1) : 1
5 1, 3 (1) : 1
5 2, 4 (1) : 1
5 3, 5 (1) : 1
5 4, 5 (1) : 1
5 5, 5 (1) : 1
_
Result:-