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

1683 lines
61 KiB
HTML
Raw Blame History

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en">
<head>
<!-- 2020-11-30 lun. 17:44 -->
<meta http-equiv="Content-Type" content="text/html;charset=utf-8" />
<title>A brief and practical introduction to \(\mathcal{H}_\infty\) Control</title>
<meta name="generator" content="Org mode" />
<meta name="author" content="Dehaeze Thomas" />
<link rel="stylesheet" type="text/css" href="https://research.tdehaeze.xyz/css/style.css"/>
<script type="text/javascript" src="https://research.tdehaeze.xyz/js/script.js"></script>
<script>MathJax = {
tex: {
tags: 'ams',
macros: {bm: ["\\boldsymbol{#1}",1],}
}
};
</script>
<script type="text/javascript" src="https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js"></script>
</head>
<body>
<div id="org-div-home-and-up">
<a accesskey="h" href="../index.html"> UP </a>
|
<a accesskey="H" href="../index.html"> HOME </a>
</div><div id="content">
<h1 class="title">A brief and practical introduction to \(\mathcal{H}_\infty\) Control</h1>
<div id="table-of-contents">
<h2>Table of Contents</h2>
<div id="text-table-of-contents">
<ul>
<li><a href="#org83646bd">1. Introduction to the Control Methodology - Model Based Control</a>
<ul>
<li><a href="#org3183a7b">1.1. Model Based Control - Methodology</a></li>
<li><a href="#org0d1d22d">1.2. Some Background: From Classical Control to Robust Control</a></li>
<li><a href="#org660e097">1.3. Example System</a></li>
</ul>
</li>
<li><a href="#org6b26771">2. Classical Open Loop Shaping</a>
<ul>
<li><a href="#orga538a88">2.1. Introduction to Loop Shaping</a></li>
<li><a href="#org972c29f">2.2. Example of Open Loop Shaping</a></li>
<li><a href="#orgdadb2c3">2.3. \(\mathcal{H}_\infty\) Loop Shaping Synthesis</a></li>
<li><a href="#org1a6689f">2.4. Example of the \(\mathcal{H}_\infty\) Loop Shaping Synthesis</a></li>
</ul>
</li>
<li><a href="#orgc213f91">3. First Steps in the \(\mathcal{H}_\infty\) world</a>
<ul>
<li><a href="#org021e3fe">3.1. The \(\mathcal{H}_\infty\) Norm</a></li>
<li><a href="#org96f76b0">3.2. \(\mathcal{H}_\infty\) Synthesis</a></li>
<li><a href="#orgefb0a59">3.3. The Generalized Plant</a></li>
<li><a href="#org4ae085b">3.4. The General Synthesis Problem Formulation</a></li>
<li><a href="#org0686082">3.5. From a Classical Feedback Architecture to a Generalized Plant</a></li>
</ul>
</li>
<li><a href="#org2cbfd77">4. Modern Interpretation of the Control Specifications</a>
<ul>
<li><a href="#org6326f86">4.1. Introduction</a></li>
<li><a href="#org3082f31">4.2. Closed Loop Transfer Functions</a></li>
<li><a href="#orgb0f4517">4.3. Sensitivity Transfer Function</a></li>
<li><a href="#org4b98ec3">4.4. Robustness: Module Margin</a></li>
<li><a href="#org0dd555d">4.5. How to <b>Shape</b> transfer function? Using of Weighting Functions!</a></li>
<li><a href="#org828800a">4.6. Design of Weighting Functions</a></li>
<li><a href="#org7b75b54">4.7. Sensitivity Function Shaping - Example</a></li>
</ul>
</li>
<li><a href="#org69e4106">5. \(\mathcal{H}_\infty\) Mixed-Sensitivity Synthesis</a>
<ul>
<li><a href="#org7551557">5.1. Problem</a></li>
<li><a href="#org591ee3f">5.2. Typical Procedure</a></li>
<li><a href="#org5f909bc">5.3. Step 1 - Shaping of the Sensitivity Function</a></li>
<li><a href="#org7e69dbf">5.4. Step 2 - Shaping of</a></li>
</ul>
</li>
<li><a href="#org7f2c9ea">6. Conclusion</a></li>
<li><a href="#org9e8b015">7. Resources</a></li>
</ul>
</div>
</div>
<div id="outline-container-org83646bd" class="outline-2">
<h2 id="org83646bd"><span class="section-number-2">1</span> Introduction to the Control Methodology - Model Based Control</h2>
<div class="outline-text-2" id="text-1">
<p>
<a id="org1aef069"></a>
</p>
</div>
<div id="outline-container-org3183a7b" class="outline-3">
<h3 id="org3183a7b"><span class="section-number-3">1.1</span> Model Based Control - Methodology</h3>
<div class="outline-text-3" id="text-1-1">
<p>
<a id="org9893f36"></a>
</p>
<p>
The typical methodology when applying Model Based Control to a plant is schematically shown in Figure <a href="#org422de71">1</a>.
It consists of three steps:
</p>
<ol class="org-ol">
<li><b>Identification or modeling</b>: \(\Longrightarrow\) mathematical model</li>
<li><b>Translate the specifications into mathematical criteria</b>:
<ul class="org-ul">
<li><span class="underline">Specifications</span>: Response Time, Noise Rejection, Maximum input amplitude, Robustness, &#x2026;</li>
<li><span class="underline">Mathematical Criteria</span>: Cost Function, Shape of TF</li>
</ul></li>
<li><b>Synthesis</b>: research of \(K\) that satisfies the specifications for the model of the system</li>
</ol>
<div id="org422de71" class="figure">
<p><img src="figs/control-procedure.png" alt="control-procedure.png" />
</p>
<p><span class="figure-number">Figure 1: </span>Typical Methodoly for Model Based Control</p>
</div>
<p>
In this document, we will mainly focus on steps 2 and 3.
</p>
</div>
</div>
<div id="outline-container-org0d1d22d" class="outline-3">
<h3 id="org0d1d22d"><span class="section-number-3">1.2</span> Some Background: From Classical Control to Robust Control</h3>
<div class="outline-text-3" id="text-1-2">
<p>
<a id="org3d134dd"></a>
</p>
<table id="org4cfc8bd" border="2" cellspacing="0" cellpadding="6" rules="groups" frame="hsides">
<caption class="t-above"><span class="table-number">Table 1:</span> Table summurazing the main differences between classical, modern and robust control</caption>
<colgroup>
<col class="org-left" />
<col class="org-center" />
<col class="org-center" />
<col class="org-center" />
</colgroup>
<thead>
<tr>
<th scope="col" class="org-left">&#xa0;</th>
<th scope="col" class="org-center"><b>Classical Control</b></th>
<th scope="col" class="org-center"><b>Modern Control</b></th>
<th scope="col" class="org-center"><b>Robust Control</b></th>
</tr>
</thead>
<tbody>
<tr>
<td class="org-left"><b>Date</b></td>
<td class="org-center">1930-</td>
<td class="org-center">1960-</td>
<td class="org-center">1980-</td>
</tr>
</tbody>
<tbody>
<tr>
<td class="org-left"><b>Tools</b></td>
<td class="org-center">Transfer Functions</td>
<td class="org-center">State Space formulation</td>
<td class="org-center">Systems and Signals Norms (\(\mathcal{H}_\infty\), \(\mathcal{H}_2\) Norms)</td>
</tr>
<tr>
<td class="org-left">&#xa0;</td>
<td class="org-center">Nyquist Plots</td>
<td class="org-center">Riccati Equations</td>
<td class="org-center">Closed Loop Transfer Functions</td>
</tr>
<tr>
<td class="org-left">&#xa0;</td>
<td class="org-center">Bode Plots</td>
<td class="org-center">&#xa0;</td>
<td class="org-center">Open/Closed Loop Shaping</td>
</tr>
<tr>
<td class="org-left">&#xa0;</td>
<td class="org-center">Phase and Gain margins</td>
<td class="org-center">&#xa0;</td>
<td class="org-center">Weighting Functions</td>
</tr>
<tr>
<td class="org-left">&#xa0;</td>
<td class="org-center">&#xa0;</td>
<td class="org-center">&#xa0;</td>
<td class="org-center">Disk margin</td>
</tr>
</tbody>
<tbody>
<tr>
<td class="org-left"><b>Control Architectures</b></td>
<td class="org-center">Proportional, Integral, Derivative</td>
<td class="org-center">Full State Feedback</td>
<td class="org-center">General Control Configuration</td>
</tr>
<tr>
<td class="org-left">&#xa0;</td>
<td class="org-center">Leads, Lags</td>
<td class="org-center">LQR, LQG</td>
<td class="org-center">&#xa0;</td>
</tr>
<tr>
<td class="org-left">&#xa0;</td>
<td class="org-center">&#xa0;</td>
<td class="org-center">Kalman Filters</td>
<td class="org-center">&#xa0;</td>
</tr>
</tbody>
<tbody>
<tr>
<td class="org-left"><b>Advantages</b></td>
<td class="org-center">Study Stability</td>
<td class="org-center">Automatic Synthesis</td>
<td class="org-center">Automatic Synthesis</td>
</tr>
<tr>
<td class="org-left">&#xa0;</td>
<td class="org-center">Simple</td>
<td class="org-center">MIMO</td>
<td class="org-center">MIMO</td>
</tr>
<tr>
<td class="org-left">&#xa0;</td>
<td class="org-center">Natural</td>
<td class="org-center">Optimization Problem</td>
<td class="org-center">Optimization Problem</td>
</tr>
<tr>
<td class="org-left">&#xa0;</td>
<td class="org-center">&#xa0;</td>
<td class="org-center">&#xa0;</td>
<td class="org-center">Guaranteed Robustness</td>
</tr>
<tr>
<td class="org-left">&#xa0;</td>
<td class="org-center">&#xa0;</td>
<td class="org-center">&#xa0;</td>
<td class="org-center">Easy specification of performances</td>
</tr>
</tbody>
<tbody>
<tr>
<td class="org-left"><b>Disadvantages</b></td>
<td class="org-center">Manual Method</td>
<td class="org-center">No Guaranteed Robustness</td>
<td class="org-center">Required knowledge of specific tools</td>
</tr>
<tr>
<td class="org-left">&#xa0;</td>
<td class="org-center">Only SISO</td>
<td class="org-center">Difficult Rejection of Perturbations</td>
<td class="org-center">Need a reasonably good model of the system</td>
</tr>
</tbody>
</table>
</div>
</div>
<div id="outline-container-org660e097" class="outline-3">
<h3 id="org660e097"><span class="section-number-3">1.3</span> Example System</h3>
<div class="outline-text-3" id="text-1-3">
<p>
<a id="org1315ed5"></a>
</p>
<p>
Let&rsquo;s consider the model shown in Figure <a href="#org46d704d">2</a>.
It could represent a suspension system with a payload to position or isolate using an force actuator and an inertial sensor.
The notations used are listed in Table <a href="#org527e3a9">2</a>.
</p>
<div id="org46d704d" class="figure">
<p><img src="figs/mech_sys_1dof_inertial_contr.png" alt="mech_sys_1dof_inertial_contr.png" />
</p>
<p><span class="figure-number">Figure 2: </span>Test System consisting of a payload with a mass \(m\) on top of an active system with a stiffness \(k\), damping \(c\) and an actuator. A feedback controller \(K(s)\) is added to position / isolate the payload.</p>
</div>
<table id="org527e3a9" border="2" cellspacing="0" cellpadding="6" rules="groups" frame="hsides">
<caption class="t-above"><span class="table-number">Table 2:</span> Example system variables</caption>
<colgroup>
<col class="org-left" />
<col class="org-left" />
<col class="org-left" />
<col class="org-left" />
</colgroup>
<thead>
<tr>
<th scope="col" class="org-left"><b>Notation</b></th>
<th scope="col" class="org-left"><b>Description</b></th>
<th scope="col" class="org-left"><b>Value</b></th>
<th scope="col" class="org-left"><b>Unit</b></th>
</tr>
</thead>
<tbody>
<tr>
<td class="org-left">\(m\)</td>
<td class="org-left">Payload&rsquo;s mass to position / isolate</td>
<td class="org-left">\(10\)</td>
<td class="org-left">[kg]</td>
</tr>
<tr>
<td class="org-left">\(k\)</td>
<td class="org-left">Stiffness of the suspension system</td>
<td class="org-left">\(10^6\)</td>
<td class="org-left">[N/m]</td>
</tr>
<tr>
<td class="org-left">\(c\)</td>
<td class="org-left">Damping coefficient of the suspension system</td>
<td class="org-left">\(400\)</td>
<td class="org-left">[N/(m/s)]</td>
</tr>
<tr>
<td class="org-left">\(y\)</td>
<td class="org-left">Payload absolute displacement (measured by an inertial sensor)</td>
<td class="org-left">&#xa0;</td>
<td class="org-left">[m]</td>
</tr>
<tr>
<td class="org-left">\(d\)</td>
<td class="org-left">Ground displacement, it acts as a disturbance</td>
<td class="org-left">&#xa0;</td>
<td class="org-left">[m]</td>
</tr>
<tr>
<td class="org-left">\(u\)</td>
<td class="org-left">Actuator force</td>
<td class="org-left">&#xa0;</td>
<td class="org-left">[N]</td>
</tr>
<tr>
<td class="org-left">\(r\)</td>
<td class="org-left">Wanted position of the mass (the reference)</td>
<td class="org-left">&#xa0;</td>
<td class="org-left">[m]</td>
</tr>
<tr>
<td class="org-left">\(\epsilon = r - y\)</td>
<td class="org-left">Position error</td>
<td class="org-left">&#xa0;</td>
<td class="org-left">[m]</td>
</tr>
<tr>
<td class="org-left">\(K\)</td>
<td class="org-left">Feedback controller</td>
<td class="org-left">to be designed</td>
<td class="org-left">[N/m]</td>
</tr>
</tbody>
</table>
<div class="exercice" id="orga7a3944">
<p>
Derive the following open-loop transfer functions:
</p>
\begin{align}
G(s) &= \frac{y}{u} \\
G_d(s) &= \frac{y}{d}
\end{align}
<details><summary>Hint</summary>
<p>
You can follow this generic procedure:
</p>
<ol class="org-ol">
<li>List all applied forces ot the mass: Actuator force, Stiffness force (Hooke&rsquo;s law), &#x2026;</li>
<li>Apply the Newton&rsquo;s Second Law on the payload
\[ m \ddot{y} = \Sigma F \]</li>
<li>Transform the differential equations into the Laplace domain:
\[ \frac{d\ \cdot}{dt} \Leftrightarrow \cdot \times s \]</li>
<li>Write \(y(s)\) as a function of \(u(s)\) and \(w(s)\)</li>
</ol>
</details>
<details><summary>Results</summary>
\begin{align}
G(s) &= \frac{1}{m s^2 + cs + k} \\
G_d(s) &= \frac{cs + k}{m s^2 + cs + k}
\end{align}
</details>
</div>
<p>
Hi Musa,
Thank you very much for sharing this awesome package.
For a long time, I am dreaming of being abble to export source blocks to HTML tha are surounded by &lt;details&gt; blocks.
</p>
<p>
For now, I am manually adding #+HTML: &lt;details&gt;&lt;summary&gt;Code&lt;/summary&gt; and #+HTML: &lt;/details&gt; around the source blocks I want to hide&#x2026;
This is a very simple solution, but not so elegent nor practical.
</p>
<p>
Do you have any idea if it would be easy to extend to org-mode export of source blocks to add such functionallity?
</p>
<p>
Similarly, I would love to be able to export a &lt;span&gt; block with the name of the file corresponding to the source block.
For instance, if a particular source block is tangled to script.sh, it would be so nice to display the filename when exporting!
</p>
<p>
Thanks in advance
</p>
<p>
Having obtained \(G(s)\) and \(G_d(s)\), we can transform the system shown in Figure <a href="#org46d704d">2</a> into a classical feedback form as shown in Figure <a href="#orgbc89f8b">6</a>.
</p>
<div id="org6516d22" class="figure">
<p><img src="figs/classical_feedback_test_system.png" alt="classical_feedback_test_system.png" />
</p>
<p><span class="figure-number">Figure 3: </span>Block diagram corresponding to the example system</p>
</div>
<p>
Let&rsquo;s define the system parameters on Matlab.
</p>
<div class="org-src-container">
<pre class="src src-matlab"><span class="linenr">1: </span>k = 1e6; <span class="org-comment">% Stiffness [N/m]</span>
<span class="linenr">2: </span>c = 4e2; <span class="org-comment">% Damping [N/(m/s)]</span>
<span class="linenr">3: </span>m = 10; <span class="org-comment">% Mass [kg]</span>
</pre>
</div>
<p>
And now the system dynamics \(G(s)\) and \(G_d(s)\) (their bode plots are shown in Figures <a href="#org340906b">4</a> and <a href="#orgd17c84a">5</a>).
</p>
<div class="org-src-container">
<pre class="src src-matlab"><span class="linenr">4: </span>G = 1<span class="org-type">/</span>(m<span class="org-type">*</span>s<span class="org-type">^</span>2 <span class="org-type">+</span> c<span class="org-type">*</span>s <span class="org-type">+</span> k); <span class="org-comment">% Plant</span>
<span class="linenr">5: </span>Gd = (c<span class="org-type">*</span>s <span class="org-type">+</span> k)<span class="org-type">/</span>(m<span class="org-type">*</span>s<span class="org-type">^</span>2 <span class="org-type">+</span> c<span class="org-type">*</span>s <span class="org-type">+</span> k); <span class="org-comment">% Disturbance</span>
</pre>
</div>
<div id="org340906b" class="figure">
<p><img src="figs/bode_plot_example_afm.png" alt="bode_plot_example_afm.png" />
</p>
<p><span class="figure-number">Figure 4: </span>Bode plot of the plant \(G(s)\)</p>
</div>
<div id="orgd17c84a" class="figure">
<p><img src="figs/bode_plot_example_Gd.png" alt="bode_plot_example_Gd.png" />
</p>
<p><span class="figure-number">Figure 5: </span>Magnitude of the disturbance transfer function \(G_d(s)\)</p>
</div>
</div>
</div>
</div>
<div id="outline-container-org6b26771" class="outline-2">
<h2 id="org6b26771"><span class="section-number-2">2</span> Classical Open Loop Shaping</h2>
<div class="outline-text-2" id="text-2">
<p>
<a id="orgc9f517e"></a>
</p>
</div>
<div id="outline-container-orga538a88" class="outline-3">
<h3 id="orga538a88"><span class="section-number-3">2.1</span> Introduction to Loop Shaping</h3>
<div class="outline-text-3" id="text-2-1">
<p>
<a id="org3e53bfd"></a>
</p>
<div class="definition" id="org73e8d85">
<p>
<b>Loop Shaping</b> refers to a design procedure that involves explicitly shaping the magnitude of the <b>Loop Transfer Function</b> \(L(s)\).
</p>
</div>
<div class="definition" id="org3bb21e8">
<p>
The <b>Loop Gain</b> \(L(s)\) usually refers to as the product of the controller and the plant (&ldquo;Gain around the loop&rdquo;, see Figure <a href="#orgbc89f8b">6</a>):
</p>
\begin{equation}
L(s) = G(s) \cdot K(s) \label{eq:loop_gain}
\end{equation}
<div id="orgbc89f8b" class="figure">
<p><img src="figs/open_loop_shaping.png" alt="open_loop_shaping.png" />
</p>
<p><span class="figure-number">Figure 6: </span>Classical Feedback Architecture</p>
</div>
</div>
<p>
This synthesis method is widely used as many characteristics of the closed-loop system depend on the shape of the open loop gain \(L(s)\) such as:
</p>
<ul class="org-ul">
<li><b>Performance</b>: \(L\) large</li>
<li><b>Good disturbance rejection</b>: \(L\) large</li>
<li><b>Limitation of measurement noise on plant output</b>: \(L\) small</li>
<li><b>Small magnitude of input signal</b>: \(K\) and \(L\) small</li>
<li><b>Nominal stability</b>: \(L\) small (RHP zeros and time delays)</li>
<li><b>Robust stability</b>: \(L\) small (neglected dynamics)</li>
</ul>
<p>
The Open Loop shape is usually done manually has the loop gain \(L(s)\) depends linearly on \(K(s)\) \eqref{eq:loop_gain}.
</p>
<p>
\(K(s)\) then consists of a combination of leads, lags, notches, etc. such that \(L(s)\) has the wanted shape (an example is shown in Figure <a href="#orga3156c8">7</a>).
</p>
<div id="orga3156c8" class="figure">
<p><img src="figs/open_loop_shaping_shape.png" alt="open_loop_shaping_shape.png" />
</p>
<p><span class="figure-number">Figure 7: </span>Typical Wanted Shape for the Loop Gain \(L(s)\)</p>
</div>
</div>
</div>
<div id="outline-container-org972c29f" class="outline-3">
<h3 id="org972c29f"><span class="section-number-3">2.2</span> Example of Open Loop Shaping</h3>
<div class="outline-text-3" id="text-2-2">
<p>
<a id="org379e0f7"></a>
</p>
<div class="exampl" id="org67ed3da">
<p>
Let&rsquo;s take our example system and try to apply the Open-Loop shaping strategy to design a controller that fulfils the following specifications:
</p>
<ul class="org-ul">
<li><b>Performance</b>: Bandwidth of approximately 10Hz</li>
<li><b>Noise Attenuation</b>: Roll-off of -40dB/decade past 30Hz</li>
<li><b>Robustness</b>: Gain margin &gt; 3dB and Phase margin &gt; 30 deg</li>
</ul>
</div>
<div class="exercice" id="org99ef999">
<p>
Using <code>SISOTOOL</code>, design a controller that fulfill the specifications.
</p>
<div class="org-src-container">
<pre class="src src-matlab">sisotool(G)
</pre>
</div>
</div>
<p>
In order to have the wanted Roll-off, two integrators are used, a lead is also added to have sufficient phase margin.
</p>
<p>
The obtained controller is shown below, and the bode plot of the Loop Gain is shown in Figure <a href="#org13c7803">8</a>.
</p>
<div class="org-src-container">
<pre class="src src-matlab">K = 14e8 <span class="org-type">*</span> ...<span class="org-comment"> % Gain</span>
1<span class="org-type">/</span>(s<span class="org-type">^</span>2) <span class="org-type">*</span> ...<span class="org-comment"> % Double Integrator</span>
1<span class="org-type">/</span>(1 <span class="org-type">+</span> s<span class="org-type">/</span>2<span class="org-type">/</span><span class="org-constant">pi</span><span class="org-type">/</span>40) <span class="org-type">*</span> ...<span class="org-comment"> % Low Pass Filter</span>
(1 <span class="org-type">+</span> s<span class="org-type">/</span>(2<span class="org-type">*</span><span class="org-constant">pi</span><span class="org-type">*</span>10<span class="org-type">/</span>sqrt(8)))<span class="org-type">/</span>(1 <span class="org-type">+</span> s<span class="org-type">/</span>(2<span class="org-type">*</span><span class="org-constant">pi</span><span class="org-type">*</span>10<span class="org-type">*</span>sqrt(8))); <span class="org-comment">% Lead</span>
</pre>
</div>
<div id="org13c7803" class="figure">
<p><img src="figs/loop_gain_manual_afm.png" alt="loop_gain_manual_afm.png" />
</p>
<p><span class="figure-number">Figure 8: </span>Bode Plot of the obtained Loop Gain \(L(s) = G(s) K(s)\)</p>
</div>
<p>
And we can verify that we have the wanted stability margins:
</p>
<div class="org-src-container">
<pre class="src src-matlab">[Gm, Pm, <span class="org-type">~</span>, Wc] = margin(G<span class="org-type">*</span>K)
</pre>
</div>
<table border="2" cellspacing="0" cellpadding="6" rules="groups" frame="hsides">
<colgroup>
<col class="org-left" />
<col class="org-right" />
</colgroup>
<thead>
<tr>
<th scope="col" class="org-left">Requirements</th>
<th scope="col" class="org-right">Manual Method</th>
</tr>
</thead>
<tbody>
<tr>
<td class="org-left">Gain Margin \(> 3\) [dB]</td>
<td class="org-right">3.1</td>
</tr>
<tr>
<td class="org-left">Phase Margin \(> 30\) [deg]</td>
<td class="org-right">35.4</td>
</tr>
<tr>
<td class="org-left">Crossover \(\approx 10\) [Hz]</td>
<td class="org-right">10.1</td>
</tr>
</tbody>
</table>
</div>
</div>
<div id="outline-container-orgdadb2c3" class="outline-3">
<h3 id="orgdadb2c3"><span class="section-number-3">2.3</span> \(\mathcal{H}_\infty\) Loop Shaping Synthesis</h3>
<div class="outline-text-3" id="text-2-3">
<p>
<a id="org4e92db7"></a>
</p>
<p>
The Open Loop Shaping synthesis can be performed using the \(\mathcal{H}_\infty\) Synthesis.
</p>
<p>
Even though we will not go into details, we will provide one example.
</p>
<p>
Using Matlab, the \(\mathcal{H}_\infty\) Loop Shaping Synthesis can be performed using the <code>loopsyn</code> command:
</p>
<div class="org-src-container">
<pre class="src src-matlab">K = loopsyn(G, Gd);
</pre>
</div>
<p>
where:
</p>
<ul class="org-ul">
<li><code>G</code> is the (LTI) plant</li>
<li><code>Gd</code> is the wanted loop shape</li>
<li><code>K</code> is the synthesize controller</li>
</ul>
<div class="seealso" id="org56dd6e3">
<p>
Matlab documentation of <code>loopsyn</code> (<a href="https://www.mathworks.com/help/robust/ref/loopsyn.html">link</a>).
</p>
</div>
</div>
</div>
<div id="outline-container-org1a6689f" class="outline-3">
<h3 id="org1a6689f"><span class="section-number-3">2.4</span> Example of the \(\mathcal{H}_\infty\) Loop Shaping Synthesis</h3>
<div class="outline-text-3" id="text-2-4">
<p>
<a id="org56e4448"></a>
</p>
<p>
Let&rsquo;s reuse the previous plant.
</p>
<p>
Translate the specification into the wanted shape of the open loop gain.
</p>
<ul class="org-ul">
<li><b>Performance</b>: Bandwidth of approximately 10Hz: \(|L_w(j2 \pi 10)| = 1\)</li>
<li><b>Noise Attenuation</b>: Roll-off of -40dB/decade past 30Hz</li>
<li><b>Robustness</b>: Gain margin &gt; 3dB and Phase margin &gt; 30 deg</li>
</ul>
<div class="org-src-container">
<pre class="src src-matlab">Lw = 2.3e3 <span class="org-type">*</span> ...
1<span class="org-type">/</span>(s<span class="org-type">^</span>2) <span class="org-type">*</span> ...<span class="org-comment"> % Double Integrator</span>
(1 <span class="org-type">+</span> s<span class="org-type">/</span>(2<span class="org-type">*</span><span class="org-constant">pi</span><span class="org-type">*</span>10<span class="org-type">/</span>sqrt(3)))<span class="org-type">/</span>(1 <span class="org-type">+</span> s<span class="org-type">/</span>(2<span class="org-type">*</span><span class="org-constant">pi</span><span class="org-type">*</span>10<span class="org-type">*</span>sqrt(3))); <span class="org-comment">% Lead</span>
</pre>
</div>
<p>
The \(\mathcal{H}_\infty\) optimal open loop shaping synthesis is performed using the <code>loopsyn</code> command:
</p>
<div class="org-src-container">
<pre class="src src-matlab">[K, <span class="org-type">~</span>, GAM] = loopsyn(G, Lw);
</pre>
</div>
<p>
The Bode plot of the obtained controller is shown in Figure <a href="#org3e6237d">9</a>.
</p>
<div class="important" id="org1e084ea">
<p>
It is always important to analyze the controller after the synthesis is performed.
</p>
<p>
In the end, a synthesize controller is just a combination of low pass filters, high pass filters, notches, leads, etc.
</p>
</div>
<p>
Let&rsquo;s briefly analyze this controller:
</p>
<ul class="org-ul">
<li>two integrators are used at low frequency to have the wanted low frequency high gain</li>
<li>a lead is added centered with the crossover frequency to increase the phase margin</li>
<li>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)</li>
</ul>
<div id="org3e6237d" class="figure">
<p><img src="figs/open_loop_shaping_hinf_K.png" alt="open_loop_shaping_hinf_K.png" />
</p>
<p><span class="figure-number">Figure 9: </span>Obtained controller \(K\) using the open-loop \(\mathcal{H}_\infty\) shaping</p>
</div>
<p>
The obtained Loop Gain is shown in Figure <a href="#orgf78bc2a">10</a>.
</p>
<div id="orgf78bc2a" class="figure">
<p><img src="figs/open_loop_shaping_hinf_L.png" alt="open_loop_shaping_hinf_L.png" />
</p>
<p><span class="figure-number">Figure 10: </span>Obtained Open Loop Gain \(L(s) = G(s) K(s)\) and comparison with the wanted Loop gain \(L_w\)</p>
</div>
<p>
Let&rsquo;s now compare the obtained stability margins of the \(\mathcal{H}_\infty\) controller and of the manually developed controller in Table <a href="#org83f2c59">3</a>.
</p>
<table id="org83f2c59" border="2" cellspacing="0" cellpadding="6" rules="groups" frame="hsides">
<caption class="t-above"><span class="table-number">Table 3:</span> Comparison of the characteristics obtained with the two methods</caption>
<colgroup>
<col class="org-left" />
<col class="org-right" />
<col class="org-right" />
</colgroup>
<thead>
<tr>
<th scope="col" class="org-left">Specifications</th>
<th scope="col" class="org-right">Manual Method</th>
<th scope="col" class="org-right">\(\mathcal{H}_\infty\) Method</th>
</tr>
</thead>
<tbody>
<tr>
<td class="org-left">Gain Margin \(> 3\) [dB]</td>
<td class="org-right">3.1</td>
<td class="org-right">31.7</td>
</tr>
<tr>
<td class="org-left">Phase Margin \(> 30\) [deg]</td>
<td class="org-right">35.4</td>
<td class="org-right">54.7</td>
</tr>
<tr>
<td class="org-left">Crossover \(\approx 10\) [Hz]</td>
<td class="org-right">10.1</td>
<td class="org-right">9.9</td>
</tr>
</tbody>
</table>
</div>
</div>
</div>
<div id="outline-container-orgc213f91" class="outline-2">
<h2 id="orgc213f91"><span class="section-number-2">3</span> First Steps in the \(\mathcal{H}_\infty\) world</h2>
<div class="outline-text-2" id="text-3">
<p>
<a id="orgf7a1df7"></a>
</p>
</div>
<div id="outline-container-org021e3fe" class="outline-3">
<h3 id="org021e3fe"><span class="section-number-3">3.1</span> The \(\mathcal{H}_\infty\) Norm</h3>
<div class="outline-text-3" id="text-3-1">
<p>
<a id="orgb6c24fc"></a>
</p>
<div class="definition" id="org04f45c6">
<p>
The \(\mathcal{H}_\infty\) norm is defined as the peak of the maximum singular value of the frequency response
</p>
\begin{equation}
\|G(s)\|_\infty = \max_\omega \bar{\sigma}\big( G(j\omega) \big)
\end{equation}
<p>
For a SISO system \(G(s)\), it is simply the peak value of \(|G(j\omega)|\) as a function of frequency:
</p>
\begin{equation}
\|G(s)\|_\infty = \max_{\omega} |G(j\omega)| \label{eq:hinf_norm_siso}
\end{equation}
</div>
<div class="exampl" id="org39b3b86">
<p>
Let&rsquo;s compute the \(\mathcal{H}_\infty\) norm of our test plant \(G(s)\) using the <code>hinfnorm</code> function:
</p>
<div class="org-src-container">
<pre class="src src-matlab">hinfnorm(G)
</pre>
</div>
<pre class="example">
7.9216e-06
</pre>
<p>
We can see that the \(\mathcal{H}_\infty\) norm of \(G(s)\) does corresponds to the peak value of \(|G(j\omega)|\) as a function of frequency as shown in Figure <a href="#org1cbaeca">11</a>.
</p>
<div id="org1cbaeca" class="figure">
<p><img src="figs/hinfinity_norm_siso_bode.png" alt="hinfinity_norm_siso_bode.png" />
</p>
<p><span class="figure-number">Figure 11: </span>Example of the \(\mathcal{H}_\infty\) norm of a SISO system</p>
</div>
</div>
</div>
</div>
<div id="outline-container-org96f76b0" class="outline-3">
<h3 id="org96f76b0"><span class="section-number-3">3.2</span> \(\mathcal{H}_\infty\) Synthesis</h3>
<div class="outline-text-3" id="text-3-2">
<p>
<a id="org069850a"></a>
</p>
<div class="definition" id="orgb559ab4">
<p>
\(\mathcal{H}_\infty\) synthesis is a method that uses an <b>algorithm</b> (LMI optimization, Riccati equation) to find a controller that stabilize the system and that <b>minimizes</b> the \(\mathcal{H}_\infty\) norms of defined transfer functions.
</p>
</div>
<p>
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.
</p>
<p>
Then applying the \(\mathcal{H}_\infty\) synthesis to a plant, the engineer work usually consists of the following steps
</p>
<ol class="org-ol">
<li>Write the problem as standard \(\mathcal{H}_\infty\) problem</li>
<li>Translate the specifications as \(\mathcal{H}_\infty\) norms of transfer functions</li>
<li>Make the synthesis and analyze the obtain controller</li>
<li>Reduce the order of the controller for implementation</li>
</ol>
<p>
Note that there are many ways to use the \(\mathcal{H}_\infty\) Synthesis:
</p>
<ul class="org-ul">
<li>Traditional \(\mathcal{H}_\infty\) Synthesis (<code>hinfsyn</code> <a href="https://www.mathworks.com/help/robust/ref/hinfsyn.html">doc</a>)</li>
<li>Open Loop Shaping \(\mathcal{H}_\infty\) Synthesis (<code>loopsyn</code> <a href="https://www.mathworks.com/help/robust/ref/loopsyn.html">doc</a>)</li>
<li>Mixed Sensitivity Loop Shaping (<code>mixsyn</code> <a href="https://www.mathworks.com/help/robust/ref/lti.mixsyn.html">doc</a>)</li>
<li>Fixed-Structure \(\mathcal{H}_\infty\) Synthesis (<code>hinfstruct</code> <a href="https://www.mathworks.com/help/robust/ref/lti.hinfstruct.html">doc</a>)</li>
<li>Signal Based \(\mathcal{H}_\infty\) Synthesis</li>
</ul>
</div>
</div>
<div id="outline-container-orgefb0a59" class="outline-3">
<h3 id="orgefb0a59"><span class="section-number-3">3.3</span> The Generalized Plant</h3>
<div class="outline-text-3" id="text-3-3">
<p>
<a id="org3bb232f"></a>
</p>
<p>
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 <b>Generalized Plant</b> for the current problem.
It makes things much easier for the following steps.
</p>
<p>
The generalized plant, usually noted \(P(s)\), is shown in Figure <a href="#org9d5fecd">12</a>.
It has two inputs and two outputs (both could contains many signals).
The meaning of the inputs and outputs are summarized in Table <a href="#org2826e2e">4</a>.
</p>
<p>
Note that this generalized plant is as its name implies, quite <i>general</i>.
It can indeed represent feedback as well as feedforward control architectures.
</p>
\begin{equation}
\begin{bmatrix} z \\ v \end{bmatrix} = P \begin{bmatrix} w \\ u \end{bmatrix} = \begin{bmatrix} P_{11} & P_{12} \\ P_{21} & P_{22} \end{bmatrix} \begin{bmatrix} w \\ u \end{bmatrix}
\end{equation}
<div id="org9d5fecd" class="figure">
<p><img src="figs/general_plant.png" alt="general_plant.png" />
</p>
<p><span class="figure-number">Figure 12: </span>Inputs and Outputs of the generalized Plant</p>
</div>
<div class="important" id="org04ea0dd">
<table id="org2826e2e" border="2" cellspacing="0" cellpadding="6" rules="groups" frame="hsides">
<caption class="t-above"><span class="table-number">Table 4:</span> Notations for the general configuration</caption>
<colgroup>
<col class="org-left" />
<col class="org-left" />
</colgroup>
<thead>
<tr>
<th scope="col" class="org-left">Notation</th>
<th scope="col" class="org-left">Meaning</th>
</tr>
</thead>
<tbody>
<tr>
<td class="org-left">\(P\)</td>
<td class="org-left">Generalized plant model</td>
</tr>
<tr>
<td class="org-left">\(w\)</td>
<td class="org-left">Exogenous inputs: commands, disturbances, noise</td>
</tr>
<tr>
<td class="org-left">\(z\)</td>
<td class="org-left">Exogenous outputs: signals to be minimized</td>
</tr>
<tr>
<td class="org-left">\(v\)</td>
<td class="org-left">Controller inputs: measurements</td>
</tr>
<tr>
<td class="org-left">\(u\)</td>
<td class="org-left">Control signals</td>
</tr>
</tbody>
</table>
</div>
</div>
</div>
<div id="outline-container-org4ae085b" class="outline-3">
<h3 id="org4ae085b"><span class="section-number-3">3.4</span> The General Synthesis Problem Formulation</h3>
<div class="outline-text-3" id="text-3-4">
<p>
<a id="orgdc161cf"></a>
</p>
<p>
Once the generalized plant is obtained, the \(\mathcal{H}_\infty\) synthesis problem can be stated as follows:
</p>
<div class="important" id="org9515a1a">
<dl class="org-dl">
<dt>\(\mathcal{H}_\infty\) Synthesis applied on the generalized plant</dt><dd></dd>
</dl>
<p>
Find a stabilizing controller \(K\) that, using the sensed output \(v\), generates a control signal \(u\) such that the \(\mathcal{H}_\infty\) norm of the closed-loop transfer function from \(w\) to \(z\) is minimized.
</p>
<p>
After \(K\) is found, the system is <i>robustified</i> by adjusting the response around the unity gain frequency to increase stability margins.
</p>
</div>
<div id="orgc9ca44d" class="figure">
<p><img src="figs/general_control_names.png" alt="general_control_names.png" />
</p>
<p><span class="figure-number">Figure 13: </span>General Control Configuration</p>
</div>
<p>
Note that the closed-loop transfer function from \(w\) to \(z\) is:
</p>
\begin{equation}
\frac{z}{w} = P_{11} + P_{12} K \big( I - P_{22} K \big)^{-1} P_{21} \triangleq F_l(P, K)
\end{equation}
<p>
Using Matlab, the \(\mathcal{H}_\infty\) Synthesis applied on a Generalized plant can be applied using the <code>hinfsyn</code> command (<a href="https://www.mathworks.com/help/robust/ref/hinfsyn.html">documentation</a>):
</p>
<div class="org-src-container">
<pre class="src src-matlab">K = hinfsyn(P, nmeas, ncont);
</pre>
</div>
<p>
where:
</p>
<ul class="org-ul">
<li><code>P</code> is the generalized plant transfer function matrix</li>
<li><code>nmeas</code> is the number of sensed output (size of \(v\))</li>
<li><code>ncont</code> is the number of control signals (size of \(u\))</li>
<li><code>K</code> obtained controller that minimized the \(\mathcal{H}_\infty\) norm from \(w\) to \(z\)</li>
</ul>
</div>
</div>
<div id="outline-container-org0686082" class="outline-3">
<h3 id="org0686082"><span class="section-number-3">3.5</span> From a Classical Feedback Architecture to a Generalized Plant</h3>
<div class="outline-text-3" id="text-3-5">
<p>
<a id="org3a5587f"></a>
</p>
<p>
The procedure to convert a typical control architecture as the one shown in Figure <a href="#org547ea75">14</a> to a generalized Plant is as follows:
</p>
<ol class="org-ol">
<li>Define signals (\(w\), \(z\), \(u\) and \(v\)) of the generalized plant</li>
<li>Remove \(K\) and rearrange the inputs and outputs to match the generalized configuration</li>
</ol>
<div class="exercice" id="org5a20871">
<p>
Compute the Generalized plant of corresponding to the tracking control architecture shown in Figure <a href="#org547ea75">14</a>
</p>
<div id="org547ea75" class="figure">
<p><img src="figs/classical_feedback_tracking.png" alt="classical_feedback_tracking.png" />
</p>
<p><span class="figure-number">Figure 14: </span>Classical Feedback Control Architecture (Tracking)</p>
</div>
<details><summary>Hint</summary>
<p>
First, define the signals of the generalized plant:
</p>
<ul class="org-ul">
<li>Exogenous inputs: \(w = r\)</li>
<li>Signals to be minimized: \(z_1 = \epsilon\), \(z_2 = u\)</li>
<li>Control signals: \(v = y\)</li>
<li>Control inputs: \(u\)</li>
</ul>
<p>
Then, Remove \(K\) and rearrange the inputs and outputs.
</p>
</details>
<details><summary>Answer</summary>
<p>
The obtained generalized plant shown in Figure <a href="#org0cbbe47">15</a>.
</p>
<div id="org0cbbe47" class="figure">
<p><img src="figs/mixed_sensitivity_ref_tracking.png" alt="mixed_sensitivity_ref_tracking.png" />
</p>
<p><span class="figure-number">Figure 15: </span>Generalized plant of the Classical Feedback Control Architecture (Tracking)</p>
</div>
</details>
</div>
<p>
Using Matlab, the generalized plant can be defined as follows:
</p>
<div class="org-src-container">
<pre class="src src-matlab">P = [1 <span class="org-type">-</span>G;
0 1;
1 <span class="org-type">-</span>G]
P.InputName = {<span class="org-string">'w'</span>, <span class="org-string">'u'</span>};
P.OutputName = {<span class="org-string">'e'</span>, <span class="org-string">'u'</span>, <span class="org-string">'v'</span>};
</pre>
</div>
</div>
</div>
</div>
<div id="outline-container-org2cbfd77" class="outline-2">
<h2 id="org2cbfd77"><span class="section-number-2">4</span> Modern Interpretation of the Control Specifications</h2>
<div class="outline-text-2" id="text-4">
<p>
<a id="org120c8b0"></a>
</p>
</div>
<div id="outline-container-org6326f86" class="outline-3">
<h3 id="org6326f86"><span class="section-number-3">4.1</span> Introduction</h3>
<div class="outline-text-3" id="text-4-1">
<p>
The
</p>
<div id="org178ab5a" class="figure">
<p><img src="figs/gang_of_four_feedback.png" alt="gang_of_four_feedback.png" />
</p>
<p><span class="figure-number">Figure 16: </span>Simple Feedback Architecture</p>
</div>
<ul class="org-ul">
<li><b>Reference tracking</b> Overshoot, Static error, Settling time
<ul class="org-ul">
<li>From \(r\) to \(\epsilon\)</li>
</ul></li>
<li><b>Disturbances rejection</b>
<ul class="org-ul">
<li>From \(d\) to \(y\)</li>
<li>\(G(s) S(s) = T_{d \rightarrow \epsilon}\)</li>
</ul></li>
<li><b>Measurement noise filtering</b>
<ul class="org-ul">
<li>From \(n\) to \(y\)</li>
<li>\(T(s) = T_{n \rightarrow \epsilon}\)</li>
</ul></li>
<li><b>Small command amplitude</b>
<ul class="org-ul">
<li>From \(n, r, d\) to \(u\)</li>
<li>\(K(s) S(s) = T_{r \rightarrow u}\)</li>
</ul></li>
<li><b>Stability</b>
<ul class="org-ul">
<li>\(S(s)\), \(T(s)\), \(K(s)S(s)\), \(G(s)S(s)\)</li>
</ul></li>
<li><b>Robustness to plant uncertainty</b> (stability margins)</li>
<li><b>Controller implementation</b></li>
</ul>
</div>
</div>
<div id="outline-container-org3082f31" class="outline-3">
<h3 id="org3082f31"><span class="section-number-3">4.2</span> Closed Loop Transfer Functions</h3>
<div class="outline-text-3" id="text-4-2">
<p>
<a id="orgd026300"></a>
</p>
<p>
As the performances of a controlled system depend on the <b>closed</b> 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)\).
</p>
<div id="org6bc915f" class="figure">
<p><img src="figs/gang_of_four_feedback.png" alt="gang_of_four_feedback.png" />
</p>
<p><span class="figure-number">Figure 17: </span>Simple Feedback Architecture</p>
</div>
<div class="exercice" id="org8d715cf">
<p>
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 <a href="#org178ab5a">16</a>.
</p>
<details><summary>Hint</summary>
<p>
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:
</p>
\begin{aligned}
y &= G u \\
&= G (d + K \epsilon) \\
&= G \big(d + K (r - n - y) \big) \\
&= G d + GK r - GK n - GK y
\end{aligned}
<p>
Isolate \(y\) at the right hand side, and finally obtain:
\[ y = \frac{GK}{1+ GK} r + \frac{G}{1 + GK} d - \frac{GK}{1 + GK} n \]
</p>
<p>
Do the same procedure for \(u\) and \(\epsilon\)
</p>
</details>
<details><summary>Anwser</summary>
<p>
The following equations should be obtained:
</p>
\begin{align}
y &= \frac{GK}{1 + GK} r + \frac{G}{1 + GK} d - \frac{GK}{1 + GK} n \\
\epsilon &= \frac{1 }{1 + GK} r - \frac{G}{1 + GK} d - \frac{G }{1 + GK} n \\
u &= \frac{K }{1 + GK} r - \frac{1}{1 + GK} d - \frac{K }{1 + GK} n
\end{align}
</details>
</div>
<p>
We can see that their are 4 different transfer functions describing the behavior of the system in Figure <a href="#org178ab5a">16</a>.
They are called the <b>Gang of Four</b>:
</p>
\begin{align}
S &= \frac{1 }{1 + GK}, \quad \text{the sensitivity function} \\
T &= \frac{GK}{1 + GK}, \quad \text{the complementary sensitivity function} \\
GS &= \frac{G }{1 + GK}, \quad \text{the load disturbance sensitivity function} \\
KS &= \frac{K }{1 + GK}, \quad \text{the noise sensitivity function}
\end{align}
<div class="seealso" id="org5861ae2">
<p>
If a feedforward controller is included, a <b>Gang of Six</b> transfer functions can be defined.
More on that in this <a href="https://www.youtube.com/watch?v=b_8v8scghh8">short video</a>.
</p>
</div>
<p>
And we have:
</p>
\begin{align}
\epsilon &= S r - GS d - GS n \\
y &= T r + GS d - T n \\
u &= KS r - S d - KS n
\end{align}
</div>
</div>
<div id="outline-container-orgb0f4517" class="outline-3">
<h3 id="orgb0f4517"><span class="section-number-3">4.3</span> Sensitivity Transfer Function</h3>
<div class="outline-text-3" id="text-4-3">
<p>
<a id="org39ba4d9"></a>
</p>
<div class="org-src-container">
<pre class="src src-matlab">K1 = 14e8 <span class="org-type">*</span> ...<span class="org-comment"> % Gain</span>
1<span class="org-type">/</span>(s<span class="org-type">^</span>2) <span class="org-type">*</span> ...<span class="org-comment"> % Double Integrator</span>
(1 <span class="org-type">+</span> s<span class="org-type">/</span>(2<span class="org-type">*</span><span class="org-constant">pi</span><span class="org-type">*</span>10<span class="org-type">/</span>sqrt(8)))<span class="org-type">/</span>(1 <span class="org-type">+</span> s<span class="org-type">/</span>(2<span class="org-type">*</span><span class="org-constant">pi</span><span class="org-type">*</span>10<span class="org-type">*</span>sqrt(8))); <span class="org-comment">% Lead</span>
K2 = 1e8 <span class="org-type">*</span> ...<span class="org-comment"> % Gain</span>
1<span class="org-type">/</span>(s<span class="org-type">^</span>2) <span class="org-type">*</span> ...<span class="org-comment"> % Double Integrator</span>
(1 <span class="org-type">+</span> s<span class="org-type">/</span>(2<span class="org-type">*</span><span class="org-constant">pi</span><span class="org-type">*</span>1<span class="org-type">/</span>sqrt(8)))<span class="org-type">/</span>(1 <span class="org-type">+</span> s<span class="org-type">/</span>(2<span class="org-type">*</span><span class="org-constant">pi</span><span class="org-type">*</span>1<span class="org-type">*</span>sqrt(8))); <span class="org-comment">% Lead</span>
K3 = 1e8 <span class="org-type">*</span> ...<span class="org-comment"> % Gain</span>
1<span class="org-type">/</span>(s<span class="org-type">^</span>2) <span class="org-type">*</span> ...<span class="org-comment"> % Double Integrator</span>
(1 <span class="org-type">+</span> s<span class="org-type">/</span>(2<span class="org-type">*</span><span class="org-constant">pi</span><span class="org-type">*</span>1<span class="org-type">/</span>sqrt(2)))<span class="org-type">/</span>(1 <span class="org-type">+</span> s<span class="org-type">/</span>(2<span class="org-type">*</span><span class="org-constant">pi</span><span class="org-type">*</span>1<span class="org-type">*</span>sqrt(2))); <span class="org-comment">% Lead</span>
S1 = 1<span class="org-type">/</span>(1 <span class="org-type">+</span> K1<span class="org-type">*</span>G);
S2 = 1<span class="org-type">/</span>(1 <span class="org-type">+</span> K2<span class="org-type">*</span>G);
S3 = 1<span class="org-type">/</span>(1 <span class="org-type">+</span> K3<span class="org-type">*</span>G);
T1 = K1<span class="org-type">*</span>G<span class="org-type">/</span>(1 <span class="org-type">+</span> K1<span class="org-type">*</span>G);
T2 = K2<span class="org-type">*</span>G<span class="org-type">/</span>(1 <span class="org-type">+</span> K2<span class="org-type">*</span>G);
T3 = K3<span class="org-type">*</span>G<span class="org-type">/</span>(1 <span class="org-type">+</span> K3<span class="org-type">*</span>G);
bodeFig({S1, S2, S3})
</pre>
</div>
<div class="org-src-container">
<pre class="src src-matlab">freqs = logspace(<span class="org-type">-</span>1, 2, 1000);
<span class="org-type">figure</span>;
tiledlayout(1, 2, <span class="org-string">'TileSpacing'</span>, <span class="org-string">'None'</span>, <span class="org-string">'Padding'</span>, <span class="org-string">'None'</span>);
ax1 = nexttile;
hold on;
plot(freqs, abs(squeeze(freqresp(S1, freqs, <span class="org-string">'Hz'</span>))), <span class="org-string">'DisplayName'</span>, <span class="org-string">'$L(s)$'</span>);
plot(freqs, abs(squeeze(freqresp(S2, freqs, <span class="org-string">'Hz'</span>))), <span class="org-string">'DisplayName'</span>, <span class="org-string">'$L_w(s)$'</span>);
plot(freqs, abs(squeeze(freqresp(S3, freqs, <span class="org-string">'Hz'</span>))), <span class="org-string">'DisplayName'</span>, <span class="org-string">'$L_w(s) / \gamma$, $L_w(s) \cdot \gamma$'</span>);
hold off;
<span class="org-type">set</span>(<span class="org-variable-name">gca</span>, <span class="org-string">'XScale'</span>, <span class="org-string">'log'</span>); <span class="org-type">set</span>(<span class="org-variable-name">gca</span>, <span class="org-string">'YScale'</span>, <span class="org-string">'log'</span>);
xlabel(<span class="org-string">'Frquency [Hz]'</span>); ylabel(<span class="org-string">'Sensitivity Magnitude'</span>);
hold off;
ax2 = nexttile;
t = linspace(0, 1, 1000);
y1 = step(T1, t);
y2 = step(T2, t);
y3 = step(T3, t);
hold on;
plot(t, y1)
plot(t, y2)
plot(t, y3)
hold off
xlabel(<span class="org-string">'Time [s]'</span>); ylabel(<span class="org-string">'Step Response'</span>);
</pre>
</div>
<div id="orgdb01649" class="figure">
<p><img src="figs/h-infinity-spec-S.png" alt="h-infinity-spec-S.png" />
</p>
<p><span class="figure-number">Figure 18: </span>Typical wanted shape of the Sensitivity transfer function</p>
</div>
</div>
</div>
<div id="outline-container-org4b98ec3" class="outline-3">
<h3 id="org4b98ec3"><span class="section-number-3">4.4</span> Robustness: Module Margin</h3>
<div class="outline-text-3" id="text-4-4">
<p>
<a id="orgee8393f"></a>
</p>
<ul class="org-ul">
<li class="off"><code>[&#xa0;]</code> Definition of Module margin</li>
<li class="off"><code>[&#xa0;]</code> Why it represents robustness</li>
<li class="off"><code>[&#xa0;]</code> Example</li>
</ul>
<p>
\[ M_S < 2 \Rightarrow \text{GM} > 2 \text{ and } \text{PM} > 29^o \]
</p>
</div>
</div>
<div id="outline-container-org0dd555d" class="outline-3">
<h3 id="org0dd555d"><span class="section-number-3">4.5</span> How to <b>Shape</b> transfer function? Using of Weighting Functions!</h3>
<div class="outline-text-3" id="text-4-5">
<p>
<a id="org769ed82"></a>
</p>
<p>
Let&rsquo;s say we want to shape the sensitivity transfer function corresponding to the transfer function from \(r\) to \(\epsilon\) of the control architecture shown in Figure <a href="#orge61b368">19</a>.
</p>
<div id="orge61b368" class="figure">
<p><img src="figs/loop_shaping_S_without_W.png" alt="loop_shaping_S_without_W.png" />
</p>
<p><span class="figure-number">Figure 19: </span>Generalized Plant</p>
</div>
<p>
If the \(\mathcal{H}_\infty\) synthesis is directly applied on the generalized plant \(P(s)\) shown in Figure <a href="#orge61b368">19</a>, if will minimize the \(\mathcal{H}_\infty\) norm of transfer function from \(r\) to \(\epsilon\) (the sensitivity transfer function).
</p>
<p>
However, as the \(\mathcal{H}_\infty\) norm is the maximum peak value of the transfer function&rsquo;s magnitude, it does not allow to <b>shape</b> the norm over all frequencies.
</p>
<p>
A <i>trick</i> is to include a <b>weighting function</b> in the generalized plant as shown in Figure <a href="#org6d29c71">20</a>.
Applying the \(\mathcal{H}_\infty\) synthesis to the <i>weighted</i> generalized plant \(\tilde{P}(s)\) (Figure <a href="#org6d29c71">20</a>) will generate a controller \(K(s)\) that minimizes the \(\mathcal{H}_\infty\) norm between \(r\) and \(\tilde{\epsilon}\):
</p>
\begin{equation}
\begin{aligned}
& \left\| \frac{\tilde{\epsilon}}{r} \right\|_\infty < \gamma (=1) \\
\Leftrightarrow & \left\| W_s(s) S(s) \right\|_\infty < 1 \\
\Leftrightarrow & \left| W_s(j\omega) S(j\omega) \right| < 1 \quad \forall \omega \\
\Leftrightarrow & \left| S(j\omega) \right| < \frac{1}{\left| W_s(j\omega) \right|} \quad \forall \omega
\end{aligned}\label{eq:sensitivity_shaping}
\end{equation}
<div class="important" id="org237ac86">
<p>
As shown in Equation \eqref{eq:sensitivity_shaping}, the \(\mathcal{H}_\infty\) synthesis allows to <b>shape</b> the magnitude of the sensitivity transfer function.
Therefore, the choice of the weighting function \(W_s(s)\) is very important.
Its inverse magnitude will define the frequency dependent upper bound of the sensitivity transfer function magnitude.
</p>
</div>
<div id="org6d29c71" class="figure">
<p><img src="figs/loop_shaping_S_with_W.png" alt="loop_shaping_S_with_W.png" />
</p>
<p><span class="figure-number">Figure 20: </span>Weighted Generalized Plant</p>
</div>
<p>
Once the weighting function is designed, it should be added to the generalized plant as shown in Figure <a href="#org6d29c71">20</a>.
</p>
<p>
The weighted generalized plant can be defined in Matlab by either re-defining all the inputs or by pre-multiplying the (non-weighted) generalized plant by a block-diagonal MIMO transfer function containing the weights for the outputs \(z\) and <code>1</code> for the outputs \(v\).
</p>
<div class="org-src-container">
<pre class="src src-matlab">Pw = [Ws <span class="org-type">-</span>Ws<span class="org-type">*</span>G;
1 <span class="org-type">-</span>G]
<span class="org-comment">% Alternative</span>
Pw = blkdiag(Ws, 1)<span class="org-type">*</span>P;
</pre>
</div>
</div>
</div>
<div id="outline-container-org828800a" class="outline-3">
<h3 id="org828800a"><span class="section-number-3">4.6</span> Design of Weighting Functions</h3>
<div class="outline-text-3" id="text-4-6">
<p>
<a id="org247846b"></a>
</p>
<p>
Weighting function used must be <b>proper</b>, <b>stable</b> and <b>minimum phase</b> transfer functions.
</p>
<dl class="org-dl">
<dt>proper</dt><dd>more poles than zeros, this implies \(\lim_{\omega \to \infty} |W(j\omega)| < \infty\)</dd>
<dt>stable</dt><dd>no poles in the right half plane</dd>
<dt>minimum phase</dt><dd>no zeros in the right half plane</dd>
</dl>
<p>
Matlab is providing the <code>makeweight</code> function that creates a first-order weights by specifying the low frequency gain, high frequency gain, and a gain at a specific frequency:
</p>
<div class="org-src-container">
<pre class="src src-matlab">W = makeweight(dcgain,[freq,mag],hfgain)
</pre>
</div>
<p>
with:
</p>
<ul class="org-ul">
<li><code>dcgain</code></li>
<li><code>freq</code></li>
<li><code>mag</code></li>
<li><code>hfgain</code></li>
</ul>
<div class="exampl" id="orgc28b1a3">
<p>
The Matlab code below produces a weighting function with a magnitude shape shown in Figure <a href="#orge18752f">21</a>.
</p>
<div class="org-src-container">
<pre class="src src-matlab">Ws = makeweight(1e2, [2<span class="org-type">*</span><span class="org-constant">pi</span><span class="org-type">*</span>10, 1], 1<span class="org-type">/</span>2);
</pre>
</div>
<div id="orge18752f" class="figure">
<p><img src="figs/first_order_weight.png" alt="first_order_weight.png" />
</p>
<p><span class="figure-number">Figure 21: </span>Obtained Magnitude of the Weighting Function</p>
</div>
</div>
<div class="seealso" id="orgaf8096b">
<p>
Quite often, higher orders weights are required.
</p>
<p>
In such case, the following formula can be used the design of these weights:
</p>
\begin{equation}
W(s) = \left( \frac{
\frac{1}{\omega_0} \sqrt{\frac{1 - \left(\frac{G_0}{G_c}\right)^{\frac{2}{n}}}{1 - \left(\frac{G_c}{G_\infty}\right)^{\frac{2}{n}}}} s + \left(\frac{G_0}{G_c}\right)^{\frac{1}{n}}
}{
\left(\frac{1}{G_\infty}\right)^{\frac{1}{n}} \frac{1}{\omega_0} \sqrt{\frac{1 - \left(\frac{G_0}{G_c}\right)^{\frac{2}{n}}}{1 - \left(\frac{G_c}{G_\infty}\right)^{\frac{2}{n}}}} s + \left(\frac{1}{G_c}\right)^{\frac{1}{n}}
}\right)^n \label{eq:weight_formula_advanced}
\end{equation}
<p>
The parameters permit to specify:
</p>
<ul class="org-ul">
<li>the low frequency gain: \(G_0 = lim_{\omega \to 0} |W(j\omega)|\)</li>
<li>the high frequency gain: \(G_\infty = lim_{\omega \to \infty} |W(j\omega)|\)</li>
<li>the absolute gain at \(\omega_0\): \(G_c = |W(j\omega_0)|\)</li>
<li>the absolute slope between high and low frequency: \(n\)</li>
</ul>
<p>
A Matlab function implementing Equation \eqref{eq:weight_formula_advanced} is shown below:
</p>
<div class="org-src-container">
<label class="org-src-name"><span class="listing-number">Listing 1: </span>Matlab Function that can be used to generate Weighting functions</label><pre class="src src-matlab" id="org7f74204"><span class="org-keyword">function</span> <span class="org-variable-name">[W]</span> = <span class="org-function-name">generateWeight</span>(<span class="org-variable-name">args</span>)
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<span class="org-type">*</span><span class="org-constant">pi</span>
args.n (1,1) double {mustBeInteger, mustBePositive} = 1
<span class="org-keyword">end</span>
<span class="org-keyword">if</span> (args.Gc <span class="org-type">&lt;=</span> args.G0 <span class="org-type">&amp;&amp;</span> args.Gc <span class="org-type">&lt;=</span> args.G1) <span class="org-type">||</span> (args.Gc <span class="org-type">&gt;=</span> args.G0 <span class="org-type">&amp;&amp;</span> args.Gc <span class="org-type">&gt;=</span> args.G1)
eid = <span class="org-string">'value:range'</span>;
msg = <span class="org-string">'Gc must be between G0 and G1'</span>;
throwAsCaller(MException(eid,msg))
<span class="org-keyword">end</span>
s = zpk(<span class="org-string">'s'</span>);
W = (((1<span class="org-type">/</span>args.wc)<span class="org-type">*</span>sqrt((1<span class="org-type">-</span>(args.G0<span class="org-type">/</span>args.Gc)<span class="org-type">^</span>(2<span class="org-type">/</span>args.n))<span class="org-type">/</span>(1<span class="org-type">-</span>(args.Gc<span class="org-type">/</span>args.G1)<span class="org-type">^</span>(2<span class="org-type">/</span>args.n)))<span class="org-type">*</span>s <span class="org-type">+</span> (args.G0<span class="org-type">/</span>args.Gc)<span class="org-type">^</span>(1<span class="org-type">/</span>args.n))<span class="org-type">/</span>((1<span class="org-type">/</span>args.G1)<span class="org-type">^</span>(1<span class="org-type">/</span>args.n)<span class="org-type">*</span>(1<span class="org-type">/</span>args.wc)<span class="org-type">*</span>sqrt((1<span class="org-type">-</span>(args.G0<span class="org-type">/</span>args.Gc)<span class="org-type">^</span>(2<span class="org-type">/</span>args.n))<span class="org-type">/</span>(1<span class="org-type">-</span>(args.Gc<span class="org-type">/</span>args.G1)<span class="org-type">^</span>(2<span class="org-type">/</span>args.n)))<span class="org-type">*</span>s <span class="org-type">+</span> (1<span class="org-type">/</span>args.Gc)<span class="org-type">^</span>(1<span class="org-type">/</span>args.n)))<span class="org-type">^</span>args.n;
<span class="org-keyword">end</span>
</pre>
</div>
<p>
Let&rsquo;s use this function to generate three weights with the same high and low frequency gains, but but different slopes.
</p>
<div class="org-src-container">
<pre class="src src-matlab">W1 = generateWeight(<span class="org-string">'G0'</span>, 1e2, <span class="org-string">'G1'</span>, 1<span class="org-type">/</span>2, <span class="org-string">'Gc'</span>, 1, <span class="org-string">'wc'</span>, 2<span class="org-type">*</span><span class="org-constant">pi</span><span class="org-type">*</span>10, <span class="org-string">'n'</span>, 1);
W2 = generateWeight(<span class="org-string">'G0'</span>, 1e2, <span class="org-string">'G1'</span>, 1<span class="org-type">/</span>2, <span class="org-string">'Gc'</span>, 1, <span class="org-string">'wc'</span>, 2<span class="org-type">*</span><span class="org-constant">pi</span><span class="org-type">*</span>10, <span class="org-string">'n'</span>, 2);
W3 = generateWeight(<span class="org-string">'G0'</span>, 1e2, <span class="org-string">'G1'</span>, 1<span class="org-type">/</span>2, <span class="org-string">'Gc'</span>, 1, <span class="org-string">'wc'</span>, 2<span class="org-type">*</span><span class="org-constant">pi</span><span class="org-type">*</span>10, <span class="org-string">'n'</span>, 3);
</pre>
</div>
<p>
The obtained shapes are shown in Figure <a href="#org257a2cb">22</a>.
</p>
<div id="org257a2cb" class="figure">
<p><img src="figs/high_order_weight.png" alt="high_order_weight.png" />
</p>
<p><span class="figure-number">Figure 22: </span>Higher order weights using Equation \eqref{eq:weight_formula_advanced}</p>
</div>
</div>
</div>
</div>
<div id="outline-container-org7b75b54" class="outline-3">
<h3 id="org7b75b54"><span class="section-number-3">4.7</span> Sensitivity Function Shaping - Example</h3>
<div class="outline-text-3" id="text-4-7">
<p>
<a id="orgfc52f05"></a>
</p>
<ul class="org-ul">
<li>Robustness: Module margin &gt; 2 (\(\Rightarrow \text{GM} > 2 \text{ and } \text{PM} > 29^o\))</li>
<li>Bandwidth:</li>
<li>Slope of -2</li>
</ul>
<p>
First, the weighting functions is generated.
</p>
<div class="org-src-container">
<pre class="src src-matlab">Ws = generateWeight(<span class="org-string">'G0'</span>, 1e3, <span class="org-string">'G1'</span>, 1<span class="org-type">/</span>2, <span class="org-string">'Gc'</span>, 1, <span class="org-string">'wc'</span>, 2<span class="org-type">*</span><span class="org-constant">pi</span><span class="org-type">*</span>10, <span class="org-string">'n'</span>, 2);
</pre>
</div>
<p>
It is then added to the generalized plant.
</p>
<div class="org-src-container">
<pre class="src src-matlab">Pw = blkdiag(Ws, 1)<span class="org-type">*</span>P;
</pre>
</div>
<p>
And the \(\mathcal{H}_\infty\) synthesis is performed.
</p>
<div class="org-src-container">
<pre class="src src-matlab">K = hinfsyn(Pw, 1, 1, <span class="org-string">'Display'</span>, <span class="org-string">'on'</span>);
</pre>
</div>
<pre class="example" id="orgbc4ce7f">
K = hinfsyn(Pw, 1, 1, 'Display', 'on');
Test bounds: 0.5 &lt;= gamma &lt;= 0.51
gamma X&gt;=0 Y&gt;=0 rho(XY)&lt;1 p/f
5.05e-01 0.0e+00 0.0e+00 4.497e-28 p
Limiting gains...
5.05e-01 0.0e+00 0.0e+00 0.000e+00 p
5.05e-01 -1.8e+01 # -2.9e-15 1.514e-15 f
Best performance (actual): 0.504
</pre>
<p>
The obtained \(\gamma \approx 0.5\) means that it found a controller \(K(s)\) that stabilize the closed-loop system, and such that:
</p>
\begin{aligned}
& \| W_s(s) S(s) \|_\infty < 0.5 \\
& \Leftrightarrow |S(j\omega)| < \frac{0.5}{|W_s(j\omega)|} \quad \forall \omega
\end{aligned}
<p>
This is indeed what we can see by comparing \(|S|\) and \(|W_S|\) in Figure <a href="#org6ab99eb">23</a>.
</p>
<div id="org6ab99eb" class="figure">
<p><img src="figs/results_sensitivity_hinf.png" alt="results_sensitivity_hinf.png" />
</p>
<p><span class="figure-number">Figure 23: </span>Weighting function and obtained closed-loop sensitivity</p>
</div>
</div>
</div>
</div>
<div id="outline-container-org69e4106" class="outline-2">
<h2 id="org69e4106"><span class="section-number-2">5</span> \(\mathcal{H}_\infty\) Mixed-Sensitivity Synthesis</h2>
<div class="outline-text-2" id="text-5">
<p>
<a id="org1343cf1"></a>
</p>
</div>
<div id="outline-container-org7551557" class="outline-3">
<h3 id="org7551557"><span class="section-number-3">5.1</span> Problem</h3>
</div>
<div id="outline-container-org591ee3f" class="outline-3">
<h3 id="org591ee3f"><span class="section-number-3">5.2</span> Typical Procedure</h3>
</div>
<div id="outline-container-org5f909bc" class="outline-3">
<h3 id="org5f909bc"><span class="section-number-3">5.3</span> Step 1 - Shaping of the Sensitivity Function</h3>
</div>
<div id="outline-container-org7e69dbf" class="outline-3">
<h3 id="org7e69dbf"><span class="section-number-3">5.4</span> Step 2 - Shaping of</h3>
</div>
</div>
<div id="outline-container-org7f2c9ea" class="outline-2">
<h2 id="org7f2c9ea"><span class="section-number-2">6</span> Conclusion</h2>
</div>
<div id="outline-container-org9e8b015" class="outline-2">
<h2 id="org9e8b015"><span class="section-number-2">7</span> Resources</h2>
<div class="outline-text-2" id="text-7">
<p>
<div class="yt"><iframe width="100%" height="100%" src="https://www.youtube.com/embed/?listType=playlist&list=PLn8PRpmsu08qFLMfgTEzR8DxOPE7fBiin" frameborder="0" allowfullscreen></iframe></div>
</p>
<p>
<div class="yt"><iframe width="100%" height="100%" src="https://www.youtube.com/embed/?listType=playlist&list=PLsjPUqcL7ZIFHCObUU_9xPUImZ203gB4o" frameborder="0" allowfullscreen></iframe></div>
</p>
</div>
</div>
</div>
<div id="postamble" class="status">
<p class="author">Author: Dehaeze Thomas</p>
<p class="date">Created: 2020-11-30 lun. 17:44</p>
</div>
</body>
</html>
Reference in New Issue View Git Blame Copy Permalink