Next: misc, Previous: sysfreq, Up: Control Theory

— 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

jet707plant, the linearized state space model of a Boeing 707-321 aircraft atv=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

W1undW2are 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

W1andW2are 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,vare zero-mean gaussian noise processes with respective intensitiessigw`= cov (`

w`,`

w`)`

andsigv`= cov (`

v`,`

v`)`

.If specified,

zis`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)

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

zincluded.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,vare zero-mean gaussian noise processes with respective intensitiesQw`= cov (`

w`,`

w`)`

andRv`= cov (`

v`,`

v`)`

.If specified,

Sis`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-LpC) 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
notimplemented for discrete time systemsnu- 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`

fh- 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`)

Inputsinput system is passed as either

asys- system data structure (see
ss,sys2ss)

- controller is implemented for continuous time systems
- controller is
notimplemented for discrete time systems (see bilinear transforms inc2d,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|| (His appropriate Hamiltonian) are considered to be on the imaginary axis. Default: 1e-9.tol- threshold for 0. Default: 200*
`eps`

.

gmax,min,tol, andtolmust 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:

- Doyle, Glover, Khargonekar, Francis, State-Space Solutions to Standard H-2 and H-infinity Control Problems, IEEE TAC August 1989.
- Maciejowksi, J.M., Multivariable feedback design, Addison-Wesley, 1989, ISBN 0-201-18243-2.
- 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 gaingsatisfies 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.

InputsAs returned by

`is_dgkf`

, except for:

g- candidate gain level
ptol- as in
`hinfsyn`

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

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

— 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_errindicates one of the following conditions:

- 0
- successful
- 1
xinfhas imaginary eigenvalues- 2
hxnot Hamiltonian- 3
xinfhas infinite eigenvalues (numerical overflow)- 4
xinfnot symmetric- 5
xinfnot positive definite- 6
ris 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 uwhere

wandvare zero-mean gaussian noise processes with respective intensitiessigw = cov (w, w) sigv = cov (v, v)The optional argument

zis 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
sigwsigv- intensities of independent Gaussian noise processes (as above)
qr- 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, orsys2zpas 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 dtto minimize the cost functional

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

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

zincluded.The following values are returned:

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

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

uis an array that contains the system's inputs. Each row inucorresponds to a different time step. Each column inucorresponds to a different input.tis an array that contains the time index of the system;tshould be regularly spaced. If initial conditions are required on the system, thex0vector 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) andx(system states).

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

Computes the matrix

Ksuch that if the state is feedback with gainK, then the eigenvalues of the closed loop system (i.e. A-BK) are those specified in the vectorp.Version: Beta (May-1997): If you have any comments, please let me know. (see the file place.m for my address)