musyn

Synthesize a stabilizing robust controller K for the system in the following illustration, where the plant G includes some dynamic uncertainty. The controller must also reject disturbances injected at the plant output.

The nominal plant model G0 is an unstable first-order system.

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

The uncertainty in G0 is as follows:

Represent the frequency-dependent model uncertainty with the weight Wu and the uncertain LTI dynamic uncertainty InputUnc, an ultidyn control design block.

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

musyn seeks a controller that optimizes robust performance from inputs to outputs. To set up this problem for musyn, then, insert a weighting function Wp that captures the disturbance rejection goal.

When you provide this augmented plant P to musyn, the function designs a controller that drives the transfer function from d to e below 1 at all frequencies. That transfer function is Wp/S, where S = 1 – GK is the sensitivity function. Thus, choose Wp to be the inverse of the desired sensitivity. For this example, choose Wp with:

Wp = makeweight(100,[1 0.5],0.25);
bodemag(Wp)

You can now construct the plant as shown in the block diagram by naming the signals, defining a sum block, and using connect. Construct the plant so that the control input is the last input, and the measurement output is the last output.

G.InputName = 'u';
G.OutputName = 'y1';
Wp.InputName = 'y';
Wp.OutputName = 'e';
SumD = sumblk('y = y1 + d');

inputs = {'d','u'};
outputs = {'e','y'};
P = connect(G,Wp,SumD,inputs,outputs);

Use musyn to design a controller K for this uncertain system.

nmeas = 1;
ncont = 1;
[K,CLperf,info] = musyn(P,nmeas,ncont); 

D-K ITERATION SUMMARY:
-----------------------------------------------------------------
                       Robust performance               Fit order
-----------------------------------------------------------------
  Iter         K Step       Peak MU       D Fit             D
    1           1.345        1.344         1.36             8
    2          0.7923       0.7904       0.7961             4
    3          0.6789       0.6789       0.6857            10
    4          0.6572       0.6572       0.6598             8
    5          0.6538       0.6538       0.6542             8
    6          0.6532       0.6532       0.6533             8

Best achieved robust performance: 0.653

The display shows that the best achieved robust performance is about 0.65. This result means that the gain from d to e remains below 0.65 for up to 1/0.65 times the uncertainty specified in the plant. Thus, the controller achieves the robust performance objectives for the full range of modeled uncertainty. (For more information on interpreting musyn results, see Robust Controller Design Using Mu Synthesis.)

You can examine the robust performance using analysis commands such as robgain and wcgainplot. For instance, examine the worst-case gain of the closed-loop system.

CL = lft(P,K);
wcg = wcgain(CL)

wcg = struct with fields:
           LowerBound: 0.5283
           UpperBound: 0.5294
    CriticalFrequency: 0

This result confirms that the actual worst-case gain over the modeled uncertainty is about 0.53, which is within the robust performance of 0.65 guaranteed by musyn.

For this problem, the controller returned by musyn is fairly high order.

size(K)

State-space model with 1 outputs, 1 inputs, and 11 states.

You can try reducing the controller order with model-reduction commands such as balred or reduce to see whether you can maintain robust performance. (For an example, see the musynperf reference page.) Or, you can try specifying a lower order controller structure and use musyn to tune it. See Robust Tuning of Fixed-Structure Controller.

Tune a fixed-structure controller for the control system in Unstructured Robust Controller Synthesis, which shows how to use musyn to design an unstructured full-order centralized controller, and returns a controller of order 11. For this example, use the same control structure, as shown in the diagram, but restrict the structure of K to a fifth-order state-space model.

First, construct the same plant P as in Unstructured Robust Controller Synthesis. The plant is an uncertain plant G augmented by a sensitivity-weighting function Wp.

G0 = tf(1,[1 -1]);
Wu = 0.25*tf([1/2 1],[1/32 1]); 
InputUnc = ultidyn('InputUnc',[1 1]);
G = G0*(1+InputUnc*Wu);
G.InputName = 'u';
G.OutputName = 'y1';

Wp = makeweight(100,[1 0.5],0.25);
Wp.InputName = 'y';
Wp.OutputName = 'e';

SumD = sumblk('y = y1 + d');
inputs = {'d','u'};
outputs = {'e','y'};
P = connect(G,Wp,SumD,inputs,outputs);

Create a tunableSS control design block to represent the fixed controller structure, a fifth-order state-space model.

C0 = tunableSS('K',5,1,1);

Form the closed-loop system, which is a generalized state-space (genss) model that has both a tunable block and an uncertain block.

CL0 = lft(P,C0)

Generalized continuous-time state-space model with 1 outputs, 1 inputs, 8 states, and the following blocks:
  InputUnc: Uncertain 1x1 LTI, peak gain = 1, 1 occurrences
  K: Tunable 1x1 state-space model, 5 states, 1 occurrences.

Type "ss(CL0)" to see the current value and "CL0.Blocks" to interact with the blocks.

Use musyn to tune the free entries of the controller.

[CL,CLperf,info] = musyn(CL0);

D-K ITERATION SUMMARY:
-----------------------------------------------------------------
                       Robust performance               Fit order
-----------------------------------------------------------------
  Iter         K Step       Peak MU       D Fit             D
    1           1.342        1.342        1.359             8
    2           0.802       0.7729       0.7775             8
    3          0.6815       0.6663       0.6732             8
    4          0.6609       0.6547       0.6621            10
    5          0.6584       0.6522       0.6609             6
    6          0.6575       0.6521       0.6574             6

Best achieved robust performance: 0.652

Even when you specify the structure of K as a fifth-order state-space model, musyn can find tuned parameter values that yield very similar robust performance to the 11th-order controller. You can try still lower controller orders to see whether the robust stability is preserved.

The robust controller returned by musyn optimizes robust performance of uncertain feedback systems. When the uncertain plant contains umargin blocks, this requirement of robust stability is equivalent to enforcing disk-based gain and phase margins equal to the umargin uncertainty. In this example, design a robust controller for an uncertain plant, enforcing closed-loop stability against gain and phase variations at the plant inputs and outputs.

Use the plant from the example "Loop Shaping with mixsyn" on the mixsyn reference page, introducing some uncertainty in the location of the system poles and zero.

a = ureal('a',1,'PlusMinus',[-0.1,0.1]);
s = zpk('s');
G = (s-a)/(s+a)^2;

The goal is to enforce closed-loop stability against gain and phase variation at the plant inputs and outputs, over the full range of parameter variation modeled in the plant G. To do so, use the target gain and phase margins to create umargin uncertain blocks and attach them to the plant. For this example, suppose that you want stability against gain variations of a factor of 1.5 in either direction, or phase variations of ±20°.

DGM = getDGM(1.5,20,'tight');
Fin = umargin('Fin',DGM);
Fout = umargin('Fout',DGM);
Gmarg = Fout*G*Fin

Uncertain continuous-time state-space model with 1 outputs, 1 inputs, 7 states.
The model uncertainty consists of the following blocks:
  Fin: Uncertain gain/phase, gain × [0.667,1.5], phase ± 22.6 deg, 1 occurrences
  Fout: Uncertain gain/phase, gain × [0.667,1.5], phase ± 22.6 deg, 1 occurrences
  a: Uncertain real, nominal = 1, variability = [-0.1,0.1], 3 occurrences

Type "Gmarg.NominalValue" to see the nominal value and "Gmarg.Uncertainty" to interact with the uncertain elements.

For tuning with musyn, you augment the plant with weighting functions that enforce your performance requirement such as reference tracking, disturbance rejection, and robustness. For this example, use the weighting functions described in the example on the mixsyn reference page.

W1 = makeweight(10,[1 0.1],0.01);
W2 = makeweight(0.1,[32 0.32],1);
W3 = makeweight(0.01,[1 0.1],10);

Gaug = augw(Gmarg,W1,W2,W3);

Use musyn to design a controller.

[K,gam] = musyn(Gaug,1,1);

D-K ITERATION SUMMARY:
-----------------------------------------------------------------
                       Robust performance               Fit order
-----------------------------------------------------------------
  Iter         K Step       Peak MU       D Fit             D
    1           7.753        1.527        1.539            24
    2           1.131        1.084        1.091            42
    3               1       0.9967        1.006            44
    4          0.9981       0.9927        1.002            42
    5          0.9953       0.9938       0.9971            34

Best achieved robust performance: 0.993

musyn achieves a robust performance of about 1, which tells you that the closed-loop gain remains below 1 for the full range of uncertainty specified in the plant. To confirm that the resulting controller achieves the target gain and phase margins, use wcdiskmargin to examine the worst-case gain and phase margins of the system against simultaneous variations at the plant inputs and outputs. Use the plant G that contains the parameter uncertainty but not the gain and phase uncertainty.

MMIO = wcdiskmargin(G,K)

MMIO = struct with fields:
           GainMargin: [0.6021 1.6607]
          PhaseMargin: [-27.8920 27.8920]
           DiskMargin: 0.4967
           LowerBound: 0.4967
           UpperBound: 0.4976
    CriticalFrequency: 1
    WorstPerturbation: [1x1 struct]

The worst-case disk-based gain margin of [0.6 1.66] is slightly larger than the target margin of [0.66 1.5], and the worst-case phase margin of ±28° is likewise better than the required margin of ±20°. Thus, the controller K enforces the desired margins for the entire parameter-uncertainty range of the plant G.

For an example that uses umargin blocks with musyn to enforce gain and phase margins in a MIMO control loop, see Robust Controller for Spinning Satellite.