2980 lines
106 KiB
HTML
2980 lines
106 KiB
HTML
<?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-12-02 mer. 19:00 -->
|
||
<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="#org034f779">1. Introduction to Model Based Control</a>
|
||
<ul>
|
||
<li><a href="#org368f83d">1.1. Model Based Control - Methodology</a></li>
|
||
<li><a href="#org4e73bc1">1.2. From Classical Control to Robust Control</a></li>
|
||
<li><a href="#org29be764">1.3. Example System</a></li>
|
||
</ul>
|
||
</li>
|
||
<li><a href="#orgfc89381">2. Classical Open Loop Shaping</a>
|
||
<ul>
|
||
<li><a href="#org928fef4">2.1. Introduction to Loop Shaping</a></li>
|
||
<li><a href="#org0630731">2.2. Example of Manual Open Loop Shaping</a></li>
|
||
<li><a href="#org7a0ade1">2.3. \(\mathcal{H}_\infty\) Loop Shaping Synthesis</a></li>
|
||
<li><a href="#orgf7c876e">2.4. Example of the \(\mathcal{H}_\infty\) Loop Shaping Synthesis</a></li>
|
||
</ul>
|
||
</li>
|
||
<li><a href="#orgd832166">3. A first Step into the \(\mathcal{H}_\infty\) world</a>
|
||
<ul>
|
||
<li><a href="#orgee200ba">3.1. The \(\mathcal{H}_\infty\) Norm</a></li>
|
||
<li><a href="#org456f5ef">3.2. \(\mathcal{H}_\infty\) Synthesis</a></li>
|
||
<li><a href="#orgf0d627c">3.3. The Generalized Plant</a></li>
|
||
<li><a href="#orgee23eb9">3.4. The \(\mathcal{H}_\infty\) Synthesis applied on the Generalized plant</a></li>
|
||
<li><a href="#orgcd45966">3.5. From a Classical Feedback Architecture to a Generalized Plant</a></li>
|
||
</ul>
|
||
</li>
|
||
<li><a href="#orgfe20d7f">4. Modern Interpretation of Control Specifications</a>
|
||
<ul>
|
||
<li><a href="#orgba5fc4e">4.1. Closed Loop Transfer Functions</a></li>
|
||
<li><a href="#org0208208">4.2. Sensitivity Function</a></li>
|
||
<li><a href="#org5d9ac3a">4.3. Robustness: Module Margin</a></li>
|
||
<li><a href="#org8603166">4.4. Other Requirements</a></li>
|
||
</ul>
|
||
</li>
|
||
<li><a href="#org3a3f16f">5. \(\mathcal{H}_\infty\) Shaping of closed-loop transfer functions</a>
|
||
<ul>
|
||
<li><a href="#org2f64aeb">5.1. How to Shape closed-loop transfer function? Using Weighting Functions!</a></li>
|
||
<li><a href="#org193cd4a">5.2. Design of Weighting Functions</a></li>
|
||
<li><a href="#orga44ffb5">5.3. Shaping the Sensitivity Function</a></li>
|
||
<li><a href="#org52c7109">5.4. Shaping multiple closed-loop transfer functions</a></li>
|
||
</ul>
|
||
</li>
|
||
<li><a href="#org22bfb42">6. Mixed-Sensitivity \(\mathcal{H}_\infty\) Control - Example</a>
|
||
<ul>
|
||
<li><a href="#org6f204af">6.1. Control Problem</a></li>
|
||
<li><a href="#org32ad71c">6.2. Control Design Procedure</a></li>
|
||
<li><a href="#orge4c6edc">6.3. Step 1 - Shaping of \(S\)</a></li>
|
||
<li><a href="#orge5810a8">6.4. Step 2 - Shaping of \(KS\)</a></li>
|
||
<li><a href="#org9df5a7e">6.5. Step 3 - Shaping of \(T\)</a></li>
|
||
</ul>
|
||
</li>
|
||
<li><a href="#org5edd8f5">7. Conclusion</a></li>
|
||
</ul>
|
||
</div>
|
||
</div>
|
||
|
||
<p>
|
||
The purpose of this document is to give a <i>practical introduction</i> to the wonderful world of \(\mathcal{H}_\infty\) Control.
|
||
</p>
|
||
|
||
<p>
|
||
No attend is made to provide an exhaustive treatment of the subject.
|
||
\(\mathcal{H}_\infty\) Control is a very broad topic and entire books are written on it.
|
||
Therefore, for more advanced discussion, please have a look at the recommended references at the bottom of this document.
|
||
</p>
|
||
|
||
<p>
|
||
When possible, Matlab scripts used for the example/exercises are provided such that you can easily test them on your computer.
|
||
</p>
|
||
|
||
|
||
<p>
|
||
The general structure of this document is as follows:
|
||
</p>
|
||
<ul class="org-ul">
|
||
<li>A short introduction to <i>model based control</i> is given in Section <a href="#orgbf56f19">1</a></li>
|
||
<li>Classical <i>open</i> loop shaping method is presented in Section <a href="#org2adccff">2</a>.
|
||
It is also shown that \(\mathcal{H}_\infty\) synthesis can be used for <i>open</i> loop shaping</li>
|
||
<li>Important concepts indispensable for \(\mathcal{H}_\infty\) control such as the \(\mathcal{H}_\infty\) norm and the generalized plant are introduced in Section <a href="#org857ce16">3</a></li>
|
||
<li>A very important step in \(\mathcal{H}_\infty\) control is to express the control specifications (performances, robustness, etc.) as an \(\mathcal{H}_\infty\) optimization problem. Such procedure is described in Section <a href="#orgdd9776f">4</a></li>
|
||
<li>One of the most useful use of the \(\mathcal{H}_\infty\) control is the shaping of closed-loop transfer functions.
|
||
Such technique is presented in Section <a href="#org1541f39">5</a></li>
|
||
<li>Finally, complete examples of the use of \(\mathcal{H}_\infty\) Control for practical problems are provided in Section <a href="#org3c7b185">6</a>.</li>
|
||
</ul>
|
||
|
||
<div id="outline-container-org034f779" class="outline-2">
|
||
<h2 id="org034f779"><span class="section-number-2">1</span> Introduction to Model Based Control</h2>
|
||
<div class="outline-text-2" id="text-1">
|
||
<p>
|
||
<a id="orgbf56f19"></a>
|
||
</p>
|
||
</div>
|
||
|
||
<div id="outline-container-org368f83d" class="outline-3">
|
||
<h3 id="org368f83d"><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="org665b6b8"></a>
|
||
</p>
|
||
|
||
<p>
|
||
The typical methodology for <b>Model Based Control</b> techniques is schematically shown in Figure <a href="#orgf50336f">1</a>.
|
||
</p>
|
||
|
||
<p>
|
||
It consists of three steps:
|
||
</p>
|
||
<ol class="org-ol">
|
||
<li><b>Identification or modeling</b>: a mathematical model \(G(s)\) representing the plant dynamics is obtained</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, …</li>
|
||
<li><span class="underline">Mathematical Criteria</span>: Cost Function, Shape of transfer function, Phase/Gain margin, Roll-Off, …</li>
|
||
</ul></li>
|
||
<li><b>Synthesis</b>: research of a controller \(K(s)\) that satisfies the specifications for the model of the system</li>
|
||
</ol>
|
||
|
||
|
||
<div id="orgf50336f" 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 suppose a model of the plant is available (step 1 already performed), and we will focus on steps 2 and 3.
|
||
</p>
|
||
|
||
|
||
<p>
|
||
In Section <a href="#org2adccff">2</a>, steps 2 and 3 will be described for a control techniques called <b>classical (open-)loop shaping</b>.
|
||
</p>
|
||
|
||
<p>
|
||
Then, steps 2 and 3 for the <b>\(\mathcal{H}_\infty\) Loop Shaping</b> of closed-loop transfer functions will be discussed in Sections <a href="#orgdd9776f">4</a>, <a href="#org1541f39">5</a> and <a href="#org3c7b185">6</a>.
|
||
</p>
|
||
</div>
|
||
</div>
|
||
|
||
<div id="outline-container-org4e73bc1" class="outline-3">
|
||
<h3 id="org4e73bc1"><span class="section-number-3">1.2</span> From Classical Control to Robust Control</h3>
|
||
<div class="outline-text-3" id="text-1-2">
|
||
<p>
|
||
<a id="org03a9198"></a>
|
||
</p>
|
||
|
||
<p>
|
||
Many different model based control techniques have been developed since the birth of <i>classical control theory</i> in the ’30s.
|
||
</p>
|
||
|
||
|
||
<p>
|
||
<b>Classical control</b> methods were developed starting from 1930 based on tools such as the Laplace and Fourier transforms.
|
||
It was then natural to study systems in the frequency domain using tools such as the Bode and Nyquist plots.
|
||
Controllers were manually tuned to optimize criteria such as control bandwidth, gain and phase margins.
|
||
</p>
|
||
|
||
|
||
<p>
|
||
The ’60s saw the development of control techniques based on a state-space.
|
||
Linear algebra and matrices were used instead of the frequency domain tool of the class control theory.
|
||
This allows multi-inputs multi-outputs systems to be easily treated.
|
||
Kalman introduced the well known <i>Kalman estimator</i> as well the notion of optimality by minimizing quadratic cost functions.
|
||
This set of developments is loosely termed <b>Modern Control</b> theory.
|
||
</p>
|
||
|
||
|
||
<p>
|
||
By the 1980’s, modern control theory was shown to have some robustness issues and to lack the intuitive tools that the classical control methods were offering.
|
||
This led to a new control theory called <b>Robust control</b> that blends the best features of classical and modern techniques.
|
||
This robust control theory is the subject of this document.
|
||
</p>
|
||
|
||
|
||
<p>
|
||
The three presented control methods are compared in Table <a href="#orgf37ba30">1</a>.
|
||
</p>
|
||
|
||
<p>
|
||
Note that in parallel, there have been numerous other developments, including non-linear control, adaptive control, machine-learning control just to name a few.
|
||
</p>
|
||
|
||
<table id="orgf37ba30" 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"> </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"> </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"> </td>
|
||
<td class="org-center">Bode Plots</td>
|
||
<td class="org-center"> </td>
|
||
<td class="org-center">Open/Closed Loop Shaping</td>
|
||
</tr>
|
||
|
||
<tr>
|
||
<td class="org-left"> </td>
|
||
<td class="org-center">Phase and Gain margins</td>
|
||
<td class="org-center"> </td>
|
||
<td class="org-center">Weighting Functions</td>
|
||
</tr>
|
||
|
||
<tr>
|
||
<td class="org-left"> </td>
|
||
<td class="org-center"> </td>
|
||
<td class="org-center"> </td>
|
||
<td class="org-center">Disk margin</td>
|
||
</tr>
|
||
|
||
<tr>
|
||
<td class="org-left"> </td>
|
||
<td class="org-center"> </td>
|
||
<td class="org-center"> </td>
|
||
<td class="org-center">Singular Value Decomposition</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, LQR</td>
|
||
<td class="org-center">General Control Configuration</td>
|
||
</tr>
|
||
|
||
<tr>
|
||
<td class="org-left"> </td>
|
||
<td class="org-center">Leads, Lags</td>
|
||
<td class="org-center">Kalman Filters, LQG</td>
|
||
<td class="org-center">Generalized Plant</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"> </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"> </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"> </td>
|
||
<td class="org-center"> </td>
|
||
<td class="org-center"> </td>
|
||
<td class="org-center">Guaranteed Robustness</td>
|
||
</tr>
|
||
|
||
<tr>
|
||
<td class="org-left"> </td>
|
||
<td class="org-center"> </td>
|
||
<td class="org-center"> </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"> </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>
|
||
|
||
<tr>
|
||
<td class="org-left"> </td>
|
||
<td class="org-center">No clear way to limit input usage</td>
|
||
<td class="org-center"> </td>
|
||
<td class="org-center"> </td>
|
||
</tr>
|
||
</tbody>
|
||
</table>
|
||
</div>
|
||
</div>
|
||
|
||
<div id="outline-container-org29be764" class="outline-3">
|
||
<h3 id="org29be764"><span class="section-number-3">1.3</span> Example System</h3>
|
||
<div class="outline-text-3" id="text-1-3">
|
||
<p>
|
||
<a id="org1ceffea"></a>
|
||
</p>
|
||
|
||
<p>
|
||
Throughout this document, multiple examples and practical application of presented control strategies will be provided.
|
||
Most of them will be applied on a physical system presented in this section.
|
||
</p>
|
||
|
||
<p>
|
||
This system is shown in Figure <a href="#org1709349">2</a>.
|
||
It could represent an active suspension stage supporting a payload.
|
||
The <i>inertial</i> motion of the payload is measured using an inertial sensor and this is feedback to a force actuator.
|
||
Such system could be used to actively isolate the payload (disturbance rejection problem) or to make it follow a trajectory (tracking problem).
|
||
</p>
|
||
|
||
<p>
|
||
The notations used on Figure <a href="#org1709349">2</a> are listed and described in Table <a href="#org2d477e0">2</a>.
|
||
</p>
|
||
|
||
|
||
<div id="org1709349" 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="org2d477e0" 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’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"> </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"> </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"> </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"> </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"> </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="orgddbd20a">
|
||
<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’s law), …</li>
|
||
<li>Apply the Newton’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>
|
||
Having obtained \(G(s)\) and \(G_d(s)\), we can transform the system shown in Figure <a href="#org1709349">2</a> into a classical feedback architecture as shown in Figure <a href="#org0264cfd">6</a>.
|
||
</p>
|
||
|
||
|
||
<div id="orgf94022d" 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 of Figure <a href="#org1709349">2</a></p>
|
||
</div>
|
||
|
||
|
||
<p>
|
||
Let’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)\).
|
||
</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>
|
||
|
||
<p>
|
||
The Bode plots of \(G(s)\) and \(G_d(s)\) are shown in Figures <a href="#orgaca324b">4</a> and <a href="#orga35ab74">5</a>.
|
||
</p>
|
||
|
||
|
||
<div id="orgaca324b" 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="orga35ab74" 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-orgfc89381" class="outline-2">
|
||
<h2 id="orgfc89381"><span class="section-number-2">2</span> Classical Open Loop Shaping</h2>
|
||
<div class="outline-text-2" id="text-2">
|
||
<p>
|
||
<a id="org2adccff"></a>
|
||
</p>
|
||
<p>
|
||
After an introduction to classical Loop Shaping in Section <a href="#org6817687">2.1</a>, a practical example is given in Section <a href="#org71ba6f4">2.2</a>.
|
||
Such Loop Shaping is usually performed manually with tools coming from the classical control theory.
|
||
</p>
|
||
|
||
<p>
|
||
However, the \(\mathcal{H}_\infty\) synthesis can be used to automate the Loop Shaping process.
|
||
This is presented in Section <a href="#orgbc374c1">2.3</a> and applied on the same example in Section <a href="#orgef1b05b">2.4</a>.
|
||
</p>
|
||
</div>
|
||
|
||
<div id="outline-container-org928fef4" class="outline-3">
|
||
<h3 id="org928fef4"><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="org6817687"></a>
|
||
</p>
|
||
|
||
<div class="definition" id="org61ce6c0">
|
||
<p>
|
||
<b>Loop Shaping</b> refers to a control design procedure that involves explicitly shaping the magnitude of the <b>Loop Transfer Function</b> \(L(s)\).
|
||
</p>
|
||
|
||
</div>
|
||
|
||
<div class="definition" id="orgea39009">
|
||
<p>
|
||
The <b>Loop Gain</b> (or Loop transfer function) \(L(s)\) usually refers to as the product of the controller and the plant (see Figure <a href="#org0264cfd">6</a>):
|
||
</p>
|
||
\begin{equation}
|
||
L(s) = G(s) \cdot K(s) \label{eq:loop_gain}
|
||
\end{equation}
|
||
|
||
<p>
|
||
Its name comes from the fact that this is actually the “gain around the loop”.
|
||
</p>
|
||
|
||
|
||
<div id="org0264cfd" 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 one of main way controllers are design in the classical control theory.
|
||
It is widely used and generally successful as many characteristics of the closed-loop system depend on the shape of the open loop gain \(L(s)\) such as:
|
||
</p>
|
||
<ul class="org-ul">
|
||
<li><b>Good Tracking</b>: \(L\) large</li>
|
||
<li><b>Good disturbance rejection</b>: \(L\) large</li>
|
||
<li><b>Attenuation of measurement noise on plant output</b>: \(L\) small</li>
|
||
<li><b>Small magnitude of input signal</b>: \(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 shaping of the Loop Gain is done manually by combining several leads, lags, notches…
|
||
This process is very much simplified by the fact that the loop gain \(L(s)\) depends <b>linearly</b> on \(K(s)\) \eqref{eq:loop_gain}.
|
||
A typical wanted Loop Shape is shown in Figure <a href="#org3218a99">7</a>.
|
||
Another interesting Loop shape called “Bode Step” is described in <a href="#citeproc_bib_item_1">[1]</a>.
|
||
</p>
|
||
|
||
|
||
<div id="org3218a99" 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>
|
||
|
||
<p>
|
||
The shaping of <b>closed-loop</b> transfer functions is obviously not as simple as they don’t depend linearly on \(K(s)\).
|
||
But this is were the \(\mathcal{H}_\infty\) Synthesis will be useful!
|
||
More details on that in Sections <a href="#orgdd9776f">4</a> and <a href="#org1541f39">5</a>.
|
||
</p>
|
||
</div>
|
||
</div>
|
||
|
||
<div id="outline-container-org0630731" class="outline-3">
|
||
<h3 id="org0630731"><span class="section-number-3">2.2</span> Example of Manual Open Loop Shaping</h3>
|
||
<div class="outline-text-3" id="text-2-2">
|
||
<p>
|
||
<a id="org71ba6f4"></a>
|
||
</p>
|
||
|
||
<div class="exampl" id="org850ee2e">
|
||
<p>
|
||
Let’s take our example system described in Section <a href="#org1ceffea">1.3</a> and design a controller using the Open-Loop shaping synthesis approach.
|
||
The specifications are:
|
||
</p>
|
||
<ol class="org-ol">
|
||
<li><b>Disturbance rejection</b>: Highest possible rejection below 1Hz</li>
|
||
<li><b>Positioning speed</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 > 3dB and Phase margin > 30 deg</li>
|
||
</ol>
|
||
|
||
</div>
|
||
|
||
<div class="exercice" id="org97b83b0">
|
||
<p>
|
||
Using <code>SISOTOOL</code>, design a controller that fulfills the specifications.
|
||
</p>
|
||
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab">sisotool(G)
|
||
</pre>
|
||
</div>
|
||
|
||
<details><summary>Hint</summary>
|
||
<p>
|
||
You can follow this procedure:
|
||
</p>
|
||
<ol class="org-ol">
|
||
<li>In order to have good disturbance rejection at low frequency, add a simple or double <b>integrator</b></li>
|
||
<li>In terms of the loop gain, the <b>bandwidth</b> can be defined at the frequency \(\omega_c\) where \(|l(j\omega_c)|\) first crosses 1 from above.
|
||
Therefore, adjust the <b>gain</b> such that \(L(j\omega)\) crosses 1 at around 10Hz</li>
|
||
<li>The roll-off at high frequency for noise attenuation should already be good enough.
|
||
If not, add a <b>low pass filter</b></li>
|
||
<li>Add a <b>Lead</b> centered around the crossover frequency (10 Hz) and tune it such that sufficient phase margin is added.
|
||
Verify that the gain margin is good enough.</li>
|
||
</ol>
|
||
</details>
|
||
|
||
</div>
|
||
|
||
<p>
|
||
Let’s say we came up with the following controller.
|
||
</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>
|
||
|
||
<p>
|
||
The bode plot of the Loop Gain is shown in Figure <a href="#org7606df4">8</a> and we can verify that we have the wanted stability margins using the <code>margin</code> command:
|
||
</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 id="org7606df4" 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>
|
||
</div>
|
||
</div>
|
||
|
||
<div id="outline-container-org7a0ade1" class="outline-3">
|
||
<h3 id="org7a0ade1"><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="orgbc374c1"></a>
|
||
</p>
|
||
|
||
<p>
|
||
The synthesis of controllers based on the Loop Shaping method can be automated using the \(\mathcal{H}_\infty\) Synthesis.
|
||
</p>
|
||
|
||
<p>
|
||
Using Matlab, it can be easily performed using the <code>loopsyn</code> command:
|
||
</p>
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab">K = loopsyn(G, Lw);
|
||
</pre>
|
||
</div>
|
||
<p>
|
||
where:
|
||
</p>
|
||
<ul class="org-ul">
|
||
<li><code>G</code> is the (LTI) plant</li>
|
||
<li><code>Lw</code> is the wanted loop shape</li>
|
||
<li><code>K</code> is the synthesize controller</li>
|
||
</ul>
|
||
|
||
<div class="seealso" id="orgb2d3491">
|
||
<p>
|
||
Matlab documentation of <code>loopsyn</code> (<a href="https://www.mathworks.com/help/robust/ref/loopsyn.html">link</a>).
|
||
</p>
|
||
|
||
</div>
|
||
|
||
<p>
|
||
Therefore, by just providing the wanted loop shape and the plant model, the \(\mathcal{H}_\infty\) Loop Shaping synthesis generates a <i>stabilizing</i> controller such that the obtained loop gain \(L(s)\) matches the specified one with an accuracy \(\gamma\).
|
||
</p>
|
||
|
||
<p>
|
||
Even though we will not go into details and explain how such synthesis is working, an example is provided in the next section.
|
||
</p>
|
||
</div>
|
||
</div>
|
||
|
||
<div id="outline-container-orgf7c876e" class="outline-3">
|
||
<h3 id="orgf7c876e"><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="orgef1b05b"></a>
|
||
</p>
|
||
|
||
<p>
|
||
To apply the \(\mathcal{H}_\infty\) Loop Shaping Synthesis, the wanted shape of the loop gain should be determined from the specifications.
|
||
This is summarized in Table <a href="#org5c9445b">3</a>.
|
||
</p>
|
||
|
||
<p>
|
||
Such shape corresponds to the typical wanted Loop gain Shape shown in Figure <a href="#org3218a99">7</a>.
|
||
</p>
|
||
|
||
<table id="org5c9445b" border="2" cellspacing="0" cellpadding="6" rules="groups" frame="hsides">
|
||
<caption class="t-above"><span class="table-number">Table 3:</span> Wanted Loop Shape corresponding to each specification</caption>
|
||
|
||
<colgroup>
|
||
<col class="org-left" />
|
||
|
||
<col class="org-left" />
|
||
|
||
<col class="org-left" />
|
||
</colgroup>
|
||
<thead>
|
||
<tr>
|
||
<th scope="col" class="org-left"> </th>
|
||
<th scope="col" class="org-left">Specification</th>
|
||
<th scope="col" class="org-left">Corresponding Loop Shape</th>
|
||
</tr>
|
||
</thead>
|
||
<tbody>
|
||
<tr>
|
||
<td class="org-left"><b>Disturbance Rejection</b></td>
|
||
<td class="org-left">Highest possible rejection below 1Hz</td>
|
||
<td class="org-left">Slope of -40dB/decade at low frequency to have a high loop gain</td>
|
||
</tr>
|
||
|
||
<tr>
|
||
<td class="org-left"><b>Positioning Speed</b></td>
|
||
<td class="org-left">Bandwidth of approximately 10Hz</td>
|
||
<td class="org-left">\(L\) crosses 1 at 10Hz: \(\vert L_w(j2 \pi 10)\vert = 1\)</td>
|
||
</tr>
|
||
|
||
<tr>
|
||
<td class="org-left"><b>Noise Attenuation</b></td>
|
||
<td class="org-left">Roll-off of -40dB/decade past 30Hz</td>
|
||
<td class="org-left">Roll-off of -40dB/decade past 30Hz</td>
|
||
</tr>
|
||
|
||
<tr>
|
||
<td class="org-left"><b>Robustness</b></td>
|
||
<td class="org-left">Gain margin > 3dB and Phase margin > 30 deg</td>
|
||
<td class="org-left">Slope of -20dB/decade near the crossover</td>
|
||
</tr>
|
||
</tbody>
|
||
</table>
|
||
|
||
<p>
|
||
Then, a (stable, minimum phase) transfer function \(L_w(s)\) should be created that has the same gain as the wanted shape of the Loop gain.
|
||
For this example, a double integrator and a lead centered on 10Hz are used.
|
||
Then the gain is adjusted such that the \(|L_w(j2 \pi 10)| = 1\).
|
||
</p>
|
||
|
||
<p>
|
||
Using Matlab, we have:
|
||
</p>
|
||
<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\) open loop shaping synthesis is then 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 obtained Loop Gain is shown in Figure <a href="#org07a4f26">9</a> and matches the specified one by a factor \(\gamma \approx 2\).
|
||
</p>
|
||
|
||
|
||
<div id="org07a4f26" 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 9: </span>Obtained Open Loop Gain \(L(s) = G(s) K(s)\) and comparison with the wanted Loop gain \(L_w\)</p>
|
||
</div>
|
||
|
||
|
||
<div class="important" id="org898607e">
|
||
<p>
|
||
When using the \(\mathcal{H}_\infty\) Synthesis, it is usually recommended to analyze the obtained controller.
|
||
</p>
|
||
|
||
<p>
|
||
This is usually done by breaking down the controller into simple elements such as low pass filters, high pass filters, notches, leads, etc.
|
||
</p>
|
||
|
||
</div>
|
||
|
||
<p>
|
||
Let’s briefly analyze the obtained controller which bode plot is shown in Figure <a href="#org0913f76">10</a>:
|
||
</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="org0913f76" 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 10: </span>Obtained controller \(K\) using the open-loop \(\mathcal{H}_\infty\) shaping</p>
|
||
</div>
|
||
|
||
|
||
<p>
|
||
Let’s finally compare the obtained stability margins of the \(\mathcal{H}_\infty\) controller and of the manually developed controller in Table <a href="#orgee7952e">4</a>.
|
||
</p>
|
||
|
||
<table id="orgee7952e" border="2" cellspacing="0" cellpadding="6" rules="groups" frame="hsides">
|
||
<caption class="t-above"><span class="table-number">Table 4:</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-orgd832166" class="outline-2">
|
||
<h2 id="orgd832166"><span class="section-number-2">3</span> A first Step into the \(\mathcal{H}_\infty\) world</h2>
|
||
<div class="outline-text-2" id="text-3">
|
||
<p>
|
||
<a id="org857ce16"></a>
|
||
</p>
|
||
<ul class="org-ul">
|
||
<li>Section <a href="#org741115c">3.1</a></li>
|
||
<li>Section <a href="#orgb9b1c65">3.2</a></li>
|
||
<li>Section <a href="#orgac2f233">3.3</a></li>
|
||
<li>Section <a href="#org45e32a4">3.4</a></li>
|
||
<li>Section <a href="#org9330c93">3.5</a></li>
|
||
</ul>
|
||
</div>
|
||
|
||
<div id="outline-container-orgee200ba" class="outline-3">
|
||
<h3 id="orgee200ba"><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="org741115c"></a>
|
||
</p>
|
||
|
||
<div class="definition" id="org7a353e8">
|
||
<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="org3c7f000">
|
||
<p>
|
||
Let’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="#orgfc15902">11</a>.
|
||
</p>
|
||
|
||
|
||
<div id="orgfc15902" 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-org456f5ef" class="outline-3">
|
||
<h3 id="org456f5ef"><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="orgb9b1c65"></a>
|
||
</p>
|
||
|
||
<div class="definition" id="orge5ef238">
|
||
<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, and many more…</li>
|
||
</ul>
|
||
</div>
|
||
</div>
|
||
|
||
<div id="outline-container-orgf0d627c" class="outline-3">
|
||
<h3 id="orgf0d627c"><span class="section-number-3">3.3</span> The Generalized Plant</h3>
|
||
<div class="outline-text-3" id="text-3-3">
|
||
<p>
|
||
<a id="orgac2f233"></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="#org4fc5f53">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="#org0024e8c">5</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="org4fc5f53" 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="orgbc13672">
|
||
<table id="org0024e8c" border="2" cellspacing="0" cellpadding="6" rules="groups" frame="hsides">
|
||
<caption class="t-above"><span class="table-number">Table 5:</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-orgee23eb9" class="outline-3">
|
||
<h3 id="orgee23eb9"><span class="section-number-3">3.4</span> The \(\mathcal{H}_\infty\) Synthesis applied on the Generalized plant</h3>
|
||
<div class="outline-text-3" id="text-3-4">
|
||
<p>
|
||
<a id="org45e32a4"></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="org0ecd0f9">
|
||
<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="orge50cd56" 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-orgcd45966" class="outline-3">
|
||
<h3 id="orgcd45966"><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="org9330c93"></a>
|
||
</p>
|
||
|
||
<p>
|
||
The procedure to convert a typical control architecture as the one shown in Figure <a href="#orgf9dd2bc">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 shown in Figure <a href="#org4fc5f53">12</a></li>
|
||
</ol>
|
||
|
||
<div class="exercice" id="orgd93a9fd">
|
||
<ol class="org-ol">
|
||
<li>Convert the tracking control architecture shown in Figure <a href="#orgf9dd2bc">14</a> to a generalized configuration</li>
|
||
<li>Compute the transfer function matrix using Matlab as a function or \(K\) and \(G\)</li>
|
||
</ol>
|
||
|
||
|
||
<div id="orgf9dd2bc" 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:
|
||
Usually, we want to minimize the tracking errors \(\epsilon\) and the control signal \(u\): \(z = [\epsilon,\ u]\)</li>
|
||
<li>Controller inputs: this is the signal at the input of the controller: \(v = \epsilon\)</li>
|
||
<li>Control inputs: signal generated by the controller: \(u\)</li>
|
||
</ul>
|
||
|
||
<p>
|
||
Then, Remove \(K\) and rearrange the inputs and outputs as in Figure <a href="#org4fc5f53">12</a>.
|
||
</p>
|
||
</details>
|
||
|
||
<details><summary>Answer</summary>
|
||
<p>
|
||
The obtained generalized plant shown in Figure <a href="#org4a2b840">15</a>.
|
||
</p>
|
||
|
||
|
||
<div id="org4a2b840" 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>
|
||
|
||
<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>
|
||
</details>
|
||
|
||
</div>
|
||
</div>
|
||
</div>
|
||
</div>
|
||
|
||
<div id="outline-container-orgfe20d7f" class="outline-2">
|
||
<h2 id="orgfe20d7f"><span class="section-number-2">4</span> Modern Interpretation of Control Specifications</h2>
|
||
<div class="outline-text-2" id="text-4">
|
||
<p>
|
||
<a id="orgdd9776f"></a>
|
||
</p>
|
||
<ul class="org-ul">
|
||
<li>Section <a href="#org5ddb185">4.1</a></li>
|
||
<li>Section <a href="#org908648d">4.2</a></li>
|
||
<li>Section <a href="#org015b6d1">4.3</a></li>
|
||
<li>Section <a href="#org1f8d4e9">4.4</a></li>
|
||
</ul>
|
||
|
||
<p>
|
||
As shown in Section <a href="#org2adccff">2</a>, 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 <i>linearly</i> 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)\).
|
||
</p>
|
||
|
||
<p>
|
||
However, the loop gain \(L(s)\) does <b>not</b> directly give the performances of the closed-loop system, which are determined by the <b>closed-loop</b> transfer functions.
|
||
</p>
|
||
|
||
<p>
|
||
If we consider the feedback system shown in Figure <a href="#org704ae85">16</a>, we can link to the following specifications to closed-loop transfer functions.
|
||
This is summarized in Table <a href="#orgec4f232">6</a>.
|
||
</p>
|
||
|
||
<table id="orgec4f232" border="2" cellspacing="0" cellpadding="6" rules="groups" frame="hsides">
|
||
<caption class="t-above"><span class="table-number">Table 6:</span> Typical Specification and associated closed-loop transfer function</caption>
|
||
|
||
<colgroup>
|
||
<col class="org-left" />
|
||
|
||
<col class="org-left" />
|
||
</colgroup>
|
||
<thead>
|
||
<tr>
|
||
<th scope="col" class="org-left">Specification</th>
|
||
<th scope="col" class="org-left">Closed-Loop Transfer Function</th>
|
||
</tr>
|
||
</thead>
|
||
<tbody>
|
||
<tr>
|
||
<td class="org-left">Reference Tracking</td>
|
||
<td class="org-left">From \(r\) to \(\epsilon\)</td>
|
||
</tr>
|
||
|
||
<tr>
|
||
<td class="org-left">Disturbance Rejection</td>
|
||
<td class="org-left">From \(d\) to \(y\)</td>
|
||
</tr>
|
||
|
||
<tr>
|
||
<td class="org-left">Measurement Noise Filtering</td>
|
||
<td class="org-left">From \(n\) to \(y\)</td>
|
||
</tr>
|
||
|
||
<tr>
|
||
<td class="org-left">Small Command Amplitude</td>
|
||
<td class="org-left">From \(n,r,d\) to \(u\)</td>
|
||
</tr>
|
||
|
||
<tr>
|
||
<td class="org-left">Stability</td>
|
||
<td class="org-left">All closed-loop transfer function</td>
|
||
</tr>
|
||
|
||
<tr>
|
||
<td class="org-left">Robustness (stability margins)</td>
|
||
<td class="org-left">Module margin (see Section <a href="#org015b6d1">4.3</a>)</td>
|
||
</tr>
|
||
</tbody>
|
||
</table>
|
||
|
||
|
||
<div id="org704ae85" 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>
|
||
</div>
|
||
|
||
<div id="outline-container-orgba5fc4e" class="outline-3">
|
||
<h3 id="orgba5fc4e"><span class="section-number-3">4.1</span> Closed Loop Transfer Functions</h3>
|
||
<div class="outline-text-3" id="text-4-1">
|
||
<p>
|
||
<a id="org5ddb185"></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 class="exercice" id="org2d0d0db">
|
||
<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="#org704ae85">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>Answer</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>
|
||
|
||
<div class="important" id="orgf4785ac">
|
||
<p>
|
||
We can see that they are 4 different transfer functions describing the behavior of the system in Figure <a href="#org704ae85">16</a>.
|
||
These 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>
|
||
|
||
<div class="seealso" id="orgb72279a">
|
||
<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}
|
||
|
||
<p>
|
||
Thus, for reference tracking, we have to shape the <i>closed-loop</i> 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)\).
|
||
</p>
|
||
</div>
|
||
</div>
|
||
|
||
<div id="outline-container-org0208208" class="outline-3">
|
||
<h3 id="org0208208"><span class="section-number-3">4.2</span> Sensitivity Function</h3>
|
||
<div class="outline-text-3" id="text-4-2">
|
||
<p>
|
||
<a id="org908648d"></a>
|
||
</p>
|
||
|
||
<p>
|
||
The sensitivity function is indisputably the most important closed-loop transfer function of a feedback system.
|
||
In this section, we will see how the shape of the sensitivity function will impact the performances of the closed-loop system.
|
||
</p>
|
||
|
||
|
||
<p>
|
||
Suppose we have developed a “<i>reference</i>” 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 <a href="#orgae1420c">17</a> and the corresponding step responses are shown in Figure <a href="#orge2d977c">18</a>.
|
||
</p>
|
||
|
||
<p>
|
||
The comparison of the sensitivity functions shapes and their effect on the step response is summarized in Table <a href="#orga8a3b9f">7</a>.
|
||
</p>
|
||
|
||
<table id="orga8a3b9f" border="2" cellspacing="0" cellpadding="6" rules="groups" frame="hsides">
|
||
<caption class="t-above"><span class="table-number">Table 7:</span> Comparison of the sensitivity function shape and the corresponding step response for the three controller variations</caption>
|
||
|
||
<colgroup>
|
||
<col class="org-left" />
|
||
|
||
<col class="org-left" />
|
||
|
||
<col class="org-left" />
|
||
</colgroup>
|
||
<thead>
|
||
<tr>
|
||
<th scope="col" class="org-left">Controller</th>
|
||
<th scope="col" class="org-left">Sensitivity Function Shape</th>
|
||
<th scope="col" class="org-left">Change of the Step Response</th>
|
||
</tr>
|
||
</thead>
|
||
<tbody>
|
||
<tr>
|
||
<td class="org-left">\(K_1(s)\)</td>
|
||
<td class="org-left">Larger bandwidth \(\omega_b\)</td>
|
||
<td class="org-left">Faster rise time</td>
|
||
</tr>
|
||
|
||
<tr>
|
||
<td class="org-left">\(K_2(s)\)</td>
|
||
<td class="org-left">Larger peak value \(\Vert S\Vert_\infty\)</td>
|
||
<td class="org-left">Large overshoot and oscillations</td>
|
||
</tr>
|
||
|
||
<tr>
|
||
<td class="org-left">\(K_3(s)\)</td>
|
||
<td class="org-left">Larger low frequency gain \(\vert S(j\cdot 0)\vert\)</td>
|
||
<td class="org-left">Larger static error</td>
|
||
</tr>
|
||
</tbody>
|
||
</table>
|
||
|
||
|
||
<div id="orgae1420c" class="figure">
|
||
<p><img src="figs/sensitivity_shape_effect.png" alt="sensitivity_shape_effect.png" />
|
||
</p>
|
||
<p><span class="figure-number">Figure 17: </span>Sensitivity function magnitude \(|S(j\omega)|\) corresponding to the reference controller \(K_r(s)\) and the three modified controllers \(K_i(s)\)</p>
|
||
</div>
|
||
|
||
|
||
<div id="orge2d977c" class="figure">
|
||
<p><img src="figs/sensitivity_shape_effect_step.png" alt="sensitivity_shape_effect_step.png" />
|
||
</p>
|
||
<p><span class="figure-number">Figure 18: </span>Step response (response from \(r\) to \(y\)) for the different controllers</p>
|
||
</div>
|
||
|
||
<div class="definition" id="org34040e3">
|
||
<dl class="org-dl">
|
||
<dt>Closed-Loop Bandwidth</dt><dd><p>
|
||
The closed-loop bandwidth \(\omega_b\) is the frequency where \(|S(j\omega)|\) first crosses \(1/\sqrt{2} = -3dB\) from below.
|
||
</p>
|
||
|
||
<p>
|
||
In general, a large bandwidth corresponds to a faster rise time.
|
||
</p></dd>
|
||
</dl>
|
||
|
||
</div>
|
||
|
||
<div class="important" id="org4740f33">
|
||
<p>
|
||
From the simple analysis above, we can draw a first estimation of the wanted shape for the sensitivity function in Figure <a href="#org60e9d75">19</a>.
|
||
</p>
|
||
|
||
<p>
|
||
The wanted characteristics on the magnitude of the sensitivity function are then:
|
||
</p>
|
||
<ul class="org-ul">
|
||
<li>A small magnitude at low frequency to make the static errors small</li>
|
||
<li>A wanted minimum closed-loop bandwidth in order to have fast rise time and good rejection of perturbations</li>
|
||
<li>A small peak value in order to limit large overshoot and oscillations.
|
||
This generally means higher robustness.
|
||
This will become clear in the next section about the <b>module margin</b>.</li>
|
||
</ul>
|
||
|
||
|
||
<div id="org60e9d75" class="figure">
|
||
<p><img src="figs/h-infinity-spec-S.png" alt="h-infinity-spec-S.png" />
|
||
</p>
|
||
<p><span class="figure-number">Figure 19: </span>Typical wanted shape of the Sensitivity transfer function</p>
|
||
</div>
|
||
|
||
</div>
|
||
</div>
|
||
</div>
|
||
|
||
<div id="outline-container-org5d9ac3a" class="outline-3">
|
||
<h3 id="org5d9ac3a"><span class="section-number-3">4.3</span> Robustness: Module Margin</h3>
|
||
<div class="outline-text-3" id="text-4-3">
|
||
<p>
|
||
<a id="org015b6d1"></a>
|
||
</p>
|
||
|
||
<p>
|
||
Let’s start by an example demonstrating why the phase and gain margins might not be good indicators of robustness.
|
||
</p>
|
||
|
||
<div class="exampl" id="org4c90db9">
|
||
<p>
|
||
Let’s consider the following plant \(G_t(s)\):
|
||
</p>
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab">w0 = 2<span class="org-type">*</span><span class="org-constant">pi</span><span class="org-type">*</span>100;
|
||
xi = 0.1;
|
||
k = 1e7;
|
||
|
||
Gt = 1<span class="org-type">/</span>k<span class="org-type">*</span>(s<span class="org-type">/</span>w0<span class="org-type">/</span>4 <span class="org-type">+</span> 1)<span class="org-type">/</span>(s<span class="org-type">^</span>2<span class="org-type">/</span>w0<span class="org-type">^</span>2 <span class="org-type">+</span> 2<span class="org-type">*</span>xi<span class="org-type">*</span>s<span class="org-type">/</span>w0 <span class="org-type">+</span> 1);
|
||
</pre>
|
||
</div>
|
||
|
||
<p>
|
||
Let’s say we have designed a controller \(K_t(s)\) that gives the loop gain shown in Figure <a href="#org961066d">20</a>.
|
||
</p>
|
||
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab">Kt = 1.2e6<span class="org-type">*</span>(s <span class="org-type">+</span> w0)<span class="org-type">/</span>s;
|
||
</pre>
|
||
</div>
|
||
|
||
<p>
|
||
The following characteristics can be determined from Figure <a href="#org961066d">20</a>:
|
||
</p>
|
||
<ul class="org-ul">
|
||
<li>bandwidth of \(\approx 10\, \text{Hz}\)</li>
|
||
<li>infinite gain margin (the phase of the loop-gain never reaches -180 degrees</li>
|
||
<li>more than 90 degrees of phase margin</li>
|
||
</ul>
|
||
|
||
<p>
|
||
This might indicate very good robustness properties of the closed-loop system.
|
||
</p>
|
||
|
||
|
||
<div id="org961066d" class="figure">
|
||
<p><img src="figs/phase_gain_margin_model_plant.png" alt="phase_gain_margin_model_plant.png" />
|
||
</p>
|
||
<p><span class="figure-number">Figure 20: </span>Bode plot of the obtained Loop Gain \(L(s)\)</p>
|
||
</div>
|
||
|
||
|
||
<p>
|
||
Now let’s suppose the “real” plant \(G_r(s)\) as a slightly lower damping factor:
|
||
</p>
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab">xi = 0.03;
|
||
</pre>
|
||
</div>
|
||
|
||
<p>
|
||
The obtained “real” loop gain is shown in Figure <a href="#orgfafef3c">21</a>.
|
||
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.
|
||
</p>
|
||
|
||
<p>
|
||
It is confirmed by checking the stability of the closed loop system:
|
||
</p>
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab">isstable(feedback(Gr,K))
|
||
</pre>
|
||
</div>
|
||
|
||
<pre class="example">
|
||
0
|
||
</pre>
|
||
|
||
|
||
|
||
<div id="orgfafef3c" class="figure">
|
||
<p><img src="figs/phase_gain_margin_real_plant.png" alt="phase_gain_margin_real_plant.png" />
|
||
</p>
|
||
<p><span class="figure-number">Figure 21: </span>Bode plots of \(L(s)\) (loop gain corresponding the nominal plant) and \(L_r(s)\) (loop gain corresponding to the real plant)</p>
|
||
</div>
|
||
|
||
<p>
|
||
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.
|
||
</p>
|
||
|
||
<p>
|
||
This is due to the fact that the gain and phase margin are robustness indicators for a <b>pure</b> change or gain or a <b>pure</b> change of phase but not a combination of both.
|
||
</p>
|
||
|
||
</div>
|
||
|
||
<p>
|
||
Let’s now determine a new robustness indicator based on the Nyquist Stability Criteria.
|
||
</p>
|
||
|
||
<div class="definition" id="orgcd6ee67">
|
||
<dl class="org-dl">
|
||
<dt>Nyquist Stability Criteria (for stable systems)</dt><dd>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.</dd>
|
||
|
||
<dt>Nyquist Plot</dt><dd>The Nyquist plot shows the evolution of \(L(j\omega)\) in the complex plane from \(\omega = 0 \to \infty\).</dd>
|
||
</dl>
|
||
|
||
</div>
|
||
|
||
<div class="seealso" id="org5d546cf">
|
||
<p>
|
||
For more information about the <i>general</i> Nyquist Stability Criteria, you may want to look at <a href="https://www.youtube.com/watch?v=sof3meN96MA">this</a> video.
|
||
</p>
|
||
|
||
</div>
|
||
|
||
<p>
|
||
From the Nyquist stability criteria, it is clear that we want \(L(j\omega)\) to be as far as possible from the \(-1\) point (called the <i>unstable point</i>) in the complex plane.
|
||
This minimum distance is called the <b>module margin</b>.
|
||
</p>
|
||
|
||
<div class="definition" id="orgbc5d627">
|
||
<dl class="org-dl">
|
||
<dt>Module Margin</dt><dd>The Module Margin \(\Delta M\) is defined as the <b>minimum distance</b> between the point \(-1\) and the loop gain \(L(j\omega)\) in the complex plane.</dd>
|
||
</dl>
|
||
|
||
</div>
|
||
|
||
<div class="exampl" id="org100bcc3">
|
||
<p>
|
||
A typical Nyquist plot is shown in Figure <a href="#org841ea89">22</a>.
|
||
The gain, phase and module margins are graphically shown to have an idea of what they represent.
|
||
</p>
|
||
|
||
|
||
<div id="org841ea89" class="figure">
|
||
<p><img src="figs/module_margin_example.png" alt="module_margin_example.png" />
|
||
</p>
|
||
<p><span class="figure-number">Figure 22: </span>Nyquist plot with visual indication of the Gain margin \(\Delta G\), Phase margin \(\Delta \phi\) and Module margin \(\Delta M\)</p>
|
||
</div>
|
||
|
||
</div>
|
||
|
||
<p>
|
||
As expected from Figure <a href="#org841ea89">22</a>, 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:
|
||
</p>
|
||
\begin{equation}
|
||
\Delta G \ge \frac{\Delta M}{\Delta M - 1}; \quad \Delta \phi \ge \frac{1}{\Delta M}
|
||
\end{equation}
|
||
|
||
|
||
<p>
|
||
Let’s now try to express the Module margin \(\Delta M\) as an \(\mathcal{H}_\infty\) norm of a closed-loop transfer function:
|
||
</p>
|
||
\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}{\|S\|_\infty}
|
||
\end{align*}
|
||
|
||
<div class="important" id="org38536b9">
|
||
<p>
|
||
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.
|
||
</p>
|
||
|
||
\begin{equation}
|
||
\Delta M = \frac{1}{\|S\|_\infty} \label{eq:module_margin_S}
|
||
\end{equation}
|
||
|
||
<p>
|
||
The wanted robustness of the closed-loop system can be specified by setting a maximum value on \(\|S\|_\infty\).
|
||
</p>
|
||
|
||
</div>
|
||
|
||
<p>
|
||
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.
|
||
</p>
|
||
|
||
<div class="exampl" id="org90f30a8">
|
||
<p>
|
||
Typical, we require \(\|S\|_\infty < 2 (6dB)\) which implies \(\Delta G \ge 2\) and \(\Delta \phi \ge 29^o\)
|
||
</p>
|
||
|
||
</div>
|
||
|
||
<div class="seealso" id="org1207008">
|
||
<p>
|
||
To learn more about module/disk margin, you can check out <a href="https://www.youtube.com/watch?v=XazdN6eZF80">this</a> video.
|
||
</p>
|
||
|
||
</div>
|
||
</div>
|
||
</div>
|
||
|
||
<div id="outline-container-org8603166" class="outline-3">
|
||
<h3 id="org8603166"><span class="section-number-3">4.4</span> Other Requirements</h3>
|
||
<div class="outline-text-3" id="text-4-4">
|
||
<p>
|
||
<a id="org1f8d4e9"></a>
|
||
</p>
|
||
|
||
<p>
|
||
Interpretation of the \(\mathcal{H}_\infty\) norm of systems:
|
||
</p>
|
||
<ul class="org-ul">
|
||
<li>frequency by frequency attenuation / amplification</li>
|
||
</ul>
|
||
|
||
<p>
|
||
Let’s note \(G_t(s)\) the closed-loop transfer function from \(w\) to \(z\).
|
||
</p>
|
||
|
||
<p>
|
||
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:
|
||
</p>
|
||
<ul class="org-ul">
|
||
<li>\(A = |G_t(j\omega_0)|\) is the magnitude of \(G_t(s)\) at \(\omega_0\)</li>
|
||
<li>\(\phi = \angle G_t(j\omega_0)\) is the phase of \(G_t(s)\) at \(\omega_0\)</li>
|
||
</ul>
|
||
|
||
|
||
<p>
|
||
Noise Attenuation: typical wanted shape for \(T\)
|
||
</p>
|
||
|
||
<table id="org1431c7d" border="2" cellspacing="0" cellpadding="6" rules="groups" frame="hsides">
|
||
<caption class="t-above"><span class="table-number">Table 8:</span> Typical Specifications and corresponding wanted norms of open and closed loop tansfer functions</caption>
|
||
|
||
<colgroup>
|
||
<col class="org-left" />
|
||
|
||
<col class="org-left" />
|
||
|
||
<col class="org-left" />
|
||
</colgroup>
|
||
<thead>
|
||
<tr>
|
||
<th scope="col" class="org-left"> </th>
|
||
<th scope="col" class="org-left">Open-Loop Shaping</th>
|
||
<th scope="col" class="org-left">Closed-Loop Shaping</th>
|
||
</tr>
|
||
</thead>
|
||
<tbody>
|
||
<tr>
|
||
<td class="org-left">Reference Tracking</td>
|
||
<td class="org-left">\(L\) large</td>
|
||
<td class="org-left">\(S\) small</td>
|
||
</tr>
|
||
|
||
<tr>
|
||
<td class="org-left">Disturbance Rejection</td>
|
||
<td class="org-left">\(L\) large</td>
|
||
<td class="org-left">\(GS\) small</td>
|
||
</tr>
|
||
|
||
<tr>
|
||
<td class="org-left">Measurement Noise Filtering</td>
|
||
<td class="org-left">\(L\) small</td>
|
||
<td class="org-left">\(T\) small</td>
|
||
</tr>
|
||
|
||
<tr>
|
||
<td class="org-left">Small Command Amplitude</td>
|
||
<td class="org-left">\(K\) and \(L\) small</td>
|
||
<td class="org-left">\(KS\) small</td>
|
||
</tr>
|
||
|
||
<tr>
|
||
<td class="org-left">Robustness</td>
|
||
<td class="org-left">Phase/Gain margins</td>
|
||
<td class="org-left">Module margin: \(\Vert S\Vert_\infty\) small</td>
|
||
</tr>
|
||
</tbody>
|
||
</table>
|
||
</div>
|
||
</div>
|
||
</div>
|
||
|
||
<div id="outline-container-org3a3f16f" class="outline-2">
|
||
<h2 id="org3a3f16f"><span class="section-number-2">5</span> \(\mathcal{H}_\infty\) Shaping of closed-loop transfer functions</h2>
|
||
<div class="outline-text-2" id="text-5">
|
||
<p>
|
||
<a id="org1541f39"></a>
|
||
</p>
|
||
<p>
|
||
In the previous sections, we have seen that the performances of the system depends on the <b>shape</b> of the closed-loop transfer function.
|
||
</p>
|
||
|
||
<p>
|
||
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.
|
||
This is clearly not simple as these closed-loop transfer functions does not depend linearly on \(K\).
|
||
</p>
|
||
|
||
<p>
|
||
But don’t worry, the \(\mathcal{H}_\infty\) synthesis will do this job for us!
|
||
</p>
|
||
|
||
<p>
|
||
This
|
||
Section <a href="#org71f6644">5.1</a>
|
||
Section <a href="#org9d243d9">5.2</a>
|
||
Section <a href="#orga27cfae">5.3</a>
|
||
Section <a href="#orgd769661">5.4</a>
|
||
</p>
|
||
</div>
|
||
|
||
<div id="outline-container-org2f64aeb" class="outline-3">
|
||
<h3 id="org2f64aeb"><span class="section-number-3">5.1</span> How to Shape closed-loop transfer function? Using Weighting Functions!</h3>
|
||
<div class="outline-text-3" id="text-5-1">
|
||
<p>
|
||
<a id="org71f6644"></a>
|
||
</p>
|
||
|
||
<p>
|
||
If the \(\mathcal{H}_\infty\) synthesis is applied on the generalized plant \(P(s)\) shown in Figure <a href="#orga81ebd4">23</a>, 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\).
|
||
</p>
|
||
|
||
<p>
|
||
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 <b>shape</b> the norm of \(S(j\omega)\) over all frequencies.
|
||
</p>
|
||
|
||
|
||
<div id="orga81ebd4" 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 23: </span>Generalized Plant</p>
|
||
</div>
|
||
|
||
|
||
<div class="important" id="orgc9184cf">
|
||
<p>
|
||
The <i>trick</i> is to include a <b>weighting function</b> \(W_S(s)\) in the generalized plant as shown in Figure <a href="#org70ac9e5">24</a>.
|
||
</p>
|
||
|
||
<p>
|
||
Now, the closed-loop transfer function from \(w\) to \(z\) is equal to \(W_s(s)S(s)\) and applying the \(\mathcal{H}_\infty\) synthesis to the <i>weighted</i> generalized plant \(\tilde{P}(s)\) will generate a controller \(K(s)\) such that \(\|W_s(s)S(s)\|_\infty\) is minimized.
|
||
</p>
|
||
|
||
</div>
|
||
|
||
<p>
|
||
Let’s now show how this is equivalent as <b>shaping</b> the sensitivity function:
|
||
</p>
|
||
\begin{align}
|
||
& \left\| W_s(s) S(s) \right\|_\infty < 1\nonumber \\
|
||
\Leftrightarrow & \left| W_s(j\omega) S(j\omega) \right| < 1 \quad \forall \omega\nonumber \\
|
||
\Leftrightarrow & \left| S(j\omega) \right| < \frac{1}{\left| W_s(j\omega) \right|} \quad \forall \omega \label{eq:sensitivity_shaping}
|
||
\end{align}
|
||
|
||
<div class="important" id="org7155fea">
|
||
<p>
|
||
As shown in Equation \eqref{eq:sensitivity_shaping}, the \(\mathcal{H}_\infty\) synthesis applying on the <i>weighted</i> generalized plant allows to <b>shape</b> the magnitude of the sensitivity transfer function.
|
||
</p>
|
||
|
||
<p>
|
||
Therefore, the choice of the weighting function \(W_s(s)\) is very important: its inverse magnitude will define the wanted <b>upper bound</b> of the sensitivity function magnitude.
|
||
</p>
|
||
|
||
</div>
|
||
|
||
|
||
<div id="org70ac9e5" 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 24: </span>Weighted Generalized Plant</p>
|
||
</div>
|
||
|
||
<div class="exercice" id="org8735fca">
|
||
<p>
|
||
Using matlab, compute the weighted generalized plant shown in Figure <a href="#org01ce2f5">25</a> as a function of \(G(s)\) and \(W_S(s)\).
|
||
</p>
|
||
|
||
<details><summary>Hint</summary>
|
||
<p>
|
||
The weighted generalized plant can be defined in Matlab using two techniques:
|
||
</p>
|
||
<ul class="org-ul">
|
||
<li>by writing manually the 4 transfer functions from \([w, u]\) to \([\tilde{\epsilon}, v]\)</li>
|
||
<li>by pre-multiplying the (non-weighted) generalized plant by a block-diagonal transfer function matrix containing the weights for the outputs \(z\) and <code>1</code> for the outputs \(v\)</li>
|
||
</ul>
|
||
</details>
|
||
|
||
<details><summary>Answer</summary>
|
||
<p>
|
||
The two solutions below can be used.
|
||
</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];
|
||
</pre>
|
||
</div>
|
||
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab">Pw = blkdiag(Ws, 1)<span class="org-type">*</span>P;
|
||
</pre>
|
||
</div>
|
||
|
||
<p>
|
||
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.
|
||
</p>
|
||
</details>
|
||
|
||
</div>
|
||
</div>
|
||
</div>
|
||
|
||
<div id="outline-container-org193cd4a" class="outline-3">
|
||
<h3 id="org193cd4a"><span class="section-number-3">5.2</span> Design of Weighting Functions</h3>
|
||
<div class="outline-text-3" id="text-5-2">
|
||
<p>
|
||
<a id="org9d243d9"></a>
|
||
</p>
|
||
|
||
<p>
|
||
Weighting function included in the generalized plant must be <b>proper</b>, <b>stable</b> and <b>minimum phase</b> transfer functions.
|
||
</p>
|
||
|
||
<div class="definition" id="org788d785">
|
||
<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>
|
||
|
||
</div>
|
||
|
||
<p>
|
||
Matlab is providing the <code>makeweight</code> function that allows to design first-order weights by specifying the low frequency gain, high frequency gain, and the 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>: low frequency gain</li>
|
||
<li><code>[freq,mag]</code>: frequency <code>freq</code> at which the gain is <code>mag</code></li>
|
||
<li><code>hfgain</code>: high frequency gain</li>
|
||
</ul>
|
||
|
||
<div class="exampl" id="org4fe1568">
|
||
<p>
|
||
The Matlab code below produces a weighting function with the following characteristics (Figure <a href="#org01ce2f5">25</a>):
|
||
</p>
|
||
<ul class="org-ul">
|
||
<li>Low frequency gain of 100</li>
|
||
<li>Gain of 1 at 10Hz</li>
|
||
<li>High frequency gain of 0.5</li>
|
||
</ul>
|
||
|
||
<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="org01ce2f5" class="figure">
|
||
<p><img src="figs/first_order_weight.png" alt="first_order_weight.png" />
|
||
</p>
|
||
<p><span class="figure-number">Figure 25: </span>Obtained Magnitude of the Weighting Function</p>
|
||
</div>
|
||
|
||
</div>
|
||
|
||
<div class="seealso" id="org433faad">
|
||
<p>
|
||
Quite often, higher orders weights are required.
|
||
</p>
|
||
|
||
<p>
|
||
In such case, the following formula can be used:
|
||
</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="org2d5bed4"><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"><=</span> args.G0 <span class="org-type">&&</span> args.Gc <span class="org-type"><=</span> args.G1) <span class="org-type">||</span> (args.Gc <span class="org-type">>=</span> args.G0 <span class="org-type">&&</span> args.Gc <span class="org-type">>=</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’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="#org16ef4bf">26</a>.
|
||
</p>
|
||
|
||
|
||
<div id="org16ef4bf" class="figure">
|
||
<p><img src="figs/high_order_weight.png" alt="high_order_weight.png" />
|
||
</p>
|
||
<p><span class="figure-number">Figure 26: </span>Higher order weights using Equation \eqref{eq:weight_formula_advanced}</p>
|
||
</div>
|
||
|
||
</div>
|
||
</div>
|
||
</div>
|
||
|
||
<div id="outline-container-orga44ffb5" class="outline-3">
|
||
<h3 id="orga44ffb5"><span class="section-number-3">5.3</span> Shaping the Sensitivity Function</h3>
|
||
<div class="outline-text-3" id="text-5-3">
|
||
<p>
|
||
<a id="orga27cfae"></a>
|
||
</p>
|
||
|
||
<p>
|
||
Let’s design a controller using the \(\mathcal{H}_\infty\) synthesis that fulfils the following requirements:
|
||
</p>
|
||
<ol class="org-ol">
|
||
<li>Bandwidth of at least 10Hz</li>
|
||
<li>Small static errors for step responses</li>
|
||
<li>Robustness: Large module margin \(\Delta M > 0.5\) (\(\Rightarrow \Delta G > 2\) and \(\Delta \phi > 29^o\))</li>
|
||
</ol>
|
||
|
||
<p>
|
||
As usual, the plant used is the one presented in Section <a href="#org1ceffea">1.3</a>.
|
||
</p>
|
||
|
||
<div class="exercice" id="org70e2a8f">
|
||
<p>
|
||
Translate the requirements as upper bounds on the Sensitivity function and design the corresponding Weight using Matlab.
|
||
</p>
|
||
|
||
<details><summary>Hint</summary>
|
||
<p>
|
||
The typical wanted upper bound of the sensitivity function is shown in Figure <a href="#org45ff50b">27</a>.
|
||
</p>
|
||
|
||
<p>
|
||
More precisely:
|
||
</p>
|
||
<ol class="org-ol">
|
||
<li>Recall that the closed-loop bandwidth is defined as the frequency \(|S(j\omega)|\) first crosses \(1/\sqrt{2} = -3dB\) from below</li>
|
||
<li>For the small static error, -60dB is usually enough as other factors (measurement noise, disturbances) will anyhow limit the performances</li>
|
||
<li>Recall that the module margin is equal to the inverse of the \(\mathcal{H}_\infty\) norm of the sensitivity function:
|
||
\[ \Delta M = \frac{1}{\|S\|_\infty} \]</li>
|
||
</ol>
|
||
|
||
<p>
|
||
Remember that the wanted upper bound of the sensitivity function is defined by the <b>inverse</b> magnitude of the weight.
|
||
</p>
|
||
|
||
|
||
<div id="org45ff50b" class="figure">
|
||
<p><img src="figs/h-infinity-spec-S.png" alt="h-infinity-spec-S.png" />
|
||
</p>
|
||
<p><span class="figure-number">Figure 27: </span>Typical wanted shape of the Sensitivity transfer function</p>
|
||
</div>
|
||
</details>
|
||
|
||
<details><summary>Answer</summary>
|
||
<ol class="org-ol">
|
||
<li>\(|W_s(j \cdot 2 \pi 10)| = \sqrt{2}\)</li>
|
||
<li>\(|W_s(j \cdot 0)| = 10^3\)</li>
|
||
<li>\(\|W_s\|_\infty = 0.5\)</li>
|
||
</ol>
|
||
|
||
<p>
|
||
Using Matlab, such weighting function can be generated using the <code>makeweight</code> function as shown below:
|
||
</p>
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab">Ws = makeweight(1e3, [2<span class="org-type">*</span><span class="org-constant">pi</span><span class="org-type">*</span>10, sqrt(2)], 1<span class="org-type">/</span>2);
|
||
</pre>
|
||
</div>
|
||
|
||
<p>
|
||
Or using the <code>generateWeight</code> function:
|
||
</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>, sqrt(2), <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>
|
||
</details>
|
||
|
||
</div>
|
||
|
||
<p>
|
||
Let’s say we came up with the following weighting function:
|
||
</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>, sqrt(2), <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>
|
||
The weighting function is then added to the generalized plant.
|
||
</p>
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab">P = [1 <span class="org-type">-</span>G;
|
||
1 <span class="org-type">-</span>G];
|
||
Pw = blkdiag(Ws, 1)<span class="org-type">*</span>P;
|
||
</pre>
|
||
</div>
|
||
|
||
<p>
|
||
And the \(\mathcal{H}_\infty\) synthesis is performed on the <i>weighted</i> generalized plant.
|
||
</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="org81afd9c">
|
||
Test bounds: 0.5 <= gamma <= 0.51
|
||
|
||
gamma X>=0 Y>=0 rho(XY)<1 p/f
|
||
5.05e-01 0.0e+00 0.0e+00 3.000e-16 p
|
||
Limiting gains...
|
||
5.05e-01 0.0e+00 0.0e+00 3.461e-16 p
|
||
5.05e-01 -3.5e+01 # -4.9e-14 1.732e-26 f
|
||
|
||
Best performance (actual): 0.503
|
||
</pre>
|
||
|
||
<p>
|
||
\(\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:
|
||
</p>
|
||
\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
|
||
\end{aligned}
|
||
|
||
<p>
|
||
This is indeed what we can see by comparing \(|S|\) and \(|W_S|\) in Figure <a href="#org9422688">28</a>.
|
||
</p>
|
||
|
||
<div class="important" id="orgf5828ce">
|
||
<p>
|
||
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.
|
||
</p>
|
||
|
||
<p>
|
||
Having \(\gamma\) slightly above one does not necessary means the obtained controller is not “good”.
|
||
It just means that at some frequency, one of the closed-loop transfer functions is above the specified upper bound by a factor \(\gamma\).
|
||
</p>
|
||
|
||
</div>
|
||
|
||
|
||
<div id="org9422688" class="figure">
|
||
<p><img src="figs/results_sensitivity_hinf.png" alt="results_sensitivity_hinf.png" />
|
||
</p>
|
||
<p><span class="figure-number">Figure 28: </span>Weighting function and obtained closed-loop sensitivity</p>
|
||
</div>
|
||
</div>
|
||
</div>
|
||
|
||
<div id="outline-container-org52c7109" class="outline-3">
|
||
<h3 id="org52c7109"><span class="section-number-3">5.4</span> Shaping multiple closed-loop transfer functions</h3>
|
||
<div class="outline-text-3" id="text-5-4">
|
||
<p>
|
||
<a id="orgd769661"></a>
|
||
</p>
|
||
|
||
<p>
|
||
As was shown in Section <a href="#orgdd9776f">4</a>, depending on the specifications, up to four closed-loop transfer function may be shaped (the Gang of four).
|
||
This was summarized in Table <a href="#org1431c7d">8</a>.
|
||
</p>
|
||
|
||
<p>
|
||
For instance to limit the control input \(u\), \(KS\) should be shaped while to filter measurement noise, \(T\) should be shaped.
|
||
</p>
|
||
|
||
<p>
|
||
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 <a href="#org3c7b185">6</a>.
|
||
</p>
|
||
|
||
<p>
|
||
Depending on the closed-loop transfer function being shaped, different general control configuration are used and are described below.
|
||
</p>
|
||
<details><summary>Shaping of S and KS</summary>
|
||
|
||
<div id="org367603e" class="figure">
|
||
<p><img src="figs/general_conf_shaping_S_KS.png" alt="general_conf_shaping_S_KS.png" />
|
||
</p>
|
||
<p><span class="figure-number">Figure 29: </span>Generalized Plant to shape \(S\) and \(KS\)</p>
|
||
</div>
|
||
|
||
<div class="org-src-container">
|
||
<label class="org-src-name"><span class="listing-number">Listing 2: </span>General Plant definition corresponding to Figure <a href="#org367603e">29</a></label><pre class="src src-matlab" id="orgaa7b456">P = [W1 <span class="org-type">-</span>G<span class="org-type">*</span>W1
|
||
0 W2
|
||
1 <span class="org-type">-</span>G];
|
||
</pre>
|
||
</div>
|
||
|
||
<ul class="org-ul">
|
||
<li>\(W_1(s)\) is used to shape \(S\)</li>
|
||
<li>\(W_2(s)\) is used to shape \(KS\)</li>
|
||
</ul>
|
||
</details>
|
||
<details><summary>Shaping of S and T</summary>
|
||
|
||
<div id="org1a08af0" class="figure">
|
||
<p><img src="figs/general_conf_shaping_S_T.png" alt="general_conf_shaping_S_T.png" />
|
||
</p>
|
||
<p><span class="figure-number">Figure 30: </span>Generalized Plant to shape \(S\) and \(T\)</p>
|
||
</div>
|
||
|
||
<div class="org-src-container">
|
||
<label class="org-src-name"><span class="listing-number">Listing 3: </span>General Plant definition corresponding to Figure <a href="#org1a08af0">30</a></label><pre class="src src-matlab" id="orgf6c1ae2">P = [W1 <span class="org-type">-</span>G<span class="org-type">*</span>W1
|
||
0 G<span class="org-type">*</span>W2
|
||
1 <span class="org-type">-</span>G];
|
||
</pre>
|
||
</div>
|
||
|
||
<ul class="org-ul">
|
||
<li>\(W_1\) is used to shape \(S\)</li>
|
||
<li>\(W_2\) is used to shape \(T\)</li>
|
||
</ul>
|
||
</details>
|
||
<details><summary>Shaping of S and GS</summary>
|
||
|
||
<div id="org03896c2" class="figure">
|
||
<p><img src="figs/general_conf_shaping_S_GS.png" alt="general_conf_shaping_S_GS.png" />
|
||
</p>
|
||
<p><span class="figure-number">Figure 31: </span>Generalized Plant to shape \(S\) and \(GS\)</p>
|
||
</div>
|
||
|
||
<div class="org-src-container">
|
||
<label class="org-src-name"><span class="listing-number">Listing 4: </span>General Plant definition corresponding to Figure <a href="#org03896c2">31</a></label><pre class="src src-matlab" id="orgfdf399e">P = [W1 <span class="org-type">-</span>W1
|
||
G<span class="org-type">*</span>W2 <span class="org-type">-</span>G<span class="org-type">*</span>W2
|
||
G <span class="org-type">-</span>G];
|
||
</pre>
|
||
</div>
|
||
<ul class="org-ul">
|
||
<li>\(W_1\) is used to shape \(S\)</li>
|
||
<li>\(W_2\) is used to shape \(GS\)</li>
|
||
</ul>
|
||
</details>
|
||
<details><summary>Shaping of S, T and KS</summary>
|
||
|
||
<div id="orgef8369a" class="figure">
|
||
<p><img src="figs/general_conf_shaping_S_T_KS.png" alt="general_conf_shaping_S_T_KS.png" />
|
||
</p>
|
||
<p><span class="figure-number">Figure 32: </span>Generalized Plant to shape \(S\), \(T\) and \(KS\)</p>
|
||
</div>
|
||
|
||
<div class="org-src-container">
|
||
<label class="org-src-name"><span class="listing-number">Listing 5: </span>General Plant definition corresponding to Figure <a href="#orgef8369a">32</a></label><pre class="src src-matlab" id="orged4e76b">P = [W1 <span class="org-type">-</span>G<span class="org-type">*</span>W1
|
||
0 W2
|
||
0 G<span class="org-type">*</span>W3
|
||
1 <span class="org-type">-</span>G];
|
||
</pre>
|
||
</div>
|
||
|
||
<ul class="org-ul">
|
||
<li>\(W_1\) is used to shape \(S\)</li>
|
||
<li>\(W_2\) is used to shape \(KS\)</li>
|
||
<li>\(W_3\) is used to shape \(T\)</li>
|
||
</ul>
|
||
</details>
|
||
<details><summary>Shaping of S, T and GS</summary>
|
||
|
||
<div id="orgbdedc18" class="figure">
|
||
<p><img src="figs/general_conf_shaping_S_T_GS.png" alt="general_conf_shaping_S_T_GS.png" />
|
||
</p>
|
||
<p><span class="figure-number">Figure 33: </span>Generalized Plant to shape \(S\), \(T\) and \(GS\)</p>
|
||
</div>
|
||
|
||
<div class="org-src-container">
|
||
<label class="org-src-name"><span class="listing-number">Listing 6: </span>General Plant definition corresponding to Figure <a href="#orgbdedc18">33</a></label><pre class="src src-matlab" id="org54d3fcc">P = [W1 <span class="org-type">-</span>W1
|
||
G<span class="org-type">*</span>W2 <span class="org-type">-</span>G<span class="org-type">*</span>W2
|
||
0 W3
|
||
G <span class="org-type">-</span>G];
|
||
</pre>
|
||
</div>
|
||
|
||
<ul class="org-ul">
|
||
<li>\(W_1\) is used to shape \(S\)</li>
|
||
<li>\(W_2\) is used to shape \(GS\)</li>
|
||
<li>\(W_3\) is used to shape \(T\)</li>
|
||
</ul>
|
||
</details>
|
||
<details><summary>Shaping of S, T, KS and GS</summary>
|
||
|
||
<div id="orgfd4184f" class="figure">
|
||
<p><img src="figs/general_conf_shaping_S_T_KS_GS.png" alt="general_conf_shaping_S_T_KS_GS.png" />
|
||
</p>
|
||
<p><span class="figure-number">Figure 34: </span>Generalized Plant to shape \(S\), \(T\), \(KS\) and \(GS\)</p>
|
||
</div>
|
||
|
||
<div class="org-src-container">
|
||
<label class="org-src-name"><span class="listing-number">Listing 7: </span>General Plant definition corresponding to Figure <a href="#orgfd4184f">34</a></label><pre class="src src-matlab" id="orga180c9c">P = [ W1 <span class="org-type">-</span>W1<span class="org-type">*</span>G<span class="org-type">*</span>W3 <span class="org-type">-</span>G<span class="org-type">*</span>W1
|
||
0 0 W2
|
||
1 <span class="org-type">-</span>G<span class="org-type">*</span>W3 <span class="org-type">-</span>G];
|
||
</pre>
|
||
</div>
|
||
|
||
<ul class="org-ul">
|
||
<li>\(W_1\) is used to shape \(S\)</li>
|
||
<li>\(W_2\) is used to shape \(KS\)</li>
|
||
<li>\(W_1W_3\) is used to shape \(GS\)</li>
|
||
<li>\(W_2W_3\) is used to shape \(T\)</li>
|
||
</ul>
|
||
</details>
|
||
<p>
|
||
When shaping multiple closed-loop transfer functions, one should be verify careful about the three following points that are further discussed:
|
||
</p>
|
||
<ul class="org-ul">
|
||
<li>The shaped closed-loop transfer functions are linked by mathematical relations and cannot be shaped</li>
|
||
<li>Closed-loop transfer function can only be shaped in certain frequency range.</li>
|
||
<li>The size of the obtained controller may be very large and not implementable in practice</li>
|
||
</ul>
|
||
|
||
|
||
|
||
<div class="warning" id="orgc69a919">
|
||
<p>
|
||
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:
|
||
</p>
|
||
\begin{equation}
|
||
S(s) + T(s) = 1
|
||
\end{equation}
|
||
|
||
<p>
|
||
This means that \(|S(j\omega)|\) and \(|T(j\omega)|\) cannot be made small at the same time!
|
||
</p>
|
||
|
||
<p>
|
||
It is therefore <b>not</b> possible to shape the four closed-loop transfer functions independently.
|
||
The weighting function should be carefully design such as these fundamental relations are not violated.
|
||
</p>
|
||
|
||
</div>
|
||
|
||
<p>
|
||
The control bandwidth is clearly limited by physical constrains such as sampling frequency, electronics bandwidth,
|
||
</p>
|
||
|
||
\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*}
|
||
|
||
<p>
|
||
Similar relationship can be found for \(T\), \(KS\) and \(GS\).
|
||
</p>
|
||
|
||
<div class="exercice" id="orgd37c5e5">
|
||
<p>
|
||
Determine the approximate norms of \(T\), \(KS\) and \(GS\) for large loop gains (\(|G(j\omega) K(j\omega)| \gg 1\)) and small loop gains (\(|G(j\omega) K(j\omega)| \ll 1\)).
|
||
</p>
|
||
|
||
<details><summary>Hint</summary>
|
||
<p>
|
||
You can follows this procedure for \(T\), \(KS\) and \(GS\):
|
||
</p>
|
||
<ol class="org-ol">
|
||
<li>Write the closed-loop transfer function \(T(s)\) as a function of \(K(s)\) and \(G(s)\)</li>
|
||
<li>Take \(|K(j\omega)G(j\omega)| \gg 1\) and conclude on \(|T(j\omega)|\)</li>
|
||
<li>Take \(|K(j\omega)G(j\omega)| \ll 1\) and conclude on \(|T(j\omega)|\)</li>
|
||
</ol>
|
||
</details>
|
||
|
||
<details><summary>Answer</summary>
|
||
<p>
|
||
The obtained constrains are shown in Figure <a href="#org8b9aa81">35</a>.
|
||
</p>
|
||
</details>
|
||
|
||
</div>
|
||
|
||
<p>
|
||
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 <b>cannot</b> be shaped.
|
||
</p>
|
||
|
||
<p>
|
||
Therefore the weighting functions should only focus on certainty frequency range depending on the transfer function being shaped.
|
||
These regions are summarized in Figure <a href="#org8b9aa81">35</a>.
|
||
</p>
|
||
|
||
|
||
<div id="org8b9aa81" class="figure">
|
||
<p><img src="figs/h-infinity-4-blocs-constrains.png" alt="h-infinity-4-blocs-constrains.png" />
|
||
</p>
|
||
<p><span class="figure-number">Figure 35: </span>Shaping the Gang of Four: Limitations</p>
|
||
</div>
|
||
|
||
<div class="warning" id="org6ba9b6e">
|
||
<p>
|
||
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.
|
||
It is thus equal to the <b>sum</b> of the number of state of the non-weighted generalized plant and the number of state of all the weighting functions.
|
||
</p>
|
||
|
||
<p>
|
||
Two approaches can be used to obtain controllers with reasonable order:
|
||
</p>
|
||
<ol class="org-ol">
|
||
<li>use simple weights (usually first order)</li>
|
||
<li>perform a model reduction on the obtained high order controller</li>
|
||
</ol>
|
||
|
||
</div>
|
||
</div>
|
||
</div>
|
||
</div>
|
||
|
||
<div id="outline-container-org22bfb42" class="outline-2">
|
||
<h2 id="org22bfb42"><span class="section-number-2">6</span> Mixed-Sensitivity \(\mathcal{H}_\infty\) Control - Example</h2>
|
||
<div class="outline-text-2" id="text-6">
|
||
<p>
|
||
<a id="org3c7b185"></a>
|
||
</p>
|
||
</div>
|
||
|
||
<div id="outline-container-org6f204af" class="outline-3">
|
||
<h3 id="org6f204af"><span class="section-number-3">6.1</span> Control Problem</h3>
|
||
<div class="outline-text-3" id="text-6-1">
|
||
<ul class="org-ul">
|
||
<li class="off"><code>[ ]</code> Control Diagram</li>
|
||
</ul>
|
||
|
||
|
||
<ul class="org-ul">
|
||
<li>Inputs Signals
|
||
<ul class="org-ul">
|
||
<li>Reference steps of 1mm</li>
|
||
<li>Measurement noise is considered to be a white noise with a power spectral density of …</li>
|
||
</ul></li>
|
||
<li>Specifications
|
||
<ul class="org-ul">
|
||
<li>Follow reference steps with a response time of 0.1s and static error less than \(1 \mu m\)</li>
|
||
<li>Maximum control signal of 10N</li>
|
||
<li>Robustness</li>
|
||
<li>Reduce the effect of measurement noise on the position</li>
|
||
</ul></li>
|
||
</ul>
|
||
|
||
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab">k = 1e6; <span class="org-comment">% Stiffness [N/m]</span>
|
||
c = 4e2; <span class="org-comment">% Damping [N/(m/s)]</span>
|
||
m = 10; <span class="org-comment">% Mass [kg]</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>
|
||
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 class="org-src-container">
|
||
<pre class="src src-matlab"><span class="org-comment">% Generate Input Signals</span>
|
||
t = 0<span class="org-type">:</span>1e<span class="org-type">-</span>3<span class="org-type">:</span>1;
|
||
|
||
r = zeros(size(t));
|
||
r(t<span class="org-type">></span>0.1) = 1e<span class="org-type">-</span>3;
|
||
|
||
|
||
Fs = 1e3; <span class="org-comment">% Sampling Frequency [Hz]</span>
|
||
Ts = 1<span class="org-type">/</span>Fs; <span class="org-comment">% Sampling Time [s]</span>
|
||
n = sqrt(Fs<span class="org-type">/</span>2)<span class="org-type">*</span>randn(1, length(t)); <span class="org-comment">% Signal with an ASD equal to one</span>
|
||
n = n<span class="org-type">*</span>1e<span class="org-type">-</span>6;
|
||
|
||
d = zeros(size(t));
|
||
d(t<span class="org-type">></span>0.5) = 5e<span class="org-type">-</span>4;
|
||
</pre>
|
||
</div>
|
||
</div>
|
||
</div>
|
||
|
||
<div id="outline-container-org32ad71c" class="outline-3">
|
||
<h3 id="org32ad71c"><span class="section-number-3">6.2</span> Control Design Procedure</h3>
|
||
<div class="outline-text-3" id="text-6-2">
|
||
<table border="2" cellspacing="0" cellpadding="6" rules="groups" frame="hsides">
|
||
|
||
|
||
<colgroup>
|
||
<col class="org-left" />
|
||
|
||
<col class="org-left" />
|
||
|
||
<col class="org-left" />
|
||
</colgroup>
|
||
<thead>
|
||
<tr>
|
||
<th scope="col" class="org-left"> </th>
|
||
<th scope="col" class="org-left"> </th>
|
||
<th scope="col" class="org-left"> </th>
|
||
</tr>
|
||
</thead>
|
||
<tbody>
|
||
<tr>
|
||
<td class="org-left">Response Time</td>
|
||
<td class="org-left"> </td>
|
||
<td class="org-left"> </td>
|
||
</tr>
|
||
|
||
<tr>
|
||
<td class="org-left">Robustness</td>
|
||
<td class="org-left"> </td>
|
||
<td class="org-left"> </td>
|
||
</tr>
|
||
|
||
<tr>
|
||
<td class="org-left">Limitation of the Command Amplitude</td>
|
||
<td class="org-left"> </td>
|
||
<td class="org-left"> </td>
|
||
</tr>
|
||
|
||
<tr>
|
||
<td class="org-left">Filtering of the measurement noise</td>
|
||
<td class="org-left"> </td>
|
||
<td class="org-left"> </td>
|
||
</tr>
|
||
</tbody>
|
||
</table>
|
||
|
||
|
||
<div id="org4f4c89a" class="figure">
|
||
<p><img src="figs/mixed_sensitivity_control_schematic.png" alt="mixed_sensitivity_control_schematic.png" />
|
||
</p>
|
||
<p><span class="figure-number">Figure 36: </span>Generalized Plant used for the Mixed Sensitivity Synthesis</p>
|
||
</div>
|
||
|
||
<ul class="org-ul">
|
||
<li>\(W_1\) is used to shape \(S\)</li>
|
||
<li>\(W_2\) is used to shape \(KS\)</li>
|
||
<li>\(W_3\) is used to shape \(T\)</li>
|
||
</ul>
|
||
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab">P = [1 <span class="org-type">-</span>G
|
||
0 1
|
||
0 G
|
||
1 <span class="org-type">-</span>G];
|
||
</pre>
|
||
</div>
|
||
</div>
|
||
</div>
|
||
|
||
<div id="outline-container-orge4c6edc" class="outline-3">
|
||
<h3 id="orge4c6edc"><span class="section-number-3">6.3</span> Step 1 - Shaping of \(S\)</h3>
|
||
<div class="outline-text-3" id="text-6-3">
|
||
<p>
|
||
<a id="orgc57c9fe"></a>
|
||
</p>
|
||
|
||
<p>
|
||
We start with the shaping of \(S\) alone.
|
||
To not constrain \(KS\) and \(T\), we set small values for \(W_2\) and \(W_3\)
|
||
</p>
|
||
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab">W2 = tf(1e<span class="org-type">-</span>8);
|
||
W3 = tf(0.1);
|
||
</pre>
|
||
</div>
|
||
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab">W1 = 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>, sqrt(2), <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);
|
||
</pre>
|
||
</div>
|
||
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab">Pw = blkdiag(W1, W2, W3, 1)<span class="org-type">*</span>P;
|
||
</pre>
|
||
</div>
|
||
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab">K1 = hinfsyn(Pw, 1, 1, <span class="org-string">'Display'</span>, <span class="org-string">'on'</span>);
|
||
</pre>
|
||
</div>
|
||
|
||
<pre class="example" id="orgf248927">
|
||
K1 = hinfsyn(Pw, 1, 1, 'Display', 'on');
|
||
|
||
Test bounds: 0.5 <= gamma <= 0.552
|
||
|
||
gamma X>=0 Y>=0 rho(XY)<1 p/f
|
||
5.25e-01 0.0e+00 0.0e+00 6.061e-16 p
|
||
5.13e-01 0.0e+00 0.0e+00 0.000e+00 p
|
||
5.06e-01 -2.5e+00 # -6.4e-14 1.440e-15 f
|
||
5.09e-01 -5.5e+00 # -4.1e-14 9.510e-16 f
|
||
Limiting gains...
|
||
5.14e-01 0.0e+00 0.0e+00 1.039e-25 p
|
||
5.14e-01 0.0e+00 0.0e+00 1.040e-25 p
|
||
|
||
Best performance (actual): 0.514
|
||
'org_babel_eoe'
|
||
ans =
|
||
'org_babel_eoe'
|
||
</pre>
|
||
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab">Z1 = lft(P, K1);
|
||
</pre>
|
||
</div>
|
||
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab"><span class="org-comment">% Create model with r and n as inputs and y and u as outputs</span>
|
||
Psim = [0 0 Gd G
|
||
0 0 0 1
|
||
1 <span class="org-type">-</span>1 <span class="org-type">-</span>Gd <span class="org-type">-</span>G];
|
||
Z1sim = lft(Psim, K1);
|
||
</pre>
|
||
</div>
|
||
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab">z = lsim(Z1sim, [r;n;d], t);
|
||
y1 = z(<span class="org-type">:</span>,1);
|
||
u1 = z(<span class="org-type">:</span>,2);
|
||
</pre>
|
||
</div>
|
||
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab"><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>);
|
||
|
||
nexttile;
|
||
hold on;
|
||
plot(t, y1);
|
||
hold off;
|
||
xlabel(<span class="org-string">'Time [s]'</span>); ylabel(<span class="org-string">'Output $y$ [m]'</span>);
|
||
|
||
nexttile;
|
||
hold on;
|
||
plot(t, u1);
|
||
hold off;
|
||
xlabel(<span class="org-string">'Time [s]'</span>); ylabel(<span class="org-string">'Control Input $u$ [N]'</span>);
|
||
</pre>
|
||
</div>
|
||
</div>
|
||
</div>
|
||
|
||
<div id="outline-container-orge5810a8" class="outline-3">
|
||
<h3 id="orge5810a8"><span class="section-number-3">6.4</span> Step 2 - Shaping of \(KS\)</h3>
|
||
<div class="outline-text-3" id="text-6-4">
|
||
<p>
|
||
<a id="org9d96e1a"></a>
|
||
</p>
|
||
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab">W2 = generateWeight(<span class="org-string">'G0'</span>, 5e<span class="org-type">-</span>7, ...
|
||
<span class="org-string">'G1'</span>, 1e<span class="org-type">-</span>3, ...
|
||
<span class="org-string">'Gc'</span>, 1e<span class="org-type">-</span>6, <span class="org-string">'wc'</span>, 2<span class="org-type">*</span><span class="org-constant">pi</span><span class="org-type">*</span>100, ...
|
||
<span class="org-string">'n'</span>, 1);
|
||
</pre>
|
||
</div>
|
||
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab">Pw = blkdiag(W1, W2, W3, 1)<span class="org-type">*</span>P;
|
||
</pre>
|
||
</div>
|
||
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab">K2 = hinfsyn(Pw, 1, 1, <span class="org-string">'Display'</span>, <span class="org-string">'on'</span>);
|
||
</pre>
|
||
</div>
|
||
|
||
<pre class="example" id="orgb52627d">
|
||
K1 = hinfsyn(Pw, 1, 1, 'Display', 'on');
|
||
|
||
Test bounds: 0.51 <= gamma <= 1.2
|
||
|
||
gamma X>=0 Y>=0 rho(XY)<1 p/f
|
||
7.82e-01 0.0e+00 0.0e+00 0.000e+00 p
|
||
6.32e-01 -2.2e+00 # -3.0e-14 -1.136e-32 f
|
||
7.03e-01 -5.1e+00 # -2.9e-14 5.128e-17 f
|
||
7.41e-01 -1.1e+01 # -1.0e-14 1.431e-22 f
|
||
7.61e-01 -2.6e+01 # -9.1e-15 1.215e-21 f
|
||
7.72e-01 -6.9e+01 # -1.9e-14 2.828e-16 f
|
||
7.77e-01 -3.6e+02 # -1.2e-14 1.213e-15 f
|
||
|
||
Best performance (actual): 0.782
|
||
'org_babel_eoe'
|
||
ans =
|
||
'org_babel_eoe'
|
||
</pre>
|
||
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab">Z2 = lft(P, K2);
|
||
</pre>
|
||
</div>
|
||
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab">Z2sim = lft(Psim, K2);
|
||
</pre>
|
||
</div>
|
||
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab">z = lsim(Z2sim, [r;n;d], t);
|
||
y2 = z(<span class="org-type">:</span>,1);
|
||
u2 = z(<span class="org-type">:</span>,2);
|
||
</pre>
|
||
</div>
|
||
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab"><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>);
|
||
|
||
nexttile;
|
||
hold on;
|
||
plot(t, y1);
|
||
plot(t, y2);
|
||
hold off;
|
||
xlabel(<span class="org-string">'Time [s]'</span>); ylabel(<span class="org-string">'Output $y$ [m]'</span>);
|
||
|
||
nexttile;
|
||
hold on;
|
||
plot(t, u1);
|
||
plot(t, u2);
|
||
hold off;
|
||
xlabel(<span class="org-string">'Time [s]'</span>); ylabel(<span class="org-string">'Control Input $u$ [N]'</span>);
|
||
</pre>
|
||
</div>
|
||
</div>
|
||
</div>
|
||
|
||
<div id="outline-container-org9df5a7e" class="outline-3">
|
||
<h3 id="org9df5a7e"><span class="section-number-3">6.5</span> Step 3 - Shaping of \(T\)</h3>
|
||
<div class="outline-text-3" id="text-6-5">
|
||
<p>
|
||
<a id="orgb19a91a"></a>
|
||
</p>
|
||
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab">W3 = generateWeight(<span class="org-string">'G0'</span>, 1e<span class="org-type">-</span>1, ...
|
||
<span class="org-string">'G1'</span>, 1e4, ...
|
||
<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>30, ...
|
||
<span class="org-string">'n'</span>, 3);
|
||
</pre>
|
||
</div>
|
||
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab">Pw = blkdiag(W1, W2, W3, 1)<span class="org-type">*</span>P;
|
||
</pre>
|
||
</div>
|
||
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab">K3 = hinfsyn(Pw, 1, 1, <span class="org-string">'Display'</span>, <span class="org-string">'on'</span>);
|
||
</pre>
|
||
</div>
|
||
|
||
<pre class="example" id="org4cf916e">
|
||
K3 = hinfsyn(Pw, 1, 1, 'Display', 'on');
|
||
|
||
Test bounds: 0.578 <= gamma <= 1.66
|
||
|
||
gamma X>=0 Y>=0 rho(XY)<1 p/f
|
||
9.78e-01 -1.3e+01 # -6.2e-15 1.141e-18 f
|
||
1.27e+00 0.0e+00 0.0e+00 1.524e-15 p
|
||
1.12e+00 0.0e+00 0.0e+00 4.481e-15 p
|
||
1.04e+00 -4.0e+01 # -1.0e-13 1.102e-42 f
|
||
1.08e+00 -6.6e+02 # -4.4e-15 3.641e-18 f
|
||
1.10e+00 0.0e+00 0.0e+00 6.052e-21 p
|
||
1.09e+00 0.0e+00 0.0e+00 5.005e-15 p
|
||
|
||
Best performance (actual): 1.09
|
||
'org_babel_eoe'
|
||
ans =
|
||
'org_babel_eoe'
|
||
</pre>
|
||
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab">Z3 = lft(P, K3);
|
||
</pre>
|
||
</div>
|
||
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab">Z3sim = lft(Psim, K3);
|
||
</pre>
|
||
</div>
|
||
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab">z = lsim(Z3sim, [r;n;d], t);
|
||
y3 = z(<span class="org-type">:</span>,1);
|
||
u3 = z(<span class="org-type">:</span>,2);
|
||
</pre>
|
||
</div>
|
||
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab"><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>);
|
||
|
||
nexttile;
|
||
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">'Output $y$ [m]'</span>);
|
||
|
||
nexttile;
|
||
hold on;
|
||
plot(t, u1);
|
||
plot(t, u2);
|
||
plot(t, u3);
|
||
hold off;
|
||
xlabel(<span class="org-string">'Time [s]'</span>); ylabel(<span class="org-string">'Control Input $u$ [N]'</span>);
|
||
</pre>
|
||
</div>
|
||
</div>
|
||
</div>
|
||
</div>
|
||
|
||
<div id="outline-container-org5edd8f5" class="outline-2">
|
||
<h2 id="org5edd8f5"><span class="section-number-2">7</span> Conclusion</h2>
|
||
<div class="outline-text-2" id="text-7">
|
||
<p>
|
||
<a id="org107ba45"></a>
|
||
</p>
|
||
</div>
|
||
</div>
|
||
|
||
<div id="outline-container-org5325241" class="outline-2">
|
||
<h2 id="org5325241">Resources</h2>
|
||
<div class="outline-text-2" id="text-org5325241">
|
||
<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>
|
||
|
||
<style>.csl-left-margin{float: left; padding-right: 0em;} .csl-right-inline{margin: 0 0 0 1.7999999999999998em;}</style><h2 class='citeproc-org-bib-h2'>Bibliography</h2>
|
||
<div class="csl-bib-body">
|
||
<div class="csl-entry"><a name="citeproc_bib_item_1"></a>
|
||
<div class="csl-left-margin">[1]</div><div class="csl-right-inline">B. J. Lurie, A. Ghavimi, F. Y. Hadaegh, and E. Mettler, “System Architecture Trades Using Bode-Step Control Design,” <i>Journal of Guidance, Control, and Dynamics</i>, vol. 25, no. 2, pp. 309–315, 2002, [Online]. Available: <a href="https://doi.org/10.2514/2.4883">https://doi.org/10.2514/2.4883</a>.</div>
|
||
</div>
|
||
</div>
|
||
</div>
|
||
</div>
|
||
</div>
|
||
<div id="postamble" class="status">
|
||
<p class="author">Author: Dehaeze Thomas</p>
|
||
<p class="date">Created: 2020-12-02 mer. 19:00</p>
|
||
</div>
|
||
</body>
|
||
</html>
|