Node:cacsd, Next:, Previous:sysfreq, Up:Control Theory



Controller Design

dgkfdemo () Function File
Octave Controls toolbox demo: H-2/H-infinity options demos.

hinfdemo () Function File

H-infinity design demos for continuous SISO and MIMO systems and a discrete system. The SISO system is difficult to control because it is non-minimum-phase and unstable. The second design example controls the jet707 plant, the linearized state space model of a Boeing 707-321 aircraft at v=80 m/s (M = 0.26, Ga0 = -3 deg, alpha0 = 4 deg, kappa = 50 deg). Inputs: (1) thrust and (2) elevator angle Outputs: (1) airspeed and (2) pitch angle. The discrete system is a stable and second order.

SISO plant:

                s - 2
     G(s) = --------------
            (s + 2)(s - 1)

                              +----+
         -------------------->| W1 |---> v1
     z   |                    +----+
     ----|-------------+
         |             |
         |    +---+    v   y  +----+
       u *--->| G |--->O--*-->| W2 |---> v2
         |    +---+       |   +----+
         |                |
         |    +---+       |
         -----| K |<-------
              +---+

min || T   ||
        vz   infty

W1 und W2 are the robustness and performance weighting functions.

MIMO plant:
The optimal controller minimizes the H-infinity norm of the augmented plant P (mixed-sensitivity problem):
     w
      1 -----------+
                   |                   +----+
               +---------------------->| W1 |----> z1
     w         |   |                   +----+
      2 ------------------------+
               |   |            |
               |   v   +----+   v      +----+
            +--*-->o-->| G  |-->o--*-->| W2 |---> z2
            |          +----+      |   +----+
            |                      |
            ^                      v
            u                       y (to K)
         (from controller K)

                  +    +           +    +
                  | z  |           | w  |
                  |  1 |           |  1 |
                  | z  | = [ P ] * | w  |
                  |  2 |           |  2 |
                  | y  |           | u  |
                  +    +           +    +

Discrete system:
This is not a true discrete design. The design is carried out in continuous time while the effect of sampling is described by a bilinear transformation of the sampled system. This method works quite well if the sampling period is "small" compared to the plant time constants.
The continuous plant:

                   1
     G (s) = --------------
      k      (s + 2)(s + 1)

is discretised with a ZOH (Sampling period = Ts = 1 second):

               0.199788z + 0.073498
     G(z) = --------------------------
            (z - 0.36788)(z - 0.13534)

                              +----+
         -------------------->| W1 |---> v1
     z   |                    +----+
     ----|-------------+
         |             |
         |    +---+    v      +----+
         *--->| G |--->O--*-->| W2 |---> v2
         |    +---+       |   +----+
         |                |
         |    +---+       |
         -----| K |<-------
              +---+

min || T   ||
        vz   infty
W1 and W2 are the robustness and performance weighting functions.

[l, m, p, e] = dlqe (a, g, c, sigw, sigv, z) Function File
Construct the linear quadratic estimator (Kalman filter) for the discrete time system
x[k+1] = A x[k] + B u[k] + G w[k]
  y[k] = C x[k] + D u[k] + v[k]

where w, v are zero-mean gaussian noise processes with respective intensities sigw = cov (w, w) and sigv = cov (v, v).

If specified, z is cov (w, v). Otherwise cov (w, v) = 0.

The observer structure is

z[k|k] = z[k|k-1] + L (y[k] - C z[k|k-1] - D u[k])
z[k+1|k] = A z[k|k] + B u[k]

The following values are returned:

l
The observer gain, (a - alc). is stable.
m
The Riccati equation solution.
p
The estimate error covariance after the measurement update.
e
The closed loop poles of (a - alc).

[k, p, e] = dlqr (a, b, q, r, z) Function File
Construct the linear quadratic regulator for the discrete time system
x[k+1] = A x[k] + B u[k]

to minimize the cost functional

J = Sum (x' Q x + u' R u)

z omitted or

J = Sum (x' Q x + u' R u + 2 x' Z u)

z included.

The following values are returned:

k
The state feedback gain, (a - bk) is stable.
p
The solution of algebraic Riccati equation.
e
The closed loop poles of (a - bk).

[Lp, Lf, P, Z] = dkalman (A, G, C, Qw, Rv, S) Function File
Construct the linear quadratic estimator (Kalman predictor) for the discrete time system
x[k+1] = A x[k] + B u[k] + G w[k]
  y[k] = C x[k] + D u[k] + v[k]

where w, v are zero-mean gaussian noise processes with respective intensities Qw = cov (w, w) and Rv = cov (v, v).

If specified, S is cov (w, v). Otherwise cov (w, v) = 0.

The observer structure is

x[k+1|k] = A x[k|k-1] + B u[k] + LP (y[k] - C x[k|k-1] - D u[k])
x[k|k] = x[k|k-1] + LF (y[k] - C x[k|k-1] - D u[k])

The following values are returned:

Lp
The predictor gain, (A - Lp C) is stable.
Lf
The filter gain.
P
The Riccati solution.

P = E [(x - x[n|n-1])(x - x[n|n-1])']

Z
The updated error covariance matrix.

Z = E [(x - x[n|n])(x - x[n|n])']

[K, gain, kc, kf, pc, pf] = h2syn (asys, nu, ny, tol) Function File
Design H-2 optimal controller per procedure in Doyle, Glover, Khargonekar, Francis, State-Space Solutions to Standard H-2 and H-infinity Control Problems, IEEE TAC August 1989.

Discrete-time control per Zhou, Doyle, and Glover, Robust and optimal control, Prentice-Hall, 1996.

Inputs

asys
system data structure (see ss, sys2ss)
  • controller is implemented for continuous time systems
  • controller is not implemented for discrete time systems

nu
number of controlled inputs
ny
number of measured outputs
tol
threshold for 0. Default: 200*eps

Outputs

k
system controller
gain
optimal closed loop gain
kc
full information control (packed)
kf
state estimator (packed)
pc
ARE solution matrix for regulator subproblem
pf
ARE solution matrix for filter subproblem

K = hinf_ctr (dgs, f, h, z, g) Function File
Called by hinfsyn to compute the H-infinity optimal controller.

Inputs

dgs
data structure returned by is_dgkf
f
h
feedback and filter gain (not partitioned)
g
final gamma value
Outputs
K
controller (system data structure)

Do not attempt to use this at home; no argument checking performed.

[k, g, gw, xinf, yinf] = hinfsyn (asys, nu, ny, gmin, gmax, gtol, ptol, tol) Function File

Inputs input system is passed as either

asys
system data structure (see ss, sys2ss)
  • controller is implemented for continuous time systems
  • controller is not implemented for discrete time systems (see bilinear transforms in c2d, d2c)

nu
number of controlled inputs
ny
number of measured outputs
gmin
initial lower bound on H-infinity optimal gain
gmax
initial upper bound on H-infinity Optimal gain.
gtol
Gain threshold. Routine quits when gmax/gmin < 1+tol.
ptol
poles with abs(real(pole)) < ptol*||H|| (H is appropriate Hamiltonian) are considered to be on the imaginary axis. Default: 1e-9.
tol
threshold for 0. Default: 200*eps.

gmax, min, tol, and tol must all be postive scalars.

Outputs
k
System controller.
g
Designed gain value.
gw
Closed loop system.
xinf
ARE solution matrix for regulator subproblem.
yinf
ARE solution matrix for filter subproblem.

References:

  1. Doyle, Glover, Khargonekar, Francis, State-Space Solutions to Standard H-2 and H-infinity Control Problems, IEEE TAC August 1989.
  2. Maciejowksi, J.M., Multivariable feedback design, Addison-Wesley, 1989, ISBN 0-201-18243-2.
  3. Keith Glover and John C. Doyle, State-space formulae for all stabilizing controllers that satisfy an H-infinity-norm bound and relations to risk sensitivity, Systems & Control Letters 11, Oct. 1988, pp 167-172.

[retval, pc, pf] = hinfsyn_chk (a, b1, b2, c1, c2, d12, d21, g, ptol) Function File
Called by hinfsyn to see if gain g satisfies conditions in Theorem 3 of Doyle, Glover, Khargonekar, Francis, State Space Solutions to Standard H-2 and H-infinity Control Problems, IEEE TAC August 1989.

Warning: do not attempt to use this at home; no argument checking performed.

Inputs

As returned by is_dgkf, except for:

g
candidate gain level
ptol
as in hinfsyn

Outputs

retval
1 if g exceeds optimal Hinf closed loop gain, else 0
pc
solution of "regulator" H-infinity ARE
pf
solution of "filter" H-infinity ARE
Do not attempt to use this at home; no argument checking performed.

[xinf, x_ha_err] = hinfsyn_ric (a, bb, c1, d1dot, r, ptol) Function File
Forms
xx = ([bb; -c1'*d1dot]/r) * [d1dot'*c1 bb'];
Ha = [a 0*a; -c1'*c1 - a'] - xx;
and solves associated Riccati equation. The error code x_ha_err indicates one of the following conditions:
0
successful
1
xinf has imaginary eigenvalues
2
hx not Hamiltonian
3
xinf has infinite eigenvalues (numerical overflow)
4
xinf not symmetric
5
xinf not positive definite
6
r is singular

[k, p, e] = lqe (a, g, c, sigw, sigv, z) Function File
Construct the linear quadratic estimator (Kalman filter) for the continuous time system
dx
-- = a x + b u
dt

y = c x + d u

where w and v are zero-mean gaussian noise processes with respective intensities

sigw = cov (w, w)
sigv = cov (v, v)

The optional argument z is the cross-covariance cov (w, v). If it is omitted, cov (w, v) = 0 is assumed.

Observer structure is dz/dt = A z + B u + k (y - C z - D u)

The following values are returned:

k
The observer gain, (a - kc) is stable.
p
The solution of algebraic Riccati equation.
e
The vector of closed loop poles of (a - kc).

[k, q1, p1, ee, er] = lqg (sys, sigw, sigv, q, r, in_idx) Function File
Design a linear-quadratic-gaussian optimal controller for the system
dx/dt = A x + B u + G w       [w]=N(0,[Sigw 0    ])
    y = C x + v               [v]  (    0   Sigv ])
or
x(k+1) = A x(k) + B u(k) + G w(k)       [w]=N(0,[Sigw 0    ])
  y(k) = C x(k) + v(k)                  [v]  (    0   Sigv ])

Inputs

sys
system data structure
sigw
sigv
intensities of independent Gaussian noise processes (as above)
q
r
state, control weighting respectively. Control ARE is
in_idx
names or indices of controlled inputs (see sysidx, cellidx)

default: last dim(R) inputs are assumed to be controlled inputs, all others are assumed to be noise inputs.

Outputs
k
system data structure format LQG optimal controller (Obtain A, B, C matrices with sys2ss, sys2tf, or sys2zp as appropriate).
p1
Solution of control (state feedback) algebraic Riccati equation.
q1
Solution of estimation algebraic Riccati equation.
ee
Estimator poles.
es
Controller poles.

[k, p, e] = lqr (a, b, q, r, z) Function File
construct the linear quadratic regulator for the continuous time system
dx
-- = A x + B u
dt

to minimize the cost functional

      infinity
      /
  J = |  x' Q x + u' R u
     /
    t=0

z omitted or

      infinity
      /
  J = |  x' Q x + u' R u + 2 x' Z u
     /
    t=0

z included.

The following values are returned:

k
The state feedback gain, (a - bk) is stable and minimizes the cost functional
p
The stabilizing solution of appropriate algebraic Riccati equation.
e
The vector of the closed loop poles of (a - bk).

Reference Anderson and Moore, Optimal control: linear quadratic methods, Prentice-Hall, 1990, pp. 56-58.

[y, x] = lsim (sys, u, t, x0) Function File
Produce output for a linear simulation of a system; produces a plot for the output of the system, sys.

u is an array that contains the system's inputs. Each row in u corresponds to a different time step. Each column in u corresponds to a different input. t is an array that contains the time index of the system; t should be regularly spaced. If initial conditions are required on the system, the x0 vector should be added to the argument list.

When the lsim function is invoked a plot is not displayed; however, the data is returned in y (system output) and x (system states).

K = place (sys, p) Function File
Computes the matrix K such that if the state is feedback with gain K, then the eigenvalues of the closed loop system (i.e. A-BK) are those specified in the vector p.

Version: Beta (May-1997): If you have any comments, please let me know. (see the file place.m for my address)