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