(Not recommended) Robust controller design for discrete-time plants using µ-synthesis

`dksyn`

is not recommended. Use `musyn`

instead. For more information, see Compatibility Considerations.

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

[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`

| `musyn`

| `robgain`

| `robstab`

| `wcdiskmargin`

| `wcgain`