Next: , Previous: sysfreq, Up: Control Theory

29.9 Controller Design

— Function File: dgkfdemo ()

Octave Controls toolbox demo: H-2/H-infinity options demos.

— Function File: hinfdemo ()

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.

— Function File: [l, m, p, e] = dlqe (a, g, c, sigw, sigv, z)

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).

— Function File: [k, p, e] = dlqr (a, b, q, r, z)

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).

— Function File: [Lp, Lf, P, Z] = dkalman (A, G, C, Qw, Rv, S)

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])']

— Function File: [K, gain, kc, kf, pc, pf] = h2syn (asys, nu, ny, tol)

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

— Function File: K = hinf_ctr (dgs, f, h, z, g)

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.

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

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.

— Function File: [retval, pc, pf] = hinfsyn_chk (a, b1, b2, c1, c2, d12, d21, g, ptol)

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.

— Function File: [xinf, x_ha_err] = hinfsyn_ric (a, bb, c1, d1dot, r, ptol)

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

— Function File: [k, p, e] = lqe (a, g, c, sigw, sigv, z)

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).

— Function File: [k, q1, p1, ee, er] = lqg (sys, sigw, sigv, q, r, in_idx)

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.

— Function File: [k, p, e] = lqr (a, b, q, r, z)

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.

— Function File: [y, x] = lsim (sys, u, t, x0)

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).

— Function File: K = place (sys, p)

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)