3042 lines
111 KiB
HTML
3042 lines
111 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. 01:06 -->
|
||
<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="#org374f9a8">1. Introduction to Model Based Control</a>
|
||
<ul>
|
||
<li><a href="#org8df4987">1.1. Model Based Control - Methodology</a></li>
|
||
<li><a href="#org661272e">1.2. From Classical Control to Robust Control</a></li>
|
||
<li><a href="#orgc22c5f8">1.3. Example System</a></li>
|
||
</ul>
|
||
</li>
|
||
<li><a href="#org0f1cd3d">2. Classical Open Loop Shaping</a>
|
||
<ul>
|
||
<li><a href="#org87e2537">2.1. Introduction to Loop Shaping</a></li>
|
||
<li><a href="#org7c1b09b">2.2. Example of Manual Open Loop Shaping</a></li>
|
||
<li><a href="#org96ef122">2.3. \(\mathcal{H}_\infty\) Loop Shaping Synthesis</a></li>
|
||
<li><a href="#org759e327">2.4. Example of the \(\mathcal{H}_\infty\) Loop Shaping Synthesis</a></li>
|
||
</ul>
|
||
</li>
|
||
<li><a href="#org80d004e">3. A first Step into the \(\mathcal{H}_\infty\) world</a>
|
||
<ul>
|
||
<li><a href="#org0bc3797">3.1. The \(\mathcal{H}_\infty\) Norm</a></li>
|
||
<li><a href="#orge31e565">3.2. \(\mathcal{H}_\infty\) Synthesis</a></li>
|
||
<li><a href="#orgc18097d">3.3. The Generalized Plant</a></li>
|
||
<li><a href="#org3e39769">3.4. The \(\mathcal{H}_\infty\) Synthesis applied on the Generalized plant</a></li>
|
||
<li><a href="#orga1c7b25">3.5. From a Classical Feedback Architecture to a Generalized Plant</a></li>
|
||
</ul>
|
||
</li>
|
||
<li><a href="#org9e968b0">4. Modern Interpretation of Control Specifications</a>
|
||
<ul>
|
||
<li><a href="#org696631c">4.1. Closed Loop Transfer Functions and the Gang of Four</a></li>
|
||
<li><a href="#org049de6d">4.2. The Sensitivity Function</a></li>
|
||
<li><a href="#org0b2cf6e">4.3. Robustness: Module Margin</a></li>
|
||
<li><a href="#orgd7964d5">4.4. Summary of</a></li>
|
||
</ul>
|
||
</li>
|
||
<li><a href="#orgb014c17">5. \(\mathcal{H}_\infty\) Shaping of closed-loop transfer functions</a>
|
||
<ul>
|
||
<li><a href="#org502268a">5.1. How to Shape closed-loop transfer function? Using Weighting Functions!</a></li>
|
||
<li><a href="#orgb5c5d0b">5.2. Design of Weighting Functions</a></li>
|
||
<li><a href="#orgeada131">5.3. Shaping the Sensitivity Function</a></li>
|
||
<li><a href="#org9159197">5.4. Shaping multiple closed-loop transfer functions - Limitations</a></li>
|
||
</ul>
|
||
</li>
|
||
<li><a href="#org5f0592a">6. Mixed-Sensitivity \(\mathcal{H}_\infty\) Control - Example</a>
|
||
<ul>
|
||
<li><a href="#org686cf2a">6.1. Control Problem</a></li>
|
||
<li><a href="#orgb714b0a">6.2. Control Design Procedure</a></li>
|
||
<li><a href="#org2c003ca">6.3. Step 1 - Shaping of \(S\)</a></li>
|
||
<li><a href="#orgc5e1a2a">6.4. Step 2 - Shaping of \(KS\)</a></li>
|
||
<li><a href="#org92995a6">6.5. Step 3 - Shaping of \(T\)</a></li>
|
||
</ul>
|
||
</li>
|
||
<li><a href="#orgff61bb6">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="#orgc2e4ef4">1</a></li>
|
||
<li>Classical <i>open</i> loop shaping method is presented in Section <a href="#orgd366933">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="#orgc50cf6a">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="#org7347675">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="#org177a482">5</a></li>
|
||
<li>Finally, complete examples of the use of \(\mathcal{H}_\infty\) Control for practical problems are provided in Section <a href="#org84e27fa">6</a>.</li>
|
||
</ul>
|
||
|
||
<div id="outline-container-org374f9a8" class="outline-2">
|
||
<h2 id="org374f9a8"><span class="section-number-2">1</span> Introduction to Model Based Control</h2>
|
||
<div class="outline-text-2" id="text-1">
|
||
<p>
|
||
<a id="orgc2e4ef4"></a>
|
||
</p>
|
||
</div>
|
||
|
||
<div id="outline-container-org8df4987" class="outline-3">
|
||
<h3 id="org8df4987"><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="orgc585904"></a>
|
||
</p>
|
||
|
||
<p>
|
||
The typical methodology for <b>Model Based Control</b> techniques is schematically shown in Figure <a href="#org5cb8b14">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="org5cb8b14" 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="#orgd366933">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="#org7347675">4</a>, <a href="#org177a482">5</a> and <a href="#org84e27fa">6</a>.
|
||
</p>
|
||
</div>
|
||
</div>
|
||
|
||
<div id="outline-container-org661272e" class="outline-3">
|
||
<h3 id="org661272e"><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="orgcf693d7"></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="#orgc543c52">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="orgc543c52" border="2" cellspacing="0" cellpadding="6" rules="groups" frame="hsides">
|
||
<caption class="t-above"><span class="table-number">Table 1:</span> Table summurazing the main differences between classical, modern and robust control</caption>
|
||
|
||
<colgroup>
|
||
<col class="org-left" />
|
||
|
||
<col class="org-center" />
|
||
|
||
<col class="org-center" />
|
||
|
||
<col class="org-center" />
|
||
</colgroup>
|
||
<thead>
|
||
<tr>
|
||
<th scope="col" class="org-left"> </th>
|
||
<th scope="col" class="org-center"><b>Classical Control</b></th>
|
||
<th scope="col" class="org-center"><b>Modern Control</b></th>
|
||
<th scope="col" class="org-center"><b>Robust Control</b></th>
|
||
</tr>
|
||
</thead>
|
||
<tbody>
|
||
<tr>
|
||
<td class="org-left"><b>Date</b></td>
|
||
<td class="org-center">1930-</td>
|
||
<td class="org-center">1960-</td>
|
||
<td class="org-center">1980-</td>
|
||
</tr>
|
||
</tbody>
|
||
<tbody>
|
||
<tr>
|
||
<td class="org-left"><b>Tools</b></td>
|
||
<td class="org-center">Transfer Functions</td>
|
||
<td class="org-center">State Space formulation</td>
|
||
<td class="org-center">Systems and Signals Norms (\(\mathcal{H}_\infty\), \(\mathcal{H}_2\) Norms)</td>
|
||
</tr>
|
||
|
||
<tr>
|
||
<td class="org-left"> </td>
|
||
<td class="org-center">Nyquist Plots</td>
|
||
<td class="org-center">Riccati Equations</td>
|
||
<td class="org-center">Closed Loop Transfer Functions</td>
|
||
</tr>
|
||
|
||
<tr>
|
||
<td class="org-left"> </td>
|
||
<td class="org-center">Bode Plots</td>
|
||
<td class="org-center"> </td>
|
||
<td class="org-center">Open/Closed Loop Shaping</td>
|
||
</tr>
|
||
|
||
<tr>
|
||
<td class="org-left"> </td>
|
||
<td class="org-center">Phase and Gain margins</td>
|
||
<td class="org-center"> </td>
|
||
<td class="org-center">Weighting Functions</td>
|
||
</tr>
|
||
|
||
<tr>
|
||
<td class="org-left"> </td>
|
||
<td class="org-center"> </td>
|
||
<td class="org-center"> </td>
|
||
<td class="org-center">Disk margin</td>
|
||
</tr>
|
||
|
||
<tr>
|
||
<td class="org-left"> </td>
|
||
<td class="org-center"> </td>
|
||
<td class="org-center"> </td>
|
||
<td class="org-center">Singular Value Decomposition</td>
|
||
</tr>
|
||
</tbody>
|
||
<tbody>
|
||
<tr>
|
||
<td class="org-left"><b>Control Architectures</b></td>
|
||
<td class="org-center">Proportional, Integral, Derivative</td>
|
||
<td class="org-center">Full State Feedback, LQR</td>
|
||
<td class="org-center">General Control Configuration</td>
|
||
</tr>
|
||
|
||
<tr>
|
||
<td class="org-left"> </td>
|
||
<td class="org-center">Leads, Lags</td>
|
||
<td class="org-center">Kalman Filters, LQG</td>
|
||
<td class="org-center">Generalized Plant</td>
|
||
</tr>
|
||
</tbody>
|
||
<tbody>
|
||
<tr>
|
||
<td class="org-left"><b>Advantages</b></td>
|
||
<td class="org-center">Study Stability</td>
|
||
<td class="org-center">Automatic Synthesis</td>
|
||
<td class="org-center">Automatic Synthesis</td>
|
||
</tr>
|
||
|
||
<tr>
|
||
<td class="org-left"> </td>
|
||
<td class="org-center">Simple</td>
|
||
<td class="org-center">MIMO</td>
|
||
<td class="org-center">MIMO</td>
|
||
</tr>
|
||
|
||
<tr>
|
||
<td class="org-left"> </td>
|
||
<td class="org-center">Natural</td>
|
||
<td class="org-center">Optimization Problem</td>
|
||
<td class="org-center">Optimization Problem</td>
|
||
</tr>
|
||
|
||
<tr>
|
||
<td class="org-left"> </td>
|
||
<td class="org-center"> </td>
|
||
<td class="org-center"> </td>
|
||
<td class="org-center">Guaranteed Robustness</td>
|
||
</tr>
|
||
|
||
<tr>
|
||
<td class="org-left"> </td>
|
||
<td class="org-center"> </td>
|
||
<td class="org-center"> </td>
|
||
<td class="org-center">Easy specification of performances</td>
|
||
</tr>
|
||
</tbody>
|
||
<tbody>
|
||
<tr>
|
||
<td class="org-left"><b>Disadvantages</b></td>
|
||
<td class="org-center">Manual Method</td>
|
||
<td class="org-center">No Guaranteed Robustness</td>
|
||
<td class="org-center">Required knowledge of specific tools</td>
|
||
</tr>
|
||
|
||
<tr>
|
||
<td class="org-left"> </td>
|
||
<td class="org-center">Only SISO</td>
|
||
<td class="org-center">Difficult Rejection of Perturbations</td>
|
||
<td class="org-center">Need a reasonably good model of the system</td>
|
||
</tr>
|
||
|
||
<tr>
|
||
<td class="org-left"> </td>
|
||
<td class="org-center">No clear way to limit input usage</td>
|
||
<td class="org-center"> </td>
|
||
<td class="org-center"> </td>
|
||
</tr>
|
||
</tbody>
|
||
</table>
|
||
</div>
|
||
</div>
|
||
|
||
<div id="outline-container-orgc22c5f8" class="outline-3">
|
||
<h3 id="orgc22c5f8"><span class="section-number-3">1.3</span> Example System</h3>
|
||
<div class="outline-text-3" id="text-1-3">
|
||
<p>
|
||
<a id="org9b1ba0d"></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="#org511ebc9">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="#org511ebc9">2</a> are listed and described in Table <a href="#orga08a22d">2</a>.
|
||
</p>
|
||
|
||
|
||
<div id="org511ebc9" 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="orga08a22d" 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="org7be3bc1">
|
||
<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="#org511ebc9">2</a> into a classical feedback architecture as shown in Figure <a href="#org303c067">6</a>.
|
||
</p>
|
||
|
||
|
||
<div id="org4d0c6fe" 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="#org511ebc9">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="#orgf5d4422">4</a> and <a href="#orgbd0da8a">5</a>.
|
||
</p>
|
||
|
||
|
||
<div id="orgf5d4422" 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="orgbd0da8a" 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-org0f1cd3d" class="outline-2">
|
||
<h2 id="org0f1cd3d"><span class="section-number-2">2</span> Classical Open Loop Shaping</h2>
|
||
<div class="outline-text-2" id="text-2">
|
||
<p>
|
||
<a id="orgd366933"></a>
|
||
</p>
|
||
<p>
|
||
After an introduction to classical Loop Shaping in Section <a href="#org9b3a4e0">2.1</a>, a practical example is given in Section <a href="#org3a08289">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="#orga368c2b">2.3</a> and applied on the same example in Section <a href="#org36eccd5">2.4</a>.
|
||
</p>
|
||
</div>
|
||
|
||
<div id="outline-container-org87e2537" class="outline-3">
|
||
<h3 id="org87e2537"><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="org9b3a4e0"></a>
|
||
</p>
|
||
|
||
<div class="definition" id="orgff51a0f">
|
||
<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="org916925b">
|
||
<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="#org303c067">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="org303c067" 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="#org3448de7">7</a>.
|
||
Another interesting Loop shape called “Bode Step” is described in <a href="#citeproc_bib_item_1">[1]</a>.
|
||
</p>
|
||
|
||
|
||
<div id="org3448de7" 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="#org7347675">4</a> and <a href="#org177a482">5</a>.
|
||
</p>
|
||
</div>
|
||
</div>
|
||
|
||
<div id="outline-container-org7c1b09b" class="outline-3">
|
||
<h3 id="org7c1b09b"><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="org3a08289"></a>
|
||
</p>
|
||
|
||
<div class="exampl" id="org3bf4600">
|
||
<p>
|
||
Let’s take our example system described in Section <a href="#org9b1ba0d">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="org3119348">
|
||
<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="#orgbc8bca4">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="orgbc8bca4" 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-org96ef122" class="outline-3">
|
||
<h3 id="org96ef122"><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="orga368c2b"></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="org96d37db">
|
||
<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-org759e327" class="outline-3">
|
||
<h3 id="org759e327"><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="org36eccd5"></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="#orge1b2777">3</a>.
|
||
</p>
|
||
|
||
<p>
|
||
Such shape corresponds to the typical wanted Loop gain Shape shown in Figure <a href="#org3448de7">7</a>.
|
||
</p>
|
||
|
||
<table id="orge1b2777" 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="#orgc8d8a84">9</a> and matches the specified one by a factor \(\gamma \approx 2\).
|
||
</p>
|
||
|
||
|
||
<div id="orgc8d8a84" 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="orgb867f2e">
|
||
<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="#org879f390">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="org879f390" 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="#org7397edf">4</a>.
|
||
</p>
|
||
|
||
<table id="org7397edf" 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-org80d004e" class="outline-2">
|
||
<h2 id="org80d004e"><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="orgc50cf6a"></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="#org20070d0">3.1</a>, the \(\mathcal{H}_\infty\) synthesis procedure is described in Section <a href="#org625e006">3.2</a> .
|
||
</p>
|
||
|
||
<p>
|
||
The generalized plant, a very useful tool to describe a control problem, is presented in Section <a href="#org5a15fbe">3.3</a>.
|
||
The \(\mathcal{H}_\infty\) is then applied to this generalized plant in Section <a href="#org543e1aa">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="#orga08b47b">3.5</a>.
|
||
</p>
|
||
</div>
|
||
|
||
<div id="outline-container-org0bc3797" class="outline-3">
|
||
<h3 id="org0bc3797"><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="org20070d0"></a>
|
||
</p>
|
||
|
||
<div class="definition" id="orge14f1d8">
|
||
<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="org46827c7">
|
||
<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="#org87ab680">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="org87ab680" 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-orge31e565" class="outline-3">
|
||
<h3 id="orge31e565"><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="org625e006"></a>
|
||
</p>
|
||
|
||
<div class="definition" id="org5d31be4">
|
||
<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="#org7347675">4</a>.
|
||
</p>
|
||
|
||
<div class="important" id="org39519c2">
|
||
<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="#org7347675">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-orgc18097d" class="outline-3">
|
||
<h3 id="orgc18097d"><span class="section-number-3">3.3</span> The Generalized Plant</h3>
|
||
<div class="outline-text-3" id="text-3-3">
|
||
<p>
|
||
<a id="org5a15fbe"></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="#org8e0b156">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="#org1e86690">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="#orga08b47b">3.5</a>.
|
||
</p>
|
||
|
||
<div class="important" id="org93496d7">
|
||
|
||
<div id="org8e0b156" 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="org1e86690" 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-org3e39769" class="outline-3">
|
||
<h3 id="org3e39769"><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="org543e1aa"></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="orgf313180">
|
||
<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="#org3457382">13</a>.
|
||
</p>
|
||
|
||
|
||
<div id="org3457382" 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="#org3457382">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-orga1c7b25" class="outline-3">
|
||
<h3 id="orga1c7b25"><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="orga08b47b"></a>
|
||
</p>
|
||
|
||
<p>
|
||
The procedure to convert a typical control architecture as the one shown in Figure <a href="#org5300f1d">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="#org8e0b156">12</a></li>
|
||
</ol>
|
||
|
||
<div class="exercice" id="org7308ff5">
|
||
<p>
|
||
Consider the feedback control architecture shown in Figure <a href="#org5300f1d">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="org5300f1d" 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="#org8e0b156">12</a>.
|
||
</p>
|
||
</details>
|
||
|
||
<details><summary>Answer</summary>
|
||
<p>
|
||
The obtained generalized plant shown in Figure <a href="#org14df428">15</a>.
|
||
</p>
|
||
|
||
|
||
<div id="org14df428" 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-org9e968b0" class="outline-2">
|
||
<h2 id="org9e968b0"><span class="section-number-2">4</span> Modern Interpretation of Control Specifications</h2>
|
||
<div class="outline-text-2" id="text-4">
|
||
<p>
|
||
<a id="org7347675"></a>
|
||
</p>
|
||
<p>
|
||
As shown in Section <a href="#orgd366933">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="#org2cee7fc">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="#org177a482">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="#orga427d45">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="#org72deda0">4.3</a>).
|
||
</p>
|
||
|
||
<p>
|
||
Links between typical control specifications and shapes of the closed-loop transfer functions are summarized in Section <a href="#orga7d27c3">4.4</a>.
|
||
</p>
|
||
</div>
|
||
|
||
<div id="outline-container-org696631c" class="outline-3">
|
||
<h3 id="org696631c"><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="org2cee7fc"></a>
|
||
</p>
|
||
|
||
<p>
|
||
Consider the typical feedback system shown in Figure <a href="#org56ecb4d">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="#orgcddaa3f">6</a>.
|
||
</p>
|
||
|
||
|
||
<div id="org56ecb4d" 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="orgcddaa3f" 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="#org72deda0">4.3</a>)</td>
|
||
</tr>
|
||
</tbody>
|
||
</table>
|
||
|
||
<div class="exercice" id="org8ab0cf7">
|
||
<p>
|
||
For the feedback system in Figure <a href="#org56ecb4d">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="org5df9302">
|
||
<p>
|
||
We can see that they are 4 different closed-loop transfer functions describing the behavior of the feedback system in Figure <a href="#org56ecb4d">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="orgec88d43">
|
||
<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="#org56ecb4d">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-org049de6d" class="outline-3">
|
||
<h3 id="org049de6d"><span class="section-number-3">4.2</span> The Sensitivity Function</h3>
|
||
<div class="outline-text-3" id="text-4-2">
|
||
<p>
|
||
<a id="orga427d45"></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="#orgf14f4e4">17</a> and the corresponding step responses are shown in Figure <a href="#org2f06ceb">18</a>.
|
||
</p>
|
||
|
||
<p>
|
||
The comparison of the sensitivity functions shapes and their effect on the step response is summarized in Table <a href="#orgf7929fd">7</a>.
|
||
</p>
|
||
|
||
<table id="orgf7929fd" 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="orgf14f4e4" 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="org2f06ceb" 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="org58246d4">
|
||
<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="orgbe46ff0">
|
||
<p>
|
||
From the simple analysis above, we can draw a first estimation of the wanted shape for the sensitivity function (Figure <a href="#org5cfa55f">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="org5cfa55f" 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-org0b2cf6e" class="outline-3">
|
||
<h3 id="org0b2cf6e"><span class="section-number-3">4.3</span> Robustness: Module Margin</h3>
|
||
<div class="outline-text-3" id="text-4-3">
|
||
<p>
|
||
<a id="org72deda0"></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="org5c4cd99">
|
||
<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="#orgb582761">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="#orgb582761">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="orgb582761" 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="#orgc3b851c">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="orgc3b851c" 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="orge7e8d9f">
|
||
<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="org601fcdf">
|
||
<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="orgb7e1653">
|
||
<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="org4af91f3">
|
||
<p>
|
||
A typical Nyquist plot is shown in Figure <a href="#orgab9e75c">22</a>.
|
||
The gain, phase and module margins are graphically shown to have an idea of what they represent.
|
||
</p>
|
||
|
||
|
||
<div id="orgab9e75c" 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="#orgab9e75c">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="orge86993f">
|
||
<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="orgc546e30">
|
||
<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="orgecbe281">
|
||
<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-orgd7964d5" class="outline-3">
|
||
<h3 id="orgd7964d5"><span class="section-number-3">4.4</span> Summary of</h3>
|
||
<div class="outline-text-3" id="text-4-4">
|
||
<p>
|
||
<a id="orga7d27c3"></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="org54297fa" 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-orgb014c17" class="outline-2">
|
||
<h2 id="orgb014c17"><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="org177a482"></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="#org6c82015">5.1</a>.
|
||
</p>
|
||
|
||
<p>
|
||
Some advice on the design of weighting functions are given in Section <a href="#org14735fc">5.2</a>.
|
||
</p>
|
||
|
||
<p>
|
||
An example of the \(\mathcal{H}_\infty\) shaping of the sensitivity function is studied in Section <a href="#org33fda7c">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="#org6e12c9e">5.4</a>.
|
||
</p>
|
||
</div>
|
||
|
||
<div id="outline-container-org502268a" class="outline-3">
|
||
<h3 id="org502268a"><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="org6c82015"></a>
|
||
</p>
|
||
|
||
<p>
|
||
Suppose we apply the \(\mathcal{H}_\infty\) synthesis on the generalized plant \(P(s)\) shown in Figure <a href="#org2b3f310">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="org2b3f310" 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="orge8dd522">
|
||
<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="#org5e9b5b1">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="orga93a01e">
|
||
<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="org5e9b5b1" 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="org79abc27">
|
||
<p>
|
||
Using matlab, compute the weighted generalized plant shown in Figure <a href="#org280495c">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-orgb5c5d0b" class="outline-3">
|
||
<h3 id="orgb5c5d0b"><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="org14735fc"></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="org0503c90">
|
||
<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>
|
||
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="orgb953d5b">
|
||
<p>
|
||
The Matlab code below produces a weighting function with the following characteristics (Figure <a href="#org280495c">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="org280495c" 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="orgcab64a0">
|
||
<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="org2a73f09"><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="#org0d1f8f6">26</a>.
|
||
</p>
|
||
|
||
|
||
<div id="org0d1f8f6" 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-orgeada131" class="outline-3">
|
||
<h3 id="orgeada131"><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="org33fda7c"></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="#org9b1ba0d">1.3</a>.
|
||
</p>
|
||
|
||
<div class="exercice" id="org1649af7">
|
||
<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="#org829eb00">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="org829eb00" 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="org990b90e">
|
||
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="#orgbea55d9">28</a>.
|
||
</p>
|
||
|
||
<div class="important" id="orgb70c241">
|
||
<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="orgbea55d9" 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-org9159197" class="outline-3">
|
||
<h3 id="org9159197"><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="org6e12c9e"></a>
|
||
</p>
|
||
<p>
|
||
As was shown in Section <a href="#org7347675">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.
|
||
</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 measurment 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="#org84e27fa">6</a>.
|
||
</p>
|
||
|
||
<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="org5e7ce6c" 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="#org5e7ce6c">29</a></label><pre class="src src-matlab" id="orgfbc9db3">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="orgb578549" 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="#orgb578549">30</a></label><pre class="src src-matlab" id="orga4e7418">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="org307b05c" 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="#org307b05c">31</a></label><pre class="src src-matlab" id="orgc30b4b1">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="orgfbd7396" 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="#orgfbd7396">32</a></label><pre class="src src-matlab" id="orgee057b9">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="org7c8640f" 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="#org7c8640f">33</a></label><pre class="src src-matlab" id="orgaf3f732">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="org46c11e1" 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="#org46c11e1">34</a></label><pre class="src src-matlab" id="org6894b8f">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>
|
||
<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 class="warning" id="orgf093621">
|
||
<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="orgfd3f536">
|
||
<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="#org36e3a84">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="#org36e3a84">35</a>.
|
||
</p>
|
||
|
||
|
||
<div id="org36e3a84" 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="orgce511d1">
|
||
<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-org5f0592a" class="outline-2">
|
||
<h2 id="org5f0592a"><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="org84e27fa"></a>
|
||
</p>
|
||
</div>
|
||
|
||
<div id="outline-container-org686cf2a" class="outline-3">
|
||
<h3 id="org686cf2a"><span class="section-number-3">6.1</span> Control Problem</h3>
|
||
<div class="outline-text-3" id="text-6-1">
|
||
<ul class="org-ul">
|
||
<li class="off"><code>[ ]</code> Control Diagram</li>
|
||
</ul>
|
||
|
||
|
||
<ul class="org-ul">
|
||
<li>Inputs Signals
|
||
<ul class="org-ul">
|
||
<li>Reference steps of 1mm</li>
|
||
<li>Measurement noise is considered to be a white noise with a power spectral density of …</li>
|
||
</ul></li>
|
||
<li>Specifications
|
||
<ul class="org-ul">
|
||
<li>Follow reference steps with a response time of 0.1s and static error less than \(1 \mu m\)</li>
|
||
<li>Maximum control signal of 10N</li>
|
||
<li>Robustness</li>
|
||
<li>Reduce the effect of measurement noise on the position</li>
|
||
</ul></li>
|
||
</ul>
|
||
|
||
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab">k = 1e6; <span class="org-comment">% Stiffness [N/m]</span>
|
||
c = 4e2; <span class="org-comment">% Damping [N/(m/s)]</span>
|
||
m = 10; <span class="org-comment">% Mass [kg]</span>
|
||
|
||
G = 1<span class="org-type">/</span>(m<span class="org-type">*</span>s<span class="org-type">^</span>2 <span class="org-type">+</span> c<span class="org-type">*</span>s <span class="org-type">+</span> k); <span class="org-comment">% Plant</span>
|
||
Gd = (c<span class="org-type">*</span>s <span class="org-type">+</span> k)<span class="org-type">/</span>(m<span class="org-type">*</span>s<span class="org-type">^</span>2 <span class="org-type">+</span> c<span class="org-type">*</span>s <span class="org-type">+</span> k); <span class="org-comment">% Disturbance</span>
|
||
</pre>
|
||
</div>
|
||
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab"><span class="org-comment">% Generate Input Signals</span>
|
||
t = 0<span class="org-type">:</span>1e<span class="org-type">-</span>3<span class="org-type">:</span>1;
|
||
|
||
r = zeros(size(t));
|
||
r(t<span class="org-type">></span>0.1) = 1e<span class="org-type">-</span>3;
|
||
|
||
|
||
Fs = 1e3; <span class="org-comment">% Sampling Frequency [Hz]</span>
|
||
Ts = 1<span class="org-type">/</span>Fs; <span class="org-comment">% Sampling Time [s]</span>
|
||
n = sqrt(Fs<span class="org-type">/</span>2)<span class="org-type">*</span>randn(1, length(t)); <span class="org-comment">% Signal with an ASD equal to one</span>
|
||
n = n<span class="org-type">*</span>1e<span class="org-type">-</span>6;
|
||
|
||
d = zeros(size(t));
|
||
d(t<span class="org-type">></span>0.5) = 5e<span class="org-type">-</span>4;
|
||
</pre>
|
||
</div>
|
||
</div>
|
||
</div>
|
||
|
||
<div id="outline-container-orgb714b0a" class="outline-3">
|
||
<h3 id="orgb714b0a"><span class="section-number-3">6.2</span> Control Design Procedure</h3>
|
||
<div class="outline-text-3" id="text-6-2">
|
||
<table border="2" cellspacing="0" cellpadding="6" rules="groups" frame="hsides">
|
||
|
||
|
||
<colgroup>
|
||
<col class="org-left" />
|
||
|
||
<col class="org-left" />
|
||
|
||
<col class="org-left" />
|
||
</colgroup>
|
||
<thead>
|
||
<tr>
|
||
<th scope="col" class="org-left"> </th>
|
||
<th scope="col" class="org-left"> </th>
|
||
<th scope="col" class="org-left"> </th>
|
||
</tr>
|
||
</thead>
|
||
<tbody>
|
||
<tr>
|
||
<td class="org-left">Response Time</td>
|
||
<td class="org-left"> </td>
|
||
<td class="org-left"> </td>
|
||
</tr>
|
||
|
||
<tr>
|
||
<td class="org-left">Robustness</td>
|
||
<td class="org-left"> </td>
|
||
<td class="org-left"> </td>
|
||
</tr>
|
||
|
||
<tr>
|
||
<td class="org-left">Limitation of the Command Amplitude</td>
|
||
<td class="org-left"> </td>
|
||
<td class="org-left"> </td>
|
||
</tr>
|
||
|
||
<tr>
|
||
<td class="org-left">Filtering of the measurement noise</td>
|
||
<td class="org-left"> </td>
|
||
<td class="org-left"> </td>
|
||
</tr>
|
||
</tbody>
|
||
</table>
|
||
|
||
|
||
<div id="orgd6a91f2" class="figure">
|
||
<p><img src="figs/mixed_sensitivity_control_schematic.png" alt="mixed_sensitivity_control_schematic.png" />
|
||
</p>
|
||
<p><span class="figure-number">Figure 36: </span>Generalized Plant used for the Mixed Sensitivity Synthesis</p>
|
||
</div>
|
||
|
||
<ul class="org-ul">
|
||
<li>\(W_1\) is used to shape \(S\)</li>
|
||
<li>\(W_2\) is used to shape \(KS\)</li>
|
||
<li>\(W_3\) is used to shape \(T\)</li>
|
||
</ul>
|
||
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab">P = [1 <span class="org-type">-</span>G
|
||
0 1
|
||
0 G
|
||
1 <span class="org-type">-</span>G];
|
||
</pre>
|
||
</div>
|
||
</div>
|
||
</div>
|
||
|
||
<div id="outline-container-org2c003ca" class="outline-3">
|
||
<h3 id="org2c003ca"><span class="section-number-3">6.3</span> Step 1 - Shaping of \(S\)</h3>
|
||
<div class="outline-text-3" id="text-6-3">
|
||
<p>
|
||
<a id="orgf2dd0dc"></a>
|
||
</p>
|
||
|
||
<p>
|
||
We start with the shaping of \(S\) alone.
|
||
To not constrain \(KS\) and \(T\), we set small values for \(W_2\) and \(W_3\)
|
||
</p>
|
||
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab">W2 = tf(1e<span class="org-type">-</span>8);
|
||
W3 = tf(0.1);
|
||
</pre>
|
||
</div>
|
||
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab">W1 = generateWeight(<span class="org-string">'G0'</span>, 1e3, ...
|
||
<span class="org-string">'G1'</span>, 1<span class="org-type">/</span>2, ...
|
||
<span class="org-string">'Gc'</span>, sqrt(2), <span class="org-string">'wc'</span>, 2<span class="org-type">*</span><span class="org-constant">pi</span><span class="org-type">*</span>10, ...
|
||
<span class="org-string">'n'</span>, 1);
|
||
</pre>
|
||
</div>
|
||
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab">Pw = blkdiag(W1, W2, W3, 1)<span class="org-type">*</span>P;
|
||
</pre>
|
||
</div>
|
||
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab">K1 = hinfsyn(Pw, 1, 1, <span class="org-string">'Display'</span>, <span class="org-string">'on'</span>);
|
||
</pre>
|
||
</div>
|
||
|
||
<pre class="example" id="orgc3af019">
|
||
K1 = hinfsyn(Pw, 1, 1, 'Display', 'on');
|
||
|
||
Test bounds: 0.5 <= gamma <= 0.552
|
||
|
||
gamma X>=0 Y>=0 rho(XY)<1 p/f
|
||
5.25e-01 0.0e+00 0.0e+00 6.061e-16 p
|
||
5.13e-01 0.0e+00 0.0e+00 0.000e+00 p
|
||
5.06e-01 -2.5e+00 # -6.4e-14 1.440e-15 f
|
||
5.09e-01 -5.5e+00 # -4.1e-14 9.510e-16 f
|
||
Limiting gains...
|
||
5.14e-01 0.0e+00 0.0e+00 1.039e-25 p
|
||
5.14e-01 0.0e+00 0.0e+00 1.040e-25 p
|
||
|
||
Best performance (actual): 0.514
|
||
'org_babel_eoe'
|
||
ans =
|
||
'org_babel_eoe'
|
||
</pre>
|
||
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab">Z1 = lft(P, K1);
|
||
</pre>
|
||
</div>
|
||
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab"><span class="org-comment">% Create model with r and n as inputs and y and u as outputs</span>
|
||
Psim = [0 0 Gd G
|
||
0 0 0 1
|
||
1 <span class="org-type">-</span>1 <span class="org-type">-</span>Gd <span class="org-type">-</span>G];
|
||
Z1sim = lft(Psim, K1);
|
||
</pre>
|
||
</div>
|
||
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab">z = lsim(Z1sim, [r;n;d], t);
|
||
y1 = z(<span class="org-type">:</span>,1);
|
||
u1 = z(<span class="org-type">:</span>,2);
|
||
</pre>
|
||
</div>
|
||
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab"><span class="org-type">figure</span>;
|
||
tiledlayout(1, 2, <span class="org-string">'TileSpacing'</span>, <span class="org-string">'None'</span>, <span class="org-string">'Padding'</span>, <span class="org-string">'None'</span>);
|
||
|
||
nexttile;
|
||
hold on;
|
||
plot(t, y1);
|
||
hold off;
|
||
xlabel(<span class="org-string">'Time [s]'</span>); ylabel(<span class="org-string">'Output $y$ [m]'</span>);
|
||
|
||
nexttile;
|
||
hold on;
|
||
plot(t, u1);
|
||
hold off;
|
||
xlabel(<span class="org-string">'Time [s]'</span>); ylabel(<span class="org-string">'Control Input $u$ [N]'</span>);
|
||
</pre>
|
||
</div>
|
||
</div>
|
||
</div>
|
||
|
||
<div id="outline-container-orgc5e1a2a" class="outline-3">
|
||
<h3 id="orgc5e1a2a"><span class="section-number-3">6.4</span> Step 2 - Shaping of \(KS\)</h3>
|
||
<div class="outline-text-3" id="text-6-4">
|
||
<p>
|
||
<a id="org1a1d6bd"></a>
|
||
</p>
|
||
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab">W2 = generateWeight(<span class="org-string">'G0'</span>, 5e<span class="org-type">-</span>7, ...
|
||
<span class="org-string">'G1'</span>, 1e<span class="org-type">-</span>3, ...
|
||
<span class="org-string">'Gc'</span>, 1e<span class="org-type">-</span>6, <span class="org-string">'wc'</span>, 2<span class="org-type">*</span><span class="org-constant">pi</span><span class="org-type">*</span>100, ...
|
||
<span class="org-string">'n'</span>, 1);
|
||
</pre>
|
||
</div>
|
||
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab">Pw = blkdiag(W1, W2, W3, 1)<span class="org-type">*</span>P;
|
||
</pre>
|
||
</div>
|
||
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab">K2 = hinfsyn(Pw, 1, 1, <span class="org-string">'Display'</span>, <span class="org-string">'on'</span>);
|
||
</pre>
|
||
</div>
|
||
|
||
<pre class="example" id="org387bf3e">
|
||
K1 = hinfsyn(Pw, 1, 1, 'Display', 'on');
|
||
|
||
Test bounds: 0.51 <= gamma <= 1.2
|
||
|
||
gamma X>=0 Y>=0 rho(XY)<1 p/f
|
||
7.82e-01 0.0e+00 0.0e+00 0.000e+00 p
|
||
6.32e-01 -2.2e+00 # -3.0e-14 -1.136e-32 f
|
||
7.03e-01 -5.1e+00 # -2.9e-14 5.128e-17 f
|
||
7.41e-01 -1.1e+01 # -1.0e-14 1.431e-22 f
|
||
7.61e-01 -2.6e+01 # -9.1e-15 1.215e-21 f
|
||
7.72e-01 -6.9e+01 # -1.9e-14 2.828e-16 f
|
||
7.77e-01 -3.6e+02 # -1.2e-14 1.213e-15 f
|
||
|
||
Best performance (actual): 0.782
|
||
'org_babel_eoe'
|
||
ans =
|
||
'org_babel_eoe'
|
||
</pre>
|
||
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab">Z2 = lft(P, K2);
|
||
</pre>
|
||
</div>
|
||
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab">Z2sim = lft(Psim, K2);
|
||
</pre>
|
||
</div>
|
||
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab">z = lsim(Z2sim, [r;n;d], t);
|
||
y2 = z(<span class="org-type">:</span>,1);
|
||
u2 = z(<span class="org-type">:</span>,2);
|
||
</pre>
|
||
</div>
|
||
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab"><span class="org-type">figure</span>;
|
||
tiledlayout(1, 2, <span class="org-string">'TileSpacing'</span>, <span class="org-string">'None'</span>, <span class="org-string">'Padding'</span>, <span class="org-string">'None'</span>);
|
||
|
||
nexttile;
|
||
hold on;
|
||
plot(t, y1);
|
||
plot(t, y2);
|
||
hold off;
|
||
xlabel(<span class="org-string">'Time [s]'</span>); ylabel(<span class="org-string">'Output $y$ [m]'</span>);
|
||
|
||
nexttile;
|
||
hold on;
|
||
plot(t, u1);
|
||
plot(t, u2);
|
||
hold off;
|
||
xlabel(<span class="org-string">'Time [s]'</span>); ylabel(<span class="org-string">'Control Input $u$ [N]'</span>);
|
||
</pre>
|
||
</div>
|
||
</div>
|
||
</div>
|
||
|
||
<div id="outline-container-org92995a6" class="outline-3">
|
||
<h3 id="org92995a6"><span class="section-number-3">6.5</span> Step 3 - Shaping of \(T\)</h3>
|
||
<div class="outline-text-3" id="text-6-5">
|
||
<p>
|
||
<a id="orgf29b96e"></a>
|
||
</p>
|
||
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab">W3 = generateWeight(<span class="org-string">'G0'</span>, 1e<span class="org-type">-</span>1, ...
|
||
<span class="org-string">'G1'</span>, 1e4, ...
|
||
<span class="org-string">'Gc'</span>, 1, <span class="org-string">'wc'</span>, 2<span class="org-type">*</span><span class="org-constant">pi</span><span class="org-type">*</span>30, ...
|
||
<span class="org-string">'n'</span>, 3);
|
||
</pre>
|
||
</div>
|
||
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab">Pw = blkdiag(W1, W2, W3, 1)<span class="org-type">*</span>P;
|
||
</pre>
|
||
</div>
|
||
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab">K3 = hinfsyn(Pw, 1, 1, <span class="org-string">'Display'</span>, <span class="org-string">'on'</span>);
|
||
</pre>
|
||
</div>
|
||
|
||
<pre class="example" id="org82efd70">
|
||
K3 = hinfsyn(Pw, 1, 1, 'Display', 'on');
|
||
|
||
Test bounds: 0.578 <= gamma <= 1.66
|
||
|
||
gamma X>=0 Y>=0 rho(XY)<1 p/f
|
||
9.78e-01 -1.3e+01 # -6.2e-15 1.141e-18 f
|
||
1.27e+00 0.0e+00 0.0e+00 1.524e-15 p
|
||
1.12e+00 0.0e+00 0.0e+00 4.481e-15 p
|
||
1.04e+00 -4.0e+01 # -1.0e-13 1.102e-42 f
|
||
1.08e+00 -6.6e+02 # -4.4e-15 3.641e-18 f
|
||
1.10e+00 0.0e+00 0.0e+00 6.052e-21 p
|
||
1.09e+00 0.0e+00 0.0e+00 5.005e-15 p
|
||
|
||
Best performance (actual): 1.09
|
||
'org_babel_eoe'
|
||
ans =
|
||
'org_babel_eoe'
|
||
</pre>
|
||
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab">Z3 = lft(P, K3);
|
||
</pre>
|
||
</div>
|
||
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab">Z3sim = lft(Psim, K3);
|
||
</pre>
|
||
</div>
|
||
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab">z = lsim(Z3sim, [r;n;d], t);
|
||
y3 = z(<span class="org-type">:</span>,1);
|
||
u3 = z(<span class="org-type">:</span>,2);
|
||
</pre>
|
||
</div>
|
||
|
||
<div class="org-src-container">
|
||
<pre class="src src-matlab"><span class="org-type">figure</span>;
|
||
tiledlayout(1, 2, <span class="org-string">'TileSpacing'</span>, <span class="org-string">'None'</span>, <span class="org-string">'Padding'</span>, <span class="org-string">'None'</span>);
|
||
|
||
nexttile;
|
||
hold on;
|
||
plot(t, y1);
|
||
plot(t, y2);
|
||
plot(t, y3);
|
||
hold off;
|
||
xlabel(<span class="org-string">'Time [s]'</span>); ylabel(<span class="org-string">'Output $y$ [m]'</span>);
|
||
|
||
nexttile;
|
||
hold on;
|
||
plot(t, u1);
|
||
plot(t, u2);
|
||
plot(t, u3);
|
||
hold off;
|
||
xlabel(<span class="org-string">'Time [s]'</span>); ylabel(<span class="org-string">'Control Input $u$ [N]'</span>);
|
||
</pre>
|
||
</div>
|
||
</div>
|
||
</div>
|
||
</div>
|
||
|
||
<div id="outline-container-orgff61bb6" class="outline-2">
|
||
<h2 id="orgff61bb6"><span class="section-number-2">7</span> Conclusion</h2>
|
||
<div class="outline-text-2" id="text-7">
|
||
<p>
|
||
<a id="org4eed41f"></a>
|
||
</p>
|
||
</div>
|
||
</div>
|
||
|
||
<div id="outline-container-orge194fb6" class="outline-2">
|
||
<h2 id="orge194fb6">Resources</h2>
|
||
<div class="outline-text-2" id="text-orge194fb6">
|
||
<p>
|
||
<div class="yt"><iframe width="100%" height="100%" src="https://www.youtube.com/embed/?listType=playlist&list=PLn8PRpmsu08qFLMfgTEzR8DxOPE7fBiin" frameborder="0" allowfullscreen></iframe></div>
|
||
</p>
|
||
|
||
<p>
|
||
<div class="yt"><iframe width="100%" height="100%" src="https://www.youtube.com/embed/?listType=playlist&list=PLsjPUqcL7ZIFHCObUU_9xPUImZ203gB4o" frameborder="0" allowfullscreen></iframe></div>
|
||
</p>
|
||
|
||
<style>.csl-left-margin{float: left; padding-right: 0em;} .csl-right-inline{margin: 0 0 0 1.7999999999999998em;}</style><h2 class='citeproc-org-bib-h2'>Bibliography</h2>
|
||
<div class="csl-bib-body">
|
||
<div class="csl-entry"><a name="citeproc_bib_item_1"></a>
|
||
<div class="csl-left-margin">[1]</div><div class="csl-right-inline">B. J. Lurie, A. Ghavimi, F. Y. Hadaegh, and E. Mettler, “System Architecture Trades Using Bode-Step Control Design,” <i>Journal of Guidance, Control, and Dynamics</i>, vol. 25, no. 2, pp. 309–315, 2002, [Online]. Available: <a href="https://doi.org/10.2514/2.4883">https://doi.org/10.2514/2.4883</a>.</div>
|
||
</div>
|
||
</div>
|
||
</div>
|
||
</div>
|
||
</div>
|
||
<div id="postamble" class="status">
|
||
<p class="author">Author: Dehaeze Thomas</p>
|
||
<p class="date">Created: 2020-12-03 jeu. 01:06</p>
|
||
</div>
|
||
</body>
|
||
</html>
|