lqr

Linear-Quadratic Regulator (LQR) design

Syntax

[K,S,P] = lqr(sys,Q,R,N)

[K,S,P] = lqr(A,B,Q,R,N)

Description

[K,S,P] = lqr(sys,Q,R,N) calculates the optimal gain matrix K, the solution S of the associated algebraic Riccati equation, and the closed-loop poles P for the continuous-time or discrete-time state-space model sys. Q and R are the weight matrices for states and inputs, respectively. The cross term matrix N is set to zero when omitted.

example

[K,S,P] = lqr(A,B,Q,R,N) calculates the optimal gain matrix K, the solution S of the associated algebraic Riccati equation and the closed-loop poles P using the continuous-time state-space matrices A and B. This syntax is only valid for continuous-time models. For discrete-time models, use dlqr.

example

Examples

collapse all

LQR Control for Inverted Pendulum Model

Open Live Script

pendulumModelCart.mat contains the state-space model of an inverted pendulum on a cart where the outputs are the cart displacement x and the pendulum angle $θ$ . The control input u is the horizontal force on the cart.

$\begin{array}{l} [\begin{array}{c} x_{}^{˙} \\ x_{}^{¨} \\ θ_{}^{˙} \\ θ_{}^{¨} \end{array}] = [\begin{array}{ccc} 0 & 1 & 0 & 0 \\ 0 & - 0.1 & 3 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & - 0.5 & 30 & 0 \end{array}] [\begin{array}{c} x \\ x_{}^{˙} \\ θ \\ θ_{}^{˙} \end{array}] + [\begin{array}{c} 0 \\ 2 \\ 0 \\ 5 \end{array}] u \\ y = [\begin{array}{cccc} 1 & 0 & 0 & 0 \\ 0 & 0 & 1 & 0 \end{array}] [\begin{array}{c} x \\ x_{}^{˙} \\ θ \\ θ_{}^{˙} \end{array}] + [\begin{array}{c} 0 \\ 0 \end{array}] u \end{array}$

First, load the state-space model sys to the workspace.

load('pendulumCartModel.mat','sys')

Since the outputs are x and $θ$ , and there is only one input, use Bryson's rule to determine Q and R.

Q = [1,0,0,0;...
    0,0,0,0;...
    0,0,1,0;...
    0,0,0,0];
R = 1;

Find the gain matrix K using lqr. Since N is not specified, lqr sets N to 0.

[K,S,P] = lqr(sys,Q,R)

K = 1×4

   -1.0000   -1.7559   16.9145    3.2274

S = 4×4

    1.5346    1.2127   -3.2274   -0.6851
    1.2127    1.5321   -4.5626   -0.9640
   -3.2274   -4.5626   26.5487    5.2079
   -0.6851   -0.9640    5.2079    1.0311

P = 4×1 complex

  -0.8684 + 0.8523i
  -0.8684 - 0.8523i
  -5.4941 + 0.4564i
  -5.4941 - 0.4564i

Although Bryson's rule usually provides satisfactory results, it is often just the starting point of a trial-and-error iterative design procedure to tune your closed-loop system response based on the design requirements.

LQR Control Using State-Space Matrices

Open Live Script

aircraftPitchModel.mat contains the state-space matrices of an aircraft where the input is the elevator deflection angle $δ$ and the output is the aircraft pitch angle $θ$ .

$\begin{array}{l} [\begin{array}{c} α_{}^{˙} \\ q_{}^{˙} \\ θ_{}^{˙} \end{array}] = [\begin{array}{ccc} - 0.313 & 56.7 & 0 \\ - 0.0139 & - 0.426 & 0 \\ 0 & 56.7 & 0 \end{array}] [\begin{array}{c} α \\ q \\ θ \end{array}] + [\begin{array}{c} 0.232 \\ 0.0203 \\ 0 \end{array}] [δ] \\ y = [\begin{array}{ccc} 0 & 0 & 1 \end{array}] [\begin{array}{c} α \\ q \\ θ \end{array}] + [0] [δ] \end{array}$

For a step reference of 0.2 radians, consider the following design criteria:

Rise time less than 2 seconds
Settling time less than 10 seconds
Steady-state error less than 2%

Load the model data to the workspace.

load('aircraftPitchModel.mat')

Define the state-cost weighted matrix Q and the control weighted matrix R. Generally, you can use Bryson's Rule to define your initial weighted matrices Q and R. For this example, consider the output vector C along with a scaling factor of 2 for matrix Q and choose R as 1. R is a scalar since the system has only one input.

R = 1

R = 
1

Q1 = 2*C'*C

Q1 = 3×3

     0     0     0
     0     0     0
     0     0     2

Compute the gain matrix using lqr.

[K1,S1,P1] = lqr(A,B,Q1,R);

Check the closed-loop step response with the generated gain matrix K1.

sys1 = ss(A-B*K1,B,C,D);
step(sys1)

MATLAB figure

Since this response does not meet the design goals, increase the scaling factor to 25, compute the gain matrix K2, and check the closed-loop step response for gain matrix K2.

Q2 = 25*C'*C

Q2 = 3×3

     0     0     0
     0     0     0
     0     0    25

[K2,S2,P2] = lqr(A,B,Q2,R);
sys2 = ss(A-B*K2,B,C,D);
step(sys2)

MATLAB figure

In the closed-loop step response plot, the rise time, settling time, and steady-state error meet the design goals.

Input Arguments

collapse all

`sys` — Dynamic system model
`ss` model object

Dynamic system model, specified as an ss model object.

`A` — State matrix
`n`-by-`n` matrix

State matrix, specified as an n-by-n matrix, where n is the number of states.

`B` — Input-to-state matrix
`n`-by-`m` matrix

Input-to-state matrix, specified as an n-by-m input-to-state matrix, where m is the number of inputs.

`Q` — State-cost weighted matrix
matrix

State-cost weighted matrix, specified as an n-by-n matrix, where n is the number of states. You can use Bryson's rule to set the initial values of Q given by:

$\begin{array}{l} Q_{i, i} = \frac{1}{maximum acceptable value of {(e r r o r_{s t a t e s})}^{2}}, i \in {1, 2, ..., n} \\ Q = [\begin{matrix} Q_{1, 1} & 0 & \dots & 0 \\ 0 & Q_{2, 2} & \dots & 0 \\ 0 & 0 & ⋱ & ⋮ \\ 0 & 0 & \dots & Q_{n, n} \end{matrix}] \end{array}$

Here, n is the number of states.

`R` — Input-cost weighted matrix
scalar | matrix

Input-cost weighted matrix, specified as a scalar or a matrix of the same size as D'D. Here, D is the feed-through state-space matrix. You can use Bryson's rule to set the initial values of R given by:

$\begin{array}{l} R_{j, j} = \frac{1}{maximum acceptable value of {(e r r o r_{i n p u t s})}^{2}}, j \in {1, 2, ..., m} \\ R = [\begin{matrix} R_{1, 1} & 0 & \dots & 0 \\ 0 & R_{2, 2} & \dots & 0 \\ 0 & 0 & ⋱ & ⋮ \\ 0 & 0 & \dots & R_{m, m} \end{matrix}] \end{array}$

Here, m is the number of inputs.

`N` — Optional cross term matrix
`0` (default) | matrix

Optional cross term matrix, specified as a matrix. If N is not specified, then lqr sets N to 0 by default.

Output Arguments

collapse all

`K` — Optimal gain
row vector

Optimal gain of the closed-loop system, returned as a row vector of size n, where n is the number of states.

`S` — Solution of the associated algebraic Riccati equation
matrix

Solution of the associated algebraic Riccati equation, returned as an n-by-n matrix, where n is the number of states. In other words, S is the same dimension as state-space matrix A. For more information, see icare and idare.

`P` — Poles of the closed-loop system
column vector

Poles of the closed-loop system, returned as a column vector of size n, where n is the number of states.

Limitations

The input data must satisfy the following conditions:

The pair (A,B) must be stabilizable.
R must be positive definite.
$[\begin{matrix} Q & N \\ N^{T} & R \end{matrix}]$ must be positive semidefinite (equivalently, $Q - N R^{- 1} N^{T} \geq 0$ ).
$(Q - N R^{- 1} N^{T}, A - B R^{- 1} N^{T})$ must have no unobservable mode on the imaginary axis (or unit circle in discrete time).

Tips

lqr supports descriptor models with nonsingular E. The output S of lqr is the solution of the algebraic Riccati equation for the equivalent explicit state-space model:

$\frac{d x}{d t} = E^{- 1} A x + E^{- 1} B u$

Algorithms

For continuous-time systems, lqr computes the state-feedback control $u = - K x$ that minimizes the quadratic cost function

$J (u) = \int_{0}^{\infty} (x^{T} Q x + u^{T} R u + 2 x^{T} N u) d t$

subject to the system dynamics $\dot{x} = A x + B u$ .

In addition to the state-feedback gain K, lqr returns the solution S of the associated algebraic Riccati equation

$A^{T} S + S A - (S B + N) R^{- 1} (B^{T} S + N^{T}) + Q = 0$

and the closed-loop poles $P = e i g (A - B K)$ . The gain matrix K is derived from S using

$K = R^{- 1} (B^{T} S + N^{T}) .$

For discrete-time systems, lqr computes the state-feedback control $u_{n} = - K x_{n}$ that minimizes

$J = \sum_{n = 0}^{\infty} {x^{T} Q x + u^{T} R u + 2 x^{T} N u}$

subject to the system dynamics $x_{n + 1} = A x_{n} + B u_{n}$ .

In all cases, when you omit the cross term matrix N, lqr sets N to 0.

Version History

Introduced before R2006a

lqr

Syntax

Description

Examples

LQR Control for Inverted Pendulum Model

LQR Control Using State-Space Matrices

Input Arguments

`sys` — Dynamic system model
`ss` model object

`A` — State matrix
`n`-by-`n` matrix

`B` — Input-to-state matrix
`n`-by-`m` matrix

`Q` — State-cost weighted matrix
matrix

`R` — Input-cost weighted matrix
scalar | matrix

`N` — Optional cross term matrix
`0` (default) | matrix

Output Arguments

`K` — Optimal gain
row vector

`S` — Solution of the associated algebraic Riccati equation
matrix

`P` — Poles of the closed-loop system
column vector

Limitations

Tips

Algorithms

Version History

See Also

Topics

lqr

Syntax

Description

Examples

LQR Control for Inverted Pendulum Model

LQR Control Using State-Space Matrices

Input Arguments

sys — Dynamic system model ss model object

A — State matrix n-by-n matrix

B — Input-to-state matrix n-by-m matrix

Q — State-cost weighted matrix matrix

R — Input-cost weighted matrix scalar | matrix

N — Optional cross term matrix 0 (default) | matrix

Output Arguments

K — Optimal gain row vector

S — Solution of the associated algebraic Riccati equation matrix

P — Poles of the closed-loop system column vector

Limitations

Tips

Algorithms

Version History

See Also

Topics

`sys` — Dynamic system model
`ss` model object

`A` — State matrix
`n`-by-`n` matrix

`B` — Input-to-state matrix
`n`-by-`m` matrix

`Q` — State-cost weighted matrix
matrix

`R` — Input-cost weighted matrix
scalar | matrix

`N` — Optional cross term matrix
`0` (default) | matrix

`K` — Optimal gain
row vector

`S` — Solution of the associated algebraic Riccati equation
matrix

`P` — Poles of the closed-loop system
column vector