Note: This page has been translated by MathWorks. Click here to see

To view all translated materials including this page, select Country from the country navigator on the bottom of this page.

To view all translated materials including this page, select Country from the country navigator on the bottom of this page.

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`