A brief and practical introduction to \(\mathcal{H}_\infty\) Control

The typical methodology for Model Based Control techniques is schematically shown in Figure 1.

It consists of three steps:

1. Identification or modeling: a mathematical model \(G(s)\) representing the plant dynamics is obtained
2. Translate the specifications into mathematical criteria:
   • Specifications: Response Time, Noise Rejection, Maximum input amplitude, Robustness, …
   • Mathematical Criteria: Cost Function, Shape of transfer function, Phase/Gain margin, Roll-Off, …
3. Synthesis: research of a controller \(K(s)\) that satisfies the specifications for the model of the system

In this document, we will suppose a model of the plant is available (step 1 already performed), and we will focus on steps 2 and 3.

In Section 2, steps 2 and 3 will be described for a control techniques called classical (open-)loop shaping.

Then, steps 2 and 3 for the \(\mathcal{H}_\infty\) Loop Shaping of closed-loop transfer functions will be discussed in Sections 4, 5 and 6.

Many different model based control techniques have been developed since the birth of classical control theory in the ’30s.

Classical control methods were developed starting from 1930 based on tools such as the Laplace and Fourier transforms. It was then natural to study systems in the frequency domain using tools such as the Bode and Nyquist plots. Controllers were manually tuned to optimize criteria such as control bandwidth, gain and phase margins.

The ’60s saw the development of control techniques based on a state-space. Linear algebra and matrices were used instead of the frequency domain tool of the class control theory. This allows multi-inputs multi-outputs systems to be easily treated. Kalman introduced the well known Kalman estimator as well the notion of optimality by minimizing quadratic cost functions. This set of developments is loosely termed Modern Control theory.

By the 1980’s, modern control theory was shown to have some robustness issues and to lack the intuitive tools that the classical control methods were offering. This led to a new control theory called Robust control that blends the best features of classical and modern techniques. This robust control theory is the subject of this document.

The three presented control methods are compared in Table 1.

Note that in parallel, there have been numerous other developments, including non-linear control, adaptive control, machine-learning control just to name a few.

Throughout this document, multiple examples and practical application of presented control strategies will be provided. Most of them will be applied on a physical system presented in this section.

This system is shown in Figure 2. It could represent an active suspension stage supporting a payload. The inertial motion of the payload is measured using an inertial sensor and this is feedback to a force actuator. Such system could be used to actively isolate the payload (disturbance rejection problem) or to make it follow a trajectory (tracking problem).

The notations used on Figure 2 are listed and described in Table 2.

Having obtained \(G(s)\) and \(G_d(s)\), we can transform the system shown in Figure 2 into a classical feedback architecture as shown in Figure 6.

Let’s define the system parameters on Matlab.

1: k = 1e6; % Stiffness [N/m]
2: c = 4e2; % Damping [N/(m/s)]
3: m = 10; % Mass [kg]

And now the system dynamics \(G(s)\) and \(G_d(s)\).

4: G = 1/(m*s^2 + c*s + k); % Plant
5: Gd = (c*s + k)/(m*s^2 + c*s + k); % Disturbance

The Bode plots of \(G(s)\) and \(G_d(s)\) are shown in Figures 4 and 5.

This synthesis method is one of main way controllers are design in the classical control theory. It is widely used and generally successful as many characteristics of the closed-loop system depend on the shape of the open loop gain \(L(s)\) such as:

• Good Tracking: \(L\) large
• Good disturbance rejection: \(L\) large
• Attenuation of measurement noise on plant output: \(L\) small
• Small magnitude of input signal: \(L\) small
• Nominal stability: \(L\) small (RHP zeros and time delays)
• Robust stability: \(L\) small (neglected dynamics)

The shaping of the Loop Gain is done manually by combining several leads, lags, notches… This process is very much simplified by the fact that the loop gain \(L(s)\) depends linearly on \(K(s)\) \eqref{eq:loop_gain}. A typical wanted Loop Shape is shown in Figure 7. Another interesting Loop shape called “Bode Step” is described in [1].

The shaping of closed-loop transfer functions is obviously not as simple as they don’t depend linearly on \(K(s)\). But this is were the \(\mathcal{H}_\infty\) Synthesis will be useful! More details on that in Sections 4 and 5.

sisotool(G)

Let’s say we came up with the following controller.

K = 14e8 * ...              % Gain
    1/(s^2) * ...           % Double Integrator
    1/(1 + s/2/pi/40) * ... % Low Pass Filter
    (1 + s/(2*pi*10/sqrt(8)))/(1 + s/(2*pi*10*sqrt(8))); % Lead

The bode plot of the Loop Gain is shown in Figure 8 and we can verify that we have the wanted stability margins using the margin command:

[Gm, Pm, ~, Wc] = margin(G*K)

The synthesis of controllers based on the Loop Shaping method can be automated using the \(\mathcal{H}_\infty\) Synthesis.

Using Matlab, it can be easily performed using the loopsyn command:

K = loopsyn(G, Lw);

where:

• G is the (LTI) plant
• Lw is the wanted loop shape
• K is the synthesize controller

Therefore, by just providing the wanted loop shape and the plant model, the \(\mathcal{H}_\infty\) Loop Shaping synthesis generates a stabilizing controller such that the obtained loop gain \(L(s)\) matches the specified one with an accuracy \(\gamma\).

Even though we will not go into details and explain how such synthesis is working, an example is provided in the next section.

To apply the \(\mathcal{H}_\infty\) Loop Shaping Synthesis, the wanted shape of the loop gain should be determined from the specifications. This is summarized in Table 3.

Such shape corresponds to the typical wanted Loop gain Shape shown in Figure 7.

Then, a (stable, minimum phase) transfer function \(L_w(s)\) should be created that has the same gain as the wanted shape of the Loop gain. For this example, a double integrator and a lead centered on 10Hz are used. Then the gain is adjusted such that the \(|L_w(j2 \pi 10)| = 1\).

Using Matlab, we have:

Lw = 2.3e3 * ...
     1/(s^2) * ... % Double Integrator
     (1 + s/(2*pi*10/sqrt(3)))/(1 + s/(2*pi*10*sqrt(3))); % Lead

The \(\mathcal{H}_\infty\) open loop shaping synthesis is then performed using the loopsyn command:

[K, ~, GAM] = loopsyn(G, Lw);

The obtained Loop Gain is shown in Figure 9 and matches the specified one by a factor \(\gamma \approx 2\).

Let’s briefly analyze the obtained controller which bode plot is shown in Figure 10:

• two integrators are used at low frequency to have the wanted low frequency high gain
• a lead is added centered with the crossover frequency to increase the phase margin
• a notch is added at the resonance of the plant to increase the gain margin (this is very typical of \(\mathcal{H}_\infty\) controllers, and can be an issue, more info on that latter)

Let’s finally compare the obtained stability margins of the \(\mathcal{H}_\infty\) controller and of the manually developed controller in Table 4.

Why optimizing the \(\mathcal{H}_\infty\) norm of transfer functions is a pertinent choice will become clear when we will translate the typical control specifications into the \(\mathcal{H}_\infty\) norm of transfer functions in Section 4.

Note that there are many ways to use the \(\mathcal{H}_\infty\) Synthesis:

• Traditional \(\mathcal{H}_\infty\) Synthesis (hinfsyn doc)
• Open Loop Shaping \(\mathcal{H}_\infty\) Synthesis (loopsyn doc)
• Mixed Sensitivity Loop Shaping (mixsyn doc)
• Fixed-Structure \(\mathcal{H}_\infty\) Synthesis (hinfstruct doc)
• Signal Based \(\mathcal{H}_\infty\) Synthesis, and many more…

The first step when applying the \(\mathcal{H}_\infty\) synthesis is usually to write the problem as a standard \(\mathcal{H}_\infty\) problem. This consist of deriving the Generalized Plant for the current problem.

The generalized plant, usually noted \(P(s)\), is shown in Figure 12. It has two sets of inputs \([w,\,u]\) and two sets of outputs \([z\,v]\) such that:

The meaning of these inputs and outputs are summarized in Table 5.

A practical example about how to derive the generalized plant for a classical control problem is given in Section 3.5.

Once the generalized plant is obtained, the \(\mathcal{H}_\infty\) synthesis problem can be stated as follows:

Using Matlab, the \(\mathcal{H}_\infty\) Synthesis applied on a Generalized plant can be applied using the hinfsyn command (documentation):

K = hinfsyn(P, nmeas, ncont);

where:

• P is the generalized plant transfer function matrix
• nmeas is the number of sensed output (size of \(v\))
• ncont is the number of control signals (size of \(u\))
• K obtained controller (of size ncont x nmeas) that minimizes the \(\mathcal{H}_\infty\) norm from \(w\) to \(z\).

Note that the general control configure of Figure 13, as its name implies, is quite general and can represent feedback control as well as feedforward control architectures.

The procedure to convert a typical control architecture as the one shown in Figure 14 to a generalized Plant is as follows:

1. Define signals of the generalized plant: \(w\), \(z\), \(u\) and \(v\)
2. Remove \(K\) and rearrange the inputs and outputs to match the generalized configuration shown in Figure 12

P = [1 -G;
     0  1;
     1 -G]
P.InputName = {'w', 'u'};
P.OutputName = {'e', 'u', 'v'};

Consider the typical feedback system shown in Figure 16.

The behavior (performances) of this feedback system is determined by the closed-loop transfer functions from the inputs (\(r\), \(d\) and \(n\)) to the important signals such as \(\epsilon\), \(u\) and \(y\).

Depending on the specification, different closed-loop transfer functions do matter. These are summarized in Table 6.

The behavior of the feedback system in Figure 16 is fully described by the following set of equations:

Thus, for reference tracking, we have to shape the closed-loop transfer function from \(r\) to \(\epsilon\), that is the sensitivity function \(S(s)\). Similarly, to reduce the effect of measurement noise \(n\) on the output \(y\), we have to act on the complementary sensitivity function \(T(s)\).

The sensitivity function is indisputably the most important closed-loop transfer function of a feedback system. In this section, we will see how the shape of the sensitivity function will impact the performances of the closed-loop system.

Suppose we have developed a “reference” controller \(K_r(s)\) and made three small changes to obtained three controllers \(K_1(s)\), \(K_2(s)\) and \(K_3(s)\). The obtained sensitivity functions for these four controllers are shown in Figure 17 and the corresponding step responses are shown in Figure 18.

The comparison of the sensitivity functions shapes and their effect on the step response is summarized in Table 7.

Let’s start this section by an example demonstrating why the phase and gain margins might not be good indicators of robustness. Will follow a discussion about the module margin, a robustness indicator that can be linked to the \(\mathcal{H}_\infty\) norm of \(S\) and that will prove to be very useful.

w0 = 2*pi*100;
xi = 0.1;
k = 1e7;

Gt = 1/k*(s/w0/4 + 1)/(s^2/w0^2 + 2*xi*s/w0 + 1);

Kt = 1.2e6*(s + w0)/s;

xi = 0.03;

isstable(feedback(Gr,K))

0

Let’s now determine a new robustness indicator based on the Nyquist Stability Criteria.

From the Nyquist stability criteria, it is clear that we want \(L(j\omega)\) to be as far as possible from the \(-1\) point (called the unstable point) in the complex plane. This minimum distance is called the module margin.

As expected from Figure 22, there is a close relationship between the module margin and the gain and phase margins. We can indeed show that for a given value of the module margin \(\Delta M\), we have:

Let’s now try to express the Module margin \(\Delta M\) as an \(\mathcal{H}_\infty\) norm of a closed-loop transfer function:

Therefore, for a given \(\mathcal{H}_\infty\) norm of \(S\) (\(\|S\|_\infty = M_S\)), we have:

Note that this is why large peak value of \(|S(j\omega)|\) usually indicate robustness problems. And we now understand why setting an upper bound on the magnitude of \(S\) is generally a good idea.

Suppose we apply the \(\mathcal{H}_\infty\) synthesis on the generalized plant \(P(s)\) shown in Figure 23. It will generate a controller \(K(s)\) such that the \(\mathcal{H}_\infty\) norm of closed-loop transfer function from \(r\) to \(\epsilon\) is minimized which is equal to the sensitivity function \(S\). Therefore, the synthesis objective is to minimize the \(\mathcal{H}_\infty\) norm of the sensitivity function: \(\|S\|_\infty\).

However, as the \(\mathcal{H}_\infty\) norm is the maximum peak value of the transfer function’s magnitude, this synthesis is quite useless as it will just try to decrease of peak value of \(S\). Clearly this does not allow to shape the norm of \(S(j\omega)\) over all frequencies nor specify the wanted low frequency gain of \(S\) or bandwidth requirements.

Let’s now show how this is equivalent as shaping the sensitivity function:

Pw = [Ws -Ws*G;
      1  -G];

P = [1 -G;
     1 -G];
Pw = blkdiag(Ws, 1)*P;

Weighting function included in the generalized plant must be proper, stable and minimum phase transfer functions.

Good guidelines for design of weighting function are given in [2].

There is a Matlab function called makeweight that allows to design first-order weights by specifying the low frequency gain, high frequency gain, and the gain at a specific frequency:

W = makeweight(dcgain,[freq,mag],hfgain)

with:

• dcgain: low frequency gain
• [freq,mag]: frequency freq at which the gain is mag
• hfgain: high frequency gain

Ws = makeweight(1e2, [2*pi*10, 1], 1/2);

function [W] = generateWeight(args)
    arguments
        args.G0 (1,1) double {mustBeNumeric, mustBePositive} = 0.1
        args.G1 (1,1) double {mustBeNumeric, mustBePositive} = 10
        args.Gc (1,1) double {mustBeNumeric, mustBePositive} = 1
        args.wc (1,1) double {mustBeNumeric, mustBePositive} = 2*pi
        args.n  (1,1) double {mustBeInteger, mustBePositive} = 1
    end

    if (args.Gc <= args.G0 && args.Gc <= args.G1) || (args.Gc >= args.G0 && args.Gc >= args.G1)
        eid = 'value:range';
        msg = 'Gc must be between G0 and G1';
        throwAsCaller(MException(eid,msg))
    end

    s = zpk('s');

    W = (((1/args.wc) * sqrt((1-(args.G0/args.Gc)^(2/args.n))/(1-(args.Gc/args.G1)^(2/args.n)))*s + (args.G0/args.Gc)^(1/args.n)) / ((1/args.G1)^(1/args.n) * (1/args.wc) * sqrt((1-(args.G0/args.Gc)^(2/args.n))/(1-(args.Gc/args.G1)^(2/args.n)))*s + (1/args.Gc)^(1/args.n)))^args.n;

end

W1 = generateWeight('G0', 1e2, 'G1', 1/2, 'Gc', 1, 'wc', 2*pi*10, 'n', 1);
W2 = generateWeight('G0', 1e2, 'G1', 1/2, 'Gc', 1, 'wc', 2*pi*10, 'n', 2);
W3 = generateWeight('G0', 1e2, 'G1', 1/2, 'Gc', 1, 'wc', 2*pi*10, 'n', 3);

Let’s design a controller using the \(\mathcal{H}_\infty\) shaping of the sensitivity function that fulfils the following requirements:

1. Bandwidth of at least 10Hz
2. Small static errors for step responses
3. Robustness: Large module margin \(\Delta M > 0.5\) (\(\Rightarrow \Delta G > 2\) and \(\Delta \phi > 29^o\))

As usual, the plant used is the one presented in Section 1.3.

Ws = makeweight(1e3, [2*pi*10, sqrt(2)], 1/2);

Ws = generateWeight('G0', 1e3, ...
                    'G1', 1/2, ...
                    'Gc', sqrt(2), 'wc', 2*pi*10, ...
                    'n', 2);

Let’s say we came up with the following weighting function:

Ws = generateWeight('G0', 1e3, ...
                    'G1', 1/2, ...
                    'Gc', sqrt(2), 'wc', 2*pi*10, ...
                    'n', 2);

The weighting function is then added to the generalized plant.

P = [1 -G;
     1 -G];
Pw = blkdiag(Ws, 1)*P;

And the \(\mathcal{H}_\infty\) synthesis is performed on the weighted generalized plant.

K = hinfsyn(Pw, 1, 1, 'Display', 'on');

Test bounds:  0.5 <=  gamma  <=  0.51

 gamma        X>=0        Y>=0       rho(XY)<1    p/f
5.05e-01     0.0e+00     0.0e+00     3.000e-16     p
Limiting gains...
5.05e-01     0.0e+00     0.0e+00     3.461e-16     p
5.05e-01    -3.5e+01 #  -4.9e-14     1.732e-26     f

Best performance (actual): 0.503

\(\gamma \approx 0.5\) means that the \(\mathcal{H}_\infty\) synthesis generated a controller \(K(s)\) that stabilizes the closed-loop system, and such that the \(\mathcal{H}_\infty\) norm of the closed-loop transfer function from \(w\) to \(z\) is less than \(\gamma\):

This is indeed what we can see by comparing \(|S|\) and \(|W_S|\) in Figure 28.

As was shown in Section 4, each of the four main closed-loop transfer functions (called the gang of four) will impact different characteristics of the closed-loop system. This is summarized in Table 9.

Therefore, we might want to shape multiple closed-loop transfer functions at the same time. For instance \(S\) could be shape to have good step responses, \(KS\) to limit the input usage and \(T\) to filter measurement noise. When multiple closed-loop transfer function are shaped at the same time, it is refereed to as Mixed-Sensitivity \(\mathcal{H}_\infty\) Control and is the subject of Section 6.

Depending on which closed-loop transfer function are to be shaped, different weighted generalized plant can be used. Some of them are described below for reference, it is a good exercise to try to re-design such weighted generalized plants.

P = [1 -G
     0  1
     1 -G];
Pw = blkdiag(W1, W2, 1)*P;

P = [1 -G
     0  G
     1 -G];
Pw = blkdiag(W1, W2, 1)*P;

P = [1 -1
     G -G
     G -G];
Pw = blkdiag(W1, W2, 1)*P;

P = [1 -G
     0  1
     0  G
     1 -G];
Pw = blkdiag(W1, W2, W3, 1)*P;

P = [1 -1
     G -G
     0  1
     G -G];
Pw = blkdiag(W1, W2, W3, 1)*P;

P = [ 1 -G -G
      0  0  1
      1 -G -G];
Pw = blkdiag(W1, W2, 1)*P*blkdiag(1, W3, 1);

For practical control systems, above some frequency (the control bandwidth), the loop gain is much smaller than 1. On the other size, there is a frequency range where the loop gain is much larger than 1, this frequency range is called the bandwidth. Let’s see what does that means for the closed-loop transfer function. First, take the case of the sensibility function:

This means that the Sensitivity function cannot be shaped at frequencies where the loop gain is small.

Similar relationship can be found for \(T\), \(KS\) and \(GS\).

Depending on the frequency band, the norms of the closed-loop transfer functions are a function of the controller \(K\) and therefore can be shaped. However, in some frequency band, the norms do not depend on the controller and therefore cannot be shaped.

Therefore the weighting functions should only focus on certainty frequency range depending on the transfer function being shaped. These regions are summarized in Figure 35.

Let’s consider our usual test system shown in Figure 36.

The considered inputs are:

• disturbances \(d\) as step inputs with an amplitude of \(5\,\mu m\)
• reference inputs with are ramp inputs with a slope of \(100\,\mu m/s\) and a time duration of \(0.2\,s\)
• measurement noise \(n\) with a large spectral density at high frequency (increasing starting from 100Hz)

Here is the general design procedure that will be followed:

1. Compute the model of the plant
2. Write the control system as a general control problem
3. Translate the specifications into the wanted shape of closed-loop transfer functions
4. Chose the suitable weighted general plant to shape the wanted quantities
5. Shape sequentially the chosen closed-loop transfer functions

Let’s first convert the system of Figure 36 into the classical feedback architecture of Figure 37.

The two transfer functions present in the system are derived and defined below:

1: k = 1e6; % Stiffness [N/m]
2: c = 4e2; % Damping [N/(m/s)]
3: m = 10; % Mass [kg]
4: 
5: % Control Plant
6: G = 1/(m*s^2 + c*s + k);
7: % Disturbance dynamics
8: Gd = (c*s + k)/(m*s^2 + c*s + k);

We also define the inputs signals that will be used for time domain simulations. They are graphically shown in Figure 38.

 9: % Time Vector
10: t = 0:1e-4:0.5;
11: 
12: % Reference Input
13: r = zeros(size(t));
14: r(t>0.05 & t<=0.25) = 1e-4*(t(t>0.05 & t<=0.25)-0.05);
15: r(t>0.25) = 2e-5;
16: 
17: % Measurement Noise
18: Fs = 1e3; % Sampling Frequency [Hz]
19: Ts = 1/Fs; % Sampling Time [s]
20: n = sqrt(Fs/2)*randn(1, length(t)); % Signal with an ASD equal to one
21: n = lsim(1e-6*(s + 2*pi*1e2)^2/(s + 2*pi*1e3)^2/(1+s/2/pi/500), n, t)'; % Shaped noise
22: 
23: % Disturbance
24: d = zeros(size(t));
25: d(t>0.3) = 5e-6;

We also define the generalized plant corresponding to the system and that will be used for time domain simulations (Figure 39).

The Generalized plant of Figure 39 is defined on Matlab as follows:

26: Psim = [0  0  Gd  G
27:         0  0  0   1
28:         1 -1 -Gd -G];
29: 
30: Psim.InputName = {'r', 'n', 'd', 'u'};
31: Psim.OutputName = {'y', 'u', 'e'};

Time domain simulations will be performed by first computing the closed-loop system using the lft command and then using the lsim command on the closed-loop system:

32: % Compute the closed-Loop System, K is the controller
33: P_CL = lft(Psim, K);
34: 
35: % Time simulation of the closed-loop system with specified inputs
36: z = lsim(P_CL, [r; n; d], t);
37: % The two outputs are
38: y = z(:,1); % Output Motion [m]
39: u = z(:,2); % Input usage [N]

After converting the control specifications into wanted shape of closed-loop transfer functions, we might come up with the Table 10.

In such case, we want to shape \(S\), \(GS\) and \(T\).

To do so, we use to generalized plant shown in Figure 40 for the synthesis where the three closed-loop tranfert functions from \(w\) to \([z_1\,,z_2\,,z_3]\) are respectively \(S\), \(GS\) and \(T\).

This generalized plant is defined on Matlab as follows:

40: P = [1 -1
41:      G -G
42:      0  1
43:      G -G];

However, to performed the \(\mathcal{H}_\infty\) loop shaping, we have to include weighting function to the Generalized plant. We obtain the weighted generalized plant in Figure 41, and that is computed using Matlab as follows:

44: Pw = blkdiag(W1, W2, W3, 1)*P;

Finlay, performing the \(\mathcal{H}_\infty\) Shaping of \(S\), \(GS\) and \(T\) is as simple as ruining the hinfsyn command:

45: K = hinfsyn(Pw, 1, 1);

Now let’s shape the three closed-loop transfer functions sequentially:

• \(S\) is shaped in Section 6.4
• \(GS\) is shaped in Section 6.5
• \(T\) is shaped in Section 6.6

Let’s first shape the Sensitivity function as it is usually the most important of the Gang of four closed-loop transfer functions. To do so, we have to create a weight \(W_1(s)\) that defines the wanted upper bound on \(|S(j\omega)|\):

• small low frequency gain: \(|S(j\cdot 0)| = 10^{-3}\)
• minimum crossover frequency of \(\approx 10Hz\): \(|S(j2\pi 10)| < \frac{1}{\sqrt{2}}\)
• small maximum peak magnitude for robustness properties: \(\|S\|_\infty < 2\)

The weighting function is design using the generateWeigh function and its inverse shape can be seen in Figure

46: W1 = generateWeight('G0', 1e3, ...
47:                     'G1', 1/2, ...
48:                     'Gc', sqrt(2), 'wc', 2*pi*10, ...
49:                     'n', 1);

To not constrain \(GS\) and \(T\) for the shaping of \(S\), \(W_2\) and \(W_3\) are first taken as very small gains:

50: W2 = tf(1e-8);
51: W3 = tf(1e-8);

The \(\mathcal{H}_\infty\) synthesis is performed and the obtained closed-loop transfer functions \(S\), \(GS\), and \(T\) and compared with the upper bounds set by the weighting functions in Figure 42.

52: Pw = blkdiag(W1, W2, W3, 1)*P;
53: K1 = hinfsyn(Pw, 1, 1, 'Display', 'on');

Test bounds:  0.5 <=  gamma  <=  0.51

 gamma        X>=0        Y>=0       rho(XY)<1    p/f
5.05e-01     0.0e+00     0.0e+00     5.511e-14     p
Limiting gains...
5.05e-01     0.0e+00     0.0e+00     1.867e-14     p

Best performance (actual): 0.502

Time domain simulation is then performed and the obtained output displacement and control inputs are shown in Figure 43.

We can see:

• we are not able to follow the ramp input. This have to be solved by modifying the weighting function \(W_1(s)\)
• we have poor rejection of disturbances. This we be solve by shaping \(GS\) in Section 6.5
• we have quite large effect of the measurement noise. This will be solved by shaping \(T\) in Section 6.6

Remember that in order to follow ramp inputs, the sensitivity function should have a slope of +40dB/dec at low frequency (Table 9).

To do so, let’s modify \(W_1\) to impose a slope of +40dB/dec at low frequency. This can simple be done by using a second order weight:

54: W1 = generateWeight('G0', 1e3, ...
55:                     'G1', 1/2, ...
56:                     'Gc', sqrt(2), 'wc', 2*pi*15, ...
57:                     'n', 2);

The \(\mathcal{H}_\infty\) synthesis is performed using the new weights and the obtained closed-loop shaped are shown in figure 44.

The time domain signals are shown in Figure 45 and it is confirmed that the ramps are now follows without static errors.

Looking at Figure 46, it is clear that the rejection of disturbances is not satisfactory. This can also be seen by the large peak of \(GS\) in Figure 44.

This poor rejection of disturbances is actually due to the fact that the obtain controller has at notch at the resonance frequency of the plant.

To overcome this issue, we can simply increase the magnitude of \(W_2\) to limit the peak magnitude of \(GS\) Let’s take \(W_2\) as a simple constant gain:

58: W2 = tf(4e5);

The \(\mathcal{H}_\infty\) Synthesis is performed and the obtained closed-loop transfer functions are shown in Figure 46.

Time domain simulation results are shown in Figure 47. If is shown that indeed, the disturbance rejection performance are much better and only very small oscillation is obtained.

Finally, we want to limit the effect of the noise on the displacement output.

To do so, \(T\) is shaped such that its high frequency gain is reduced.

This is done by increasing the high frequency gain of the weighting function \(W_3\) until the \(\mathcal{H}_\infty\) synthesis gives \(\gamma \approx 1\).

The final weighting function \(W_3\) is defined as follows:

59: W3 = generateWeight('G0', 1e-1, ...
60:                     'G1', 1e4, ...
61:                     'Gc', 1, 'wc', 2*pi*70, ...
62:                     'n', 2);

The \(\mathcal{H}_\infty\) synthesis is performed and \(\gamma\) is closed to one. The obtained closed-loop transfer functions are shown in Figure 48 and we can obverse that:

• The high frequency gain of \(T\) is indeed reduced
• This comes as the expense of a large magnitude both \(GS\) and \(S\). This means we will probably have slightly less good disturbance rejection and tracking performances.

The time domain simulation signals are shown in Figure 49. We can indeed see a slightly less good disturbance rejection. However, the vibrations induced by the sensor noise is well reduced. This can be seen when zooming on the output signal in Figure 50.

Hopefully this practical example will help you apply the \(\mathcal{H}_\infty\) Shaping synthesis on other control problems.

As an exercise, plot and analyze the evolution of the controller and loop gain transfer functions during the 3 synthesis steps.

If the large input usage is considered to be not acceptable, the shaping of \(KS\) could be included in the synthesis and all the Gang of four closed-loop transfer function shapes.