Functions for Compensator Design :: Designing Compensators (Control System Toolbox™)

Control System Toolbox™

Functions for Compensator Design

On this page…
When to Use Functions for Compensator Design Root Locus Design Pole Placement Linear-Quadratic-Gaussian (LQG) Design Example — Designing an LQG Regulator Example — Designing an LQG Servo Controller Example — Designing an LQR Servo Controller in Simulink

On this page…

When to Use Functions for Compensator Design

Root Locus Design

Pole Placement

Linear-Quadratic-Gaussian (LQG) Design

Example — Designing an LQG Regulator

Example — Designing an LQG Servo Controller

Example — Designing an LQR Servo Controller in Simulink

When to Use Functions for Compensator Design

The term control system design refers to the process of selecting feedback gains that meet design specifications in a closed-loop control system. Most design methods are iterative, combining parameter selection with analysis, simulation, and insight into the dynamics of the plant.

In addition to the SISO Design Tool, you can use functions for a broader range of control applications, including

Classical SISO design
Modern MIMO design techniques such as pole placement and linear quadratic Gaussian (LQG) methods

Root Locus Design

The following table summarizes the functions for designing compensators using root locus design techniques.

Function	Description
`pzmap`	Pole-zero map
`rlocus`	Evans root locus plot
`sgrid`	Continuous grid for root locus plots
`sisotool`	Root Locus Design GUI
`zgrid`	Discrete grid for root locus plots

Pole Placement

The closed-loop pole locations have a direct impact on time response characteristics such as rise time, settling time, and transient oscillations. Root locus uses compensator gains to move closed-loop poles to achieve design specifications for SISO systems. You can, however, use state-space techniques to assign closed-loop poles. This design technique is known as pole placement, which differs from root locus in the following ways:

Using pole placement techniques, you can design dynamic compensators.
Pole placement techniques are applicable to MIMO systems.

Pole placement requires a state-space model of the system (use ss to convert other model formats to state space). In continuous time, such models are of the form

where u is the vector of control inputs, x is the state vector, and y is the vector of measurements.

State-Feedback Gain Selection

Under state feedback , the closed-loop dynamics are given by

and the closed-loop poles are the eigenvalues of A-BK. Using the place function, you can compute a gain matrix K that assigns these poles to any desired locations in the complex plane (provided that (A,B) is controllable).

For example, for state matrices A and B, and vector p that contains the desired locations of the closed loop poles,

K = place(A,B,p);

computes an appropriate gain matrix K.

State Estimator Design

You cannot implement the state-feedback law unless the full state x is measured. However, you can construct a state estimate such that the law retains similar pole assignment and closed-loop properties. You can achieve this by designing a state estimator (or observer) of the form

The estimator poles are the eigenvalues of A-LC, which can be arbitrarily assigned by proper selection of the estimator gain matrix L, provided that (C, A) is observable. Generally, the estimator dynamics should be faster than the controller dynamics (eigenvalues of A-BK).

Use the place function to calculate the L matrix

L = place(A',C',q)

where A and C are the state and output matrices, and q is the vector containing the desired closed-loop poles for the observer.

Replacing x by its estimate in yields the dynamic output-feedback compensator

Note that the resulting closed-loop dynamics are

Hence, you actually assign all closed-loop poles by independently placing the eigenvalues of A-BK and A-LC.

Example. Given a continuous-time state-space model

sys_pp = ss(A,B,C,D)

with seven outputs and four inputs, suppose you have designed

A state-feedback controller gain K using inputs 1, 2, and 4 of the plant as control inputs
A state estimator with gain L using outputs 4, 7, and 1 of the plant as sensors
Input 3 of the plant as an additional known input

You can then connect the controller and estimator and form the dynamic compensator using this code:

controls = [1,2,4];
sensors = [4,7,1];
known = [3];
regulator = reg(sys_pp,K,L,sensors,known,controls)

Pole Placement Tools

You can use functions to

Compute gain matrices K and L that achieve the desired closed-loop pole locations.
Form the state estimator and dynamic compensator using these gains.

The following table summarizes the functions for pole placement.

Functions	Description
`acker`	SISO pole placement
`estim`	Form state estimator given estimator gain
`place`	MIMO pole placement
`reg`	Form output-feedback compensator given state-feedback and estimator gains

The function acker is limited to SISO systems, and you should use it only for systems with a small number of states. The function place is a more general and numerically robust alternative to acker.

Caution

Pole placement can be badly conditioned if you choose unrealistic pole locations. In particular, you should avoid:

Placing multiple poles at the same location.
Moving poles that are weakly controllable or observable. This typically requires high gain, which in turn makes the entire closed-loop eigenstructure very sensitive to perturbation.

Linear-Quadratic-Gaussian (LQG) Design

Linear-quadratic-Gaussian (LQG) control is a modern state-space technique for designing optimal dynamic regulators and servo controllers with integral action (also known as set point trackers). This technique allows you to trade off regulation/tracker performance and control effort, and to take into account process disturbances and measurement noise.

To design LQG regulators and set point trackers, you perform the following steps:

Construct the LQ-optimal gain.
Construct a Kalman filter (state estimator).
Form the LQG design by connecting the LQ-optimal gain and the Kalman filter.

For more information about using LQG design to create LQG regulators , see Linear-Quadratic-Gaussian (LQG) Design for Regulation.

For more information about using LQG design to create LQG servo controllers, see Linear-Quadratic-Gaussian (LQG) Design of Servo Controller with Integral Action.

These sections focus on the continuous-time case. For information about discrete-time LQG design, see the dlqr and kalman reference pages.

Linear-Quadratic-Gaussian (LQG) Design for Regulation

You can design an LQG regulator to regulate the output y around zero in the following model.

The plant in this model experiences disturbances (process noise) w and is driven by controls u. The regulator relies on the noisy measurements y to generate these controls. The plant state and measurement equations take the form of

and both w and v are modeled as white noise.

Note LQG design requires a state-space model of the plant. You can use ss to convert other model formats to state space.

To design LQG regulators, you can use the design techniques shown in the following table.

To design an LQG regulator using... Use the following commands:

To design an LQG regulator using...	Use the following commands:
A quick, one-step design technique when the following is true: G is an identity matrix and H = 0. All known (deterministic) inputs are control inputs and all outputs are measured. Integrator states are weighted independently of states of plants and control inputs. The state estimator of the Kalman filter is based on .	`lqg` For more information, see the `lqg` reference page.
A more flexible, three-step design technique that allows you to specify: Arbitrary G and H. Known (deterministic) inputs that are not controls and/or outputs that are not measured. A flexible weighting scheme for integrator states, plant states, and controls. The state estimator of the Kalman filter based on either or .	`lqr`, `kalman`, and `lqgreg` For more information, see Constructing the Optimal State-Feedback Gain for Regulation Constructing the Kalman State Estimator Forming the LQG Regulator

A quick, one-step design technique when the following is true:

G is an identity matrix and H = 0.
All known (deterministic) inputs are control inputs and all outputs are measured.
Integrator states are weighted independently of states of plants and control inputs.
The state estimator of the Kalman filter is based on .

lqg

For more information, see the lqg reference page.

A more flexible, three-step design technique that allows you to specify:

Arbitrary G and H.
Known (deterministic) inputs that are not controls and/or outputs that are not measured.
A flexible weighting scheme for integrator states, plant states, and controls.
The state estimator of the Kalman filter based on either or .

lqr, kalman, and lqgreg

For more information, see

Constructing the Optimal State-Feedback Gain for Regulation. You construct the LQ-optimal gain from the following elements:

State-space system matrices
Weighting matrices Q, R, and N, which define the tradeoff between regulation performance (how fast x(t) goes to zero) and control effort.

To construct the optimal gain, type the following command:

K= lqr(A,B,Q,R,N)

This command computes the optimal gain matrix K, for which the state feedback law minimizes the following quadratic cost function for continuous time:

The software computes the gain matrix K by solving an algebraic Riccati equation.

For information about constructing LQ-optimal gain, including the cost function that the software minimizes for discrete time, see the lqr reference page.

Constructing the Kalman State Estimator. You need a Kalman state estimator for LQG regulation and servo control because you cannot implement optimal LQ-optimal state feedback without full state measurement.

You construct the state estimate such that remains optimal for the output-feedback problem. You construct the Kalman state estimator gain from the following elements:

State-space plant model sys
Noise covariance data, Qn, Rn, and Nn
The following figure shows the required dimensions for Qn, Rn, and Nn. If Nn is 0, you can omit it.
Required Dimensions for Qn, Rn, and Nn

Note You construct the Kalman state estimator in the same way for both regulation and servo control.

To construct the Kalman state estimator, type the following command:

[kest,L,P] = kalman(sys,Qn,Rn,Nn);

This command computes a Kalman state estimator, kest with the following plant equations:

where w and v are modeled as white noise. L is the Kalman gain and P the covariance matrix.

The software generates this state estimate using the Kalman filter

with inputs u (controls) and y (measurements). The noise covariance data

determines the Kalman gain L through an algebraic Riccati equation.

The Kalman filter is an optimal estimator when dealing with Gaussian white noise. Specifically, it minimizes the asymptotic covariance

of the estimation error .

For more information, see the kalman reference page. For a complete example of a Kalman filter implementation, see Kalman Filtering.

Forming the LQG Regulator. To form the LQG regulator, connect the Kalman filter kest and LQ-optimal gain K by typing the following command:

regulator = lqgreg(kest, K);

This command forms the LQG regulator shown in the following figure.

The regulator has the following state-space equations:

For more information on forming LQG regulators, see the lqgreg reference page and LQG Regulation: Rolling Mill Example.

Linear-Quadratic-Gaussian (LQG) Design of Servo Controller with Integral Action

You can design a servo controller with integral action for the following model:

The servo controller you design ensures that the output y tracks the reference command r while rejecting process disturbances w and measurement noise v.

The plant in the previous figure is subject to disturbances w and is driven by controls u. The servo controller relies on the noisy measurements y to generate these controls. The plant state and measurement equations are of the form

and both w and v are modeled as white noise.

Note LQG design requires a state-space model of the plant. You can use ss to convert other model formats to state space.

To design LQG servo controllers, you can use the design techniques shown in the following table.

To design an LQG servo controller using... Use the following commands:

To design an LQG servo controller using...	Use the following commands:
A quick, one-step design technique when the following is true: G is an identity matrix and H = 0. All known (deterministic) inputs are control inputs and all outputs are measured. Integrator states are weighted independently of states of plants and control inputs. The state estimator of the Kalman filter is based on .	`lqg` For more information, see the `lqg` reference page.
A more flexible, three-step design technique that allows you to specify: Arbitrary G and H. Known (deterministic) inputs that are not controls and/or outputs that are not measured. A flexible weighting scheme for integrator states, plant states, and controls. The state estimator of the Kalman filter based on either or .	`lqi`, `kalman`, and `lqgtrack` For more information, see Constructing the Optimal State-Feedback Gain for Servo Control Constructing the Kalman State Estimator Forming the LQG Servo Control

A quick, one-step design technique when the following is true:

G is an identity matrix and H = 0.
All known (deterministic) inputs are control inputs and all outputs are measured.
Integrator states are weighted independently of states of plants and control inputs.
The state estimator of the Kalman filter is based on .

lqg

For more information, see the lqg reference page.

A more flexible, three-step design technique that allows you to specify:

Arbitrary G and H.
Known (deterministic) inputs that are not controls and/or outputs that are not measured.
A flexible weighting scheme for integrator states, plant states, and controls.
The state estimator of the Kalman filter based on either or .

lqi, kalman, and lqgtrack

For more information, see

Constructing the Optimal State-Feedback Gain for Servo Control. You construct the LQ-optimal gain from the

State-space plant model sys
Weighting matrices Q, R, and N, which define the tradeoff between tracker performance and control effort

To construct the optimal gain, type the following command:

K= lqi(sys,Q,R,N)

This command computes the optimal gain matrix K, for which the state feedback law minimizes the following quadratic cost function for continuous time:

The software computes the gain matrix K by solving an algebraic Riccati equation.

For information about constructing LQ-optimal gain, including the cost function that the software minimizes for discrete time, see the lqi reference page.

Constructing the Kalman State Estimator. You need a Kalman state estimator for LQG regulation and servo control because you cannot implement LQ-optimal state feedback without full state measurement.

You construct the state estimate such that remains optimal for the output-feedback problem. You construct the Kalman state estimator gain from the following elements:

State-space plant model sys
Noise covariance data, Qn, Rn, and Nn
The following figure shows the required dimensions for Qn, Rn, and Nn. If Nn is 0, you can omit it.
Required Dimensions for Qn, Rn, and Nn

Note You construct the Kalman state estimator in the same way for both regulation and servo control.

To construct the Kalman state estimator, type the following command:

[kest,L,P] = kalman(sys,Qn,Rn,Nn);

This command computes a Kalman state estimator, kest with the following plant equations:

where w and v are modeled as white noise. L is the Kalman gain and P the covariance matrix.

The software generates this state estimate using the Kalman filter

with inputs u (controls) and y (measurements). The noise covariance data

determines the Kalman gain L through an algebraic Riccati equation.

The Kalman filter is an optimal estimator when dealing with Gaussian white noise. Specifically, it minimizes the asymptotic covariance

of the estimation error .

For more information, see the kalman reference page. For a complete example of a Kalman filter implementation, see Kalman Filtering.

Forming the LQG Servo Control. To form a two-degree-of-freedom LQG servo controller, connect the Kalman filter kest and LQ-optimal gain K by typing the following command:

servocontroller = lqgtrack(kest, K);

This command forms the LQG servo controller shown in the following figure.

The servo controller has the following state-space equations:

For more information on forming LQG servo controllers, including how to form a one-degree-of-freedom LQG servo controller, see the lqgtrack reference page.

Example — Designing an LQG Regulator

As an example of LQG design, consider the following regulation problem.

The goal is to regulate the plant output around zero. The input disturbance d is low frequency with power spectral density (PSD) concentrated below 10 rad/s. For LQG design purposes, it is modeled as white noise driving a lowpass filter with a cutoff at 10 rad/s, shown in the following figure.

For simplicity, this noise is modeled as Gaussian white noise with variance of 1.

The following figure shows the Bode magnitude of the shaping filter.

Bode Magnitude of the Lowpass Filter

There is some measurement noise n, with noise intensity given by

Use the cost function

to specify the tradeoff between regulation performance and cost of control. The following equations represent an open-loop state-space model:

where (A,B,C) is a state-space realization of .

The following commands design the optimal LQG regulator F(s) for this problem:

sys = ss(tf(100,[1 1 100])) % State-space plant model

% Design LQ-optimal gain K
K = lqry(sys,10,1)	 % u = -Kx minimizes J(u)

% Separate control input u and disturbance input d
P = sys(:,[1 1]);
% input [u;d], output y

% Design Kalman state estimator Kest.
Kest = kalman(P,1,0.01)

% Form LQG regulator = LQ gain + Kalman filter.
F = lqgreg(Kest,K)

These commands returns a state-space model F of the LQG regulator F(s). The lqry, kalman, and lqgreg functions perform discrete-time LQG design when you apply them to discrete plants.

To validate the design, close the loop with feedback, create and add the lowpass filter in series with the closed-loop system, and compare the open- and closed-loop impulse responses by using the impulse function.

% Close loop
clsys = feedback(sys,F,+1)
% Note positive feedback.

% Create the lowpass filter and add it in series with clsys.
s = tf('s');
lpf= 10/(s+10) ;
clsys_fin = lpf*clsys;

% Open- vs. closed-loop impulse responses
impulse(sys,'r--',clsys_fin,'b-')

These commands produce the following figure, which compares the open- and closed-loop impulse responses for this example.

Comparison of Open- and Closed-Loop Impulse Response

Example — Designing an LQG Servo Controller

This example shows you how to design a servo controller for the following system.

The plant has two states (x), two control inputs (u), two random inputs (w), one output (y), measurement noise for the output (v), and the following state and measurement equations:

where

The system has the following noise covariance data:

Use the following cost function to define the tradeoff between tracker performance and control effort:

To design an LQG servo controller for this system:

Create the state space system by typing the following in the MATLAB Command Window:

A = [0 1 0;0 0 1;1 0 0];    
B = [0.3 1;0 1;-0.3 0.9];
G = [-0.7 1.12; -1.17 1; .14 1.5];
C = [1.9 1.3 1];  
D = [0.53 -0.61];
H = [-1.2 -0.89];
sys = ss(A,[B G],C,[D H]);

Construct the optimal state-feedback gain using the given cost function by typing the following commands:

nx = 3;    %Number of states
ny = 1;    %Number of outputs
Q = blkdiag(0.1*eye(nx),eye(ny));
R = [1 0;0 2];
K = lqi(ss(A,B,C,D),Q,R);

Construct the Kalman state estimator using the given noise covariance data by typing the following commands:
```
Qn = [4 2;2 1]; 
Rn = 0.7;
kest = kalman(sys,Qn,Rn);
```

Connect the Kalman state estimator and the optimal state-feedback gain to form the LQG servo controller by typing the following command:

trksys = lqgtrack(kest,K)

This command returns the following LQG servo controller:

>> trksys = lqgtrack(kest,K)
 
a = 
           x1_e    x2_e    x3_e     xi1
   x1_e  -2.373  -1.062  -1.649   0.772
   x2_e  -3.443  -2.876  -1.335  0.6351
   x3_e  -1.963  -2.483  -2.043  0.4049
   xi1        0       0       0       0
 
b = 
             r1      y1
   x1_e       0  0.2849
   x2_e       0  0.7727
   x3_e       0  0.7058
   xi1        1      -1
 
c = 
          x1_e     x2_e     x3_e      xi1
   u1  -0.5388  -0.4173  -0.2481   0.5578
   u2   -1.492   -1.388   -1.131   0.5869
 
d = 
       r1  y1
   u1   0   0
   u2   0   0
 
Input groups:              
       Name        Channels
     Setpoint         1    
    Measurement       2    
                           
Output groups:             
      Name      Channels   
    Controls      1,2      
                           
Continuous-time model.

Example — Designing an LQR Servo Controller in Simulink

The following figure shows a Simulink^® block diagram shows a tracking problem in aircraft autopilot design. To open this diagram, type lqrpilot at the MATLAB prompt.

Tracking Loop

Key features of this diagram to note are the following:

The Linearized Dynamics block contains the linearized airframe.
sf_aerodyn is an S-Function block that contains the nonlinear equations for .
The error signal between and the is passed through an integrator. This aids in driving the error to zero.

State-Space Equations for an Airframe

Beginning with the standard state-space equation

where

The variables u, v, and w are the three velocities with respect to the body frame, shown as follows.

Body Coordinate Frame for an Aircraft

The variables and are roll and pitch, and p, q, and r are the roll, pitch, and yaw rates, respectively.

The airframe dynamics are nonlinear. The following equation shows the nonlinear components added to the state space equation.

Nonlinear Component of the State-Space Equation

To see the numerical values for A and B, type

load lqrpilot
A, B

at the MATLAB prompt.

Trimming

For LQG design purposes, the nonlinear dynamics are trimmed at and p, q, r, and set to zero. Since u, v, and w do not enter into the nonlinear term in the preceding figure, this amounts to linearizing around with all remaining states set to zero. The resulting state matrix of the linearized model is called A15.

Problem Definition

The goal to perform a steady coordinated turn, as shown in this figure.

Aircraft Making a 60° Turn

To achieve this goal, you must design a controller that commands a steady turn by going through a 60° roll. In addition, assume that , the pitch angle, is required to stay as close to zero as possible.

Results

To calculate the LQG gain matrix, K, type

lqrdes

at the MATLAB prompt. Then, start the lqrpilot model with the nonlinear model, sf_aerodyn, selected.

This figure shows the response of to the 60° step command.

Tracking the Roll Step Command

As you can see, the system tracks the commanded 60° roll in about 60 seconds.

Another goal was to keep , the pitch angle, relatively small. This figure shows how well the LQG controller did.

Minimizing the Displacement in the Pitch Angle, Theta

Finally, this figure shows the control inputs.

Control Inputs for the LQG Tracking Problem

Try adjusting the Q and R matrices in lqrdes.m and inspecting the control inputs and the system states, making sure to rerun lqrdes to update the LQG gain matrix K. Through trial and error, you may improve the response time of this design. Also, compare the linear and nonlinear designs to see the effects of the nonlinearities on the system performance.

Multi-Loop Compensator Design

Learning More