tdehaeze/lecture-h-infinity
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Re-worked section 5

Browse Source
This commit is contained in:
Thomas Dehaeze 2020-12-03 01:07:02 +01:00
parent e90f4285db
commit 2f5399af97
2 changed files with 654 additions and 570 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

940
index.html
View File

File diff suppressed because it is too large Load Diff

284
index.org
View File

@ -1103,30 +1103,36 @@ The procedure to convert a typical control architecture as the one shown in Figu
** Introduction :ignore:
- Section [[sec:closed_loop_tf]]
- Section [[sec:sensitivity_transfer_functions]]
- Section [[sec:module_margin]]
- Section [[sec:other_requirements]]
As shown in Section [[sec:open_loop_shaping]], the loop gain $L(s) = G(s) K(s)$ is a useful and easy tool when manually designing controllers.
This is mainly due to the fact that $L(s)$ is very easy to shape as it depends /linearly/ on $K(s)$.
Moreover, important quantities such as the stability margins and the control bandwidth can be estimated from the shape/phase of $L(s)$.
However, the loop gain $L(s)$ does *not* directly give the performances of the closed-loop system, which are determined by the *closed-loop* transfer functions.
However, the loop gain $L(s)$ does *not* directly give the performances of the closed-loop system.
As a matter of fact, the behavior of the closed-loop system by the *closed-loop* transfer functions.
These are derived of a typical feedback architecture functions in Section [[sec:closed_loop_tf]].
If we consider the feedback system shown in Figure [[fig:gang_of_four_feedback]], we can link to the following specifications to closed-loop transfer functions.
This is summarized in Table [[tab:spec_closed_loop_tf]].
#+name: tab:spec_closed_loop_tf
#+caption: Typical Specification and associated closed-loop transfer function
| Specification | Closed-Loop Transfer Function |
|--------------------------------+-----------------------------------------------|
| Reference Tracking | From $r$ to $\epsilon$ |
| Disturbance Rejection | From $d$ to $y$ |
| Measurement Noise Filtering | From $n$ to $y$ |
| Small Command Amplitude | From $n,r,d$ to $u$ |
| Stability | All closed-loop transfer function |
| Robustness (stability margins) | Module margin (see Section [[sec:module_margin]]) |
The modern interpretation of control specifications then consists of determining the *required shape of the closed-loop transfer functions* such that the system behavior corresponds to the requirements.
Once this is done, the $\mathcal{H}_\infty$ synthesis can be used to generate a controller that will *shape* the closed-loop transfer function as specified..
This method is presented in Section [[sec:closed-loop-shaping]].
One of the most important closed-loop transfer function is called the *sensitivity function*.
Its link with the closed-loop behavior of the feedback system is studied in Section [[sec:sensitivity_transfer_functions]].
The robustness (stability margins) of the system can also be linked to the shape of the sensitivity function with the use of the *module margin* (Section [[sec:module_margin]]).
Links between typical control specifications and shapes of the closed-loop transfer functions are summarized in Section [[sec:other_requirements]].
** Closed Loop Transfer Functions and the Gang of Four
<<sec:closed_loop_tf>>
Consider the typical feedback system shown in Figure [[fig:gang_of_four_feedback]].
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 [[tab:spec_closed_loop_tf]].
#+begin_src latex :file gang_of_four_feedback.pdf
\begin{tikzpicture}
@ -1149,17 +1155,23 @@ This is summarized in Table [[tab:spec_closed_loop_tf]].
#+end_src
#+name: fig:gang_of_four_feedback
#+caption: Simple Feedback Architecture
#+caption: Simple Feedback Architecture with $r$ the reference signal, $\epsilon$ the tracking error, $d$ a disturbance acting at the plant input $u$, $y$ is the output signal and $n$ the measurement noise
#+RESULTS:
[[file:figs/gang_of_four_feedback.png]]
** Closed Loop Transfer Functions
<<sec:closed_loop_tf>>
As the performances of a controlled system depend on the *closed* loop transfer functions, it is very important to derive these closed-loop transfer functions as a function of the plant $G(s)$ and controller $K(s)$.
#+name: tab:spec_closed_loop_tf
#+caption: Typical Specification and associated closed-loop transfer function
| Specification | Closed-Loop Transfer Function |
|--------------------------------+-----------------------------------------------|
| Reference Tracking | From $r$ to $\epsilon$ |
| Disturbance Rejection | From $d$ to $y$ |
| Measurement Noise Filtering | From $n$ to $y$ |
| Small Command Amplitude | From $n,r,d$ to $u$ |
| Stability | All |
| Robustness (stability margins) | Module margin (see Section [[sec:module_margin]]) |
#+begin_exercice
Write the output signals $[\epsilon, u, y]$ as a function of the systems $K(s), G(s)$ and of the input signals $[r, d, n]$ as shown in Figure [[fig:gang_of_four_feedback]].
For the feedback system in Figure [[fig:gang_of_four_feedback]], write the output signals $[\epsilon, u, y]$ as a function of the systems $K(s), G(s)$ and the input signals $[r, d, n]$.
#+HTML: <details><summary>Hint</summary>
Take one of the output (e.g. $y$), and write it as a function of the inputs $[d, r, n]$ going step by step around the loop:
@ -1187,7 +1199,7 @@ The following equations should be obtained:
#+end_exercice
#+begin_important
We can see that they are 4 different transfer functions describing the behavior of the system in Figure [[fig:gang_of_four_feedback]].
We can see that they are 4 different closed-loop transfer functions describing the behavior of the feedback system in Figure [[fig:gang_of_four_feedback]].
These called the *Gang of Four*:
\begin{align}
S &= \frac{1 }{1 + GK}, \quad \text{the sensitivity function} \\
@ -1202,7 +1214,7 @@ If a feedforward controller is included, a *Gang of Six* transfer functions can
More on that in this [[https://www.youtube.com/watch?v=b_8v8scghh8][short video]].
#+end_seealso
And we have:
The behavior of the feedback system in Figure [[fig:gang_of_four_feedback]] is fully described by the following set of equations:
\begin{align}
\epsilon &= S r - GS d - GS n \\
y &= T r + GS d - T n \\
@ -1212,7 +1224,7 @@ And we have:
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)$.
** Sensitivity Function
** The Sensitivity Function
<<sec:sensitivity_transfer_functions>>
The sensitivity function is indisputably the most important closed-loop transfer function of a feedback system.
@ -1220,7 +1232,7 @@ In this section, we will see how the shape of the sensitivity function will impa
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 are shown in Figure [[fig:sensitivity_shape_effect]] and the corresponding step responses are shown in Figure [[fig:sensitivity_shape_effect_step]].
The obtained sensitivity functions for these four controllers are shown in Figure [[fig:sensitivity_shape_effect]] and the corresponding step responses are shown in Figure [[fig:sensitivity_shape_effect_step]].
The comparison of the sensitivity functions shapes and their effect on the step response is summarized in Table [[tab:compare_sensitivity_shapes]].
@ -1358,12 +1370,10 @@ The comparison of the sensitivity functions shapes and their effect on the step
#+end_definition
#+begin_important
From the simple analysis above, we can draw a first estimation of the wanted shape for the sensitivity function in Figure [[fig:h-infinity-spec-S]].
The wanted characteristics on the magnitude of the sensitivity function are then:
From the simple analysis above, we can draw a first estimation of the wanted shape for the sensitivity function (Figure [[fig:h-infinity-spec-S]]):
- A small magnitude at low frequency to make the static errors small
- A wanted minimum closed-loop bandwidth in order to have fast rise time and good rejection of perturbations
- A small peak value in order to limit large overshoot and oscillations.
- A small peak value (small $\mathcal{H}_\infty$ norm) in order to limit large overshoot and oscillations.
This generally means higher robustness.
This will become clear in the next section about the *module margin*.
@ -1375,10 +1385,11 @@ The wanted characteristics on the magnitude of the sensitivity function are then
** Robustness: Module Margin
<<sec:module_margin>>
Let's start by an example demonstrating why the phase and gain margins might not be good indicators of robustness.
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.
#+begin_exampl
Let's consider the following plant $G_t(s)$:
Consider the following plant $G_t(s)$:
#+begin_src matlab
w0 = 2*pi*100;
xi = 0.1;
@ -1393,12 +1404,13 @@ Let's say we have designed a controller $K_t(s)$ that gives the loop gain shown
Kt = 1.2e6*(s + w0)/s;
#+end_src
The following characteristics can be determined from Figure [[fig:phase_gain_margin_model_plant]]:
- bandwidth of $\approx 10\, \text{Hz}$
- infinite gain margin (the phase of the loop-gain never reaches -180 degrees
- more than 90 degrees of phase margin
The following characteristics can be determined from the Loop gain in Figure [[fig:phase_gain_margin_model_plant]]:
- Control bandwidth of $\approx 10\, \text{Hz}$
- Infinite gain margin (the phase of the loop-gain never reaches $-180^o$)
- More than $90^o$ of phase margin
This might indicate very good robustness properties of the closed-loop system.
This clearly indicate very good robustness of the closed-loop system!
Or does it? Let's find out.
#+begin_src matlab :exports none
freqs = logspace(0, 3, 1000);
@ -1437,7 +1449,7 @@ This might indicate very good robustness properties of the closed-loop system.
[[file:figs/phase_gain_margin_model_plant.png]]
Now let's suppose the "real" plant $G_r(s)$ as a slightly lower damping factor:
Now let's suppose the controller is implemented in practice, and the "real" plant $G_r(s)$ as a slightly lower damping factor than the one estimated for the model:
#+begin_src matlab
xi = 0.03;
#+end_src
@ -1447,7 +1459,7 @@ Now let's suppose the "real" plant $G_r(s)$ as a slightly lower damping factor:
#+end_src
The obtained "real" loop gain is shown in Figure [[fig:phase_gain_margin_real_plant]].
At a frequency little bit above 100Hz, the phase of the loop gain reaches -180 degrees while its magnitude is more than one which indicated instability.
At a frequency little bit above 100Hz, the phase of the loop gain reaches -180 degrees while its magnitude is more than one which indicates instability.
It is confirmed by checking the stability of the closed loop system:
#+begin_src matlab :results value replace
@ -1495,16 +1507,16 @@ It is confirmed by checking the stability of the closed loop system:
#+RESULTS:
[[file:figs/phase_gain_margin_real_plant.png]]
Therefore, even a small change of the plant parameter makes the system unstable even though both the gain margin and the phase margin for the nominal plant are excellent.
Therefore, even a small change of the plant parameter renders the system unstable even though both the gain margin and the phase margin for the nominal plant are excellent.
This is due to the fact that the gain and phase margin are robustness indicators for a *pure* change or gain or a *pure* change of phase but not a combination of both.
This is due to the fact that the gain and phase margin are robustness indicators corresponding a *pure* change or gain or a *pure* change of phase but not a combination of both.
#+end_exampl
Let's now determine a new robustness indicator based on the Nyquist Stability Criteria.
#+begin_definition
- Nyquist Stability Criteria (for stable systems) ::
If the open-loop transfer function $L(s)$ is stable, then the closed-loop system is unstable for any encirclement of the point $−1$ on the Nyquist plot.
If the open-loop transfer function $L(s)$ is stable, then the closed-loop system will be unstable for any encirclement of the point $−1$ on the Nyquist plot.
- Nyquist Plot ::
The Nyquist plot shows the evolution of $L(j\omega)$ in the complex plane from $\omega = 0 \to \infty$.
@ -1586,19 +1598,24 @@ The gain, phase and module margins are graphically shown to have an idea of what
As expected from Figure [[fig:module_margin_example]], 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:
\begin{equation}
\Delta G \ge \frac{\Delta M}{\Delta M - 1}; \quad \Delta \phi \ge \frac{1}{\Delta M}
\Delta G \ge \frac{1}{1 - \Delta M}; \quad \Delta \phi \ge \Delta M
\end{equation}
Let's now try to express the Module margin $\Delta M$ as an $\mathcal{H}_\infty$ norm of a closed-loop transfer function:
\begin{align*}
\Delta M &= \text{minimum distance between } L(j\omega) \text{ and point } (-1) \\
&= \min_\omega |L(j\omega) - (-1)| \\
&= \min_\omega |1 + L(j\omega)| \\
&= \frac{1}{\max_\omega \frac{1}{|1 + L(j\omega)|}} \\
&= \frac{1}{\max_\omega \left| \frac{1}{1 + G(j\omega)K(j\omega)}\right|} \\
&= \frac{1}{\|S\|_\infty}
\end{align*}
Therefore, for a given $\mathcal{H}_\infty$ norm of $S$ ($\|S\|_\infty = M_S$), we have:
\begin{equation}
\Delta G \ge \frac{M_S}{M_S - 1}; \quad \Delta \phi \ge \frac{1}{M_S}
\end{equation}
#+begin_important
The $\mathcal{H}_\infty$ norm of the sensitivity function $\|S\|_\infty$ is a measure of the Module margin $\Delta M$ and therefore an indicator of the system robustness.
@ -1610,7 +1627,7 @@ The wanted robustness of the closed-loop system can be specified by setting a ma
#+end_important
Note that this is why large peak value of $|S(j\omega)|$ usually indicate robustness problems.
And we know understand why setting an upper bound on the magnitude of $S$ is generally a good idea.
And we now understand why setting an upper bound on the magnitude of $S$ is generally a good idea.
#+begin_exampl
Typical, we require $\|S\|_\infty < 2 (6dB)$ which implies $\Delta G \ge 2$ and $\Delta \phi \ge 29^o$
@ -1620,23 +1637,29 @@ And we know understand why setting an upper bound on the magnitude of $S$ is gen
To learn more about module/disk margin, you can check out [[https://www.youtube.com/watch?v=XazdN6eZF80][this]] video.
#+end_seealso
** TODO Other Requirements
** TODO Summary of
<<sec:other_requirements>>
Interpretation of the $\mathcal{H}_\infty$ norm of systems:
- frequency by frequency attenuation / amplification
# Interpretation of the $\mathcal{H}_\infty$ norm of systems:
# - frequency by frequency attenuation / amplification
Let's note $G_t(s)$ the closed-loop transfer function from $w$ to $z$.
# Let's note $G_t(s)$ the closed-loop transfer function from $w$ to $z$.
Consider an input sinusoidal signal $w(t) = \sin\left( \omega_0 t \right)$, then the output signal $z(t)$ will be equal to:
\[ z(t) = A \sin\left( \omega_0 t + \phi \right) \]
with:
- $A = |G_t(j\omega_0)|$ is the magnitude of $G_t(s)$ at $\omega_0$
- $\phi = \angle G_t(j\omega_0)$ is the phase of $G_t(s)$ at $\omega_0$
# Consider an input sinusoidal signal $w(t) = \sin\left( \omega_0 t \right)$, then the output signal $z(t)$ will be equal to:
# \[ z(t) = A \sin\left( \omega_0 t + \phi \right) \]
# with:
# - $A = |G_t(j\omega_0)|$ is the magnitude of $G_t(s)$ at $\omega_0$
# - $\phi = \angle G_t(j\omega_0)$ is the phase of $G_t(s)$ at $\omega_0$
Noise Attenuation: typical wanted shape for $T$
$S$ can be used to set a lower bound on the bandwidth
$T$ can be used to set a higher bound on the bandwidth
$T$ is used to make the system more robust to high frequency model uncertainties
#+name: tab:specification_modern
#+caption: Typical Specifications and corresponding wanted norms of open and closed loop tansfer functions
| | Open-Loop Shaping | Closed-Loop Shaping |
@ -1653,26 +1676,30 @@ Noise Attenuation: typical wanted shape for $T$
** Introduction :ignore:
In the previous sections, we have seen that the performances of the system depends on the *shape* of the closed-loop transfer function.
Therefore, the synthesis problem is to design $K(s)$ such that closed-loop system is stable and such that various closed-loop transfer functions such as $S$, $KS$ and $T$ are shaped as wanted.
Therefore, the synthesis problem is to design $K(s)$ such that closed-loop system is stable and such that the closed-loop transfer functions such as $S$, $KS$ and $T$ are shaped as wanted.
This is clearly not simple as these closed-loop transfer functions does not depend linearly on $K$.
But don't worry, the $\mathcal{H}_\infty$ synthesis will do this job for us!
This
Section [[sec:weighting_functions]]
Section [[sec:weighting_functions_design]]
Section [[sec:sensitivity_shaping_example]]
Section [[sec:shaping_multiple_tf]]
To do so, *weighting functions* are included in the generalized plant and the $\mathcal{H}_\infty$ synthesis applied on the *weighted* generalized plant.
Such procedure is presented in Section [[sec:weighting_functions]].
Some advice on the design of weighting functions are given in Section [[sec:weighting_functions_design]].
An example of the $\mathcal{H}_\infty$ shaping of the sensitivity function is studied in Section [[sec:sensitivity_shaping_example]].
Multiple closed-loop transfer functions can be shaped at the same time.
Such synthesis is usually called *Mixed-sensitivity Loop Shaping* and is one of the most powerful tool of the robust control theory.
Some insight on the use and limitations of such techniques are given in Section [[sec:shaping_multiple_tf]].
** How to Shape closed-loop transfer function? Using Weighting Functions!
<<sec:weighting_functions>>
If the $\mathcal{H}_\infty$ synthesis is applied on the generalized plant $P(s)$ shown in Figure [[fig:loop_shaping_S_without_W]], 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.
This closed-loop transfer function actually correspond to the sensitivity function.
Therefore, it will minimize the the $\mathcal{H}_\infty$ norm of the sensitivity function: $\|S\|_\infty$.
Suppose we apply the $\mathcal{H}_\infty$ synthesis on the generalized plant $P(s)$ shown in Figure [[fig:loop_shaping_S_without_W]].
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 and clearly does not allow to *shape* the norm of $S(j\omega)$ over all frequencies.
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.
#+begin_src latex :file loop_shaping_S_without_W.pdf
\begin{tikzpicture}
@ -1720,9 +1747,9 @@ Let's now show how this is equivalent as *shaping* the sensitivity function:
\end{align}
#+begin_important
As shown in Equation eqref:eq:sensitivity_shaping, the $\mathcal{H}_\infty$ synthesis applying on the /weighted/ generalized plant allows to *shape* the magnitude of the sensitivity transfer function.
As shown in Equation eqref:eq:sensitivity_shaping, the objective of the $\mathcal{H}_\infty$ synthesis applied on the /weighted/ plant is to make the norm sensitivity function smaller than the inverse of the norm of the weighting function, and that at all frequencies.
Therefore, the choice of the weighting function $W_s(s)$ is very important: its inverse magnitude will define the wanted *upper bound* of the sensitivity function magnitude.
Therefore, the choice of the weighting function $W_s(s)$ is very important: its inverse magnitude will define the wanted *upper bound* of the sensitivity function magnitude over all frequencies.
#+end_important
#+begin_src latex :file loop_shaping_S_with_W.pdf
@ -1775,11 +1802,13 @@ The two solutions below can be used.
1 -G];
#+end_src
The second solution is however more general, and can also be used when weights are added at the inputs by post-multiplying instead of pre-multiplying.
#+begin_src matlab :tangle no :eval no
P = [1 -G;
1 -G];
Pw = blkdiag(Ws, 1)*P;
#+end_src
The second solution is however more general, and can also be used when weights are added at the inputs by post-multiplying instead of pre-multiplying.
#+HTML: </details>
#+end_exercice
@ -1797,7 +1826,7 @@ Weighting function included in the generalized plant must be *proper*, *stable*
no zeros in the right half plane
#+end_definition
Matlab is providing the =makeweight= function that allows to design first-order weights by specifying the low frequency gain, high frequency gain, and the gain at a specific frequency:
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:
#+begin_src matlab :tangle no :eval no
W = makeweight(dcgain,[freq,mag],hfgain)
#+end_src
@ -1924,7 +1953,7 @@ The obtained shapes are shown in Figure [[fig:high_order_weight]].
** Shaping the Sensitivity Function
<<sec:sensitivity_shaping_example>>
Let's design a controller using the $\mathcal{H}_\infty$ synthesis that fulfils the following requirements:
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$)
@ -1932,7 +1961,7 @@ Let's design a controller using the $\mathcal{H}_\infty$ synthesis that fulfils
As usual, the plant used is the one presented in Section [[sec:example_system]].
#+begin_exercice
Translate the requirements as upper bounds on the Sensitivity function and design the corresponding Weight using Matlab.
Translate the requirements as upper bounds on the Sensitivity function and design the corresponding weighting functions using Matlab.
#+HTML: <details><summary>Hint</summary>
The typical wanted upper bound of the sensitivity function is shown in Figure [[fig:h-infinity-spec-S-bis]].
@ -1951,6 +1980,7 @@ Remember that the wanted upper bound of the sensitivity function is defined by t
#+HTML: </details>
#+HTML: <details><summary>Answer</summary>
We want to design the weighting function $W_s(s)$ such that:
1. $|W_s(j \cdot 2 \pi 10)| = \sqrt{2}$
2. $|W_s(j \cdot 0)| = 10^3$
3. $\|W_s\|_\infty = 0.5$
@ -2003,7 +2033,7 @@ And the $\mathcal{H}_\infty$ synthesis is performed on the /weighted/ generalize
Best performance (actual): 0.503
#+end_example
$\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:
$\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$:
\begin{aligned}
& \| W_s(s) S(s) \|_\infty \approx 0.5 \\
& \Leftrightarrow |S(j\omega)| < \frac{0.5}{|W_s(j\omega)|} \quad \forall \omega
@ -2012,9 +2042,9 @@ $\gamma \approx 0.5$ means that the $\mathcal{H}_\infty$ synthesis generated a c
This is indeed what we can see by comparing $|S|$ and $|W_S|$ in Figure [[fig:results_sensitivity_hinf]].
#+begin_important
Having $\gamma < 1$ means that the $\mathcal{H}_\infty$ synthesis found a controller such that the specified closed-loop transfer functions are bellow the specified upper bounds.
Obtaining $\gamma < 1$ means that the $\mathcal{H}_\infty$ synthesis found a controller such that the specified closed-loop transfer functions are bellow the specified upper bounds.
Having $\gamma$ slightly above one does not necessary means the obtained controller is not "good".
Yet, obtaining a $\gamma$ slightly above one does not necessary means the synthesis is unsuccessful.
It just means that at some frequency, one of the closed-loop transfer functions is above the specified upper bound by a factor $\gamma$.
#+end_important
@ -2037,17 +2067,19 @@ It just means that at some frequency, one of the closed-loop transfer functions
#+RESULTS:
[[file:figs/results_sensitivity_hinf.png]]
** Shaping multiple closed-loop transfer functions
** Shaping multiple closed-loop transfer functions - Limitations
<<sec:shaping_multiple_tf>>
As was shown in Section [[sec:modern_interpretation_specification]], depending on the specifications, up to four closed-loop transfer function may be shaped (the Gang of four).
This was summarized in Table [[tab:specification_modern]].
*** Introduction :ignore:
For instance to limit the control input $u$, $KS$ should be shaped while to filter measurement noise, $T$ should be shaped.
As was shown in Section [[sec:modern_interpretation_specification]], each of the four main closed-loop transfer functions (called the /gang of four/) will impact different characteristics of the closed-loop system.
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 [[sec:h_infinity_mixed_sensitivity]].
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 measurment 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 [[sec:h_infinity_mixed_sensitivity]].
Depending on the closed-loop transfer function being shaped, different general control configuration are used and are described below.
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.
*** S KS :ignore:
#+HTML: <details><summary>Shaping of S and KS</summary>
@ -2092,6 +2124,10 @@ Depending on the closed-loop transfer function being shaped, different general c
#+RESULTS:
[[file:figs/general_conf_shaping_S_KS.png]]
Weighting functions:
- $W_1(s)$ is used to shape $S$
- $W_2(s)$ is used to shape $KS$
#+name: lst:general_plant_S_KS
#+caption: General Plant definition corresponding to Figure [[fig:general_conf_shaping_S_KS]]
#+begin_src matlab :eval no :tangle no
@ -2099,9 +2135,6 @@ Depending on the closed-loop transfer function being shaped, different general c
0 W2
1 -G];
#+end_src
- $W_1(s)$ is used to shape $S$
- $W_2(s)$ is used to shape $KS$
#+HTML: </details>
*** S T :ignore:
@ -2145,6 +2178,10 @@ Depending on the closed-loop transfer function being shaped, different general c
#+RESULTS:
[[file:figs/general_conf_shaping_S_T.png]]
Weighting functions:
- $W_1$ is used to shape $S$
- $W_2$ is used to shape $T$
#+name: lst:general_plant_S_T
#+caption: General Plant definition corresponding to Figure [[fig:general_conf_shaping_S_T]]
#+begin_src matlab :eval no :tangle no
@ -2152,9 +2189,6 @@ Depending on the closed-loop transfer function being shaped, different general c
0 G*W2
1 -G];
#+end_src
- $W_1$ is used to shape $S$
- $W_2$ is used to shape $T$
#+HTML: </details>
*** S GS :ignore:
@ -2198,6 +2232,10 @@ Depending on the closed-loop transfer function being shaped, different general c
#+RESULTS:
[[file:figs/general_conf_shaping_S_GS.png]]
Weighting functions:
- $W_1$ is used to shape $S$
- $W_2$ is used to shape $GS$
#+name: lst:general_plant_S_GS
#+caption: General Plant definition corresponding to Figure [[fig:general_conf_shaping_S_GS]]
#+begin_src matlab :eval no :tangle no
@ -2205,8 +2243,6 @@ Depending on the closed-loop transfer function being shaped, different general c
G*W2 -G*W2
G -G];
#+end_src
- $W_1$ is used to shape $S$
- $W_2$ is used to shape $GS$
#+HTML: </details>
*** S T KS :ignore:
@ -2255,6 +2291,11 @@ Depending on the closed-loop transfer function being shaped, different general c
#+RESULTS:
[[file:figs/general_conf_shaping_S_T_KS.png]]
Weighting functions:
- $W_1$ is used to shape $S$
- $W_2$ is used to shape $KS$
- $W_3$ is used to shape $T$
#+name: lst:general_plant_S_T_KS
#+caption: General Plant definition corresponding to Figure [[fig:general_conf_shaping_S_T_KS]]
#+begin_src matlab :eval no :tangle no
@ -2263,10 +2304,6 @@ Depending on the closed-loop transfer function being shaped, different general c
0 G*W3
1 -G];
#+end_src
- $W_1$ is used to shape $S$
- $W_2$ is used to shape $KS$
- $W_3$ is used to shape $T$
#+HTML: </details>
*** S T GS :ignore:
@ -2315,6 +2352,11 @@ Depending on the closed-loop transfer function being shaped, different general c
#+RESULTS:
[[file:figs/general_conf_shaping_S_T_GS.png]]
Weighting functions:
- $W_1$ is used to shape $S$
- $W_2$ is used to shape $GS$
- $W_3$ is used to shape $T$
#+name: lst:general_plant_S_T_GS
#+caption: General Plant definition corresponding to Figure [[fig:general_conf_shaping_S_T_GS]]
#+begin_src matlab :eval no :tangle no
@ -2323,10 +2365,6 @@ Depending on the closed-loop transfer function being shaped, different general c
0 W3
G -G];
#+end_src
- $W_1$ is used to shape $S$
- $W_2$ is used to shape $GS$
- $W_3$ is used to shape $T$
#+HTML: </details>
*** S T KS GS :ignore:
@ -2379,6 +2417,12 @@ Depending on the closed-loop transfer function being shaped, different general c
#+RESULTS:
[[file:figs/general_conf_shaping_S_T_KS_GS.png]]
Weighting functions:
- $W_1$ is used to shape $S$
- $W_2$ is used to shape $KS$
- $W_1W_3$ is used to shape $GS$
- $W_2W_3$ is used to shape $T$
#+name: lst:general_plant_S_T_KS_GS
#+caption: General Plant definition corresponding to Figure [[fig:general_conf_shaping_S_T_KS_GS]]
#+begin_src matlab :eval no :tangle no
@ -2386,27 +2430,18 @@ Depending on the closed-loop transfer function being shaped, different general c
0 0 W2
1 -G*W3 -G];
#+end_src
- $W_1$ is used to shape $S$
- $W_2$ is used to shape $KS$
- $W_1W_3$ is used to shape $GS$
- $W_2W_3$ is used to shape $T$
#+HTML: </details>
*** Limitation :ignore:
When shaping multiple closed-loop transfer functions, one should be verify careful about the three following points that are further discussed:
- The shaped closed-loop transfer functions are linked by mathematical relations and cannot be shaped
- Closed-loop transfer function can only be shaped in certain frequency range.
When shaping multiple closed-loop transfer functions, one should be very careful about the three following points that are further discussed:
- The shaped closed-loop transfer functions are linked by mathematical relations and cannot be shaped independently
- Closed-loop transfer function can only be shaped in certain frequency range
- The size of the obtained controller may be very large and not implementable in practice
#+begin_warning
Mathematical relations are linking the closed-loop transfer functions.
For instance, the sensitivity function $S(s)$ and the complementary sensitivity function $T(s)$ as link by the following well known relation:
For instance, the sensitivity function $S(s)$ and the complementary sensitivity function $T(s)$ are linked by the following well known relation:
\begin{equation}
S(s) + T(s) = 1
\end{equation}
@ -2417,13 +2452,17 @@ When shaping multiple closed-loop transfer functions, one should be verify caref
The weighting function should be carefully design such as these fundamental relations are not violated.
#+end_warning
The control bandwidth is clearly limited by physical constrains such as sampling frequency, electronics bandwidth,
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:
\begin{align*}
&|G(j\omega) K(j\omega)| \ll 1 \Longrightarrow |S(j\omega)| = \frac{1}{1 + |G(j\omega)K(j\omega)|} \approx 1 \\
&|G(j\omega) K(j\omega)| \gg 1 \Longrightarrow |S(j\omega)| = \frac{1}{1 + |G(j\omega)K(j\omega)|} \approx \frac{1}{|G(j\omega)K(j\omega)|}
\end{align*}
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$.
#+begin_exercice
@ -2431,9 +2470,9 @@ Determine the approximate norms of $T$, $KS$ and $GS$ for large loop gains ($|G(
#+HTML: <details><summary>Hint</summary>
You can follows this procedure for $T$, $KS$ and $GS$:
1. Write the closed-loop transfer function $T(s)$ as a function of $K(s)$ and $G(s)$
2. Take $|K(j\omega)G(j\omega)| \gg 1$ and conclude on $|T(j\omega)|$
3. Take $|K(j\omega)G(j\omega)| \ll 1$ and conclude on $|T(j\omega)|$
1. Write the closed-loop transfer function as a function of $K(s)$ and $G(s)$
2. Take $|K(j\omega)G(j\omega)| \gg 1$ and conclude on the norm of the closed-loop transfer function
3. Take $|K(j\omega)G(j\omega)| \ll 1$ and conclude
#+HTML: </details>
#+HTML: <details><summary>Answer</summary>
@ -2441,8 +2480,8 @@ The obtained constrains are shown in Figure [[fig:h-infinity-4-blocs-constrains]
#+HTML: </details>
#+end_exercice
Depending on the frequency band, the norms of the closed-loop transfer functions depend on the controller $K$ and therefore can be shaped.
However, in some frequency bands, the norms do not depend on the controller and therefore *cannot* be shaped.
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 [[fig:h-infinity-4-blocs-constrains]].
@ -2507,13 +2546,14 @@ These regions are summarized in Figure [[fig:h-infinity-4-blocs-constrains]].
#+end_src
#+name: fig:h-infinity-4-blocs-constrains
#+caption: Shaping the Gang of Four: Limitations
#+caption: Shaping the Gang of Four. Blue regions indicate that the transfer function can be shaped using $K$. Red regions indicate this is not the case
#+RESULTS:
[[file:figs/h-infinity-4-blocs-constrains.png]]
#+begin_warning
The order (resp. number of state) of the controller given by the $\mathcal{H}_\infty$ synthesis is equal to the order (resp. number of state) of the weighted generalized plant.
The order (e.g. number of state) of the controller given by the $\mathcal{H}_\infty$ synthesis is equal to the order (e.g. number of state) of the weighted generalized plant.
It is thus equal to the *sum* of the number of state of the non-weighted generalized plant and the number of state of all the weighting functions.
Then, the $\mathcal{H}_\infty$ synthesis usually generate a controller with a very high order that is not implementable in practice.
Two approaches can be used to obtain controllers with reasonable order:
1. use simple weights (usually first order)