3356 lines
126 KiB
HTML
3356 lines
126 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-03 jeu. 11:50 -->
|
||
<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="#orgbd74025">1. Introduction to Model Based Control</a>
|
||
<ul>
|
||
<li><a href="#orgbf87e5b">1.1. Model Based Control - Methodology</a></li>
|
||
<li><a href="#org9ddcc91">1.2. From Classical Control to Robust Control</a></li>
|
||
<li><a href="#org616fdf1">1.3. Example System</a></li>
|
||
</ul>
|
||
</li>
|
||
<li><a href="#org0fe772d">2. Classical Open Loop Shaping</a>
|
||
<ul>
|
||
<li><a href="#org01b7508">2.1. Introduction to Loop Shaping</a></li>
|
||
<li><a href="#org801bad7">2.2. Example of Manual Open Loop Shaping</a></li>
|
||
<li><a href="#orgfe9ee3a">2.3. \(\mathcal{H}_\infty\) Loop Shaping Synthesis</a></li>
|
||
<li><a href="#org3909dce">2.4. Example of the \(\mathcal{H}_\infty\) Loop Shaping Synthesis</a></li>
|
||
</ul>
|
||
</li>
|
||
<li><a href="#orgaeeba39">3. A first Step into the \(\mathcal{H}_\infty\) world</a>
|
||
<ul>
|
||
<li><a href="#org1b07c31">3.1. The \(\mathcal{H}_\infty\) Norm</a></li>
|
||
<li><a href="#org3a7e72b">3.2. \(\mathcal{H}_\infty\) Synthesis</a></li>
|
||
<li><a href="#orgfe86f9e">3.3. The Generalized Plant</a></li>
|
||
<li><a href="#org1db279f">3.4. The \(\mathcal{H}_\infty\) Synthesis applied on the Generalized plant</a></li>
|
||
<li><a href="#orgb588036">3.5. From a Classical Feedback Architecture to a Generalized Plant</a></li>
|
||
</ul>
|
||
</li>
|
||
<li><a href="#org89ee567">4. Modern Interpretation of Control Specifications</a>
|
||
<ul>
|
||
<li><a href="#org77a5834">4.1. Closed Loop Transfer Functions and the Gang of Four</a></li>
|
||
<li><a href="#orgf6a982e">4.2. The Sensitivity Function</a></li>
|
||
<li><a href="#orgc66e6d9">4.3. Robustness: Module Margin</a></li>
|
||
<li><a href="#org4050a50">4.4. Summary of</a></li>
|
||
</ul>
|
||
</li>
|
||
<li><a href="#orgf854cea">5. \(\mathcal{H}_\infty\) Shaping of closed-loop transfer functions</a>
|
||
<ul>
|
||
<li><a href="#org3dc9ac4">5.1. How to Shape closed-loop transfer function? Using Weighting Functions!</a></li>
|
||
<li><a href="#org448f9ca">5.2. Design of Weighting Functions</a></li>
|
||
<li><a href="#org2a78d75">5.3. Shaping the Sensitivity Function</a></li>
|
||
<li><a href="#orgdfea9a1">5.4. Shaping multiple closed-loop transfer functions - Limitations</a></li>
|
||
</ul>
|
||
</li>
|
||
<li><a href="#org7f7d381">6. Mixed-Sensitivity \(\mathcal{H}_\infty\) Control - Example</a>
|
||
<ul>
|
||
<li><a href="#org312dce5">6.1. Control Problem</a></li>
|
||
<li><a href="#org7967c7a">6.2. Control Design Procedure</a></li>
|
||
<li><a href="#orgd8515b8">6.3. Modern Interpretation of control specifications</a></li>
|
||
<li><a href="#org4dd52c5">6.4. Step 1 - Shaping of \(S\)</a></li>
|
||
<li><a href="#org9f0fcd6">6.5. Step 2 - Shaping of \(GS\)</a></li>
|
||
<li><a href="#orgdc318b7">6.6. Step 3 - Shaping of \(T\)</a></li>
|
||
<li><a href="#orgd3e7a58">6.7. Conclusion and Discussion</a></li>
|
||
</ul>
|
||
</li>
|
||
<li><a href="#orgfc86d06">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="#org7bab004">1</a></li>
|
||
<li>Classical <i>open</i> loop shaping method is presented in Section <a href="#org2a78693">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="#orgf832318">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="#org9f2323d">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="#org298ba4a">5</a></li>
|
||
<li>Finally, complete examples of the use of \(\mathcal{H}_\infty\) Control for practical problems are provided in Section <a href="#org1e723f2">6</a>.</li>
|
||
</ul>
|
||
|
||
<div id="outline-container-orgbd74025" class="outline-2">
|
||
<h2 id="orgbd74025"><span class="section-number-2">1</span> Introduction to Model Based Control</h2>
|
||
<div class="outline-text-2" id="text-1">
|
||
<p>
|
||
<a id="org7bab004"></a>
|
||
</p>
|
||
</div>
|
||
|
||
<div id="outline-container-orgbf87e5b" class="outline-3">
|
||
<h3 id="orgbf87e5b"><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="org4684f17"></a>
|
||
</p>
|
||
|
||
<p>
|
||
The typical methodology for <b>Model Based Control</b> techniques is schematically shown in Figure <a href="#orgd7ca06c">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="orgd7ca06c" 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="#org2a78693">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="#org9f2323d">4</a>, <a href="#org298ba4a">5</a> and <a href="#org1e723f2">6</a>.
|
||
</p>
|
||
</div>
|
||
</div>
|
||
|
||
<div id="outline-container-org9ddcc91" class="outline-3">
|
||
<h3 id="org9ddcc91"><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="orge1f79e8"></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="#orgc2b5958">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="orgc2b5958" 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</td>
|
||
</tr>
|
||
|
||
<tr>
|
||
<td class="org-left"> </td>
|
||
<td class="org-center">Nyquist, Bode 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">Root Locus</td>
|
||
<td class="org-center"> </td>
|
||
<td class="org-center">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">Open Loop Shaping</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-org616fdf1" class="outline-3">
|
||
<h3 id="org616fdf1"><span class="section-number-3">1.3</span> Example System</h3>
|
||
<div class="outline-text-3" id="text-1-3">
|
||
<p>
|
||
<a id="orgf5e8646"></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="#orgdde0131">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="#orgdde0131">2</a> are listed and described in Table <a href="#orge85f4f6">2</a>.
|
||
</p>
|
||
|
||
|
||
<div id="orgdde0131" 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="orge85f4f6" 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="org63b7c31">
|
||
<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="#orgdde0131">2</a> into a classical feedback architecture as shown in Figure <a href="#org5b93071">6</a>.
|
||
</p>
|
||
|
||
|
||
<div id="org4bb8ed5" 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="#orgdde0131">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="#org5c9e5bc">4</a> and <a href="#orgc4074a4">5</a>.
|
||
</p>
|
||
|
||
|
||
<div id="org5c9e5bc" 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="orgc4074a4" 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-org0fe772d" class="outline-2">
|
||
<h2 id="org0fe772d"><span class="section-number-2">2</span> Classical Open Loop Shaping</h2>
|
||
<div class="outline-text-2" id="text-2">
|
||
<p>
|
||
<a id="org2a78693"></a>
|
||
</p>
|
||
<p>
|
||
After an introduction to classical Loop Shaping in Section <a href="#org4d79822">2.1</a>, a practical example is given in Section <a href="#org6855c28">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="#org1422060">2.3</a> and applied on the same example in Section <a href="#org5931353">2.4</a>.
|
||
</p>
|
||
</div>
|
||
|
||
<div id="outline-container-org01b7508" class="outline-3">
|
||
<h3 id="org01b7508"><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="org4d79822"></a>
|
||
</p>
|
||
|
||
<div class="definition" id="org60a90b9">
|
||
<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="org4e06e9b">
|
||
<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="#org5b93071">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="org5b93071" 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="#orgd405e80">7</a>.
|
||
Another interesting Loop shape called “Bode Step” is described in <a href="#citeproc_bib_item_1">[1]</a>.
|
||
</p>
|
||
|
||
|
||
<div id="orgd405e80" 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="#org9f2323d">4</a> and <a href="#org298ba4a">5</a>.
|
||
</p>
|
||
</div>
|
||
</div>
|
||
|
||
<div id="outline-container-org801bad7" class="outline-3">
|
||
<h3 id="org801bad7"><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="org6855c28"></a>
|
||
</p>
|
||
|
||
<div class="exampl" id="org15717a7">
|
||
<p>
|
||
Let’s take our example system described in Section <a href="#orgf5e8646">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="org7516477">
|
||
<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="#orgee2a97f">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="orgee2a97f" 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-orgfe9ee3a" class="outline-3">
|
||
<h3 id="orgfe9ee3a"><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="org1422060"></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="org0341a6e">
|
||
<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-org3909dce" class="outline-3">
|
||
<h3 id="org3909dce"><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="org5931353"></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="#org166ad6d">3</a>.
|
||
</p>
|
||
|
||
<p>
|
||
Such shape corresponds to the typical wanted Loop gain Shape shown in Figure <a href="#orgd405e80">7</a>.
|
||
</p>
|
||
|
||
<table id="org166ad6d" 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="#org06947d0">9</a> and matches the specified one by a factor \(\gamma \approx 2\).
|
||
</p>
|
||
|
||
|
||
<div id="org06947d0" 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="org53f8e5f">
|
||
<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="#org0a14374">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="org0a14374" 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="#org546e1eb">4</a>.
|
||
</p>
|
||
|
||
<table id="org546e1eb" 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-orgaeeba39" class="outline-2">
|
||
<h2 id="orgaeeba39"><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="orgf832318"></a>
|
||
</p>
|
||
<p>
|
||
In this section, the \(\mathcal{H}_\infty\) Synthesis method, which is based on the optimization of the \(\mathcal{H}_\infty\) norm of transfer functions, is introduced.
|
||
</p>
|
||
|
||
<p>
|
||
After the \(\mathcal{H}_\infty\) norm is defined in Section <a href="#org4628244">3.1</a>, the \(\mathcal{H}_\infty\) synthesis procedure is described in Section <a href="#org38ee764">3.2</a> .
|
||
</p>
|
||
|
||
<p>
|
||
The generalized plant, a very useful tool to describe a control problem, is presented in Section <a href="#org9503ed0">3.3</a>.
|
||
The \(\mathcal{H}_\infty\) is then applied to this generalized plant in Section <a href="#orgea00823">3.4</a>.
|
||
</p>
|
||
|
||
<p>
|
||
Finally, an example showing how to convert a typical feedback control architecture into a generalized plant is given in Section <a href="#org0992771">3.5</a>.
|
||
</p>
|
||
</div>
|
||
|
||
<div id="outline-container-org1b07c31" class="outline-3">
|
||
<h3 id="org1b07c31"><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="org4628244"></a>
|
||
</p>
|
||
|
||
<div class="definition" id="orgdcbc4bf">
|
||
<p>
|
||
The \(\mathcal{H}_\infty\) norm of a multi-input multi-output system \(G(s)\) is defined as the peak of the maximum singular value of its frequency response
|
||
</p>
|
||
\begin{equation}
|
||
\|G(s)\|_\infty = \max_\omega \bar{\sigma}\big( G(j\omega) \big)
|
||
\end{equation}
|
||
|
||
<p>
|
||
For a single-input single-output 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="orgcd8db7a">
|
||
<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 in Figure <a href="#org6675917">11</a> that indeed, the \(\mathcal{H}_\infty\) norm of \(G(s)\) does corresponds to the peak value of \(|G(j\omega)|\).
|
||
</p>
|
||
|
||
|
||
<div id="org6675917" 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-org3a7e72b" class="outline-3">
|
||
<h3 id="org3a7e72b"><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="org38ee764"></a>
|
||
</p>
|
||
|
||
<div class="definition" id="org81a75e6">
|
||
<p>
|
||
The \(\mathcal{H}_\infty\) synthesis is a method that uses an <b>algorithm</b> (LMI optimization, Riccati equation) to find a controller that stabilizes 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 in Section <a href="#org9f2323d">4</a>.
|
||
</p>
|
||
|
||
<div class="important" id="orgedd1d2e">
|
||
<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 using the generalized plant (described in the next section)</li>
|
||
<li>Translate the specifications as \(\mathcal{H}_\infty\) norms of transfer functions (Section <a href="#org9f2323d">4</a>)</li>
|
||
<li>Make the synthesis and analyze the obtained controller</li>
|
||
</ol>
|
||
|
||
<p>
|
||
As the \(\mathcal{H}_\infty\) synthesis usually gives very high order controllers, an additional step that reduces the controller order is sometimes required for practical implementation.
|
||
</p>
|
||
|
||
</div>
|
||
|
||
<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-orgfe86f9e" class="outline-3">
|
||
<h3 id="orgfe86f9e"><span class="section-number-3">3.3</span> The Generalized Plant</h3>
|
||
<div class="outline-text-3" id="text-3-3">
|
||
<p>
|
||
<a id="org9503ed0"></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.
|
||
</p>
|
||
|
||
<p>
|
||
The generalized plant, usually noted \(P(s)\), is shown in Figure <a href="#orgeab9299">12</a>.
|
||
It has two <i>sets</i> of inputs \([w,\,u]\) and two <i>sets</i> of outputs \([z\,v]\) such that:
|
||
</p>
|
||
\begin{equation}
|
||
\begin{bmatrix} z \\ v \end{bmatrix} = P \begin{bmatrix} w \\ u \end{bmatrix}
|
||
\end{equation}
|
||
|
||
<p>
|
||
The meaning of these inputs and outputs are summarized in Table <a href="#orga1fa892">5</a>.
|
||
</p>
|
||
|
||
<p>
|
||
A practical example about how to derive the generalized plant for a classical control problem is given in Section <a href="#org0992771">3.5</a>.
|
||
</p>
|
||
|
||
<div class="important" id="org970bf11">
|
||
|
||
<div id="orgeab9299" 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>
|
||
|
||
<table id="orga1fa892" 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-org1db279f" class="outline-3">
|
||
<h3 id="org1db279f"><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="orgea00823"></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="org02f4191">
|
||
<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 outputs \(v\), generates control signals \(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>
|
||
|
||
<p>
|
||
The obtained controller \(K\) and the generalized plant are connected as shown in Figure <a href="#org722dc48">13</a>.
|
||
</p>
|
||
|
||
|
||
<div id="org722dc48" 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>
|
||
|
||
</div>
|
||
|
||
<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 (of size <code>ncont x nmeas</code>) that minimizes the \(\mathcal{H}_\infty\) norm from \(w\) to \(z\).</li>
|
||
</ul>
|
||
|
||
<p>
|
||
Note that the general control configure of Figure <a href="#org722dc48">13</a>, as its name implies, is quite <i>general</i> and can represent feedback control as well as feedforward control architectures.
|
||
</p>
|
||
</div>
|
||
</div>
|
||
|
||
<div id="outline-container-orgb588036" class="outline-3">
|
||
<h3 id="orgb588036"><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="org0992771"></a>
|
||
</p>
|
||
|
||
<p>
|
||
The procedure to convert a typical control architecture as the one shown in Figure <a href="#orgb7115b6">14</a> to a generalized Plant is as follows:
|
||
</p>
|
||
<ol class="org-ol">
|
||
<li>Define signals of the generalized plant: \(w\), \(z\), \(u\) and \(v\)</li>
|
||
<li>Remove \(K\) and rearrange the inputs and outputs to match the generalized configuration shown in Figure <a href="#orgeab9299">12</a></li>
|
||
</ol>
|
||
|
||
<div class="exercice" id="orgeb8d17b">
|
||
<p>
|
||
Consider the feedback control architecture shown in Figure <a href="#orgb7115b6">14</a>.
|
||
Suppose we want to design \(K\) using the general \(\mathcal{H}_\infty\) synthesis, and suppose the signals to be minimized are the control input \(u\) and the tracking error \(\epsilon\).
|
||
</p>
|
||
<ol class="org-ol">
|
||
<li>Convert the control architecture to a generalized configuration</li>
|
||
<li>Compute the transfer function matrix of the generalized plant \(P\) using Matlab as a function or \(K\) and \(G\)</li>
|
||
</ol>
|
||
|
||
|
||
<div id="orgb7115b6" 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="#orgeab9299">12</a>.
|
||
</p>
|
||
</details>
|
||
|
||
<details><summary>Answer</summary>
|
||
<p>
|
||
The obtained generalized plant shown in Figure <a href="#org1cdf62c">15</a>.
|
||
</p>
|
||
|
||
|
||
<div id="org1cdf62c" 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-org89ee567" class="outline-2">
|
||
<h2 id="org89ee567"><span class="section-number-2">4</span> Modern Interpretation of Control Specifications</h2>
|
||
<div class="outline-text-2" id="text-4">
|
||
<p>
|
||
<a id="org9f2323d"></a>
|
||
</p>
|
||
<p>
|
||
As shown in Section <a href="#org2a78693">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.
|
||
As a matter of fact, the behavior of the closed-loop system by the <b>closed-loop</b> transfer functions.
|
||
These are derived of a typical feedback architecture functions in Section <a href="#org5925810">4.1</a>.
|
||
</p>
|
||
|
||
|
||
<p>
|
||
The modern interpretation of control specifications then consists of determining the <b>required shape of the closed-loop transfer functions</b> such that the system behavior corresponds to the requirements.
|
||
Once this is done, the \(\mathcal{H}_\infty\) synthesis can be used to generate a controller that will <b>shape</b> the closed-loop transfer function as specified..
|
||
This method is presented in Section <a href="#org298ba4a">5</a>.
|
||
</p>
|
||
|
||
|
||
<p>
|
||
One of the most important closed-loop transfer function is called the <b>sensitivity function</b>.
|
||
Its link with the closed-loop behavior of the feedback system is studied in Section <a href="#org4929f38">4.2</a>.
|
||
</p>
|
||
|
||
<p>
|
||
The robustness (stability margins) of the system can also be linked to the shape of the sensitivity function with the use of the <b>module margin</b> (Section <a href="#org4fbaa84">4.3</a>).
|
||
</p>
|
||
|
||
<p>
|
||
Links between typical control specifications and shapes of the closed-loop transfer functions are summarized in Section <a href="#org8d9bfb1">4.4</a>.
|
||
</p>
|
||
</div>
|
||
|
||
<div id="outline-container-org77a5834" class="outline-3">
|
||
<h3 id="org77a5834"><span class="section-number-3">4.1</span> Closed Loop Transfer Functions and the Gang of Four</h3>
|
||
<div class="outline-text-3" id="text-4-1">
|
||
<p>
|
||
<a id="org5925810"></a>
|
||
</p>
|
||
|
||
<p>
|
||
Consider the typical feedback system shown in Figure <a href="#org565b086">16</a>.
|
||
</p>
|
||
|
||
<p>
|
||
The behavior (performances) of this feedback system is determined by the closed-loop transfer functions from the inputs (\(r\), \(d\) and \(n\)) to the important signals such as \(\epsilon\), \(u\) and \(y\).
|
||
</p>
|
||
|
||
<p>
|
||
Depending on the specification, different closed-loop transfer functions do matter.
|
||
These are summarized in Table <a href="#orgb680c53">6</a>.
|
||
</p>
|
||
|
||
|
||
<div id="org565b086" 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 with \(r\) the reference signal, \(\epsilon\) the tracking error, \(d\) a disturbance acting at the plant input \(u\), \(y\) is the output signal and \(n\) the measurement noise</p>
|
||
</div>
|
||
|
||
<table id="orgb680c53" 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</td>
|
||
</tr>
|
||
|
||
<tr>
|
||
<td class="org-left">Robustness (stability margins)</td>
|
||
<td class="org-left">Module margin (see Section <a href="#org4fbaa84">4.3</a>)</td>
|
||
</tr>
|
||
</tbody>
|
||
</table>
|
||
|
||
<div class="exercice" id="orgce3df34">
|
||
<p>
|
||
For the feedback system in Figure <a href="#org565b086">16</a>, write the output signals \([\epsilon, u, y]\) as a function of the systems \(K(s), G(s)\) and the input signals \([r, d, n]\).
|
||
</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="org8e6356f">
|
||
<p>
|
||
We can see that they are 4 different closed-loop transfer functions describing the behavior of the feedback system in Figure <a href="#org565b086">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="org0b66697">
|
||
<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>
|
||
The behavior of the feedback system in Figure <a href="#org565b086">16</a> is fully described by the following set of equations:
|
||
</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-orgf6a982e" class="outline-3">
|
||
<h3 id="orgf6a982e"><span class="section-number-3">4.2</span> The Sensitivity Function</h3>
|
||
<div class="outline-text-3" id="text-4-2">
|
||
<p>
|
||
<a id="org4929f38"></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 for these four controllers are shown in Figure <a href="#orga88a27f">17</a> and the corresponding step responses are shown in Figure <a href="#org599081d">18</a>.
|
||
</p>
|
||
|
||
<p>
|
||
The comparison of the sensitivity functions shapes and their effect on the step response is summarized in Table <a href="#orgc658bf0">7</a>.
|
||
</p>
|
||
|
||
<table id="orgc658bf0" 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="orga88a27f" 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="org599081d" 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="org7accf3a">
|
||
<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="orgec2f4d3">
|
||
<p>
|
||
From the simple analysis above, we can draw a first estimation of the wanted shape for the sensitivity function (Figure <a href="#org481d31c">19</a>):
|
||
</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 (small \(\mathcal{H}_\infty\) norm) in order to limit large overshoot and oscillations.
|
||
This generally means higher robustness.
|
||
This will become clear in the next section about the <b>module margin</b>.</li>
|
||
</ul>
|
||
|
||
|
||
<div id="org481d31c" 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-orgc66e6d9" class="outline-3">
|
||
<h3 id="orgc66e6d9"><span class="section-number-3">4.3</span> Robustness: Module Margin</h3>
|
||
<div class="outline-text-3" id="text-4-3">
|
||
<p>
|
||
<a id="org4fbaa84"></a>
|
||
</p>
|
||
|
||
<p>
|
||
Let’s start this section by an example demonstrating why the phase and gain margins might not be good indicators of robustness.
|
||
Will follow a discussion about the module margin, a robustness indicator that can be linked to the \(\mathcal{H}_\infty\) norm of \(S\) and that will prove to be very useful.
|
||
</p>
|
||
|
||
<div class="exampl" id="org0e15abd">
|
||
<p>
|
||
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="#orga63a6d7">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 the Loop gain in Figure <a href="#orga63a6d7">20</a>:
|
||
</p>
|
||
<ul class="org-ul">
|
||
<li>Control bandwidth of \(\approx 10\, \text{Hz}\)</li>
|
||
<li>Infinite gain margin (the phase of the loop-gain never reaches \(-180^o\))</li>
|
||
<li>More than \(90^o\) of phase margin</li>
|
||
</ul>
|
||
|
||
<p>
|
||
This clearly indicate very good robustness of the closed-loop system!
|
||
Or does it? Let’s find out.
|
||
</p>
|
||
|
||
|
||
<div id="orga63a6d7" 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 controller is implemented in practice, and the “real” plant \(G_r(s)\) as a slightly lower damping factor than the one estimated for the model:
|
||
</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="#org1caa278">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 indicates 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="org1caa278" 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 renders 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 corresponding 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="orgcce62ef">
|
||
<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 will be 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="org2109057">
|
||
<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="org9d8c7d5">
|
||
<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="org0cfd81d">
|
||
<p>
|
||
A typical Nyquist plot is shown in Figure <a href="#org2e58fcc">22</a>.
|
||
The gain, phase and module margins are graphically shown to have an idea of what they represent.
|
||
</p>
|
||
|
||
|
||
<div id="org2e58fcc" 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="#org2e58fcc">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{1}{1 - \Delta M}; \quad \Delta \phi \ge \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}{\max_\omega \left| \frac{1}{1 + G(j\omega)K(j\omega)}\right|} \\
|
||
&= \frac{1}{\|S\|_\infty}
|
||
\end{align*}
|
||
|
||
<p>
|
||
Therefore, for a given \(\mathcal{H}_\infty\) norm of \(S\) (\(\|S\|_\infty = M_S\)), we have:
|
||
</p>
|
||
\begin{equation}
|
||
\Delta G \ge \frac{M_S}{M_S - 1}; \quad \Delta \phi \ge \frac{1}{M_S}
|
||
\end{equation}
|
||
|
||
<div class="important" id="orge85fca4">
|
||
<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 now understand why setting an upper bound on the magnitude of \(S\) is generally a good idea.
|
||
</p>
|
||
|
||
<div class="exampl" id="org7a9e6b0">
|
||
<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="org58e06ec">
|
||
<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-org4050a50" class="outline-3">
|
||
<h3 id="org4050a50"><span class="section-number-3">4.4</span> Summary of</h3>
|
||
<div class="outline-text-3" id="text-4-4">
|
||
<p>
|
||
<a id="org8d9bfb1"></a>
|
||
</p>
|
||
|
||
|
||
<p>
|
||
Noise Attenuation: typical wanted shape for \(T\)
|
||
</p>
|
||
|
||
<p>
|
||
\(S\) can be used to set a lower bound on the bandwidth
|
||
\(T\) can be used to set a higher bound on the bandwidth
|
||
\(T\) is used to make the system more robust to high frequency model uncertainties
|
||
</p>
|
||
|
||
|
||
|
||
<table id="org8a5a90a" 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-orgf854cea" class="outline-2">
|
||
<h2 id="orgf854cea"><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="org298ba4a"></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.
|
||
Therefore, the synthesis problem is to design \(K(s)\) such that closed-loop system is stable and such that the closed-loop transfer functions such as \(S\), \(KS\) and \(T\) are shaped as wanted.
|
||
This is clearly not simple as these closed-loop transfer functions does not depend linearly on \(K\).
|
||
But don’t worry, the \(\mathcal{H}_\infty\) synthesis will do this job for us!
|
||
</p>
|
||
|
||
<p>
|
||
To do so, <b>weighting functions</b> are included in the generalized plant and the \(\mathcal{H}_\infty\) synthesis applied on the <b>weighted</b> generalized plant.
|
||
Such procedure is presented in Section <a href="#org9dd595a">5.1</a>.
|
||
</p>
|
||
|
||
<p>
|
||
Some advice on the design of weighting functions are given in Section <a href="#orgfd97063">5.2</a>.
|
||
</p>
|
||
|
||
<p>
|
||
An example of the \(\mathcal{H}_\infty\) shaping of the sensitivity function is studied in Section <a href="#org427b7f9">5.3</a>.
|
||
</p>
|
||
|
||
<p>
|
||
Multiple closed-loop transfer functions can be shaped at the same time.
|
||
Such synthesis is usually called <b>Mixed-sensitivity Loop Shaping</b> and is one of the most powerful tool of the robust control theory.
|
||
Some insight on the use and limitations of such techniques are given in Section <a href="#org86dd54b">5.4</a>.
|
||
</p>
|
||
</div>
|
||
|
||
<div id="outline-container-org3dc9ac4" class="outline-3">
|
||
<h3 id="org3dc9ac4"><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="org9dd595a"></a>
|
||
</p>
|
||
|
||
<p>
|
||
Suppose we apply the \(\mathcal{H}_\infty\) synthesis on the generalized plant \(P(s)\) shown in Figure <a href="#org967010a">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 which is equal to the sensitivity function \(S\).
|
||
Therefore, the synthesis objective is to minimize the \(\mathcal{H}_\infty\) norm of the sensitivity function: \(\|S\|_\infty\).
|
||
</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 as it will just try to decrease of peak value of \(S\).
|
||
Clearly this does not allow to <b>shape</b> the norm of \(S(j\omega)\) over all frequencies nor specify the wanted low frequency gain of \(S\) or bandwidth requirements.
|
||
</p>
|
||
|
||
|
||
<div id="org967010a" 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="org534bf32">
|
||
<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="#orgfda2d99">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="org8cdea70">
|
||
<p>
|
||
As shown in Equation \eqref{eq:sensitivity_shaping}, the objective of the \(\mathcal{H}_\infty\) synthesis applied on the <i>weighted</i> plant is to make the norm sensitivity function smaller than the inverse of the norm of the weighting function, and that at all frequencies.
|
||
</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 over all frequencies.
|
||
</p>
|
||
|
||
</div>
|
||
|
||
|
||
<div id="orgfda2d99" 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="org2200c91">
|
||
<p>
|
||
Using matlab, compute the weighted generalized plant shown in Figure <a href="#orgc2bf97c">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>
|
||
|
||
<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>
|
||
|
||
<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>
|
||
</details>
|
||
|
||
</div>
|
||
</div>
|
||
</div>
|
||
|
||
<div id="outline-container-org448f9ca" class="outline-3">
|
||
<h3 id="org448f9ca"><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="orgfd97063"></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="orgfa9bfec">
|
||
<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>
|
||
Good guidelines for design of weighting function are given in <a href="#citeproc_bib_item_2">[2]</a>.
|
||
</p>
|
||
|
||
<p>
|
||
There is a Matlab function called <code>makeweight</code> 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="org7a3c9a3">
|
||
<p>
|
||
The Matlab code below produces a weighting function with the following characteristics (Figure <a href="#orgc2bf97c">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="orgc2bf97c" 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="orgfd4fe3a">
|
||
<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="orgf02bddb"><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="#orgf61d132">26</a>.
|
||
</p>
|
||
|
||
|
||
<div id="orgf61d132" 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-org2a78d75" class="outline-3">
|
||
<h3 id="org2a78d75"><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="org427b7f9"></a>
|
||
</p>
|
||
|
||
<p>
|
||
Let’s design a controller using the \(\mathcal{H}_\infty\) shaping of the sensitivity function 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="#orgf5e8646">1.3</a>.
|
||
</p>
|
||
|
||
<div class="exercice" id="org4e4695f">
|
||
<p>
|
||
Translate the requirements as upper bounds on the Sensitivity function and design the corresponding weighting functions using Matlab.
|
||
</p>
|
||
|
||
<details><summary>Hint</summary>
|
||
<p>
|
||
The typical wanted upper bound of the sensitivity function is shown in Figure <a href="#org105e39f">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="org105e39f" 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>
|
||
<p>
|
||
We want to design the weighting function \(W_s(s)\) such that:
|
||
</p>
|
||
<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="orgf54fed9">
|
||
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 the \(\mathcal{H}_\infty\) norm of the closed-loop transfer function from \(w\) to \(z\) is less than \(\gamma\):
|
||
</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="#org0a8d4de">28</a>.
|
||
</p>
|
||
|
||
<div class="important" id="orgff2aa23">
|
||
<p>
|
||
Obtaining \(\gamma < 1\) means that the \(\mathcal{H}_\infty\) synthesis found a controller such that the specified closed-loop transfer functions are bellow the specified upper bounds.
|
||
</p>
|
||
|
||
<p>
|
||
Yet, obtaining a \(\gamma\) slightly above one does not necessary means the synthesis is unsuccessful.
|
||
It just means that at some frequency, one of the closed-loop transfer functions is above the specified upper bound by a factor \(\gamma\).
|
||
</p>
|
||
|
||
</div>
|
||
|
||
|
||
<div id="org0a8d4de" 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-orgdfea9a1" class="outline-3">
|
||
<h3 id="orgdfea9a1"><span class="section-number-3">5.4</span> Shaping multiple closed-loop transfer functions - Limitations</h3>
|
||
<div class="outline-text-3" id="text-5-4">
|
||
<p>
|
||
<a id="org86dd54b"></a>
|
||
</p>
|
||
<p>
|
||
As was shown in Section <a href="#org9f2323d">4</a>, each of the four main closed-loop transfer functions (called the <i>gang of four</i>) will impact different characteristics of the closed-loop system.
|
||
This is summarized in Table <a href="#orgb8dbe5d">9</a>.
|
||
</p>
|
||
|
||
<p>
|
||
Therefore, we might want to shape multiple closed-loop transfer functions at the same time.
|
||
For instance \(S\) could be shape to have good step responses, \(KS\) to limit the input usage and \(T\) to filter measurement noise.
|
||
When multiple closed-loop transfer function are shaped at the same time, it is refereed to as <b>Mixed-Sensitivity \(\mathcal{H}_\infty\) Control</b> and is the subject of Section <a href="#org1e723f2">6</a>.
|
||
</p>
|
||
|
||
<table id="orgb8dbe5d" border="2" cellspacing="0" cellpadding="6" rules="groups" frame="hsides">
|
||
<caption class="t-above"><span class="table-number">Table 9:</span> Typical specifications and corresponding shaping of the <i>Gang of four</i></caption>
|
||
|
||
<colgroup>
|
||
<col class="org-left" />
|
||
|
||
<col class="org-center" />
|
||
|
||
<col class="org-left" />
|
||
</colgroup>
|
||
<thead>
|
||
<tr>
|
||
<th scope="col" class="org-left">Specification</th>
|
||
<th scope="col" class="org-center">Gang of Four</th>
|
||
<th scope="col" class="org-left">Wanted shape</th>
|
||
</tr>
|
||
</thead>
|
||
<tbody>
|
||
<tr>
|
||
<td class="org-left">Fast Reference Tracking</td>
|
||
<td class="org-center">\(S\)</td>
|
||
<td class="org-left">Set lower bound on the bandwidth</td>
|
||
</tr>
|
||
|
||
<tr>
|
||
<td class="org-left">Small Steady State Errors</td>
|
||
<td class="org-center">\(S\)</td>
|
||
<td class="org-left">Small low frequency gain</td>
|
||
</tr>
|
||
|
||
<tr>
|
||
<td class="org-left">Follow Step ref. inputs</td>
|
||
<td class="org-center">\(S\)</td>
|
||
<td class="org-left">+20dB/dec slope at low frequency</td>
|
||
</tr>
|
||
|
||
<tr>
|
||
<td class="org-left">Follow Ramp ref. inputs</td>
|
||
<td class="org-center">\(S\)</td>
|
||
<td class="org-left">+40db/dec slope at low frequency</td>
|
||
</tr>
|
||
|
||
<tr>
|
||
<td class="org-left">Follow Sinusoidal ref. inputs</td>
|
||
<td class="org-center">\(S\)</td>
|
||
<td class="org-left">Small magnitude centered on the sin. frequency</td>
|
||
</tr>
|
||
</tbody>
|
||
<tbody>
|
||
<tr>
|
||
<td class="org-left">Output Disturbance Rejection</td>
|
||
<td class="org-center">\(S\)</td>
|
||
<td class="org-left">Small gain in the disturbance bandwidth</td>
|
||
</tr>
|
||
|
||
<tr>
|
||
<td class="org-left">Input Disturbance Rejection</td>
|
||
<td class="org-center">\(GS\)</td>
|
||
<td class="org-left">Small gain in the disturbance bandwidth</td>
|
||
</tr>
|
||
|
||
<tr>
|
||
<td class="org-left">Prevent inversion of resonant plants</td>
|
||
<td class="org-center">\(GS\)</td>
|
||
<td class="org-left">Limit gain around resonance</td>
|
||
</tr>
|
||
</tbody>
|
||
<tbody>
|
||
<tr>
|
||
<td class="org-left">Small Command Amplitude</td>
|
||
<td class="org-center">\(KS\)</td>
|
||
<td class="org-left">Small at high frequency</td>
|
||
</tr>
|
||
|
||
<tr>
|
||
<td class="org-left">Limitation of the Control Bandwidth</td>
|
||
<td class="org-center">\(T\)</td>
|
||
<td class="org-left">Set an upper bound on the bandwidth</td>
|
||
</tr>
|
||
|
||
<tr>
|
||
<td class="org-left">Measurement Noise Filtering</td>
|
||
<td class="org-center">\(T\)</td>
|
||
<td class="org-left">Small high frequency gain</td>
|
||
</tr>
|
||
</tbody>
|
||
<tbody>
|
||
<tr>
|
||
<td class="org-left">Stability margins</td>
|
||
<td class="org-center">\(S\)</td>
|
||
<td class="org-left">Module margin: \(\Vert S\Vert_\infty\) small</td>
|
||
</tr>
|
||
|
||
<tr>
|
||
<td class="org-left">Robustness to un-modelled dynamics</td>
|
||
<td class="org-center">\(T\)</td>
|
||
<td class="org-left">Small at frequencies where the plant uncertainty is large</td>
|
||
</tr>
|
||
</tbody>
|
||
</table>
|
||
|
||
<p>
|
||
Depending on which closed-loop transfer function are to be shaped, different weighted generalized plant can be used.
|
||
Some of them are described below for reference, it is a good exercise to try to re-design such weighted generalized plants.
|
||
</p>
|
||
<details><summary>Shaping of S and KS</summary>
|
||
|
||
<div id="org66b7a6f" 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>
|
||
|
||
<p>
|
||
Weighting functions:
|
||
</p>
|
||
<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>
|
||
|
||
<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="#org66b7a6f">29</a></label><pre class="src src-matlab" id="org7f14eb4">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>
|
||
</details>
|
||
<details><summary>Shaping of S and T</summary>
|
||
|
||
<div id="orge40c14a" 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>
|
||
|
||
<p>
|
||
Weighting functions:
|
||
</p>
|
||
<ul class="org-ul">
|
||
<li>\(W_1\) is used to shape \(S\)</li>
|
||
<li>\(W_2\) is used to shape \(T\)</li>
|
||
</ul>
|
||
|
||
<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="#orge40c14a">30</a></label><pre class="src src-matlab" id="orgd826517">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>
|
||
</details>
|
||
<details><summary>Shaping of S and GS</summary>
|
||
|
||
<div id="orgeaf3f27" 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>
|
||
|
||
<p>
|
||
Weighting functions:
|
||
</p>
|
||
<ul class="org-ul">
|
||
<li>\(W_1\) is used to shape \(S\)</li>
|
||
<li>\(W_2\) is used to shape \(GS\)</li>
|
||
</ul>
|
||
|
||
<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="#orgeaf3f27">31</a></label><pre class="src src-matlab" id="orgc83dfc9">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>
|
||
</details>
|
||
<details><summary>Shaping of S, T and KS</summary>
|
||
|
||
<div id="orge18d8ca" 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>
|
||
|
||
<p>
|
||
Weighting functions:
|
||
</p>
|
||
<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">
|
||
<label class="org-src-name"><span class="listing-number">Listing 5: </span>General Plant definition corresponding to Figure <a href="#orge18d8ca">32</a></label><pre class="src src-matlab" id="orgf394ec6">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>
|
||
</details>
|
||
<details><summary>Shaping of S, T and GS</summary>
|
||
|
||
<div id="org3531dc5" 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>
|
||
|
||
<p>
|
||
Weighting functions:
|
||
</p>
|
||
<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>
|
||
|
||
<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="#org3531dc5">33</a></label><pre class="src src-matlab" id="org1c29c8f">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>
|
||
</details>
|
||
<details><summary>Shaping of S, T, KS and GS</summary>
|
||
|
||
<div id="org368bc10" 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>
|
||
|
||
<p>
|
||
Weighting functions:
|
||
</p>
|
||
<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>
|
||
|
||
<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="#org368bc10">34</a></label><pre class="src src-matlab" id="org3e97ed3">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>
|
||
</details>
|
||
<div class="important" id="orgb344cf3">
|
||
<p>
|
||
When shaping multiple closed-loop transfer functions, one should be very 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 independently</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>
|
||
|
||
<div class="warning" id="orgaeed4f3">
|
||
<p>
|
||
Mathematical relations are linking the closed-loop transfer functions.
|
||
For instance, the sensitivity function \(S(s)\) and the complementary sensitivity function \(T(s)\) are linked 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>
|
||
For practical control systems, above some frequency (the control bandwidth), the loop gain is much smaller than 1.
|
||
On the other size, there is a frequency range where the loop gain is much larger than 1, this frequency range is called the bandwidth.
|
||
Let’s see what does that means for the closed-loop transfer function.
|
||
First, take the case of the sensibility function:
|
||
</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>
|
||
This means that the Sensitivity function cannot be shaped at frequencies where the loop gain is small.
|
||
</p>
|
||
|
||
<p>
|
||
Similar relationship can be found for \(T\), \(KS\) and \(GS\).
|
||
</p>
|
||
|
||
<div class="exercice" id="orgcd66e8b">
|
||
<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 as a function of \(K(s)\) and \(G(s)\)</li>
|
||
<li>Take \(|K(j\omega)G(j\omega)| \gg 1\) and conclude on the norm of the closed-loop transfer function</li>
|
||
<li>Take \(|K(j\omega)G(j\omega)| \ll 1\) and conclude</li>
|
||
</ol>
|
||
</details>
|
||
|
||
<details><summary>Answer</summary>
|
||
<p>
|
||
The obtained constrains are shown in Figure <a href="#org6c8bca1">35</a>.
|
||
</p>
|
||
</details>
|
||
|
||
</div>
|
||
|
||
<p>
|
||
Depending on the frequency band, the norms of the closed-loop transfer functions are a function of the controller \(K\) and therefore can be shaped.
|
||
However, in some frequency band, the norms do not depend on the controller and therefore <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="#org6c8bca1">35</a>.
|
||
</p>
|
||
|
||
|
||
<div id="org6c8bca1" 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. Blue regions indicate that the transfer function can be shaped using \(K\). Red regions indicate this is not the case</p>
|
||
</div>
|
||
|
||
<div class="warning" id="orgcb364bd">
|
||
<p>
|
||
The order (e.g. number of state) of the controller given by the \(\mathcal{H}_\infty\) synthesis is equal to the order (e.g. number of state) of the weighted generalized plant.
|
||
It is thus equal to the <b>sum</b> of the number of state of the non-weighted generalized plant and the number of state of all the weighting functions.
|
||
Then, the \(\mathcal{H}_\infty\) synthesis usually generate a controller with a very high order that is not implementable in practice.
|
||
</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-org7f7d381" class="outline-2">
|
||
<h2 id="org7f7d381"><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="org1e723f2"></a>
|
||
</p>
|
||
<p>
|
||
Let’s now apply the \(\mathcal{H}_\infty\) Shaping control procedure on a practical example.
|
||
</p>
|
||
|
||
<p>
|
||
In Section <a href="#org7fd199e">6.1</a> the control problem is presented.
|
||
The design procedure used for the \(\matcal{H}_\infty\) Mixed Sensitivity synthesis is described in Section <a href="#org1f946a8">6.2</a>.
|
||
</p>
|
||
|
||
<p>
|
||
The important step of interpreting the specifications is performed in Section <a href="#org2af1794">6.3</a>.
|
||
</p>
|
||
|
||
<p>
|
||
Then, the shaping of closed-loop transfer functions is performed in Sections <a href="#org179d83b">6.4</a>, <a href="#org2b37171">6.5</a> and <a href="#org96669b9">6.6</a>.
|
||
</p>
|
||
</div>
|
||
|
||
<div id="outline-container-org312dce5" class="outline-3">
|
||
<h3 id="org312dce5"><span class="section-number-3">6.1</span> Control Problem</h3>
|
||
<div class="outline-text-3" id="text-6-1">
|
||
<p>
|
||
<a id="org7fd199e"></a>
|
||
</p>
|
||
|
||
<p>
|
||
Let’s take out usual <i>test system</i> shown in Figure <a href="#org9bacaae">36</a>.
|
||
</p>
|
||
|
||
|
||
<div id="org9bacaae" class="figure">
|
||
<p><img src="figs/ex_test_system.png" alt="ex_test_system.png" />
|
||
</p>
|
||
<p><span class="figure-number">Figure 36: </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>
|
||
|
||
<div class="important" id="org9fc8be0">
|
||
<p>
|
||
The control specifications are:
|
||
</p>
|
||
<ul class="org-ul">
|
||
<li>The displacement \(y\) should follow reference inputs \(r\) with negligible static error after 0.1s</li>
|
||
<li>Reject disturbances \(d\) in less than 0.1s</li>
|
||
<li>Limit the effect of measurement noise \(n\) on both the control input \(u\) and on the output displacement \(y\)</li>
|
||
<li>Obtain a Robust System with good stability margins</li>
|
||
</ul>
|
||
|
||
</div>
|
||
|
||
<p>
|
||
The considered inputs are:
|
||
</p>
|
||
<ul class="org-ul">
|
||
<li>disturbances \(d\) as step inputs with an amplitude of \(5\,\mu m\)</li>
|
||
<li>reference inputs with are ramp inputs with a slope of \(100\,\mu m/s\) and a time duration of \(0.2\,s\)</li>
|
||
<li>measurement noise \(n\) with a large spectral density at high frequency (increasing starting from 100Hz)</li>
|
||
</ul>
|
||
</div>
|
||
</div>
|
||
|
||
<div id="outline-container-org7967c7a" class="outline-3">
|
||
<h3 id="org7967c7a"><span class="section-number-3">6.2</span> Control Design Procedure</h3>
|
||
<div class="outline-text-3" id="text-6-2">
|
||
<p>
|
||
<a id="org1f946a8"></a>
|
||
</p>
|
||
|
||
<p>
|
||
Here is the general design procedure that will be followed:
|
||
</p>
|
||
<ol class="org-ol">
|
||
<li>Compute the model of the plant</li>
|
||
<li>Translate the specifications into the wanted shape of closed-loop transfer functions</li>
|
||
<li>Write the system as a general control configuration</li>
|
||
<li>Shape sequentially the chosen closed-loop transfer functions</li>
|
||
</ol>
|
||
|
||
<p>
|
||
Let’s first convert the system of Figure <a href="#org9bacaae">36</a> into the classical feedback architecture of Figure <a href="#org4bb8ed5">3</a>.
|
||
</p>
|
||
|
||
|
||
<div id="orgdea495d" class="figure">
|
||
<p><img src="figs/ex_test_system_feedback.png" alt="ex_test_system_feedback.png" />
|
||
</p>
|
||
<p><span class="figure-number">Figure 37: </span>Block diagram corresponding to the example system</p>
|
||
</div>
|
||
|
||
<p>
|
||
The two transfer functions present in the system are derived and defined below:
|
||
</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>
|
||
<span class="linenr">4: </span>
|
||
<span class="linenr">5: </span><span class="org-comment">% Control Plant</span>
|
||
<span class="linenr">6: </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="linenr">7: </span><span class="org-comment">% Disturbance dynamics</span>
|
||
<span class="linenr">8: </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);
|
||
</pre>
|
||
</div>
|
||
|
||
<p>
|
||
We also define the inputs signals that will be used for time domain simulations.
|
||
They are graphically shown in Figure <a href="#org590e472">38</a>.
|
||
</p>
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab"><span class="linenr"> 9: </span><span class="org-comment">% Time Vector</span>
|
||
<span class="linenr">10: </span>t = 0<span class="org-type">:</span>1e<span class="org-type">-</span>4<span class="org-type">:</span>0.5;
|
||
<span class="linenr">11: </span>
|
||
<span class="linenr">12: </span><span class="org-comment">% Reference Input</span>
|
||
<span class="linenr">13: </span>r = zeros(size(t));
|
||
<span class="linenr">14: </span>r(t<span class="org-type">></span>0.05 <span class="org-type">&</span> t<span class="org-type"><=</span>0.25) = 1e<span class="org-type">-</span>4<span class="org-type">*</span>(t(t<span class="org-type">></span>0.05 <span class="org-type">&</span> t<span class="org-type"><=</span>0.25)<span class="org-type">-</span>0.05);
|
||
<span class="linenr">15: </span>r(t<span class="org-type">></span>0.25) = 2e<span class="org-type">-</span>5;
|
||
<span class="linenr">16: </span>
|
||
<span class="linenr">17: </span><span class="org-comment">% Measurement Noise</span>
|
||
<span class="linenr">18: </span>Fs = 1e3; <span class="org-comment">% Sampling Frequency [Hz]</span>
|
||
<span class="linenr">19: </span>Ts = 1<span class="org-type">/</span>Fs; <span class="org-comment">% Sampling Time [s]</span>
|
||
<span class="linenr">20: </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>
|
||
<span class="linenr">21: </span>n = lsim(1e<span class="org-type">-</span>6<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>1e2)<span class="org-type">^</span>2<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>1e3)<span class="org-type">^</span>2<span class="org-type">/</span>(1<span class="org-type">+</span>s<span class="org-type">/</span>2<span class="org-type">/</span><span class="org-constant">pi</span><span class="org-type">/</span>500), n, t)<span class="org-type">'</span>; <span class="org-comment">% Shaped noise</span>
|
||
<span class="linenr">22: </span>
|
||
<span class="linenr">23: </span><span class="org-comment">% Disturbance</span>
|
||
<span class="linenr">24: </span>d = zeros(size(t));
|
||
<span class="linenr">25: </span>d(t<span class="org-type">></span>0.3) = 5e<span class="org-type">-</span>6;
|
||
</pre>
|
||
</div>
|
||
|
||
|
||
<div id="org590e472" class="figure">
|
||
<p><img src="figs/ex_inputs_signals.png" alt="ex_inputs_signals.png" />
|
||
</p>
|
||
<p><span class="figure-number">Figure 38: </span>Time domain inputs signals</p>
|
||
</div>
|
||
|
||
<p>
|
||
We also define the generalized plant corresponding to the system and that will be used for time domain simulations (Figure <a href="#org254778d">39</a>).
|
||
</p>
|
||
|
||
<div id="org254778d" class="figure">
|
||
<p><img src="figs/ex_general_plant_sim.png" alt="ex_general_plant_sim.png" />
|
||
</p>
|
||
<p><span class="figure-number">Figure 39: </span>Generalized plant that will be used for simulations</p>
|
||
</div>
|
||
|
||
<p>
|
||
The Generalized plant of Figure <a href="#org254778d">39</a> is defined on Matlab as follows:
|
||
</p>
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab"><span class="linenr">26: </span>Psim = [0 0 Gd G
|
||
<span class="linenr">27: </span> 0 0 0 1
|
||
<span class="linenr">28: </span> 1 <span class="org-type">-</span>1 <span class="org-type">-</span>Gd <span class="org-type">-</span>G];
|
||
<span class="linenr">29: </span>
|
||
<span class="linenr">30: </span>Psim.InputName = {<span class="org-string">'r'</span>, <span class="org-string">'n'</span>, <span class="org-string">'d'</span>, <span class="org-string">'u'</span>};
|
||
<span class="linenr">31: </span>Psim.OutputName = {<span class="org-string">'y'</span>, <span class="org-string">'u'</span>, <span class="org-string">'e'</span>};
|
||
</pre>
|
||
</div>
|
||
|
||
<p>
|
||
Time domain simulations will be performed by first computing the closed-loop system using the <code>lft</code> command and then using the <code>lsim</code> command on the closed-loop system:
|
||
</p>
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab"><span class="linenr">32: </span><span class="org-comment">% Compute the closed-Loop System, K is the controller</span>
|
||
<span class="linenr">33: </span>P_CL = lft(Psim, K);
|
||
<span class="linenr">34: </span>
|
||
<span class="linenr">35: </span><span class="org-comment">% Time simulation of the closed-loop system with specified inputs</span>
|
||
<span class="linenr">36: </span>z = lsim(P_CL, [r; n; d], t);
|
||
<span class="linenr">37: </span><span class="org-comment">% The two outputs are</span>
|
||
<span class="linenr">38: </span>y = z(<span class="org-type">:</span>,1); <span class="org-comment">% Output Motion [m]</span>
|
||
<span class="linenr">39: </span>u = z(<span class="org-type">:</span>,2); <span class="org-comment">% Input usage [N]</span>
|
||
</pre>
|
||
</div>
|
||
</div>
|
||
</div>
|
||
|
||
<div id="outline-container-orgd8515b8" class="outline-3">
|
||
<h3 id="orgd8515b8"><span class="section-number-3">6.3</span> Modern Interpretation of control specifications</h3>
|
||
<div class="outline-text-3" id="text-6-3">
|
||
<p>
|
||
<a id="org2af1794"></a>
|
||
</p>
|
||
|
||
<div class="exercice" id="org33d55df">
|
||
<ol class="org-ol">
|
||
<li>Translate the control specifications into wanted shape of closed-loop transfer functions</li>
|
||
<li>Conclude and the closed-loop transfer functions to be shaped</li>
|
||
<li>Chose a general configuration architecture that allows to shape the wanted closed-loop transfer function</li>
|
||
<li>Using Matlab, define the generalized plant</li>
|
||
</ol>
|
||
|
||
<details><summary>Hint</summary>
|
||
<ol class="org-ol">
|
||
<li>Make use of Table <a href="#orgb8dbe5d">9</a></li>
|
||
<li>Make use of Table <a href="#orgb8dbe5d">9</a></li>
|
||
<li>See Section <a href="#org86dd54b">5.4</a></li>
|
||
<li>See Section <a href="#org86dd54b">5.4</a></li>
|
||
</ol>
|
||
</details>
|
||
|
||
</div>
|
||
|
||
<p>
|
||
After converting the control specifications into wanted shape of closed-loop transfer functions, we might come up with the Table <a href="#org0fe15a4">10</a>.
|
||
</p>
|
||
|
||
<p>
|
||
In such case, we want to shape \(S\), \(GS\) and \(T\).
|
||
</p>
|
||
|
||
<table id="org0fe15a4" border="2" cellspacing="0" cellpadding="6" rules="groups" frame="hsides">
|
||
<caption class="t-above"><span class="table-number">Table 10:</span> Control Specifications and associated wanted shape of the closed-loop transfer functions</caption>
|
||
|
||
<colgroup>
|
||
<col class="org-left" />
|
||
|
||
<col class="org-center" />
|
||
|
||
<col class="org-left" />
|
||
</colgroup>
|
||
<thead>
|
||
<tr>
|
||
<th scope="col" class="org-left">Specification</th>
|
||
<th scope="col" class="org-center">Corresponding Transfer Function</th>
|
||
<th scope="col" class="org-left">Wanted Shape</th>
|
||
</tr>
|
||
</thead>
|
||
<tbody>
|
||
<tr>
|
||
<td class="org-left">Follow Step Reference</td>
|
||
<td class="org-center">\(S\)</td>
|
||
<td class="org-left">+40dB of slope at low frequency</td>
|
||
</tr>
|
||
|
||
<tr>
|
||
<td class="org-left">Reject Disturbances</td>
|
||
<td class="org-center">\(S\), \(GS\)</td>
|
||
<td class="org-left">Small gain</td>
|
||
</tr>
|
||
|
||
<tr>
|
||
<td class="org-left">Reject measurement noise</td>
|
||
<td class="org-center">\(T\)</td>
|
||
<td class="org-left">Small high frequency (>100Hz) gain</td>
|
||
</tr>
|
||
|
||
<tr>
|
||
<td class="org-left">Robust System</td>
|
||
<td class="org-center">\(S\)</td>
|
||
<td class="org-left">Small \(\Vert S \Vert_\infty\)</td>
|
||
</tr>
|
||
</tbody>
|
||
</table>
|
||
|
||
<p>
|
||
To do so, we use to generalized plant shown in Figure <a href="#org668b9a9">40</a> for the synthesis where the three closed-loop tranfert functions from \(w\) to \([z_1\,,z_2\,,z_3]\) are respectively \(S\), \(GS\) and \(T\).
|
||
</p>
|
||
|
||
<p>
|
||
This generalized plant is defined on Matlab as follows:
|
||
</p>
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab"><span class="linenr">40: </span>P = [1 <span class="org-type">-</span>1
|
||
<span class="linenr">41: </span> G <span class="org-type">-</span>G
|
||
<span class="linenr">42: </span> 0 1
|
||
<span class="linenr">43: </span> G <span class="org-type">-</span>G];
|
||
</pre>
|
||
</div>
|
||
|
||
|
||
<div id="org668b9a9" class="figure">
|
||
<p><img src="figs/ex_general_plant.png" alt="ex_general_plant.png" />
|
||
</p>
|
||
<p><span class="figure-number">Figure 40: </span>Generalized plant chosen for the shaping of \(S\), \(GS\) \(T\)</p>
|
||
</div>
|
||
|
||
<p>
|
||
However, to performed the \(\mathcal{H}_\infty\) loop shaping, we have to include <b>weighting function</b> to the Generalized plant.
|
||
We obtain the <b>weighted generalized plant</b> in Figure <a href="#orgc62a32d">41</a>, and that is computed using Matlab as follows:
|
||
</p>
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab"><span class="linenr">44: </span>Pw = blkdiag(W1, W2, W3, 1)<span class="org-type">*</span>P;
|
||
</pre>
|
||
</div>
|
||
|
||
|
||
<div id="orgc62a32d" class="figure">
|
||
<p><img src="figs/ex_general_weighted_plant.png" alt="ex_general_weighted_plant.png" />
|
||
</p>
|
||
<p><span class="figure-number">Figure 41: </span>Generalized weighted plant used for the \(\mathcal{H}_\infty\) Synthesis</p>
|
||
</div>
|
||
|
||
<p>
|
||
Finlay, performing the \(\mathcal{H}_infty\) Shaping of \(S\), \(GS\) and \(T\) can be done using the <code>hinfsyn</code> command:
|
||
</p>
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab"><span class="linenr">45: </span>K = hinfsyn(Pw, 1, 1);
|
||
</pre>
|
||
</div>
|
||
|
||
<p>
|
||
Now the closed-loop transfer functions are shaped sequentially:
|
||
</p>
|
||
<ul class="org-ul">
|
||
<li>\(S\) is shaped in Section <a href="#org179d83b">6.4</a></li>
|
||
<li>\(GS\) is shaped in Section <a href="#org2b37171">6.5</a></li>
|
||
<li>\(T\) is shaped in Section <a href="#org96669b9">6.6</a></li>
|
||
</ul>
|
||
</div>
|
||
</div>
|
||
|
||
<div id="outline-container-org4dd52c5" class="outline-3">
|
||
<h3 id="org4dd52c5"><span class="section-number-3">6.4</span> Step 1 - Shaping of \(S\)</h3>
|
||
<div class="outline-text-3" id="text-6-4">
|
||
<p>
|
||
<a id="org179d83b"></a>
|
||
</p>
|
||
|
||
<p>
|
||
Let’s first shape the Sensitivity function as it is usually the most important of the <i>Gang of four</i> closed-loop transfer functions.
|
||
To do so, we have to create a weight \(W_1(s)\) that defines the wanted upper bound on \(|S(j\omega)|\):
|
||
</p>
|
||
<ul class="org-ul">
|
||
<li>small low frequency gain: \(|S(j\cdot 0)| = 10^{-3}\)</li>
|
||
<li>minimum crossover frequency of \(\approx 10Hz\): \(|S(j2\pi 10)| < \frac{1}{\sqrt{2}}\)</li>
|
||
<li>small maximum peak magnitude for robustness properties: \(\|S\|_\infty < 2\)</li>
|
||
</ul>
|
||
|
||
<p>
|
||
The weighting function is design using the <code>generateWeigh</code> function and its inverse shape can be seen in Figure
|
||
</p>
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab"><span class="linenr">46: </span>W1 = generateWeight(<span class="org-string">'G0'</span>, 1e3, ...
|
||
<span class="linenr">47: </span> <span class="org-string">'G1'</span>, 1<span class="org-type">/</span>2, ...
|
||
<span class="linenr">48: </span> <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="linenr">49: </span> <span class="org-string">'n'</span>, 1);
|
||
</pre>
|
||
</div>
|
||
|
||
<p>
|
||
To not constrain \(GS\) and \(T\) for the shaping of \(S\), \(W_2\) and \(W_3\) are first taken as very small gains:
|
||
</p>
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab"><span class="linenr">50: </span>W2 = tf(1e<span class="org-type">-</span>8);
|
||
<span class="linenr">51: </span>W3 = tf(1e<span class="org-type">-</span>8);
|
||
</pre>
|
||
</div>
|
||
|
||
<p>
|
||
The \(\mathcal{H}_\infty\) synthesis is performed and the obtained closed-loop transfer functions \(S\), \(GS\), and \(T\) and compared with the upper bounds set by the weighting functions in Figure <a href="#org7266d77">42</a>.
|
||
</p>
|
||
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab">Pw = blkdiag(W1, W2, W3, 1)<span class="org-type">*</span>P;
|
||
K1 = hinfsyn(Pw, 1, 1, <span class="org-string">'Display'</span>, <span class="org-string">'on'</span>);
|
||
</pre>
|
||
</div>
|
||
|
||
<pre class="example" id="org239d4b1">
|
||
Test bounds: 0.5 <= gamma <= 0.51
|
||
|
||
gamma X>=0 Y>=0 rho(XY)<1 p/f
|
||
5.05e-01 0.0e+00 0.0e+00 5.511e-14 p
|
||
Limiting gains...
|
||
5.05e-01 0.0e+00 0.0e+00 1.867e-14 p
|
||
|
||
Best performance (actual): 0.502
|
||
</pre>
|
||
|
||
|
||
<div id="org7266d77" class="figure">
|
||
<p><img src="figs/ex_results_1.png" alt="ex_results_1.png" />
|
||
</p>
|
||
<p><span class="figure-number">Figure 42: </span>Obtained Shape Closed-Loop transfer functions (dashed black lines indicate inverse magnitude of the weighting functions)</p>
|
||
</div>
|
||
|
||
<p>
|
||
Time domain simulation is then performed and the obtained output displacement and control inputs are shown in Figure <a href="#org181b898">43</a>.
|
||
</p>
|
||
|
||
<p>
|
||
We can see:
|
||
</p>
|
||
<ul class="org-ul">
|
||
<li>we are not able to follow the ramp input. This have to be solved by modifying the weighting function \(W_1(s)\)</li>
|
||
<li>we have poor rejection of disturbances. This we be solve by shaping \(GS\) in Section <a href="#org2b37171">6.5</a></li>
|
||
<li>we have quite large effect of the measurement noise. This will be solved by shaping \(T\) in Section <a href="#org96669b9">6.6</a></li>
|
||
</ul>
|
||
|
||
|
||
<div id="org181b898" class="figure">
|
||
<p><img src="figs/ex_time_domain_1.png" alt="ex_time_domain_1.png" />
|
||
</p>
|
||
<p><span class="figure-number">Figure 43: </span>Time domain simulation results</p>
|
||
</div>
|
||
|
||
<p>
|
||
Remember that in order to follow ramp inputs, the sensitivity function should have a slope of +40dB/dec at low frequency (Table <a href="#orgb8dbe5d">9</a>).
|
||
</p>
|
||
|
||
<p>
|
||
To do so, let’s modify \(W_1\) to impose a slope of +40dB/dec at low frequency.
|
||
This can simple be done by using a second order weight:
|
||
</p>
|
||
<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>15, ...
|
||
<span class="org-string">'n'</span>, 2);
|
||
</pre>
|
||
</div>
|
||
|
||
<p>
|
||
The \(\mathcal{H}_\infty\) synthesis is performed using the new weights and the obtained closed-loop shaped are shown in figure <a href="#org30bc293">44</a>.
|
||
</p>
|
||
|
||
<p>
|
||
The time domain signals are shown in Figure <a href="#org19c0a92">45</a> and it is confirmed that the ramps are now follows without static errors.
|
||
</p>
|
||
|
||
|
||
<div id="org30bc293" class="figure">
|
||
<p><img src="figs/ex_results_1b.png" alt="ex_results_1b.png" />
|
||
</p>
|
||
<p><span class="figure-number">Figure 44: </span>Obtained Shape Closed-Loop transfer functions</p>
|
||
</div>
|
||
|
||
|
||
<div id="org19c0a92" class="figure">
|
||
<p><img src="figs/ex_time_domain_1b.png" alt="ex_time_domain_1b.png" />
|
||
</p>
|
||
<p><span class="figure-number">Figure 45: </span>Time domain simulation results</p>
|
||
</div>
|
||
</div>
|
||
</div>
|
||
|
||
<div id="outline-container-org9f0fcd6" class="outline-3">
|
||
<h3 id="org9f0fcd6"><span class="section-number-3">6.5</span> Step 2 - Shaping of \(GS\)</h3>
|
||
<div class="outline-text-3" id="text-6-5">
|
||
<p>
|
||
<a id="org2b37171"></a>
|
||
</p>
|
||
|
||
<p>
|
||
Looking at Figure <a href="#org4fb0242">46</a>, it is clear that the rejection of disturbances is not satisfactory.
|
||
This can also be seen by the large peak of \(GS\) in Figure <a href="#org30bc293">44</a>.
|
||
</p>
|
||
|
||
<p>
|
||
This poor rejection of disturbances is actually due to the fact that the obtain controller has at notch at the resonance frequency of the plant.
|
||
</p>
|
||
|
||
|
||
<p>
|
||
To overcome this issue, we can simply increase the magnitude of \(W_2\) to limit the peak magnitude of \(GS\)
|
||
Let’s take \(W_2\) as a simple constant gain:
|
||
</p>
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab">W2 = tf(4e5);
|
||
</pre>
|
||
</div>
|
||
|
||
<p>
|
||
The \(\mathcal{H}_\infty\) Synthesis is performed and the obtained closed-loop transfer functions are shown in Figure <a href="#org4fb0242">46</a>.
|
||
</p>
|
||
|
||
<div id="org4fb0242" class="figure">
|
||
<p><img src="figs/ex_results_2.png" alt="ex_results_2.png" />
|
||
</p>
|
||
<p><span class="figure-number">Figure 46: </span>Obtained Shape Closed-Loop transfer functions</p>
|
||
</div>
|
||
|
||
<p>
|
||
Time domain simulation results are shown in Figure <a href="#org0dae7d4">47</a>.
|
||
If is shown that indeed, the disturbance rejection performance are much better and only very small oscillation is obtained.
|
||
</p>
|
||
|
||
|
||
<div id="org0dae7d4" class="figure">
|
||
<p><img src="figs/ex_time_domain_2.png" alt="ex_time_domain_2.png" />
|
||
</p>
|
||
<p><span class="figure-number">Figure 47: </span>Time domain simulation results</p>
|
||
</div>
|
||
</div>
|
||
</div>
|
||
|
||
<div id="outline-container-orgdc318b7" class="outline-3">
|
||
<h3 id="orgdc318b7"><span class="section-number-3">6.6</span> Step 3 - Shaping of \(T\)</h3>
|
||
<div class="outline-text-3" id="text-6-6">
|
||
<p>
|
||
<a id="org96669b9"></a>
|
||
</p>
|
||
|
||
<p>
|
||
Finally, we want to limit the effect of the noise on the displacement output.
|
||
</p>
|
||
|
||
<p>
|
||
To do so, \(T\) is shaped such that its high frequency gain is reduced.
|
||
</p>
|
||
|
||
<p>
|
||
This is done by increasing the high frequency gain of the weighting function \(W_3\) until the \(\mathcal{H}_\infty\) synthesis gives \(\gamma \approx 1\).
|
||
</p>
|
||
|
||
<p>
|
||
The final weighting function \(W_3\) is defined as follows:
|
||
</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>70, ...
|
||
<span class="org-string">'n'</span>, 2);
|
||
</pre>
|
||
</div>
|
||
|
||
<p>
|
||
The \(\mathcal{H}_\infty\) synthesis is performed and \(\gamma\) is closed to one.
|
||
The obtained closed-loop transfer functions are shown in Figure <a href="#org9f627ec">48</a> and we can obverse that:
|
||
</p>
|
||
<ul class="org-ul">
|
||
<li>The high frequency gain of \(T\) is indeed reduced</li>
|
||
<li>This comes as the expense of a large magnitude both \(GS\) and \(S\).
|
||
This means we will probably have slightly less good disturbance rejection and tracking performances.</li>
|
||
</ul>
|
||
|
||
|
||
<div id="org9f627ec" class="figure">
|
||
<p><img src="figs/ex_results_3.png" alt="ex_results_3.png" />
|
||
</p>
|
||
<p><span class="figure-number">Figure 48: </span>Obtained Shape Closed-Loop transfer functions</p>
|
||
</div>
|
||
|
||
<p>
|
||
The time domain simulation signals are shown in Figure <a href="#org8b37ff2">49</a>.
|
||
We can indeed see a slightly less good disturbance rejection.
|
||
However, the vibrations induced by the sensor noise is well reduced.
|
||
This can be seen when zooming on the output signal in Figure <a href="#org6caa72f">50</a>.
|
||
</p>
|
||
|
||
|
||
<div id="org8b37ff2" class="figure">
|
||
<p><img src="figs/ex_time_domain_3.png" alt="ex_time_domain_3.png" />
|
||
</p>
|
||
<p><span class="figure-number">Figure 49: </span>Time domain simulation results</p>
|
||
</div>
|
||
|
||
|
||
<div id="org6caa72f" class="figure">
|
||
<p><img src="figs/ex_time_domaim_3_zoom.png" alt="ex_time_domaim_3_zoom.png" />
|
||
</p>
|
||
<p><span class="figure-number">Figure 50: </span>Zoom on the output signal</p>
|
||
</div>
|
||
</div>
|
||
</div>
|
||
|
||
<div id="outline-container-orgd3e7a58" class="outline-3">
|
||
<h3 id="orgd3e7a58"><span class="section-number-3">6.7</span> Conclusion and Discussion</h3>
|
||
<div class="outline-text-3" id="text-6-7">
|
||
<p>
|
||
Hopefully this practical example will help you apply the \(\mathcal{H}_\infty\) Shaping synthesis on other control problems.
|
||
</p>
|
||
|
||
<p>
|
||
As an exercise, plot and analyze the evolution of the controller and loop gain transfer functions during the 3 synthesis steps.
|
||
</p>
|
||
|
||
<p>
|
||
If the large input usage is considered to be not acceptable, the shaping of \(KS\) could be included in the synthesis and all the <i>Gang of four</i> closed-loop transfer function shapes.
|
||
</p>
|
||
</div>
|
||
</div>
|
||
</div>
|
||
|
||
<div id="outline-container-orgfc86d06" class="outline-2">
|
||
<h2 id="orgfc86d06"><span class="section-number-2">7</span> Conclusion</h2>
|
||
<div class="outline-text-2" id="text-7">
|
||
<p>
|
||
<a id="org5fd483c"></a>
|
||
</p>
|
||
|
||
<p>
|
||
Hopefully, this document gave you a glimpse on how useful and powerful the \(\mathcal{H}_\infty\) loop shaping synthesis can be.
|
||
One of the true power of \(\mathcal{H}_\infty\) synthesis is that is can easily be applied to multi-input multi-output systems!
|
||
If you want to know more about the “\(\mathcal{H}_\infty\) and robust control world” some resources are given below.
|
||
</p>
|
||
</div>
|
||
</div>
|
||
|
||
<div id="outline-container-orgba87692" class="outline-2">
|
||
<h2 id="orgba87692">Resources</h2>
|
||
<div class="outline-text-2" id="text-orgba87692">
|
||
<p>
|
||
For a complete treatment of multivariable robust control, I would highly recommend this book <a href="#citeproc_bib_item_3">[3]</a>
|
||
If you want to nice reference in French, look at <a href="#citeproc_bib_item_4">[4]</a>.
|
||
</p>
|
||
|
||
<p>
|
||
You can also look at the very good lectures below.
|
||
</p>
|
||
|
||
<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 class="csl-entry"><a name="citeproc_bib_item_2"></a>
|
||
<div class="csl-left-margin">[2]</div><div class="csl-right-inline">J. E. Bibel and D. S. Malyevac, “Guidelines for the selection of weighting functions for H-infinity control,” NAVAL SURFACE WARFARE CENTER DAHLGREN DIV VA, 1992.</div>
|
||
</div>
|
||
<div class="csl-entry"><a name="citeproc_bib_item_3"></a>
|
||
<div class="csl-left-margin">[3]</div><div class="csl-right-inline">S. Skogestad and I. Postlethwaite, <i>Multivariable Feedback Control: Analysis and Design</i>. John Wiley, 2007.</div>
|
||
</div>
|
||
<div class="csl-entry"><a name="citeproc_bib_item_4"></a>
|
||
<div class="csl-left-margin">[4]</div><div class="csl-right-inline">G. Duc and S. Font, <i>Commande H infinie et mu-analyse-des outils pour la robustesse</i>. Lavoisier, 1999.</div>
|
||
</div>
|
||
</div>
|
||
</div>
|
||
</div>
|
||
</div>
|
||
<div id="postamble" class="status">
|
||
<p class="author">Author: Dehaeze Thomas</p>
|
||
<p class="date">Created: 2020-12-03 jeu. 11:50</p>
|
||
</div>
|
||
</body>
|
||
</html>
|