Robust controller design using mu synthesis

`musyn`

designs a robust controller for an uncertain plant
using D-K iteration, which combines *H*_{∞} synthesis (K
step) with *μ* analysis (D step) to optimize closed-loop robust
performance.

You can use `musyn`

to:

Synthesize "black box" unstructured robust controllers.

Robustly tune a fixed-order or fixed-structure controller made up of tunable components such as PID controllers, state-space models, and static gains.

For additional information about performing *μ* synthesis and
interpreting results, see Robust Controller Design Using Mu Synthesis.

`[`

returns a controller `K`

,`CLperf`

] = musyn(`P`

,`nmeas`

,`ncont`

)`K`

that optimizes the robust performance of the
uncertain closed-loop system `CL = lft(P,K)`

. The plant
`P`

is a continuous or discrete uncertain plant with the partitioned
form

$$\left[\begin{array}{c}z\\ y\end{array}\right]=\left[\begin{array}{cc}{P}_{11}& {P}_{12}\\ {P}_{21}& {P}_{22}\end{array}\right]\left[\begin{array}{c}w\\ u\end{array}\right],$$

where:

*w*represents the disturbance inputs.*u*represents the control inputs.*z*represents the error outputs to be kept small.*y*represents the measurement outputs provided to the controller.

`nmeas`

and `ncont`

are the numbers of signals
in *y* and *u*, respectively. *y* and
*u* are the last outputs and inputs of `P`

,
respectively. The closed-loop system `CL = lft(P,K)`

achieves the robust
performance `CLperf`

, which is the *μ* upper bound,
the robust performance metric calculated by `musynperf`

.

For this syntax, `musyn`

uses `hinfsyn`

for
*H*_{∞} synthesis (the *K*
step).

`[`

uses additional options for the D-K iteration and underlying `K`

,`CLperf`

,`info`

] = musyn(___,`opts`

)`hinfsyn`

computations. Use `musynOptions`

to create the option set. You can use this syntax with any of the previous input and
output argument combinations.

`[`

optimizes the robust performance by tuning the free parameters in the tunable, uncertain
closed-loop model `CL`

,`CLperf`

] = musyn(`CL0`

)`CL0`

. The `genss`

model
`CL0`

is an uncertain and tunable model of the closed-loop system
whose robust performance you want to optimize. The model contains:

Uncertain control design blocks such as

`ureal`

and`ultidyn`

to represent the uncertaintyTunable control design blocks such as

`tunablePID`

,`tunableSS`

, and`tunableGain`

to represent the tunable components of the control structure

`musyn`

returns the closed-loop model `CL`

with
the tunable control design blocks set to the tuned values. The best achieved robust
performance is returned as `CLperf`

.

For this syntax, `musyn`

uses `hinfstruct`

for
*H*_{∞} synthesis (*K*
step).

`[`

initializes the D-K iteration with the tunable block values in
`CL`

,`CLperf`

,`info`

] = musyn(`CL0`

,`blockvals`

)`blockvals`

. You can specify the block values as a structure or by
providing a closed-loop model whose blocks are tuned to the values you want to initialize.
For instance, to use the tuned values obtained in a previous `musyn`

run, set `blockvalues = CL`

.

`[`

uses additional options for the D-K iteration and underlying
`CL`

,`CLperf`

,`info`

] = musyn(___,`opts`

)`hinfstruct`

computations. Use `musynOptions`

to create the option set. You can use this syntax with any of the previous input and
output argument combinations.

For discrete-time plants, sample times that are very small compared to other dynamics in the problem can cause the synthesis to fail due to numeric issues. For best results, choose sample times such that significant dynamics (system dynamics and weighting functions) are not more than a decade or two below the Nyquist frequency. The issue arises because the dynamics of the

*D*and*G*scalings tend to concentrate around the system dynamics. A too-small sample time results an accumulation of poles near*z*= 1 (relative to the Nyquist frequency), which causes numeric problems with the Riccati solvers. Alternatively, design in continuous time.

For more information on how to interpret the displays and outputs of

`musyn`

, see Robust Controller Design Using Mu Synthesis.For information about how to improve the results you obtain with

`musyn`

, see Improve Results of Mu Synthesis.

`musyn`

uses an iterative process called *D-K
iteration*. In this process, the function:

Uses

*H*_{∞}synthesis to find a controller that minimizes the closed-loop gain of the nominal system.Performs a robustness analysis to estimate the robust

*H*_{∞}performance of the closed-loop system. This amount is expressed as a scaled*H*_{∞}norm involving dynamic scalings called the*D*and*G*scalings (the*D*step).Finds a new controller to minimize the scaled

*H*_{∞}norm obtained in step 2 (the*K*step).Repeats steps 2 and 3 until the robust performance stops improving.

For more details about how this algorithm works, see D-K Iteration Process.

`hinfstruct`

| `hinfsyn`

| `musynOptions`

| `musynperf`

| `uscale`

| `wcgain`