Design and Simulation of Aircraft Autopilot to Control the Pitch Angle

UNIVERSITY OF JORDAN
Department Of Mechatronics Engineering
Design and Simulation of Aircraft Autopilot to
Control the Pitch Angle
Ehab Al Hamayel
University Of Jordan
Qusai Haltam
University Of Jordan

Abstract
In this paper, we are going to design an aircraft
autopilot to control the pitch angle by apply the state-
space controller design technique. In particular, we
will attempt to place the closed-loop poles of the
system by designing a controller that calculates its
control based on the state of the system. Because the
dynamic equations covering the motion of the motion
of the aircraft are a very complicated set of six
nonlinear coupled differential equations. We will use a
linearized longitudinal model equation under certain
assumption to build the aircraft pitch controller also
we will verify the design and check the response using
MatLab&Simulink.
Keywords: pitch angle, angle of attack, state-space,
state feedback, pole placement, Observer.
1. Introduction
Flight dynamics the study of the motion of an aircraft
or missile; concerned with transient or short-term
effects relating to the stability and control of the
vehicle, rather than to calculating such performance as
altitude or velocity. The three critical flight dynamics
parameters are the angles of rotation in
three dimensions about the vehicle's center of mass,
known as roll, pitch and yaw [1]. Aircraft engineers
develop control systems for a vehicle's orientation
(attitude) about its center of mass. The control systems
include actuators, which exert forces in various
directions, and generate rotational forces
or moments about the center of gravity of the aircraft,
and thus rotate the aircraft in pitch, roll, or yaw. For
example, a pitching moment is a vertical force applied
at a distance forward or aft from the center of gravity
of the aircraft, causing the aircraft to pitch up or down.
Some fighter planes are capable of achieving a very
high angle of attach hence the pitch angle.one of the
first and best fighters capable of doing so is the
Russian Sukhoi Su-27. The unstable aerodynamically
design gives it the ability of doing a difficult and
dangerous maneuverings that can cause the majority of
Fighters to stall or even frame damage, figure.1 shows
a signature maneuvering done by the Russian su-27
pilots called “Pugachev Cobra”, The manoeuvre is
named after the Soviet test pilot Viktor Pugachev, who
first performed the maneuver publicly in 1989 at
the Paris Le Bourget air show.[2]
Such maneuver needs a capable and reliable controller
to prevent the fighter from being out of control!
in this paper we propose a state-space pitch controller
based on a linearized dynamic model (for simplicity)
under a specific assumptions for a commercial jet
aircraft.
2. System model equations
The equations governing the motion of an aircraft are a
very complicated set of six nonlinear coupled
differential equations. However, under certain
assumptions, they can be decoupled and linearized into
longitudinal and lateral equations. Aircraft pitch is
governed by the longitudinal dynamics. The basic
coordinate axes and forces acting on an aircraft are
shown in the figure given below in fig.2.
Design and Simulation of Aircraft Autopilot to Control
the Pitch Angle
ehab al hamayel, qusai haltam/ department of mechatronics
engineering/ University of Jordan
Under the supervision of Dr. Mohammad Janaideh
Department of mechatronics engineering/university of jordan
20 Dec 2014
Fig.1 An Su-27 performing the Cobra manoeuvre
Fig.2 Forces acting on an aircraft

We will assume that the aircraft is in steady-cruise at
constant altitude and velocity; thus, the thrust, drag,
weight and lift forces balance each other in the x-
and y-directions. We will also assume that a change in
pitch angle will not change the speed of the aircraft
under any circumstance (unrealistic but simplifies the
problem a bit). Under these assumptions, the
longitudinal equations of motion for the aircraft can be
written as follows:
For this system, the input will be the elevator
deflection angle and the output will be the pitch
angle of the aircraft.
We will plug in some numerical values in our
equations taken from the data from one of Boeing's
commercial aircraft [3].
2.1. Transfer function
To find the transfer function of the above system, we
need to take the Laplace transform of the above
modeling equations. Recall that when finding a
transfer function, zero initial conditions must be
assumed. The Laplace transform of the above
equations are shown below:
Then we obtain the following transfer function:
2.2. State space
Recognizing the fact that the modeling equations
above are already in the state-variable form, we can
rewrite them as matrices as shown below.
Since our output is pitch angle, the output equation is
the following:
3. System Analysis
3.1Open-loop response
Now let's see how the uncompensated open-loop
system performs. Specifically, we will use the
MATLAB command “step” to analyze the open-loop
step response where we have scaled the input to
represent an elevator angle input ( ) of 0.15 radians
(8.6 degrees) we will get the plot in fig.3
From the above plot, we see that the open-loop
response is unstable. Stability of a system can be
determined by examining the poles of the transfer
function. The poles can be identified using the
MATLAB command pole. The result is shown below:
p1= 0
p2= -0.3695 + 0.8857i
p2=-0.3695 - 0.8857i
As indicated above, one of the poles of the open-loop
transfer function is on the imaginary axis while the
other two poles are in the left-half of the complex s-
plane. A pole on the imaginary axis indicates that the
free response of the system will not grow unbounded,
but also will not decay to zero. Even though the free
response will not grow unbounded, a system with a
pole on the imaginary axis can grow unbounded when
given an input, even when the input is bounded. This
fact is in agreement with what we have already seen.
In this particular case, the pole at the origin behaves
Fig.3 open loop response

like an integrator. Therefore, when the system is given
a step input its output continues to grow to infinity in
the same manner that an integral of a constant would
grow to infinity as the upper limit of the integral is
made large!
3.2Closed-loop response
The closed-loop transfer function for the transfer
function in (10) with the controller C(s) simply set
equal to one can be generated using the MATLAB
command feedback as shown below.
Examining the above closed-loop step response, the
addition of feedback has stabilized the system. In fact,
the steady-state error appears to be driven to zero and
there is no overshoot in the response, though the rise-
time and settle-time appear to be very high! The
character of the resulting step response is indicated by
the location of the poles and zeros of the system's
transfer function, in a similar manner to the way the
system's stability properties were. The MATLAB
commands pole and zero can be used to reveal the
poles and zeros of the closed-loop transfer function as
shown below:
poles =
-0.3255 + 1.3816i
-0.3255 - 1.3816i
-0.0881
zeros =
-0.1541
The root locus for the closed loop system is shown in
fig.5.
The above results demonstrate that the closed-loop
transfer function is third order with a zero.
4. State-Space Methods for Controller
Design
4.1 Design requirements
The chosen design criteria for our controller:
 Overshoot less than 5%
 Rise time less than 1.5 seconds
 Settling time less than 5 seconds
 Steady-state error less than 2%
We will attempt to place the closed-loop poles of the
system by designing a controller that calculates its
control based on the state of the system.
4.2 Controllability
In order to apply our state-space controller design
techniques we need to first verify an important
property, controllability. The controllability property is
necessary to guarantee that we have the authority to
drive the state of the system anywhere we like. This
corresponds to the ability to place the closed-loop
poles of the system anywhere in the complex s-plane.
For the system to be completely state controllable, the
controllability matrix is:
This matrix must have rank n. The rank of a matrix is
the number of independent rows (or columns). The
number n corresponds to the number of state variables
Fig.4 Closed-loop response
Fig.5 Root-locus of the closed-loop system

of the system. Since our controllability matrix is 3x3,
the rank of the matrix is 3 so the system is
controllable.
4.3 Control design via pole placement
The schematic of a full-state feedback control system
is shown below in Fig.6 (with D = 0).
Where
K = control gain matrix
x = [α, q, θ]' = state vector
θdes = reference (r)
δ = θdes - K x = control input (u)
θ = output (y)
Referring to the state-space equations (13)and (14), we
see that substituting the state-feedback law δ = θdes- Kx
leads to (15)&(16).
Based on the above, matrix A - BK determines the
closed-loop dynamics of our system. Specifically, the
roots of the determinant of the matrix [ sI - ( A - BK ) ]
are the closed-loop poles of the system. Since the
determinant of [ sI - ( A - BK ) ] is a third-order
polynomial, there are three poles we can place and
since our system is completely state controllable, we
can place the poles anywhere we like. "pole-placement"
technique can be used to find the control gain matrix K
to place the closed-loop poles in the desired locations.
Note that this feedback law presumes that all of the
state variables in the vector x are measured, even
though θ is our only output. If this is not the case, then
an observer needs to be designed to estimate the other
state variables.
We know from the above that we can place the closed-
loop poles of the system anywhere we would like. The
question then that is left is, where should we place
them? If we have a standard first- or second-order
system, we then have relationships that directly relate
pole locations to characteristics of the step response and
can use these relations to place the poles in order to
meet our given requirements. This process becomes
more difficult if we have a higher-order system or
zeros. With a higher-order system, one approach is to
place the higher-order poles 5-10 times farther to the
left in the complex plane than the dominant poles,
thereby leading them to have negligible contribution to
the transient response. The effect of zeros is more
difficult to address using a pole-placement approach to
control. Another limitation of this pole-placement
approach is that it doesn't explicitly take into account
other factors like the amount of required control effort!
4.4 Linear quadratic regulation
We will use a technique called the Linear Quadratic
Regulator (LQR) method to generate the "best" gain
matrix K, without explicitly choosing to place the
closed-loop poles in particular locations. This type of
control technique optimally balances the system error
and the control effort based on a cost that the designer
specifies that defines the relative importance of
minimizing errors and minimizing control effort. In the
case of the regulator problem, it is assumed that the
reference is zero. Therefore, in this case the magnitude
of the error is equal to the magnitude of the state. To
use this LQR method, we need to define two
parameters: the state-cost weighted matrix (Q) and the
control weighted matrix (R). For simplicity, we will
choose the control weighted matrix equal to 1 (R=1),
and the state-cost matrix (Q) equal to pC'C. Employing
the vector C from the output equation means that we
will only consider those states in the output in defining
our cost. In this case, is the only state variable in the
output. The weighting factor (p) will be varied in order
to modify the step response. In this case, R is a scalar
since we have a single input system.
We will employ the MATLAB command lqr to find
the proper poles location, we will first let the weighting
factor (p) equal 10 then checking the system response.
>> p = 10;
Q = p*C'*C
R = 1;
[K] = lqr(A,B,Q,R)
sys_CL = ss(A-B*K, B, C, D);
Fig.6 Full state feedback control system

step(0.15*sys_CL)
ylabel('pitch angle (rad)');
title('Closed-Loop Step Response: LQR');
Q =
0 0 0
0 0 0
0 0 10
K =
-0.5963 100.4036 3.1623
And the system output response can be seen in fig.7
Examination of the above demonstrates that the
response is too slow. We can tune the performance of
our system to be faster by weighting the importance of
the error more heavily than the importance of the
control effort. More specifically, this can be done by
increasing the weighting factor p. After some trial and
error, we settle on a value of p = 50. The response for
the new weighting factor p=50 is shown in fig.8
Examination of the above demonstrates that the rise
time, overshoot, and settling time are satisfactory.
However, there is a large steady-state error. One way
to correct this is by introducing a precompensator ( ̅)
to scale the overall output.
4.5 Adding Precompensator (̅)
Unlike other design methods, the full-state feedback
system does not compare the output to the reference;
instead, it compares all states multiplied by the control
matrix (K x) to the reference. Thus, we should not
expect the output to equal the commanded reference!
To obtain the desired output, we can scale the reference
input so that the output does equal the reference in
steady state. This can be done by introducing a
precompensator scaling factor called̅̅̅. The basic
schematic of our state-feedback system with scaling
factor ( ̅) is shown in Fig.9.
We can easily find Nbar from the MATLAB by using
a user-defined function called “Rescale.m” see
appendix.
>> p = 50;
Q = p*C'*C
R = 1;
[K] = lqr(A,B,Q,R)
Nbar = Rescale(A,B,C,D,K)
sys_CL = ss(A-B*K, B*Nbar, C, D);
step(0.15*sys_CL)
axis([0 8 0 0.18])
Q =
0 0 0
0 0 0
0 0 50
Fig.7 the system response with weighting factor p=10

K =
-0.6435 169.6950 7.0711
Nbar =
7.0711
The new system response is shown in fig.10
Now the steady-state error has been eliminated and all
design requirements are satisfied.
Note that the precompensator Nbar employed above is
calculated based on the model of the plant and further
that the precompensator is located outside of the
feedback loop. Therefore, if there are errors in the
model (or unknown disturbances) the precompensator
will not correct for them and there will be steady-state
error. You may recall that the addition of integral
control may also be used to eliminate steady-state error,
even in the presence of model uncertainty and step
disturbances. The tradeoff with using integral control is
that the error must first develop before it can be
corrected for, therefore, the system may be slow to
respond. The precompensator on the other hand is able
to anticipate the steady-state offset using knowledge of
the plant model. A useful technique is to combine the
precompensator with integral control to leverage the
advantages of each approach. The system with
disturbance and its response are shown in fig.11&12
5. 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. in our case the
pitch angle θ, we will add three new, estimated states to
the system. The schematic is shown in fig.13:
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 ̂; this will cause the estimated
states ̂ 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;
L = place(A',C',[op1 op2 op3])';
The equations in the block diagram on fig.13 are given
for ̂ It is conventional to write the combined equations
for the system plus observer using the original state x
plus the error state: e = x -̂. We use as state feedback u
= -K ̂. After a little bit of algebra, we arrive at the
combined state and error equations with the full-state
feedback and an observer. Equations 17 to 21
the observer with the perfect model and the system
response are shown on Fig.14 &15 respectively .
6. Conclusion
On this paper we have designed and simulated a pitch
controller for a commercial aircraft. we have obtained
the design requirements through the use of state
feedback controller, also an observer has been belt to
estimate the state variables.
6. Future Work
 Analyzing and develop controllers for the nonlinear
system instead of linearizing the system at a trim
point.
 Designing an autopilot that can control all the flight
parameter such as pitch, yaw, and roll.
 Experimental verification and implementation of
the autopilot on working aircraft prototype.
7. References
[1] McGraw-Hill Dictionary of Scientific & Technical Terms, 6E,
Copyright © 2003 by The McGraw-Hill Companies, Inc.
[2] Mike Spick (2002). The Illustrated Directory of Fighters. St.
Paul, Minnesotta: MBI Publishing Company. p. 442. ISBN 0-7603-
1343-1. Retrieved 29 October 2011.
[3] Control Tutorials for MATLAB and Simulink. Bill Messner ,
Department of Mechanical Engineering at Carnegie Mellon
University , Dawn Tilbury of the Department of Mechanical
Engineering and Applied Mechanics at the University of Michigan,
http://ctms.engin.umich.edu/
[4] Stengel, Robert F. (2010), Aircraft Flight Dynamics (MAE 331)
course summary, retrieved November 16, 2011
[5] Anderson, John D. (2004), Introduction to Flight (5th ed.),
McGraw-Hill, ISBN 0-07-282569-3
[6] Sidi, M.J. "Spacecraft Dynamics & Control. Cambridge, 1997.
[7] Crane, David. "Air-to-Air Fighter Combat Application of
Pugachev’s Cobra Maneuver: Busting the Western Myth". Defense
Review. Retrieved 14 January 2012.
[8] Crane, David. "Air-to-Air Fighter Combat Application of
Pugachev’s Cobra Maneuver: Busting the Western Myth".
Defense Review. Retrieved 14 January 2012.
[9] Malcolm J. Abzug; E. Eugene Larrabee. Airplane stability and
control: a history of the technologies that made aviation possible.
pp. 157–161. ISBN 978-0-521-80992-4. Retrieved 23 March 2011.

Appendix
Matlab codes
% Ehab Al Hamayel and Qusai Haltam
% Department Of Mechatronics Engineering|University Of
Jordan
%File name: AirCraft_model.m
% This code will generate the openloop transfer function
of the
% longitudinal equations of motion for the aircraft, since
Aircraft pitch
% is governed by the longitudinal dynamics
%*Important note: We will assume that the aircraft is in
steady-cruise at
%constant altitude and velocity; thus, the thrust, drag,
%weight and lift forces balance each other in the x- and
y-directions.
% We will also assume that a change in pitch angle will
not change the speed
%of the aircraft under any circumstance
%** values are taken from the data from one of Boeing's
commercial aircraft
%*** Thanks to http://ctms.engin.umich.edu | Prof. Bill
Messner at Carnegie Mellon
%And Prof. Dawn Tilbury at the University of Michigan
%*********************************************************
*****************
%Transfer function:
s = tf('s');
pitch_angle = (1.151*s+0.1774)/(s^3+0.739*s^2+0.921*s)
t = [0:0.01:20];
step(0.15*pitch_angle,t);
axis([0 20 0 0.8]);
title('Open-loop Step Response');
rlocus(pitch_angle)
sys_CL = feedback(pitch_angle,1)
step(0.15*sys_CL);
title('Closed-loop Step Response');
p = 50;
Q = p*C'*C
R = 1;
[K] = lqr(A,B,Q,R)
Nbar = Rescale(A,B,C,D,K)
sys_CL = ss(A-B*K, B, C, D);
step(0.15*sys_CL)
axis([0 8 0 0.025])
% State-space representation:
A = [-0.313 56.7 0; -0.0139 -0.426 0; 0 56.7 0];
B = [0.232; 0.0203; 0];
C = [0 0 1];
D = [0];
pitch_ss = ss(A,B,C,D)
User defined functions:
function[Nbar]=Rescale(a,b,c,d,k)
% Given the single-input linear system:
% .
% x = Ax + Bu
% y = Cx + Du
% and the feedback matrix K,
%
% the function rscale(sys,K) or
rscale(A,B,C,D,K)
% finds the scale factor N which will
% eliminate the steady-state error to a
step reference
% for a continuous-time, single-input
system
% with full-state feedback using the
schematic below:
%
% /---------
% R + u | . |
% ---> N --->() ---->| X=Ax+Bu |-->
y=Cx ---> y
% -| ---------/
% | |
% |<---- K <----|
%
%8/21/96 Yanjie Sun of the University of
Michigan
% under the supervision of Prof.
D. Tilbury
%6/12/98 John Yook, Dawn Tilbury revised
error(nargchk(2,5,nargin));
% --- Determine which syntax is being
used ---
nargin1 = nargin;
if (nargin1==2), % System form
[A,B,C,D] = ssdata(a);
K=b;
elseif (nargin1==5), % A,B,C,D matrices
A=a; B=b; C=c; D=d; K=k;
else error('Input must be of the form
(sys,K) or (A,B,C,D,K)')
end;
% compute Nbar
s = size(A,1);
Z = [zeros([1,s]) 1];
N = inv([A,B;C,D])*Z';
Nx = N(1:s);
Nu = N(1+s);
Nbar=Nu + K*Nx;

Design and Simulation of Aircraft Autopilot to Control the Pitch Angle

More Related Content

What's hot

Viewers also liked

Similar to Design and Simulation of Aircraft Autopilot to Control the Pitch Angle

Recently uploaded

Design and Simulation of Aircraft Autopilot to Control the Pitch Angle