Robust controller design using µ-synthesis

[k,clp,bnd] = dksyn(p,nmeas,ncont) [k,clp,bnd] = dksyn(p,nmeas,ncont,opt) [k,clp,bnd,dkinfo] = dksyn(p,nmeas,ncont,...) [k,clp,bnd,dkinfo] = dksyn(p,nmeas,ncont,prevdkinfo,opt) [...] = dksyn(p)

`[k,clp,bnd] = dksyn(p,nmeas,ncont)`

synthesizes
a robust controller `k`

for the uncertain open-loop
plant model `p`

via the D-K or D-G-K algorithm for
µ-synthesis. `p`

is an uncertain state-space `uss`

model.
The last `nmeas`

outputs and` ncont`

inputs
of` p`

are assumed to be the measurement and control
channels. `k`

is the controller, `clp`

is
the closed-loop model and `bnd`

is the robust closed-loop
performance bound. `p`

, `k`

, `clp`

,
and `bnd`

are related as follows:

clp = lft(p,k); bnd1 = dksynperf(clp); bnd = 1/bnd1.LowerBound;

`[k,clp,bnd] = dksyn(p,nmeas,ncont,opt) `

specifies
user-defined options `opt`

for the D-K or D-K-G
algorithm. Use `dksynOptions`

to
create `opt`

.

`[k,clp,bnd,dkinfo] = dksyn(p,nmeas,ncont,...) `

returns
a log of the algorithm execution in` dkinfo. dkinfo`

is
an *N*-by-1 cell array where N is the total number
of iterations performed. The `i`

th cell contains
a structure with the following fields:

Field | Description |
---|---|

`K` | Controller at |

`Bnds` | Robust performance bound on the closed-loop system ( |

`DL` | Left D-scale, an |

`DR` | Right D-scale, an |

`GM` | Offset G-scale, an |

`GR` | Right G-scale, an |

`GFC` | Center G-scale, an |

`MussvBnds` | Upper and lower µ bounds, an |

`MussvInfo` | Structure returned from |

```
[k,clp,bnd,dkinfo] = dksyn(p,nmeas,ncont,prevdkinfo,opt)
allows you to use information from a previous dksyn iteration. prevdkinfo
```

is
a structure from a previous attempt at designing a robust controller
using `dksyn`

. `prevdkinfo`

is used
when the `dksyn`

starting iteration is not 1 (```
opt.StartingIterationNumber
= 1
```

) to determine the correct D-scalings to initiate the
iteration procedure.

`[...] = dksyn(p)`

takes `p`

as
a `uss`

object that has two-input/two-output partitioning
as defined by `mktito`

.

The following statements create a robust performance control design for an unstable, uncertain single-input/single-output plant model. The nominal plant model, G, is an unstable first order system $$\frac{s}{s-1}$$.

G = tf(1,[1 -1]);

The model itself is uncertain. At low frequency, below 2 rad/s,
it can vary up to 25% from its nominal value. Around 2 rad/s the percentage
variation starts to increase and reaches 400% at approximately 32
rad/s. The percentage model uncertainty is represented by the weight `Wu`

which
corresponds to the frequency variation of the model uncertainty and
the uncertain LTI dynamic object `InputUnc`

.

```
Wu = 0.25*tf([1/2 1],[1/32 1]);
InputUnc = ultidyn('InputUnc',[1 1]);
```

The uncertain plant model `Gpert`

represents
the model of the physical system to be controlled.

Gpert = G*(1+InputUnc*Wu);

The robust stability objective is to synthesize a stabilizing
LTI controller for all the plant models parameterized by the uncertain
plant model, `Gpert`

. The performance objective is
defined as a weighted sensitivity minimization problem. The control
interconnection structure is shown in the following figure.

The sensitivity function, S, is defined as

$$S=\frac{1}{1+PK}$$

where `P`

is the plant model
and `K`

is the controller. A weighted sensitivity
minimization problem selects a weight `Wp`

, which
corresponds to the *inverse* of the desired sensitivity
function of the closed-loop system as a function of frequency. Hence
the product of the sensitivity weight `Wp`

and actual
closed-loop sensitivity function is less than 1 across all frequencies.
The sensitivity weight `Wp`

has a gain of 100 at
low frequency, begins to decrease at 0.006 rad/s, and reaches a minimum
magnitude of 0.25 after 2.4 rad/s.

Wp = tf([1/4 0.6],[1 0.006]);

The defined sensitivity weight `Wp`

implies
that the desired disturbance rejection should be at least 100:1 disturbance
rejection at DC, rise slowly between 0.006 and 2.4 rad/s, and allow
the disturbance rejection to increase above the open-loop level, 0.25,
at high frequency.

When the plant model is uncertain, the closed-loop performance
objective is to achieve the desired sensitivity function for all plant
models defined by the uncertain plant model, `Gpert`

.
The performance objective for an uncertain system is a robust performance
objective. A block diagram of this uncertain closed-loop system illustrating
the performance objective (closed-loop transfer function from *d*→*e*)
is shown.

From the definition of the robust performance control objective,
the weighted, uncertain control design interconnection model, which
includes the robustness and performance objectives, can be constructed
and is denoted by `P`

. The robustness and performance
weights are selected such that if the robust performance structure
singular value, `bnd`

, of the closed-loop uncertain
system, `clp`

, is less than 1 then the performance
objectives have been achieved for all the plant models in the model
set.

You can form the uncertain transfer matrix `P`

from ```
[d;
u]
```

to `[e; y]`

using the following commands.

P = [Wp; 1 ]*[1 Gpert]; [K,clp,bnd] = dksyn(P,1,1); bnd

bnd = 0.6806

The controller `K`

achieves a robust performance µ value
`bnd`

of about 0.68. Therefore you have achieved the robust
performance objectives for the given problem.

You can use the `robgain`

command to analyze
the closed-loop robust performance of `clp`

.

[rpmarg,rpmargunc] = robgain(clp,1);

There are two shortcomings of the D-K iteration control design procedure:

Calculation of the structured singular value µΔ(·) is approximated by its upper bound. This is not a serious problem because the value of µ and its upper bound are often close.

The D-K iteration is not guaranteed to converge to a global, or even local minimum. This is a serious problem, and represents the biggest limitation of the design procedure.

In spite of these drawbacks, the D-K iteration control design technique appears to work well on many engineering problems. It has been applied to a number of real-world applications with success. These applications include vibration suppression for flexible structures, flight control, chemical process control problems, and acoustic reverberation suppression in enclosures.

Control of Spring-Mass-Damper Using Mixed mu-Synthesis

[1] Balas, G.J., and J.C. Doyle, “Robust control of
flexible modes in the controller crossover region,” *AIAA
Journal of Guidance, Dynamics and Control*, Vol. 17, no.
2, March-April, 1994, p. 370-377.

[2] Balas, G.J., A.K. Packard, and J.T. Harduvel, “Application
of µ-synthesis techniques to momentum management and attitude
control of the space station,” *AIAA Guidance, Navigation
and Control Conference*, New Orleans, August 1991.

[3] Doyle, J.C., K. Lenz, and A. Packard, “Design
examples using µ-synthesis: Space shuttle lateral axis FCS during
reentry,” *NATO ASI Series, Modelling, Robustness,
and Sensitivity Reduction in Control Systems*, vol. 34,
Springer-Verlag, Berlin 1987.

[4] Packard, A., J. Doyle, and G. Balas, “Linear,
multivariable robust control with a µ perspective,” *ASME
Journal of Dynamic Systems, Measurement and Control*, 50th
Anniversary Issue, Vol. 115, no. 2b, June 1993, p. 310-319.

[5] Stein, G., and J. Doyle, “Beyond singular values
and loopshapes,” *AIAA Journal of Guidance and Control*,
Vol. 14, No. 1, January, 1991, p. 5-16.

`dksynOptions`

| `dksynperf`

| `h2syn`

| `hinfsyn`

| `mktito`

| `mussv`

| `robgain`

| `robstab`

| `wcdiskmargin`

| `wcgain`