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-12-04 23:38:01 +01:00
<!-- 2020 - 12 - 04 ven. 23:00 -->
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-12-04 23:38:01 +01:00
< li > < a href = "#org1af4d7c" > Introduction< / a > < / li >
< li > < a href = "#org1274078" > 1. Introduction to Model Based Control< / a >
2020-11-25 19:35:11 +01:00
< ul >
2020-12-04 23:38:01 +01:00
< li > < a href = "#org7627c7b" > 1.1. Model Based Control - Methodology< / a > < / li >
< li > < a href = "#org6a6f40b" > 1.2. From Classical Control to Robust Control< / a > < / li >
< li > < a href = "#orgc87c5ae" > 1.3. Example System< / a > < / li >
2020-11-25 19:35:11 +01:00
< / ul >
< / li >
2020-12-04 23:38:01 +01:00
< li > < a href = "#orgfd7b3af" > 2. Classical Open Loop Shaping< / a >
2020-11-27 18:26:06 +01:00
< ul >
2020-12-04 23:38:01 +01:00
< li > < a href = "#org89bda02" > 2.1. Introduction to Loop Shaping< / a > < / li >
< li > < a href = "#orgd820df1" > 2.2. Example of Manual Open Loop Shaping< / a > < / li >
< li > < a href = "#org44f6138" > 2.3. \(\mathcal{H}_\infty\) Loop Shaping Synthesis< / a > < / li >
< li > < a href = "#orgca27c56" > 2.4. Example of the \(\mathcal{H}_\infty\) Loop Shaping Synthesis< / a > < / li >
2020-11-27 18:26:06 +01:00
< / ul >
< / li >
2020-12-04 23:38:01 +01:00
< li > < a href = "#org30b75b7" > 3. A first Step into the \(\mathcal{H}_\infty\) world< / a >
2020-11-27 18:26:06 +01:00
< ul >
2020-12-04 23:38:01 +01:00
< li > < a href = "#org439f43b" > 3.1. The \(\mathcal{H}_\infty\) Norm< / a > < / li >
< li > < a href = "#org000a363" > 3.2. \(\mathcal{H}_\infty\) Synthesis< / a > < / li >
< li > < a href = "#org415bc1a" > 3.3. The Generalized Plant< / a > < / li >
< li > < a href = "#org7e02151" > 3.4. The \(\mathcal{H}_\infty\) Synthesis applied on the Generalized plant< / a > < / li >
< li > < a href = "#orga1c5b17" > 3.5. From a Classical Feedback Architecture to a Generalized Plant< / a > < / li >
2020-11-27 18:26:06 +01:00
< / ul >
< / li >
2020-12-04 23:38:01 +01:00
< li > < a href = "#org20cd912" > 4. Modern Interpretation of Control Specifications< / a >
2020-11-27 23:13:29 +01:00
< ul >
2020-12-04 23:38:01 +01:00
< li > < a href = "#org6f0140b" > 4.1. Closed Loop Transfer Functions and the Gang of Four< / a > < / li >
< li > < a href = "#orgaa60a5b" > 4.2. The Sensitivity Function< / a > < / li >
< li > < a href = "#orgecf3c2d" > 4.3. Robustness: Module Margin< / a > < / li >
< li > < a href = "#org2ed2ced" > 4.4. Summary of typical specification and associated wanted shaping< / a > < / li >
2020-11-27 23:13:29 +01:00
< / ul >
< / li >
2020-12-04 23:38:01 +01:00
< li > < a href = "#org1087d13" > 5. \(\mathcal{H}_\infty\) Shaping of closed-loop transfer functions< / a >
2020-11-30 17:44:13 +01:00
< ul >
2020-12-04 23:38:01 +01:00
< li > < a href = "#org769efcc" > 5.1. How to Shape closed-loop transfer function? Using Weighting Functions!< / a > < / li >
< li > < a href = "#org861b5dc" > 5.2. Design of Weighting Functions< / a > < / li >
< li > < a href = "#org5f9d52e" > 5.3. Shaping the Sensitivity Function< / a > < / li >
< li > < a href = "#orgd94d43f" > 5.4. Shaping multiple closed-loop transfer functions - Limitations< / a > < / li >
2020-11-30 17:44:13 +01:00
< / ul >
< / li >
2020-12-04 23:38:01 +01:00
< li > < a href = "#org34cdfb9" > 6. Mixed-Sensitivity \(\mathcal{H}_\infty\) Control - Example< / a >
2020-12-01 18:49:40 +01:00
< ul >
2020-12-04 23:38:01 +01:00
< li > < a href = "#org77cb7c8" > 6.1. Control Problem< / a > < / li >
< li > < a href = "#orgb525282" > 6.2. Control Design Procedure< / a > < / li >
< li > < a href = "#org8b275d3" > 6.3. Modern Interpretation of control specifications< / a > < / li >
< li > < a href = "#orgc183526" > 6.4. Step 1 - Shaping of \(S\)< / a > < / li >
< li > < a href = "#org5ddc09e" > 6.5. Step 2 - Shaping of \(GS\)< / a > < / li >
< li > < a href = "#org55212fe" > 6.6. Step 3 - Shaping of \(T\)< / a > < / li >
< li > < a href = "#org06be7c7" > 6.7. Conclusion and Discussion< / a > < / li >
2020-12-01 18:49:40 +01:00
< / ul >
< / li >
2020-12-04 23:38:01 +01:00
< li > < a href = "#org8c77df4" > 7. Conclusion< / a > < / li >
2020-11-25 19:35:11 +01:00
< / ul >
< / div >
< / div >
2020-12-04 23:38:01 +01:00
< div id = "outline-container-org1af4d7c" class = "outline-2" >
< h2 id = "org1af4d7c" > Introduction< / h2 >
< div class = "outline-text-2" id = "text-org1af4d7c" >
2020-12-01 00:23:13 +01:00
< p >
2020-12-02 11:00:11 +01:00
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:
2020-12-01 00:23:13 +01:00
< / p >
< ul class = "org-ul" >
2020-12-04 23:38:01 +01:00
< li > A short introduction to < i > model based control< / i > is given in Section < a href = "#orgca3473c" > 1< / a > < / li >
< li > Classical < i > open< / i > loop shaping method is presented in Section < a href = "#org8ee7fc6" > 2< / a > .
2020-12-02 11:00:11 +01:00
It is also shown that \(\mathcal{H}_\infty\) synthesis can be used for < i > open< / i > loop shaping< / li >
2020-12-04 23:38:01 +01:00
< 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 = "#orge17d00d" > 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 = "#org8b8ea1e" > 4< / a > < / li >
2020-12-02 11:00:11 +01:00
< li > One of the most useful use of the \(\mathcal{H}_\infty\) control is the shaping of closed-loop transfer functions.
2020-12-04 23:38:01 +01:00
Such technique is presented in Section < a href = "#org392aca0" > 5< / a > < / li >
< li > Finally, complete examples of the use of \(\mathcal{H}_\infty\) Control for practical problems are provided in Section < a href = "#orgfcbbd2c" > 6< / a > < / li >
2020-12-01 00:23:13 +01:00
< / ul >
2020-12-04 23:38:01 +01:00
< / div >
< / div >
2020-12-01 00:23:13 +01:00
2020-12-04 23:38:01 +01:00
< div id = "outline-container-org1274078" class = "outline-2" >
< h2 id = "org1274078" > < span class = "section-number-2" > 1< / span > Introduction to 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 >
2020-12-04 23:38:01 +01:00
< a id = "orgca3473c" > < / a >
2020-11-30 17:44:13 +01:00
< / p >
2020-11-27 18:26:06 +01:00
< / div >
2020-11-30 17:44:13 +01:00
2020-12-04 23:38:01 +01:00
< div id = "outline-container-org7627c7b" class = "outline-3" >
< h3 id = "org7627c7b" > < 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-12-04 23:38:01 +01:00
< a id = "org94d0e03" > < / a >
2020-12-02 17:01:03 +01:00
< / p >
< p >
2020-12-04 23:38:01 +01:00
The typical methodology for < b > Model Based Control< / b > techniques is schematically shown in Figure < a href = "#orgfd32205" > 1< / a > .
2020-11-30 17:44:13 +01:00
< / p >
< p >
2020-11-25 19:35:11 +01:00
It consists of three steps:
< / p >
< ol class = "org-ol" >
2020-12-02 17:01:03 +01:00
< li > < b > Identification or modeling< / b > : a mathematical model \(G(s)\) representing the plant dynamics is obtained< / li >
2020-11-25 19:35:11 +01:00
< 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 >
2020-12-02 17:01:03 +01:00
< li > < span class = "underline" > Mathematical Criteria< / span > : Cost Function, Shape of transfer function, Phase/Gain margin, Roll-Off, … < / li >
2020-11-25 19:35:11 +01:00
< / ul > < / li >
2020-12-02 17:01:03 +01:00
< li > < b > Synthesis< / b > : research of a controller \(K(s)\) that satisfies the specifications for the model of the system< / li >
2020-11-25 19:35:11 +01:00
< / ol >
2020-12-04 23:38:01 +01:00
< div id = "orgfd32205" 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 >
2020-12-02 17:01:03 +01:00
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 >
2020-12-04 23:38:01 +01:00
In Section < a href = "#org8ee7fc6" > 2< / a > , steps 2 and 3 will be described for a control techniques called < b > classical (open-)loop shaping< / b > .
2020-11-25 19:35:11 +01:00
< / p >
2020-12-01 00:23:13 +01:00
< p >
2020-12-04 23:38:01 +01:00
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 = "#org8b8ea1e" > 4< / a > , < a href = "#org392aca0" > 5< / a > and < a href = "#orgfcbbd2c" > 6< / a > .
2020-12-01 00:23:13 +01:00
< / p >
2020-11-25 19:35:11 +01:00
< / div >
< / div >
2020-12-04 23:38:01 +01:00
< div id = "outline-container-org6a6f40b" class = "outline-3" >
< h3 id = "org6a6f40b" > < span class = "section-number-3" > 1.2< / span > 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 >
2020-12-04 23:38:01 +01:00
< a id = "orgd01368f" > < / a >
2020-11-30 17:44:13 +01:00
< / p >
2020-12-02 17:01:03 +01:00
< 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.
2020-12-02 19:01:04 +01:00
This led to a new control theory called < b > Robust control< / b > that blends the best features of classical and modern techniques.
2020-12-02 17:01:03 +01:00
This robust control theory is the subject of this document.
< / p >
< p >
2020-12-04 23:38:01 +01:00
The three presented control methods are compared in Table < a href = "#org3309cd6" > 1< / a > .
2020-12-02 17:01:03 +01:00
< / 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 >
2020-12-04 23:38:01 +01:00
< table id = "org3309cd6" 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 >
2020-12-04 23:38:01 +01:00
< td class = "org-center" > Systems/Signal Norms< / td >
2020-11-27 23:13:29 +01:00
< / tr >
< tr >
< td class = "org-left" >   < / td >
2020-12-03 11:51:44 +01:00
< td class = "org-center" > Nyquist, Bode Plots< / td >
2020-11-27 23:13:29 +01:00
< td class = "org-center" > Riccati Equations< / td >
2020-12-04 23:38:01 +01:00
< td class = "org-center" > Closed Loop TF< / td >
2020-11-27 23:13:29 +01:00
< / tr >
< tr >
< td class = "org-left" >   < / td >
2020-12-03 11:51:44 +01:00
< td class = "org-center" > Root Locus< / td >
2020-12-04 23:38:01 +01:00
< td class = "org-center" > Kalman Filters< / td >
2020-12-03 11:51:44 +01:00
< td class = "org-center" > Closed Loop Shaping< / td >
2020-11-27 23:13:29 +01:00
< / tr >
< tr >
< td class = "org-left" >   < / td >
2020-12-04 23:38:01 +01:00
< td class = "org-center" > Phase/Gain margins< / td >
2020-11-27 23:13:29 +01:00
< td class = "org-center" >   < / td >
< td class = "org-center" > Weighting Functions< / td >
< / tr >
< tr >
< td class = "org-left" >   < / td >
2020-12-03 11:51:44 +01:00
< td class = "org-center" > Open Loop Shaping< / td >
2020-11-27 23:13:29 +01:00
< td class = "org-center" >   < / td >
< td class = "org-center" > Disk margin< / td >
< / tr >
< / tbody >
< tbody >
< tr >
2020-12-04 23:38:01 +01:00
< td class = "org-left" > < b > Controllers< / b > < / td >
< td class = "org-center" > P, PI, PID< / td >
< td class = "org-center" > Full State Feedback< / td >
< td class = "org-center" > General Control Conf.< / td >
2020-11-27 23:13:29 +01:00
< / tr >
< tr >
< td class = "org-left" >   < / td >
< td class = "org-center" > Leads, Lags< / td >
2020-12-04 23:38:01 +01:00
< td class = "org-center" > LQG, LQR< / td >
< td class = "org-center" >   < / td >
2020-11-27 23:13:29 +01:00
< / 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 >
< / tbody >
< tbody >
< tr >
2020-12-04 23:38:01 +01:00
< td class = "org-left" > < b > Disadvant.< / b > < / td >
2020-11-27 23:13:29 +01:00
< td class = "org-center" > Manual Method< / td >
< td class = "org-center" > No Guaranteed Robustness< / td >
2020-12-04 23:38:01 +01:00
< td class = "org-center" > Requires knowledge of tools< / td >
2020-11-27 23:13:29 +01:00
< / tr >
< tr >
< td class = "org-left" >   < / td >
< td class = "org-center" > Only SISO< / td >
2020-12-04 23:38:01 +01:00
< td class = "org-center" > Rejection of Pert.< / td >
< td class = "org-center" > Need good model of the system< / td >
2020-11-27 23:13:29 +01:00
< / tr >
2020-12-02 17:01:03 +01:00
< tr >
< td class = "org-left" >   < / td >
2020-12-04 23:38:01 +01:00
< td class = "org-center" > No input usage lim.< / td >
2020-12-02 17:01:03 +01:00
< td class = "org-center" >   < / td >
< td class = "org-center" >   < / td >
< / tr >
2020-11-27 23:13:29 +01:00
< / tbody >
< / table >
2020-11-25 19:35:11 +01:00
< / div >
< / div >
2020-12-04 23:38:01 +01:00
< div id = "outline-container-orgc87c5ae" class = "outline-3" >
< h3 id = "orgc87c5ae" > < 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-12-04 23:38:01 +01:00
< a id = "org8bf164e" > < / a >
2020-11-30 17:44:13 +01:00
< / p >
< p >
2020-12-02 19:01:04 +01:00
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.
2020-11-27 18:26:06 +01:00
< / p >
2020-12-02 19:01:04 +01:00
< p >
2020-12-04 23:38:01 +01:00
This system is shown in Figure < a href = "#org132cf56" > 2< / a > .
2020-12-02 19:01:04 +01:00
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 >
2020-11-27 18:26:06 +01:00
2020-12-02 19:01:04 +01:00
< p >
2020-12-04 23:38:01 +01:00
The notations used on Figure < a href = "#org132cf56" > 2< / a > are listed and described in Table < a href = "#org04dcd19" > 2< / a > .
2020-12-02 19:01:04 +01:00
< / p >
2020-12-04 23:38:01 +01:00
< div id = "org132cf56" 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-12-02 19:01:04 +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-12-04 23:38:01 +01:00
< table id = "org04dcd19" 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-12-04 23:38:01 +01:00
< div class = "exercice" id = "org3b53a9b" >
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 >
2020-12-04 23:38:01 +01:00
Having obtained \(G(s)\) and \(G_d(s)\), we can transform the system shown in Figure < a href = "#org132cf56" > 2< / a > into a classical feedback architecture as shown in Figure < a href = "#orgaf47372" > 6< / a > .
2020-11-30 17:44:13 +01:00
< / p >
2020-11-27 18:26:06 +01:00
2020-12-04 23:38:01 +01:00
< div id = "org6c8966a" 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 >
2020-12-04 23:38:01 +01:00
< p > < span class = "figure-number" > Figure 3: < / span > Block diagram corresponding to the example system of Figure < a href = "#org132cf56" > 2< / a > < / 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
< 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-12-02 19:01:04 +01:00
And now the system dynamics \(G(s)\) and \(G_d(s)\).
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-12-02 19:01:04 +01:00
< p >
2020-12-04 23:38:01 +01:00
The Bode plots of \(G(s)\) and \(G_d(s)\) are shown in Figures < a href = "#org139a896" > 4< / a > and < a href = "#org346fa42" > 5< / a > .
2020-12-02 19:01:04 +01:00
< / p >
2020-11-27 18:26:06 +01:00
2020-12-02 19:01:04 +01:00
2020-12-04 23:38:01 +01:00
< div id = "org139a896" 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 >
2020-12-02 19:01:04 +01:00
< p > < span class = "figure-number" > Figure 4: < / span > Bode plot of the plant \(G(s)\)< / p >
2020-11-27 23:13:29 +01:00
< / div >
2020-11-27 18:26:06 +01:00
2020-11-27 23:13:29 +01:00
2020-12-04 23:38:01 +01:00
< div id = "org346fa42" 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-12-02 19:01:04 +01:00
< p > < span class = "figure-number" > Figure 5: < / span > Magnitude of the disturbance transfer function \(G_d(s)\)< / p >
2020-11-27 23:13:29 +01:00
< / div >
< / div >
< / div >
2020-11-27 18:26:06 +01:00
< / div >
2020-12-04 23:38:01 +01:00
< div id = "outline-container-orgfd7b3af" class = "outline-2" >
< h2 id = "orgfd7b3af" > < 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 >
2020-12-04 23:38:01 +01:00
< a id = "org8ee7fc6" > < / a >
2020-12-02 19:01:04 +01:00
< / p >
< p >
2020-12-04 23:38:01 +01:00
After an introduction to classical Loop Shaping in Section < a href = "#org61cae1c" > 2.1< / a > , a practical example is given in Section < a href = "#orgba1aaf1" > 2.2< / a > .
2020-12-02 19:01:04 +01:00
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.
2020-12-04 23:38:01 +01:00
This is presented in Section < a href = "#org5e51b09" > 2.3< / a > and applied on the same example in Section < a href = "#org2b4c431" > 2.4< / a > .
2020-11-30 17:44:13 +01:00
< / p >
2020-11-27 23:13:29 +01:00
< / div >
2020-11-30 17:44:13 +01:00
2020-12-04 23:38:01 +01:00
< div id = "outline-container-org89bda02" class = "outline-3" >
< h3 id = "org89bda02" > < 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-12-04 23:38:01 +01:00
< a id = "org61cae1c" > < / a >
2020-11-30 17:44:13 +01:00
< / p >
2020-12-04 23:38:01 +01:00
< div class = "definition" id = "orgffbb786" >
2020-11-30 17:44:13 +01:00
< p >
2020-12-02 19:01:04 +01:00
< 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)\).
2020-11-30 17:44:13 +01:00
< / p >
< / div >
2020-12-04 23:38:01 +01:00
< div class = "definition" id = "org3cf7b3b" >
2020-11-30 17:44:13 +01:00
< p >
2020-12-04 23:38:01 +01:00
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 = "#orgaf47372" > 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-12-02 19:01:04 +01:00
< p >
Its name comes from the fact that this is actually the “ gain around the loop” .
< / p >
2020-11-27 23:13:29 +01:00
2020-12-04 23:38:01 +01:00
< div id = "orgaf47372" 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-12-02 19:01:04 +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-12-02 19:01:04 +01:00
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:
2020-11-27 23:13:29 +01:00
< / p >
< ul class = "org-ul" >
2020-12-02 19:01:04 +01:00
< li > < b > Good Tracking< / b > : \(L\) large< / li >
2020-11-27 23:13:29 +01:00
< li > < b > Good disturbance rejection< / b > : \(L\) large< / li >
2020-12-02 19:01:04 +01:00
< li > < b > Attenuation of measurement noise on plant output< / b > : \(L\) small< / li >
< li > < b > Small magnitude of input signal< / b > : \(L\) small< / li >
2020-11-27 23:13:29 +01:00
< 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 >
2020-12-02 19:01:04 +01:00
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}.
2020-12-04 23:38:01 +01:00
A typical wanted Loop Shape is shown in Figure < a href = "#org7ce6018" > 7< / a > .
2020-12-02 19:01:04 +01:00
Another interesting Loop shape called “ Bode Step” is described in < a href = "#citeproc_bib_item_1" > [1]< / a > .
2020-11-30 17:44:13 +01:00
< / p >
2020-12-04 23:38:01 +01:00
< div id = "org7ce6018" class = "figure" >
2020-11-30 17:44:13 +01:00
< 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-12-02 19:01:04 +01:00
< p > < span class = "figure-number" > Figure 7: < / span > Typical Wanted Shape for the Loop Gain \(L(s)\)< / p >
2020-11-30 17:44:13 +01:00
< / div >
2020-12-02 19:01:04 +01:00
< 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!
2020-12-04 23:38:01 +01:00
More details on that in Sections < a href = "#org8b8ea1e" > 4< / a > and < a href = "#org392aca0" > 5< / a > .
2020-12-02 19:01:04 +01:00
< / p >
2020-11-27 23:13:29 +01:00
< / div >
2020-11-27 18:26:06 +01:00
< / div >
2020-12-04 23:38:01 +01:00
< div id = "outline-container-orgd820df1" class = "outline-3" >
< h3 id = "orgd820df1" > < span class = "section-number-3" > 2.2< / span > Example of Manual 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 >
2020-12-04 23:38:01 +01:00
< a id = "orgba1aaf1" > < / a >
2020-11-30 17:44:13 +01:00
< / p >
2020-12-04 23:38:01 +01:00
< div class = "exampl" id = "org0720c80" >
2020-11-27 18:26:06 +01:00
< p >
2020-12-04 23:38:01 +01:00
Let’ s take our example system described in Section < a href = "#org8bf164e" > 1.3< / a > and design a controller using the Open-Loop shaping synthesis approach.
2020-12-02 19:01:04 +01:00
The specifications are:
2020-11-27 18:26:06 +01:00
< / p >
2020-12-02 19:01:04 +01:00
< 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 >
2020-11-27 23:13:29 +01:00
< li > < b > Robustness< / b > : Gain margin > 3dB and Phase margin > 30 deg< / li >
2020-12-02 19:01:04 +01:00
< / ol >
2020-11-27 18:26:06 +01:00
2020-11-27 23:13:29 +01:00
< / div >
2020-12-04 23:38:01 +01:00
< div class = "exercice" id = "orgf053051" >
2020-11-27 18:26:06 +01:00
< p >
2020-12-02 19:01:04 +01:00
Using < code > SISOTOOL< / code > , design a controller that fulfills the specifications.
2020-11-27 18:26:06 +01:00
< / p >
< div class = "org-src-container" >
< pre class = "src src-matlab" > sisotool(G)
< / pre >
< / div >
2020-12-02 19:01:04 +01:00
< details > < summary > Hint< / summary >
2020-11-27 18:26:06 +01:00
< p >
2020-12-02 19:01:04 +01:00
You can follow this procedure:
2020-11-27 18:26:06 +01:00
< / p >
2020-12-02 19:01:04 +01:00
< 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 >
2020-11-27 18:26:06 +01:00
< p >
2020-12-02 19:01:04 +01:00
Let’ s say we came up with the following controller.
2020-11-27 18:26:06 +01:00
< / p >
< div class = "org-src-container" >
2020-12-02 19:01:04 +01:00
< 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 >
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 >
< p >
2020-12-04 23:38:01 +01:00
The bode plot of the Loop Gain is shown in Figure < a href = "#org6decb51" > 8< / a > and we can verify that we have the wanted stability margins using the < code > margin< / code > command:
2020-11-27 18:26:06 +01:00
< / 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 >
2020-12-02 19:01:04 +01:00
2020-12-04 23:38:01 +01:00
< div id = "org6decb51" class = "figure" >
2020-12-02 19:01:04 +01:00
< 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 >
2020-11-27 18:26:06 +01:00
< / div >
< / div >
2020-12-04 23:38:01 +01:00
< div id = "outline-container-org44f6138" class = "outline-3" >
< h3 id = "org44f6138" > < 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 >
2020-12-04 23:38:01 +01:00
< a id = "org5e51b09" > < / a >
2020-11-30 17:44:13 +01:00
< / p >
2020-11-27 18:26:06 +01:00
< p >
2020-12-02 19:01:04 +01:00
The synthesis of controllers based on the Loop Shaping method can be automated using the \(\mathcal{H}_\infty\) Synthesis.
2020-11-27 18:26:06 +01:00
< / p >
< p >
2020-12-02 19:01:04 +01:00
Using Matlab, it can be easily performed using the < code > loopsyn< / code > command:
2020-11-27 18:26:06 +01:00
< / p >
< div class = "org-src-container" >
2020-12-02 19:01:04 +01:00
< pre class = "src src-matlab" > K = loopsyn(G, Lw);
2020-11-27 18:26:06 +01:00
< / pre >
< / div >
< p >
where:
< / p >
< ul class = "org-ul" >
< li > < code > G< / code > is the (LTI) plant< / li >
2020-12-02 19:01:04 +01:00
< li > < code > Lw< / code > is the wanted loop shape< / li >
2020-11-27 18:26:06 +01:00
< li > < code > K< / code > is the synthesize controller< / li >
< / ul >
2020-12-04 23:38:01 +01:00
< div class = "seealso" id = "org47ea12f" >
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 >
2020-12-02 19:01:04 +01:00
< 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 >
2020-11-27 18:26:06 +01:00
< / div >
< / div >
2020-12-04 23:38:01 +01:00
< div id = "outline-container-orgca27c56" class = "outline-3" >
< h3 id = "orgca27c56" > < 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 >
2020-12-04 23:38:01 +01:00
< a id = "org2b4c431" > < / a >
2020-11-30 17:44:13 +01:00
< / p >
2020-11-27 18:26:06 +01:00
< p >
2020-12-02 19:01:04 +01:00
To apply the \(\mathcal{H}_\infty\) Loop Shaping Synthesis, the wanted shape of the loop gain should be determined from the specifications.
2020-12-04 23:38:01 +01:00
This is summarized in Table < a href = "#org0a0b7ca" > 3< / a > .
2020-11-27 18:26:06 +01:00
< / p >
< p >
2020-12-04 23:38:01 +01:00
Such shape corresponds to the typical wanted Loop gain Shape shown in Figure < a href = "#org7ce6018" > 7< / a > .
2020-11-27 18:26:06 +01:00
< / p >
2020-12-04 23:38:01 +01:00
< table id = "org0a0b7ca" border = "2" cellspacing = "0" cellpadding = "6" rules = "groups" frame = "hsides" >
2020-12-02 19:01:04 +01:00
< 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 >
2020-12-04 23:38:01 +01:00
< th scope = "col" class = "org-left" > < b > Specification< / b > < / th >
< th scope = "col" class = "org-left" > < b > Corresponding Loop Shape< / b > < / th >
2020-12-02 19:01:04 +01:00
< / tr >
< / thead >
< tbody >
< tr >
2020-12-04 23:38:01 +01:00
< td class = "org-left" > < b > Dist. Rej.< / b > < / td >
2020-12-02 19:01:04 +01:00
< td class = "org-left" > Highest possible rejection below 1Hz< / td >
2020-12-04 23:38:01 +01:00
< td class = "org-left" > Slope of -40dB/dec at low frequency< / td >
2020-12-02 19:01:04 +01:00
< / tr >
< tr >
2020-12-04 23:38:01 +01:00
< td class = "org-left" > < b > Pos. Speed< / b > < / td >
2020-12-02 19:01:04 +01:00
< td class = "org-left" > Bandwidth of approximately 10Hz< / td >
2020-12-04 23:38:01 +01:00
< td class = "org-left" > \(L\) crosses 1 at 10Hz< / td >
2020-12-02 19:01:04 +01:00
< / tr >
< tr >
2020-12-04 23:38:01 +01:00
< td class = "org-left" > < b > Noise Att.< / b > < / td >
2020-12-02 19:01:04 +01:00
< 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 >
2020-12-04 23:38:01 +01:00
< td class = "org-left" > \(\Delta G > 3dB\), \(\Delta \phi > 30^o\)< / td >
2020-12-02 19:01:04 +01:00
< 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 >
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-12-02 19:01:04 +01:00
The \(\mathcal{H}_\infty\) open loop shaping synthesis is then 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-12-04 23:38:01 +01:00
The obtained Loop Gain is shown in Figure < a href = "#org67c7814" > 9< / a > and matches the specified one by a factor \(\gamma \approx 2\).
2020-12-02 19:01:04 +01:00
< / p >
2020-12-04 23:38:01 +01:00
< div id = "org67c7814" class = "figure" >
2020-12-02 19:01:04 +01:00
< 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 >
2020-12-04 23:38:01 +01:00
< div class = "important" id = "orgc38c35a" >
2020-12-02 19:01:04 +01:00
< p >
When using the \(\mathcal{H}_\infty\) Synthesis, it is usually recommended to analyze the obtained controller.
2020-11-27 23:13:29 +01:00
< / p >
< p >
2020-12-02 19:01:04 +01:00
This is usually done by breaking down the controller into simple elements such as low pass filters, high pass filters, notches, leads, etc.
2020-11-27 23:13:29 +01:00
< / p >
2020-11-27 18:26:06 +01:00
< / div >
2020-11-27 23:13:29 +01:00
< p >
2020-12-04 23:38:01 +01:00
Let’ s briefly analyze the obtained controller which bode plot is shown in Figure < a href = "#org3fa54c9" > 10< / a > :
2020-11-27 23:13:29 +01:00
< / 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-12-04 23:38:01 +01:00
< div id = "org3fa54c9" 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 19:42:57 +01:00
< p > < span class = "figure-number" > Figure 10: < / span > Obtained controller \(K\) using the open-loop \(\mathcal{H}_\infty\) shaping< / p >
2020-11-27 23:13:29 +01:00
< / div >
< p >
2020-12-04 23:38:01 +01:00
Let’ s finally compare the obtained stability margins of the \(\mathcal{H}_\infty\) controller and of the manually developed controller in Table < a href = "#org23ae0b4" > 4< / a > .
2020-11-27 23:13:29 +01:00
< / p >
2020-12-04 23:38:01 +01:00
< table id = "org23ae0b4" border = "2" cellspacing = "0" cellpadding = "6" rules = "groups" frame = "hsides" >
2020-12-02 19:01:04 +01:00
< caption class = "t-above" > < span class = "table-number" > Table 4:< / span > Comparison of the characteristics obtained with the two methods< / caption >
2020-11-27 23:13:29 +01:00
< colgroup >
< col class = "org-left" / >
< col class = "org-right" / >
< col class = "org-right" / >
< / colgroup >
< thead >
< tr >
2020-12-04 23:38:01 +01:00
< th scope = "col" class = "org-left" > < b > Specifications< / b > < / th >
< th scope = "col" class = "org-right" > < b > Manual Method< / b > < / th >
< th scope = "col" class = "org-right" > < b > \(\mathcal{H}_\infty\) Method< / b > < / th >
2020-11-27 23:13:29 +01:00
< / 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-12-04 23:38:01 +01:00
< div id = "outline-container-org30b75b7" class = "outline-2" >
< h2 id = "org30b75b7" > < span class = "section-number-2" > 3< / span > A first Step into 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 >
2020-12-04 23:38:01 +01:00
< a id = "orge17d00d" > < / a >
2020-12-02 19:53:19 +01:00
< / 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 >
2020-12-04 23:38:01 +01:00
After the \(\mathcal{H}_\infty\) norm is defined in Section < a href = "#org14a14ae" > 3.1< / a > , the \(\mathcal{H}_\infty\) synthesis procedure is described in Section < a href = "#org10e44d6" > 3.2< / a > .
2020-12-02 19:53:19 +01:00
< / p >
< p >
2020-12-04 23:38:01 +01:00
The generalized plant, a very useful tool to describe a control problem, is presented in Section < a href = "#org5acf485" > 3.3< / a > .
The \(\mathcal{H}_\infty\) is then applied to this generalized plant in Section < a href = "#org704c34e" > 3.4< / a > .
2020-12-02 19:53:19 +01:00
< / p >
< p >
2020-12-04 23:38:01 +01:00
Finally, an example showing how to convert a typical feedback control architecture into a generalized plant is given in Section < a href = "#org73bfffc" > 3.5< / a > .
2020-11-30 17:44:13 +01:00
< / p >
2020-11-27 23:13:29 +01:00
< / div >
2020-11-30 17:44:13 +01:00
2020-12-04 23:38:01 +01:00
< div id = "outline-container-org439f43b" class = "outline-3" >
< h3 id = "org439f43b" > < 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 >
2020-12-04 23:38:01 +01:00
< a id = "org14a14ae" > < / a >
2020-11-30 17:44:13 +01:00
< / p >
2020-12-04 23:38:01 +01:00
< div class = "definition" id = "org06e5b8d" >
2020-11-25 19:35:11 +01:00
< p >
2020-12-02 19:53:19 +01:00
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
2020-11-25 19:35:11 +01:00
< / p >
\begin{equation}
\|G(s)\|_\infty = \max_\omega \bar{\sigma}\big( G(j\omega) \big)
\end{equation}
< p >
2020-12-02 19:53:19 +01:00
For a single-input single-output system \(G(s)\), it is simply the peak value of \(|G(j\omega)|\) as a function of frequency:
2020-11-25 19:35:11 +01:00
< / p >
\begin{equation}
\|G(s)\|_\infty = \max_{\omega} |G(j\omega)| \label{eq:hinf_norm_siso}
\end{equation}
< / div >
2020-12-04 23:38:01 +01:00
< div class = "exampl" id = "org7f8d649" >
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-12-04 23:38:01 +01:00
We can see in Figure < a href = "#orge8a5418" > 11< / a > that indeed, the \(\mathcal{H}_\infty\) norm of \(G(s)\) does corresponds to the peak value of \(|G(j\omega)|\).
2020-11-25 19:35:11 +01:00
< / p >
2020-12-04 23:38:01 +01:00
< div id = "orge8a5418" 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-12-02 19:01:04 +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-12-04 23:38:01 +01:00
< div id = "outline-container-org000a363" class = "outline-3" >
< h3 id = "org000a363" > < 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-12-04 23:38:01 +01:00
< a id = "org10e44d6" > < / a >
2020-11-30 17:44:13 +01:00
< / p >
2020-12-04 23:38:01 +01:00
< div class = "definition" id = "org31d7a12" >
2020-11-30 17:44:13 +01:00
< p >
2020-12-02 19:53:19 +01:00
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.
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-12-04 23:38:01 +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 in Section < a href = "#org8b8ea1e" > 4< / a > .
2020-11-30 17:44:13 +01:00
< / p >
2020-12-04 23:38:01 +01:00
< div class = "important" id = "org63c96c8" >
2020-11-30 17:44:13 +01:00
< p >
2020-12-02 19:53:19 +01:00
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-12-02 19:53:19 +01:00
< li > Write the problem as standard \(\mathcal{H}_\infty\) problem using the generalized plant (described in the next section)< / li >
2020-12-04 23:38:01 +01:00
< li > Translate the specifications as \(\mathcal{H}_\infty\) norms of transfer functions (Section < a href = "#org8b8ea1e" > 4< / a > )< / li >
2020-12-02 19:53:19 +01:00
< li > Make the synthesis and analyze the obtained controller< / li >
2020-11-25 19:35:11 +01:00
< / ol >
2020-12-02 19:53:19 +01:00
< 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 >
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-12-01 18:49:40 +01:00
< li > Signal Based \(\mathcal{H}_\infty\) Synthesis, and many more… < / li >
2020-11-25 19:35:11 +01:00
< / ul >
< / div >
< / div >
2020-12-04 23:38:01 +01:00
< div id = "outline-container-org415bc1a" class = "outline-3" >
< h3 id = "org415bc1a" > < 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 >
2020-12-04 23:38:01 +01:00
< a id = "org5acf485" > < / a >
2020-11-30 17:44:13 +01:00
< / 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.
< / p >
< p >
2020-12-04 23:38:01 +01:00
The generalized plant, usually noted \(P(s)\), is shown in Figure < a href = "#org589c96b" > 12< / a > .
2020-12-02 19:53:19 +01:00
It has two < i > sets< / i > of inputs \([w,\,u]\) and two < i > sets< / i > of outputs \([z\,v]\) such that:
2020-11-30 17:44:13 +01:00
< / p >
2020-12-02 19:53:19 +01:00
\begin{equation}
\begin{bmatrix} z \\ v \end{bmatrix} = P \begin{bmatrix} w \\ u \end{bmatrix}
\end{equation}
2020-11-30 17:44:13 +01:00
< p >
2020-12-04 23:38:01 +01:00
The meaning of these inputs and outputs are summarized in Table < a href = "#orgdfc656b" > 5< / a > .
2020-11-30 17:44:13 +01:00
< / p >
2020-12-02 19:53:19 +01:00
< p >
2020-12-04 23:38:01 +01:00
A practical example about how to derive the generalized plant for a classical control problem is given in Section < a href = "#org73bfffc" > 3.5< / a > .
2020-12-02 19:53:19 +01:00
< / p >
2020-11-30 17:44:13 +01:00
2020-12-04 23:38:01 +01:00
< div class = "important" id = "org962d4d5" >
2020-11-30 17:44:13 +01:00
2020-12-04 23:38:01 +01:00
< div id = "org589c96b" class = "figure" >
2020-11-25 19:35:11 +01:00
< p > < img src = "figs/general_plant.png" alt = "general_plant.png" / >
< / p >
2020-12-02 19:01:04 +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-12-04 23:38:01 +01:00
< table id = "orgdfc656b" border = "2" cellspacing = "0" cellpadding = "6" rules = "groups" frame = "hsides" >
2020-12-02 19:01:04 +01:00
< caption class = "t-above" > < span class = "table-number" > Table 5:< / 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 >
2020-12-04 23:38:01 +01:00
< th scope = "col" class = "org-left" > < b > Notation< / b > < / th >
< th scope = "col" class = "org-left" > < b > Meaning< / b > < / th >
2020-11-25 19:35:11 +01:00
< / 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 >
2020-12-03 13:25:07 +01:00
< td class = "org-left" > Exogenous inputs: references, disturbances, noises< / td >
2020-11-25 19:35:11 +01:00
< / 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-12-04 23:38:01 +01:00
< div id = "outline-container-org7e02151" class = "outline-3" >
< h3 id = "org7e02151" > < span class = "section-number-3" > 3.4< / span > The \(\mathcal{H}_\infty\) Synthesis applied on the Generalized plant< / 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 >
2020-12-04 23:38:01 +01:00
< a id = "org704c34e" > < / 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-12-04 23:38:01 +01:00
< div class = "important" id = "org1004a31" >
2020-11-30 17:44:13 +01:00
< dl class = "org-dl" >
< dt > \(\mathcal{H}_\infty\) Synthesis applied on the generalized plant< / dt > < dd > < / dd >
< / dl >
< p >
2020-12-02 19:53:19 +01:00
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.
2020-11-30 17:44:13 +01:00
< / 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-12-02 19:53:19 +01:00
< p >
2020-12-04 23:38:01 +01:00
The obtained controller \(K\) and the generalized plant are connected as shown in Figure < a href = "#org5336dca" > 13< / a > .
2020-12-02 19:53:19 +01:00
< / p >
2020-11-25 19:35:11 +01:00
2020-12-04 23:38:01 +01:00
< div id = "org5336dca" class = "figure" >
2020-11-30 17:44:13 +01:00
< p > < img src = "figs/general_control_names.png" alt = "general_control_names.png" / >
< / p >
2020-12-02 19:01:04 +01:00
< p > < span class = "figure-number" > Figure 13: < / span > General Control Configuration< / p >
2020-11-30 17:44:13 +01:00
< / div >
2020-11-25 19:35:11 +01:00
2020-12-02 19:53:19 +01:00
< / div >
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 >
2020-12-02 19:53:19 +01:00
< 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 >
2020-11-30 17:44:13 +01:00
< / ul >
2020-12-02 19:53:19 +01:00
< p >
2020-12-04 23:38:01 +01:00
Note that the general control configure of Figure < a href = "#org5336dca" > 13< / a > , as its name implies, is quite < i > general< / i > and can represent feedback control as well as feedforward control architectures.
2020-12-02 19:53:19 +01:00
< / p >
2020-11-30 17:44:13 +01:00
< / div >
< / div >
2020-11-25 19:35:11 +01:00
2020-12-04 23:38:01 +01:00
< div id = "outline-container-orga1c5b17" class = "outline-3" >
< h3 id = "orga1c5b17" > < span class = "section-number-3" > 3.5< / span > From a Classical Feedback Architecture to a Generalized Plant< / h3 >
2020-11-30 17:44:13 +01:00
< div class = "outline-text-3" id = "text-3-5" >
< p >
2020-12-04 23:38:01 +01:00
< a id = "org73bfffc" > < / a >
2020-11-30 17:44:13 +01:00
< / p >
2020-11-25 19:35:11 +01:00
< p >
2020-12-04 23:38:01 +01:00
The procedure to convert a typical control architecture as the one shown in Figure < a href = "#org9fb1d2d" > 14< / a > to a generalized Plant is as follows:
2020-11-25 19:35:11 +01:00
< / p >
< ol class = "org-ol" >
2020-12-02 19:53:19 +01:00
< li > Define signals of the generalized plant: \(w\), \(z\), \(u\) and \(v\)< / li >
2020-12-04 23:38:01 +01:00
< li > Remove \(K\) and rearrange the inputs and outputs to match the generalized configuration shown in Figure < a href = "#org589c96b" > 12< / a > < / li >
2020-11-25 19:35:11 +01:00
< / ol >
2020-12-04 23:38:01 +01:00
< div class = "exercice" id = "org03ec899" >
2020-12-02 19:53:19 +01:00
< p >
2020-12-04 23:38:01 +01:00
Consider the feedback control architecture shown in Figure < a href = "#org9fb1d2d" > 14< / a > .
2020-12-02 19:53:19 +01:00
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 >
2020-12-02 11:00:11 +01:00
< ol class = "org-ol" >
2020-12-02 19:53:19 +01:00
< 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 >
2020-12-02 11:00:11 +01:00
< / ol >
2020-11-25 19:35:11 +01:00
2020-12-04 23:38:01 +01:00
< div id = "org9fb1d2d" 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-12-02 19:01:04 +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 >
2020-12-02 11:00:11 +01:00
< 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 >
2020-12-04 23:38:01 +01:00
< li > Controller outputs: signal generated by the controller: \(u\)< / li >
2020-11-25 19:35:11 +01:00
< / ul >
< p >
2020-12-04 23:38:01 +01:00
Then, Remove \(K\) and rearrange the inputs and outputs as in Figure < a href = "#org589c96b" > 12< / a > .
2020-11-30 17:44:13 +01:00
< / p >
< / details >
< details > < summary > Answer< / summary >
< p >
2020-12-04 23:38:01 +01:00
The obtained generalized plant shown in Figure < a href = "#orgdce16bb" > 15< / a > .
2020-11-25 19:35:11 +01:00
< / p >
2020-12-04 23:38:01 +01:00
< div id = "orgdce16bb" 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-12-02 19:01:04 +01:00
< p > < span class = "figure-number" > Figure 15: < / span > Generalized plant of the Classical Feedback Control Architecture (Tracking)< / p >
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 >
2020-12-02 11:00:11 +01:00
< / div >
< / details >
2020-11-25 19:35:11 +01:00
< / div >
< / div >
< / div >
< / div >
2020-12-04 23:38:01 +01:00
< div id = "outline-container-org20cd912" class = "outline-2" >
< h2 id = "org20cd912" > < span class = "section-number-2" > 4< / span > Modern Interpretation of Control Specifications< / h2 >
2020-11-30 17:44:13 +01:00
< div class = "outline-text-2" id = "text-4" >
2020-11-27 23:13:29 +01:00
< p >
2020-12-04 23:38:01 +01:00
< a id = "org8b8ea1e" > < / a >
2020-11-27 23:13:29 +01:00
< / p >
2020-11-30 19:42:57 +01:00
< p >
2020-12-04 23:38:01 +01:00
As shown in Section < a href = "#org8ee7fc6" > 2< / a > , the loop gain \(L(s) = G(s) K(s)\) is a useful and easy tool when manually designing controllers.
2020-12-01 18:49:40 +01:00
This is mainly due to the fact that \(L(s)\) is very easy to shape as it depends < i > linearly< / i > on \(K(s)\).
2020-12-01 00:23:13 +01:00
Moreover, important quantities such as the stability margins and the control bandwidth can be estimated from the shape/phase of \(L(s)\).
2020-11-30 19:42:57 +01:00
< / p >
2020-11-27 23:13:29 +01:00
2020-11-30 19:42:57 +01:00
< p >
2020-12-03 01:07:02 +01:00
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.
2020-12-04 23:38:01 +01:00
These are derived of a typical feedback architecture functions in Section < a href = "#org9e44bfd" > 4.1< / a > .
2020-12-03 01:07:02 +01:00
< / 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..
2020-12-04 23:38:01 +01:00
This method is presented in Section < a href = "#org392aca0" > 5< / a > .
2020-12-03 01:07:02 +01:00
< / p >
< p >
One of the most important closed-loop transfer function is called the < b > sensitivity function< / b > .
2020-12-04 23:38:01 +01:00
Its link with the closed-loop behavior of the feedback system is studied in Section < a href = "#org8660f77" > 4.2< / a > .
2020-12-03 01:07:02 +01:00
< / p >
< p >
2020-12-04 23:38:01 +01:00
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 = "#org77b423b" > 4.3< / a > ).
2020-12-03 01:07:02 +01:00
< / p >
< p >
2020-12-04 23:38:01 +01:00
Links between typical control specifications and shapes of the closed-loop transfer functions are summarized in Section < a href = "#org61f2712" > 4.4< / a > .
2020-12-03 01:07:02 +01:00
< / p >
< / div >
2020-12-04 23:38:01 +01:00
< div id = "outline-container-org6f0140b" class = "outline-3" >
< h3 id = "org6f0140b" > < span class = "section-number-3" > 4.1< / span > Closed Loop Transfer Functions and the Gang of Four< / h3 >
2020-12-03 01:07:02 +01:00
< div class = "outline-text-3" id = "text-4-1" >
< p >
2020-12-04 23:38:01 +01:00
< a id = "org9e44bfd" > < / a >
2020-12-03 01:07:02 +01:00
< / p >
< p >
2020-12-04 23:38:01 +01:00
Consider the typical feedback system shown in Figure < a href = "#orgaad765d" > 16< / a > .
2020-12-03 01:07:02 +01:00
< / 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\).
2020-11-30 17:44:13 +01:00
< / p >
2020-11-30 19:42:57 +01:00
< p >
2020-12-03 01:07:02 +01:00
Depending on the specification, different closed-loop transfer functions do matter.
2020-12-04 23:38:01 +01:00
These are summarized in Table < a href = "#org20b5475" > 6< / a > .
2020-11-30 19:42:57 +01:00
< / p >
2020-12-03 01:07:02 +01:00
2020-12-04 23:38:01 +01:00
< div id = "orgaad765d" class = "figure" >
2020-12-03 01:07:02 +01:00
< 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 >
2020-12-04 23:38:01 +01:00
< table id = "org20b5475" border = "2" cellspacing = "0" cellpadding = "6" rules = "groups" frame = "hsides" >
2020-12-02 19:01:04 +01:00
< caption class = "t-above" > < span class = "table-number" > Table 6:< / span > Typical Specification and associated closed-loop transfer function< / caption >
2020-12-01 00:23:13 +01:00
< colgroup >
< col class = "org-left" / >
2020-11-30 19:42:57 +01:00
2020-12-01 00:23:13 +01:00
< col class = "org-left" / >
< / colgroup >
< thead >
< tr >
2020-12-04 23:38:01 +01:00
< th scope = "col" class = "org-left" > < b > Specification< / b > < / th >
< th scope = "col" class = "org-left" > < b > CL Transfer Function< / b > < / th >
2020-12-01 00:23:13 +01:00
< / 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 >
2020-12-03 01:07:02 +01:00
< td class = "org-left" > All< / td >
2020-12-01 00:23:13 +01:00
< / tr >
< tr >
< td class = "org-left" > Robustness (stability margins)< / td >
2020-12-04 23:38:01 +01:00
< td class = "org-left" > Module margin (see Section < a href = "#org77b423b" > 4.3< / a > )< / td >
2020-12-01 00:23:13 +01:00
< / tr >
< / tbody >
< / table >
2020-12-04 23:38:01 +01:00
< div class = "exercice" id = "org2c3d808" >
2020-11-30 17:44:13 +01:00
< p >
2020-12-04 23:38:01 +01:00
For the feedback system in Figure < a href = "#orgaad765d" > 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]\).
2020-11-30 17:44:13 +01:00
< / 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 >
2020-12-04 23:38:01 +01:00
\begin{align*}
2020-11-30 17:44:13 +01:00
y & = G u \\
& = G (d + K \epsilon) \\
& = G \big(d + K (r - n - y) \big) \\
& = G d + GK r - GK n - GK y
2020-12-04 23:38:01 +01:00
\end{align*}
2020-11-30 17:44:13 +01:00
< 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 >
2020-12-01 18:49:40 +01:00
< details > < summary > Answer< / summary >
2020-11-30 17:44:13 +01:00
< 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
2020-12-04 23:38:01 +01:00
< div class = "important" id = "org9a81b58" >
2020-11-30 17:44:13 +01:00
< p >
2020-12-04 23:38:01 +01:00
We can see that they are 4 different closed-loop transfer functions describing the behavior of the feedback system in Figure < a href = "#orgaad765d" > 16< / a > .
2020-11-30 19:42:57 +01:00
These called the < b > Gang of Four< / b > :
2020-11-30 17:44:13 +01:00
< / 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}
2020-11-30 19:42:57 +01:00
< / div >
2020-12-04 23:38:01 +01:00
< div class = "seealso" id = "org72e5854" >
2020-11-30 17:44:13 +01:00
< 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 >
2020-12-04 23:38:01 +01:00
The behavior of the feedback system in Figure < a href = "#orgaad765d" > 16< / a > is fully described by the following set of equations:
2020-11-30 17:44:13 +01:00
< / 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}
2020-11-30 19:42:57 +01:00
< p >
2020-12-01 18:49:40 +01:00
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)\).
2020-11-30 19:42:57 +01:00
< / p >
2020-11-30 17:44:13 +01:00
< / div >
< / div >
2020-12-04 23:38:01 +01:00
< div id = "outline-container-orgaa60a5b" class = "outline-3" >
< h3 id = "orgaa60a5b" > < span class = "section-number-3" > 4.2< / span > The Sensitivity Function< / h3 >
2020-12-01 18:49:40 +01:00
< div class = "outline-text-3" id = "text-4-2" >
< p >
2020-12-04 23:38:01 +01:00
< a id = "org8660f77" > < / a >
2020-12-01 18:49:40 +01:00
< / p >
2020-11-30 17:44:13 +01:00
< p >
2020-12-01 18:49:40 +01:00
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.
2020-11-30 17:44:13 +01:00
< / p >
2020-12-01 18:49:40 +01:00
2020-12-01 13:41:12 +01:00
< 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)\).
2020-12-04 23:38:01 +01:00
The obtained sensitivity functions for these four controllers are shown in Figure < a href = "#orgab55c77" > 17< / a > and the corresponding step responses are shown in Figure < a href = "#orgf61d0f9" > 18< / a > .
2020-12-01 13:41:12 +01:00
< / p >
2020-11-30 17:44:13 +01:00
2020-12-01 13:41:12 +01:00
< p >
2020-12-04 23:38:01 +01:00
The comparison of the sensitivity functions shapes and their effect on the step response is summarized in Table < a href = "#org851c9cb" > 7< / a > .
2020-12-01 13:41:12 +01:00
< / p >
2020-11-30 17:44:13 +01:00
2020-12-04 23:38:01 +01:00
< table id = "org851c9cb" border = "2" cellspacing = "0" cellpadding = "6" rules = "groups" frame = "hsides" >
2020-12-02 19:01:04 +01:00
< 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 >
2020-11-30 17:44:13 +01:00
2020-12-01 13:41:12 +01:00
< colgroup >
< col class = "org-left" / >
2020-11-30 17:44:13 +01:00
2020-12-01 13:41:12 +01:00
< col class = "org-left" / >
2020-11-30 17:44:13 +01:00
2020-12-01 13:41:12 +01:00
< col class = "org-left" / >
< / colgroup >
< thead >
< tr >
2020-12-04 23:38:01 +01:00
< th scope = "col" class = "org-left" > < b > Controller< / b > < / th >
< th scope = "col" class = "org-left" > < b > Sensitivity Function Shape< / b > < / th >
< th scope = "col" class = "org-left" > < b > Change of the Step Response< / b > < / th >
2020-12-01 13:41:12 +01:00
< / 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 >
2020-12-04 23:38:01 +01:00
< div id = "orgab55c77" class = "figure" >
2020-12-01 13:41:12 +01:00
< p > < img src = "figs/sensitivity_shape_effect.png" alt = "sensitivity_shape_effect.png" / >
< / p >
2020-12-02 19:01:04 +01:00
< 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 >
2020-12-01 13:41:12 +01:00
< / div >
2020-12-04 23:38:01 +01:00
< div id = "orgf61d0f9" class = "figure" >
2020-12-01 13:41:12 +01:00
< p > < img src = "figs/sensitivity_shape_effect_step.png" alt = "sensitivity_shape_effect_step.png" / >
< / p >
2020-12-02 19:01:04 +01:00
< p > < span class = "figure-number" > Figure 18: < / span > Step response (response from \(r\) to \(y\)) for the different controllers< / p >
2020-12-01 13:41:12 +01:00
< / div >
2020-12-04 23:38:01 +01:00
< div class = "definition" id = "org5616519" >
2020-12-01 13:41:12 +01:00
< 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 >
2020-12-04 23:38:01 +01:00
< div class = "important" id = "org8570a9f" >
2020-12-01 13:41:12 +01:00
< p >
2020-12-04 23:38:01 +01:00
From the simple analysis above, we can draw a first estimation of the wanted shape for the sensitivity function (Figure < a href = "#org99295f6" > 19< / a > ):
2020-12-01 13:41:12 +01:00
< / 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 >
2020-12-03 01:07:02 +01:00
< li > A small peak value (small \(\mathcal{H}_\infty\) norm) in order to limit large overshoot and oscillations.
2020-12-01 13:41:12 +01:00
This generally means higher robustness.
This will become clear in the next section about the < b > module margin< / b > .< / li >
< / ul >
2020-12-04 23:38:01 +01:00
< div id = "org99295f6" class = "figure" >
2020-12-01 13:41:12 +01:00
< p > < img src = "figs/h-infinity-spec-S.png" alt = "h-infinity-spec-S.png" / >
< / p >
2020-12-02 19:01:04 +01:00
< p > < span class = "figure-number" > Figure 19: < / span > Typical wanted shape of the Sensitivity transfer function< / p >
2020-11-30 17:44:13 +01:00
< / div >
< / div >
< / div >
< / div >
2020-12-04 23:38:01 +01:00
< div id = "outline-container-orgecf3c2d" class = "outline-3" >
< h3 id = "orgecf3c2d" > < span class = "section-number-3" > 4.3< / span > Robustness: Module Margin< / h3 >
2020-12-01 18:49:40 +01:00
< div class = "outline-text-3" id = "text-4-3" >
2020-11-30 17:44:13 +01:00
< p >
2020-12-04 23:38:01 +01:00
< a id = "org77b423b" > < / a >
2020-11-30 17:44:13 +01:00
< / p >
2020-12-01 00:23:13 +01:00
< p >
2020-12-03 01:07:02 +01:00
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.
2020-12-01 00:23:13 +01:00
< / p >
2020-12-04 23:38:01 +01:00
< div class = "exampl" id = "orgc8cc747" >
2020-12-01 00:23:13 +01:00
< p >
2020-12-03 01:07:02 +01:00
Consider the following plant \(G_t(s)\):
2020-12-01 00:23:13 +01:00
< / 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 >
2020-12-04 23:38:01 +01:00
Let’ s say we have designed a controller \(K_t(s)\) that gives the loop gain shown in Figure < a href = "#orgc669494" > 20< / a > .
2020-12-01 10:54:06 +01:00
< / 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 >
2020-12-04 23:38:01 +01:00
The following characteristics can be determined from the Loop gain in Figure < a href = "#orgc669494" > 20< / a > :
2020-12-01 00:23:13 +01:00
< / p >
< ul class = "org-ul" >
2020-12-03 01:07:02 +01:00
< 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 >
2020-12-01 00:23:13 +01:00
< / ul >
< p >
2020-12-03 01:07:02 +01:00
This clearly indicate very good robustness of the closed-loop system!
Or does it? Let’ s find out.
2020-12-01 00:23:13 +01:00
< / p >
2020-12-04 23:38:01 +01:00
< div id = "orgc669494" class = "figure" >
2020-12-01 00:23:13 +01:00
< p > < img src = "figs/phase_gain_margin_model_plant.png" alt = "phase_gain_margin_model_plant.png" / >
< / p >
2020-12-02 19:01:04 +01:00
< p > < span class = "figure-number" > Figure 20: < / span > Bode plot of the obtained Loop Gain \(L(s)\)< / p >
2020-12-01 00:23:13 +01:00
< / div >
< p >
2020-12-03 01:07:02 +01:00
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:
2020-12-01 00:23:13 +01:00
< / p >
< div class = "org-src-container" >
< pre class = "src src-matlab" > xi = 0.03;
< / pre >
< / div >
< p >
2020-12-04 23:38:01 +01:00
The obtained “ real” loop gain is shown in Figure < a href = "#org92b8c55" > 21< / a > .
2020-12-03 01:07:02 +01:00
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.
2020-12-01 00:23:13 +01:00
< / p >
< p >
It is confirmed by checking the stability of the closed loop system:
< / p >
< div class = "org-src-container" >
2020-12-01 18:49:40 +01:00
< pre class = "src src-matlab" > isstable(feedback(Gr,K))
2020-12-01 00:23:13 +01:00
< / pre >
< / div >
< pre class = "example" >
0
< / pre >
2020-12-04 23:38:01 +01:00
< div id = "org92b8c55" class = "figure" >
2020-12-01 00:23:13 +01:00
< p > < img src = "figs/phase_gain_margin_real_plant.png" alt = "phase_gain_margin_real_plant.png" / >
< / p >
2020-12-02 19:01:04 +01:00
< 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 >
2020-12-01 00:23:13 +01:00
< / div >
< p >
2020-12-03 01:07:02 +01:00
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.
2020-12-01 00:23:13 +01:00
< / p >
< p >
2020-12-03 01:07:02 +01:00
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.
2020-12-01 00:23:13 +01:00
< / p >
< / div >
< p >
2020-12-01 10:54:06 +01:00
Let’ s now determine a new robustness indicator based on the Nyquist Stability Criteria.
2020-12-01 00:23:13 +01:00
< / p >
2020-12-04 23:38:01 +01:00
< div class = "definition" id = "org33c7235" >
2020-12-01 10:54:06 +01:00
< dl class = "org-dl" >
2020-12-04 23:38:01 +01:00
< 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 >
2020-12-01 10:54:06 +01:00
< 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 >
2020-12-01 00:23:13 +01:00
< / div >
2020-12-04 23:38:01 +01:00
< div class = "seealso" id = "org2939797" >
2020-12-01 10:54:06 +01:00
< 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 >
2020-12-01 00:23:13 +01:00
2020-12-01 10:54:06 +01:00
< / div >
2020-12-01 00:23:13 +01:00
< p >
2020-12-01 18:49:40 +01:00
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 > .
2020-12-01 00:23:13 +01:00
< / p >
2020-12-04 23:38:01 +01:00
< div class = "definition" id = "orgc8c821e" >
2020-12-01 10:54:06 +01:00
< 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 >
2020-12-01 00:23:13 +01:00
< / div >
2020-12-04 23:38:01 +01:00
< div class = "exampl" id = "orgca6245c" >
2020-12-01 00:23:13 +01:00
< p >
2020-12-04 23:38:01 +01:00
A typical Nyquist plot is shown in Figure < a href = "#org8779e1b" > 22< / a > .
2020-12-01 10:54:06 +01:00
The gain, phase and module margins are graphically shown to have an idea of what they represent.
2020-12-01 00:23:13 +01:00
< / p >
2020-12-01 18:49:40 +01:00
2020-12-04 23:38:01 +01:00
< div id = "org8779e1b" class = "figure" >
2020-12-01 18:49:40 +01:00
< p > < img src = "figs/module_margin_example.png" alt = "module_margin_example.png" / >
< / p >
2020-12-02 19:01:04 +01:00
< 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 >
2020-12-01 18:49:40 +01:00
< / div >
< / div >
2020-12-01 10:54:06 +01:00
< p >
2020-12-04 23:38:01 +01:00
As expected from Figure < a href = "#org8779e1b" > 22< / a > , there is a close relationship between the module margin and the gain and phase margins.
2020-12-01 10:54:06 +01:00
We can indeed show that for a given value of the module margin \(\Delta M\), we have:
< / p >
\begin{equation}
2020-12-03 01:07:02 +01:00
\Delta G \ge \frac{1}{1 - \Delta M}; \quad \Delta \phi \ge \Delta M
2020-12-01 10:54:06 +01:00
\end{equation}
2020-11-30 17:44:13 +01:00
< p >
2020-12-01 10:54:06 +01:00
Let’ s now try to express the Module margin \(\Delta M\) as an \(\mathcal{H}_\infty\) norm of a closed-loop transfer function:
2020-11-30 17:44:13 +01:00
< / p >
2020-12-01 10:54:06 +01:00
\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)|}} \\
2020-12-03 01:07:02 +01:00
& = \frac{1}{\max_\omega \left| \frac{1}{1 + G(j\omega)K(j\omega)}\right|} \\
2020-12-01 10:54:06 +01:00
& = \frac{1}{\|S\|_\infty}
\end{align*}
2020-12-01 00:23:13 +01:00
2020-12-03 01:07:02 +01:00
< 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}
2020-12-04 23:38:01 +01:00
< div class = "important" id = "org030d546" >
2020-12-01 00:23:13 +01:00
< p >
2020-12-01 10:54:06 +01:00
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.
2020-12-01 00:23:13 +01:00
< / p >
2020-12-01 10:54:06 +01:00
\begin{equation}
\Delta M = \frac{1}{\|S\|_\infty} \label{eq:module_margin_S}
\end{equation}
2020-12-01 00:23:13 +01:00
< p >
2020-12-01 10:54:06 +01:00
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.
2020-12-03 01:07:02 +01:00
And we now understand why setting an upper bound on the magnitude of \(S\) is generally a good idea.
2020-12-01 10:54:06 +01:00
< / p >
2020-12-04 23:38:01 +01:00
< div class = "exampl" id = "orgc449b56" >
2020-12-01 10:54:06 +01:00
< p >
Typical, we require \(\|S\|_\infty < 2 ( 6dB ) \ ) which implies \ ( \ Delta G \ ge 2 \ ) and \ ( \ Delta \ phi \ ge 29 ^ o \ )
< / p >
< / div >
2020-12-04 23:38:01 +01:00
< div class = "seealso" id = "orgd1eaf94" >
2020-12-01 10:54:06 +01:00
< p >
To learn more about module/disk margin, you can check out < a href = "https://www.youtube.com/watch?v=XazdN6eZF80" > this< / a > video.
2020-12-01 00:23:13 +01:00
< / p >
< / div >
2020-11-30 17:44:13 +01:00
< / div >
< / div >
2020-12-04 23:38:01 +01:00
< div id = "outline-container-org2ed2ced" class = "outline-3" >
< h3 id = "org2ed2ced" > < span class = "section-number-3" > 4.4< / span > Summary of typical specification and associated wanted shaping< / h3 >
2020-12-01 18:49:40 +01:00
< div class = "outline-text-3" id = "text-4-4" >
2020-11-30 17:44:13 +01:00
< p >
2020-12-04 23:38:01 +01:00
< a id = "org61f2712" > < / a >
2020-11-30 17:44:13 +01:00
< / p >
2020-12-04 23:38:01 +01:00
< table id = "org26050a8" border = "2" cellspacing = "0" cellpadding = "6" rules = "groups" frame = "hsides" >
2020-12-02 19:01:04 +01:00
< 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 >
2020-12-01 18:49:40 +01:00
< colgroup >
< col class = "org-left" / >
< col class = "org-left" / >
< col class = "org-left" / >
< / colgroup >
< thead >
< tr >
< th scope = "col" class = "org-left" >   < / th >
2020-12-04 23:38:01 +01:00
< th scope = "col" class = "org-left" > < b > Open-Loop Shaping< / b > < / th >
< th scope = "col" class = "org-left" > < b > Closed-Loop Shaping< / b > < / th >
2020-12-01 18:49:40 +01:00
< / 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 >
2020-11-30 17:44:13 +01:00
2020-12-01 18:49:40 +01:00
< 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 >
2020-12-04 23:38:01 +01:00
< div id = "outline-container-org1087d13" class = "outline-2" >
< h2 id = "org1087d13" > < span class = "section-number-2" > 5< / span > \(\mathcal{H}_\infty\) Shaping of closed-loop transfer functions< / h2 >
2020-12-01 18:49:40 +01:00
< div class = "outline-text-2" id = "text-5" >
< p >
2020-12-04 23:38:01 +01:00
< a id = "org392aca0" > < / a >
2020-12-01 18:49:40 +01:00
< / 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.
2020-12-03 01:07:02 +01:00
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!
2020-12-01 18:49:40 +01:00
< / p >
< p >
2020-12-03 01:07:02 +01:00
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.
2020-12-04 23:38:01 +01:00
Such procedure is presented in Section < a href = "#org76c7f5f" > 5.1< / a > .
2020-12-01 18:49:40 +01:00
< / p >
< p >
2020-12-04 23:38:01 +01:00
Some advice on the design of weighting functions are given in Section < a href = "#orgfdcae90" > 5.2< / a > .
2020-12-01 18:49:40 +01:00
< / p >
< p >
2020-12-04 23:38:01 +01:00
An example of the \(\mathcal{H}_\infty\) shaping of the sensitivity function is studied in Section < a href = "#orgcf381cb" > 5.3< / a > .
2020-12-03 01:07:02 +01:00
< / 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.
2020-12-04 23:38:01 +01:00
Some insight on the use and limitations of such techniques are given in Section < a href = "#org5149495" > 5.4< / a > .
2020-12-01 18:49:40 +01:00
< / p >
< / div >
2020-12-04 23:38:01 +01:00
< div id = "outline-container-org769efcc" class = "outline-3" >
< h3 id = "org769efcc" > < span class = "section-number-3" > 5.1< / span > How to Shape closed-loop transfer function? Using Weighting Functions!< / h3 >
2020-12-01 18:49:40 +01:00
< div class = "outline-text-3" id = "text-5-1" >
< p >
2020-12-04 23:38:01 +01:00
< a id = "org76c7f5f" > < / a >
2020-12-01 18:49:40 +01:00
< / p >
< p >
2020-12-04 23:38:01 +01:00
Suppose we apply the \(\mathcal{H}_\infty\) synthesis on the generalized plant \(P(s)\) shown in Figure < a href = "#orgbc5cb40" > 23< / a > .
2020-12-03 01:07:02 +01:00
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\).
2020-12-01 18:49:40 +01:00
< / p >
< p >
2020-12-03 01:07:02 +01:00
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.
2020-12-01 18:49:40 +01:00
< / p >
2020-12-04 23:38:01 +01:00
< div id = "orgbc5cb40" class = "figure" >
2020-11-30 17:44:13 +01:00
< p > < img src = "figs/loop_shaping_S_without_W.png" alt = "loop_shaping_S_without_W.png" / >
< / p >
2020-12-02 19:01:04 +01:00
< p > < span class = "figure-number" > Figure 23: < / span > Generalized Plant< / p >
2020-11-30 17:44:13 +01:00
< / div >
2020-12-01 18:49:40 +01:00
2020-12-04 23:38:01 +01:00
< div class = "important" id = "org991b5ab" >
2020-11-30 17:44:13 +01:00
< p >
2020-12-04 23:38:01 +01:00
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 = "#org5364569" > 24< / a > .
2020-11-30 17:44:13 +01:00
< / p >
< p >
2020-12-01 18:49:40 +01:00
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.
2020-11-30 17:44:13 +01:00
< / p >
2020-12-01 18:49:40 +01:00
< / div >
2020-11-30 17:44:13 +01:00
< p >
2020-12-01 18:49:40 +01:00
Let’ s now show how this is equivalent as < b > shaping< / b > the sensitivity function:
2020-11-30 17:44:13 +01:00
< / p >
2020-11-30 19:42:57 +01:00
\begin{align}
2020-12-01 18:49:40 +01:00
& \left\| W_s(s) S(s) \right\|_\infty < 1 \ nonumber \ \
2020-11-30 19:42:57 +01:00
\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}
2020-11-30 17:44:13 +01:00
2020-12-04 23:38:01 +01:00
< div class = "important" id = "org8699507" >
2020-12-01 18:49:40 +01:00
< p >
2020-12-03 01:07:02 +01:00
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.
2020-12-01 18:49:40 +01:00
< / p >
2020-11-30 17:44:13 +01:00
< p >
2020-12-03 01:07:02 +01:00
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.
2020-11-30 17:44:13 +01:00
< / p >
2020-11-25 19:35:11 +01:00
< / div >
2020-11-30 17:44:13 +01:00
2020-12-04 23:38:01 +01:00
< div id = "org5364569" class = "figure" >
2020-11-30 17:44:13 +01:00
< p > < img src = "figs/loop_shaping_S_with_W.png" alt = "loop_shaping_S_with_W.png" / >
< / p >
2020-12-02 19:01:04 +01:00
< p > < span class = "figure-number" > Figure 24: < / span > Weighted Generalized Plant< / p >
2020-11-30 17:44:13 +01:00
< / div >
2020-12-04 23:38:01 +01:00
< div class = "exercice" id = "orgac9786f" >
2020-11-30 17:44:13 +01:00
< p >
2020-12-04 23:38:01 +01:00
Using matlab, compute the weighted generalized plant shown in Figure < a href = "#org2a5b732" > 25< / a > as a function of \(G(s)\) and \(W_S(s)\).
2020-11-30 17:44:13 +01:00
< / p >
2020-12-01 18:49:40 +01:00
< 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 >
2020-11-30 17:44:13 +01:00
< p >
2020-12-01 18:49:40 +01:00
The two solutions below can be used.
2020-11-30 17:44:13 +01:00
< / 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;
2020-12-01 18:49:40 +01:00
1 < span class = "org-type" > -< / span > G];
< / pre >
< / div >
2020-11-30 17:44:13 +01:00
2020-12-01 18:49:40 +01:00
< 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 >
2020-12-03 01:07:02 +01:00
< 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 >
2020-12-01 18:49:40 +01:00
< / details >
2020-11-30 17:44:13 +01:00
< / div >
< / div >
< / div >
2020-12-04 23:38:01 +01:00
< div id = "outline-container-org861b5dc" class = "outline-3" >
< h3 id = "org861b5dc" > < span class = "section-number-3" > 5.2< / span > Design of Weighting Functions< / h3 >
2020-12-01 18:49:40 +01:00
< div class = "outline-text-3" id = "text-5-2" >
2020-11-30 17:44:13 +01:00
< p >
2020-12-04 23:38:01 +01:00
< a id = "orgfdcae90" > < / a >
2020-11-30 17:44:13 +01:00
< / p >
< p >
2020-12-01 18:49:40 +01:00
Weighting function included in the generalized plant must be < b > proper< / b > , < b > stable< / b > and < b > minimum phase< / b > transfer functions.
2020-11-30 17:44:13 +01:00
< / p >
2020-12-01 18:49:40 +01:00
2020-12-04 23:38:01 +01:00
< div class = "definition" id = "org76a2332" >
2020-11-30 17:44:13 +01:00
< 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 >
2020-12-01 18:49:40 +01:00
< / div >
2020-12-03 11:51:44 +01:00
< p >
Good guidelines for design of weighting function are given in < a href = "#citeproc_bib_item_2" > [2]< / a > .
< / p >
2020-11-30 17:44:13 +01:00
< p >
2020-12-03 01:07:02 +01:00
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:
2020-11-30 17:44:13 +01:00
< / 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" >
2020-12-01 18:49:40 +01:00
< 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 >
2020-11-30 17:44:13 +01:00
< / ul >
2020-12-04 23:38:01 +01:00
< div class = "exampl" id = "org4129e59" >
2020-11-30 17:44:13 +01:00
< p >
2020-12-04 23:38:01 +01:00
The Matlab code below produces a weighting function with the following characteristics (Figure < a href = "#org2a5b732" > 25< / a > ):
2020-11-30 17:44:13 +01:00
< / p >
2020-12-01 18:49:40 +01:00
< 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 >
2020-11-30 17:44:13 +01:00
< 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 >
2020-12-04 23:38:01 +01:00
< div id = "org2a5b732" class = "figure" >
2020-11-30 17:44:13 +01:00
< p > < img src = "figs/first_order_weight.png" alt = "first_order_weight.png" / >
< / p >
2020-12-02 19:01:04 +01:00
< p > < span class = "figure-number" > Figure 25: < / span > Obtained Magnitude of the Weighting Function< / p >
2020-11-30 17:44:13 +01:00
< / div >
< / div >
2020-12-04 23:38:01 +01:00
< div class = "seealso" id = "org24d89c8" >
2020-11-30 17:44:13 +01:00
< p >
Quite often, higher orders weights are required.
< / p >
< p >
2020-12-01 18:49:40 +01:00
In such case, the following formula can be used:
2020-11-30 17:44:13 +01:00
< / 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" >
2020-12-04 23:38:01 +01:00
< pre class = "src src-matlab" > < 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 > )
2020-11-30 17:44:13 +01:00
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 >
2020-12-04 23:38:01 +01:00
The obtained shapes are shown in Figure < a href = "#org636d7d1" > 26< / a > .
2020-11-30 17:44:13 +01:00
< / p >
2020-12-04 23:38:01 +01:00
< div id = "org636d7d1" class = "figure" >
2020-11-30 17:44:13 +01:00
< p > < img src = "figs/high_order_weight.png" alt = "high_order_weight.png" / >
< / p >
2020-12-02 19:01:04 +01:00
< p > < span class = "figure-number" > Figure 26: < / span > Higher order weights using Equation \eqref{eq:weight_formula_advanced}< / p >
2020-11-30 17:44:13 +01:00
< / div >
< / div >
< / div >
< / div >
2020-12-04 23:38:01 +01:00
< div id = "outline-container-org5f9d52e" class = "outline-3" >
< h3 id = "org5f9d52e" > < span class = "section-number-3" > 5.3< / span > Shaping the Sensitivity Function< / h3 >
2020-12-01 18:49:40 +01:00
< div class = "outline-text-3" id = "text-5-3" >
2020-11-30 17:44:13 +01:00
< p >
2020-12-04 23:38:01 +01:00
< a id = "orgcf381cb" > < / a >
2020-12-01 10:54:06 +01:00
< / p >
2020-12-01 18:49:40 +01:00
< p >
2020-12-03 01:07:02 +01:00
Let’ s design a controller using the \(\mathcal{H}_\infty\) shaping of the sensitivity function that fulfils the following requirements:
2020-12-01 18:49:40 +01:00
< / 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 >
2020-12-01 10:54:06 +01:00
2020-12-01 18:49:40 +01:00
< p >
2020-12-04 23:38:01 +01:00
As usual, the plant used is the one presented in Section < a href = "#org8bf164e" > 1.3< / a > .
2020-12-01 18:49:40 +01:00
< / p >
2020-11-30 17:44:13 +01:00
2020-12-04 23:38:01 +01:00
< div class = "exercice" id = "org5f85262" >
2020-11-30 17:44:13 +01:00
< p >
2020-12-03 01:07:02 +01:00
Translate the requirements as upper bounds on the Sensitivity function and design the corresponding weighting functions using Matlab.
2020-12-01 18:49:40 +01:00
< / p >
< details > < summary > Hint< / summary >
< p >
2020-12-04 23:38:01 +01:00
The typical wanted upper bound of the sensitivity function is shown in Figure < a href = "#orgee9fe0e" > 27< / a > .
2020-12-01 18:49:40 +01:00
< / 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 >
2020-12-04 23:38:01 +01:00
< div id = "orgee9fe0e" class = "figure" >
2020-12-01 18:49:40 +01:00
< p > < img src = "figs/h-infinity-spec-S.png" alt = "h-infinity-spec-S.png" / >
< / p >
2020-12-02 19:01:04 +01:00
< p > < span class = "figure-number" > Figure 27: < / span > Typical wanted shape of the Sensitivity transfer function< / p >
2020-12-01 18:49:40 +01:00
< / div >
< / details >
< details > < summary > Answer< / summary >
2020-12-03 01:07:02 +01:00
< p >
We want to design the weighting function \(W_s(s)\) such that:
< / p >
2020-12-01 18:49:40 +01:00
< 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:
2020-11-30 17:44:13 +01:00
< / p >
< div class = "org-src-container" >
2020-12-01 18:49:40 +01:00
< 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);
2020-11-30 17:44:13 +01:00
< / pre >
< / div >
< p >
2020-12-01 18:49:40 +01:00
Or using the < code > generateWeight< / code > function:
2020-11-30 17:44:13 +01:00
< / p >
< div class = "org-src-container" >
2020-12-01 18:49:40 +01:00
< 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);
2020-11-30 17:44:13 +01:00
< / pre >
2020-12-01 18:49:40 +01:00
< / div >
< / details >
2020-11-30 17:44:13 +01:00
< / div >
< p >
2020-12-01 18:49:40 +01:00
Let’ s say we came up with the following weighting function:
2020-11-30 17:44:13 +01:00
< / p >
< div class = "org-src-container" >
2020-12-01 18:49:40 +01:00
< 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;
2020-11-30 17:44:13 +01:00
< / pre >
< / div >
2020-12-01 18:49:40 +01:00
< 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 >
2020-11-30 17:44:13 +01:00
2020-12-04 23:38:01 +01:00
< pre class = "example" id = "org5a44392" >
2020-12-01 18:49:40 +01:00
Test bounds: 0.5 < = gamma < = 0.51
2020-11-30 17:44:13 +01:00
2020-12-01 18:49:40 +01:00
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
2020-11-30 17:44:13 +01:00
2020-12-01 18:49:40 +01:00
Best performance (actual): 0.503
2020-11-30 17:44:13 +01:00
< / pre >
< p >
2020-12-03 01:07:02 +01:00
\(\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\):
2020-11-30 17:44:13 +01:00
< / p >
2020-12-04 23:38:01 +01:00
\begin{align*}
2020-12-01 18:49:40 +01:00
& \| W_s(s) S(s) \|_\infty \approx 0.5 \\
2020-11-30 17:44:13 +01:00
& \Leftrightarrow |S(j\omega)| < \frac{0.5}{|W_s(j\omega)|} \quad \forall \omega
2020-12-04 23:38:01 +01:00
\end{align*}
2020-11-30 17:44:13 +01:00
< p >
2020-12-04 23:38:01 +01:00
This is indeed what we can see by comparing \(|S|\) and \(|W_S|\) in Figure < a href = "#orgba77edf" > 28< / a > .
2020-11-30 17:44:13 +01:00
< / p >
2020-12-04 23:38:01 +01:00
< div class = "important" id = "org13c8e5f" >
2020-12-01 18:49:40 +01:00
< p >
2020-12-03 01:07:02 +01:00
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 .
2020-12-01 18:49:40 +01:00
< / p >
2020-11-30 17:44:13 +01:00
2020-12-01 18:49:40 +01:00
< p >
2020-12-03 01:07:02 +01:00
Yet, obtaining a \(\gamma\) slightly above one does not necessary means the synthesis is unsuccessful.
2020-12-01 18:49:40 +01:00
It just means that at some frequency, one of the closed-loop transfer functions is above the specified upper bound by a factor \(\gamma\).
2020-11-30 17:44:13 +01:00
< / p >
2020-11-30 19:42:57 +01:00
2020-11-30 17:44:13 +01:00
< / div >
2020-11-30 19:42:57 +01:00
2020-12-04 23:38:01 +01:00
< div id = "orgba77edf" class = "figure" >
2020-12-01 18:49:40 +01:00
< p > < img src = "figs/results_sensitivity_hinf.png" alt = "results_sensitivity_hinf.png" / >
2020-11-30 19:42:57 +01:00
< / p >
2020-12-02 19:01:04 +01:00
< p > < span class = "figure-number" > Figure 28: < / span > Weighting function and obtained closed-loop sensitivity< / p >
2020-11-30 19:42:57 +01:00
< / div >
< / div >
< / div >
2020-12-04 23:38:01 +01:00
< div id = "outline-container-orgd94d43f" class = "outline-3" >
< h3 id = "orgd94d43f" > < span class = "section-number-3" > 5.4< / span > Shaping multiple closed-loop transfer functions - Limitations< / h3 >
2020-12-01 18:49:40 +01:00
< div class = "outline-text-3" id = "text-5-4" >
2020-11-25 19:35:11 +01:00
< p >
2020-12-04 23:38:01 +01:00
< a id = "org5149495" > < / a >
2020-11-30 19:42:57 +01:00
< / p >
2020-12-01 18:49:40 +01:00
< p >
2020-12-04 23:38:01 +01:00
As was shown in Section < a href = "#org8b8ea1e" > 4< / a > , each of the four main closed-loop transfer functions (called the < i > gang of four< / i > ) will impact different characteristics of the closed-loop system.
This is summarized in Table < a href = "#org43d2a07" > 9< / a > .
2020-12-01 18:49:40 +01:00
< / p >
2020-11-30 19:42:57 +01:00
2020-12-01 18:49:40 +01:00
< p >
2020-12-03 01:07:02 +01:00
Therefore, we might want to shape multiple closed-loop transfer functions at the same time.
2020-12-03 11:51:44 +01:00
For instance \(S\) could be shape to have good step responses, \(KS\) to limit the input usage and \(T\) to filter measurement noise.
2020-12-04 23:38:01 +01:00
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 = "#orgfcbbd2c" > 6< / a > .
2020-12-01 18:49:40 +01:00
< / p >
2020-11-30 19:42:57 +01:00
2020-12-04 23:38:01 +01:00
< table id = "org43d2a07" border = "2" cellspacing = "0" cellpadding = "6" rules = "groups" frame = "hsides" >
2020-12-03 11:51:44 +01:00
< caption class = "t-above" > < span class = "table-number" > Table 9:< / span > Typical specifications and corresponding shaping of the < i > Gang of four< / i > < / caption >
< colgroup >
< col class = "org-left" / >
< col class = "org-center" / >
< col class = "org-left" / >
< / colgroup >
< thead >
< tr >
2020-12-04 23:38:01 +01:00
< th scope = "col" class = "org-left" > < b > Specifications< / b > < / th >
< th scope = "col" class = "org-center" > < b > TF< / b > < / th >
< th scope = "col" class = "org-left" > < b > Wanted shape< / b > < / th >
2020-12-03 11:51:44 +01:00
< / tr >
< / thead >
< tbody >
< tr >
< td class = "org-left" > Fast Reference Tracking< / td >
< td class = "org-center" > \(S\)< / td >
< td class = "org-left" > Set lower bound on the bandwidth< / td >
< / tr >
< tr >
< td class = "org-left" > Small Steady State Errors< / td >
< td class = "org-center" > \(S\)< / td >
< td class = "org-left" > Small low frequency gain< / td >
< / tr >
< tr >
< td class = "org-left" > Follow Step ref. inputs< / td >
< td class = "org-center" > \(S\)< / td >
2020-12-03 13:25:07 +01:00
< td class = "org-left" > Slope of +20dB/dec at low frequency< / td >
2020-12-03 11:51:44 +01:00
< / tr >
< tr >
< td class = "org-left" > Follow Ramp ref. inputs< / td >
< td class = "org-center" > \(S\)< / td >
2020-12-03 13:25:07 +01:00
< td class = "org-left" > Slope of +40dB/dec at low frequency< / td >
2020-12-03 11:51:44 +01:00
< / tr >
< tr >
2020-12-04 23:38:01 +01:00
< td class = "org-left" > Follow Sin. ref. inputs< / td >
2020-12-03 11:51:44 +01:00
< td class = "org-center" > \(S\)< / td >
< td class = "org-left" > Small magnitude centered on the sin. frequency< / td >
< / tr >
< / tbody >
< tbody >
< tr >
< td class = "org-left" > Output Disturbance Rejection< / td >
< td class = "org-center" > \(S\)< / td >
< td class = "org-left" > Small gain in the disturbance bandwidth< / td >
< / tr >
< tr >
< td class = "org-left" > Input Disturbance Rejection< / td >
< td class = "org-center" > \(GS\)< / td >
< td class = "org-left" > Small gain in the disturbance bandwidth< / td >
< / tr >
< tr >
2020-12-04 23:38:01 +01:00
< td class = "org-left" > Prevent notching resonances< / td >
2020-12-03 11:51:44 +01:00
< td class = "org-center" > \(GS\)< / td >
< td class = "org-left" > Limit gain around resonance< / td >
< / tr >
< / tbody >
< tbody >
< tr >
< td class = "org-left" > Small Command Amplitude< / td >
< td class = "org-center" > \(KS\)< / td >
< td class = "org-left" > Small at high frequency< / td >
< / tr >
< tr >
2020-12-04 23:38:01 +01:00
< td class = "org-left" > Limitation of the Bandwidth< / td >
2020-12-03 11:51:44 +01:00
< td class = "org-center" > \(T\)< / td >
< td class = "org-left" > Set an upper bound on the bandwidth< / td >
< / tr >
< tr >
< td class = "org-left" > Measurement Noise Filtering< / td >
< td class = "org-center" > \(T\)< / td >
< td class = "org-left" > Small high frequency gain< / td >
< / tr >
< / tbody >
< tbody >
< tr >
< td class = "org-left" > Stability margins< / td >
< td class = "org-center" > \(S\)< / td >
< td class = "org-left" > Module margin: \(\Vert S\Vert_\infty\) small< / td >
< / tr >
< tr >
2020-12-04 23:38:01 +01:00
< td class = "org-left" > Robust to unmodelled dynamics< / td >
2020-12-03 11:51:44 +01:00
< td class = "org-center" > \(T\)< / td >
2020-12-04 23:38:01 +01:00
< td class = "org-left" > Small at freq. where uncertainty is large< / td >
2020-12-03 11:51:44 +01:00
< / tr >
< / tbody >
< / table >
2020-12-01 18:49:40 +01:00
< p >
2020-12-03 01:07:02 +01:00
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.
2020-12-01 18:49:40 +01:00
< / p >
2020-11-30 19:42:57 +01:00
< details > < summary > Shaping of S and KS< / summary >
2020-12-04 23:38:01 +01:00
< div id = "org499d555" class = "figure" >
2020-11-30 19:42:57 +01:00
< p > < img src = "figs/general_conf_shaping_S_KS.png" alt = "general_conf_shaping_S_KS.png" / >
< / p >
2020-12-02 19:01:04 +01:00
< p > < span class = "figure-number" > Figure 29: < / span > Generalized Plant to shape \(S\) and \(KS\)< / p >
2020-11-30 19:42:57 +01:00
< / div >
2020-12-03 01:07:02 +01:00
< 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 >
2020-11-30 19:42:57 +01:00
< div class = "org-src-container" >
2020-12-04 23:38:01 +01:00
< label class = "org-src-name" > < span class = "listing-number" > Listing 1: < / span > General Plant definition corresponding to Figure < a href = "#org499d555" > 29< / a > < / label > < pre class = "src src-matlab" id = "org5677fd9" > P = [W1 < span class = "org-type" > -< / span > G< span class = "org-type" > *< / span > W1
2020-11-30 19:42:57 +01:00
0 W2
1 < span class = "org-type" > -< / span > G];
< / pre >
< / div >
< / details >
< details > < summary > Shaping of S and T< / summary >
2020-12-04 23:38:01 +01:00
< div id = "orgd0e7f7a" class = "figure" >
2020-11-30 19:42:57 +01:00
< p > < img src = "figs/general_conf_shaping_S_T.png" alt = "general_conf_shaping_S_T.png" / >
< / p >
2020-12-02 19:01:04 +01:00
< p > < span class = "figure-number" > Figure 30: < / span > Generalized Plant to shape \(S\) and \(T\)< / p >
2020-11-30 19:42:57 +01:00
< / div >
2020-12-03 01:07:02 +01:00
< 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 >
2020-11-30 19:42:57 +01:00
< div class = "org-src-container" >
2020-12-04 23:38:01 +01:00
< label class = "org-src-name" > < span class = "listing-number" > Listing 2: < / span > General Plant definition corresponding to Figure < a href = "#orgd0e7f7a" > 30< / a > < / label > < pre class = "src src-matlab" id = "org1246bdd" > P = [W1 < span class = "org-type" > -< / span > G< span class = "org-type" > *< / span > W1
2020-11-30 19:42:57 +01:00
0 G< span class = "org-type" > *< / span > W2
1 < span class = "org-type" > -< / span > G];
< / pre >
< / div >
< / details >
2020-12-02 11:00:11 +01:00
< details > < summary > Shaping of S and GS< / summary >
2020-12-04 23:38:01 +01:00
< div id = "org350deed" class = "figure" >
2020-12-02 11:00:11 +01:00
< p > < img src = "figs/general_conf_shaping_S_GS.png" alt = "general_conf_shaping_S_GS.png" / >
< / p >
2020-12-02 19:01:04 +01:00
< p > < span class = "figure-number" > Figure 31: < / span > Generalized Plant to shape \(S\) and \(GS\)< / p >
2020-12-02 11:00:11 +01:00
< / div >
2020-12-03 01:07:02 +01:00
< 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 >
2020-12-02 11:00:11 +01:00
< div class = "org-src-container" >
2020-12-04 23:38:01 +01:00
< label class = "org-src-name" > < span class = "listing-number" > Listing 3: < / span > General Plant definition corresponding to Figure < a href = "#org350deed" > 31< / a > < / label > < pre class = "src src-matlab" id = "org0f74b57" > P = [W1 < span class = "org-type" > -< / span > W1
2020-12-02 11:00:11 +01:00
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 >
2020-11-30 19:42:57 +01:00
< details > < summary > Shaping of S, T and KS< / summary >
2020-12-04 23:38:01 +01:00
< div id = "orgd9c65ad" class = "figure" >
2020-11-30 19:42:57 +01:00
< p > < img src = "figs/general_conf_shaping_S_T_KS.png" alt = "general_conf_shaping_S_T_KS.png" / >
2020-11-30 17:44:13 +01:00
< / p >
2020-12-02 19:01:04 +01:00
< p > < span class = "figure-number" > Figure 32: < / span > Generalized Plant to shape \(S\), \(T\) and \(KS\)< / p >
2020-11-30 17:44:13 +01:00
< / div >
2020-12-03 01:07:02 +01:00
< 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 >
2020-11-30 19:42:57 +01:00
< div class = "org-src-container" >
2020-12-04 23:38:01 +01:00
< label class = "org-src-name" > < span class = "listing-number" > Listing 4: < / span > General Plant definition corresponding to Figure < a href = "#orgd9c65ad" > 32< / a > < / label > < pre class = "src src-matlab" id = "org971a86a" > P = [W1 < span class = "org-type" > -< / span > G< span class = "org-type" > *< / span > W1
2020-11-30 19:42:57 +01:00
0 W2
0 G< span class = "org-type" > *< / span > W3
1 < span class = "org-type" > -< / span > G];
< / pre >
2020-11-30 17:44:13 +01:00
< / div >
2020-11-30 19:42:57 +01:00
< / details >
2020-12-02 11:00:11 +01:00
< details > < summary > Shaping of S, T and GS< / summary >
2020-12-04 23:38:01 +01:00
< div id = "orgac6cf8c" class = "figure" >
2020-12-02 11:00:11 +01:00
< p > < img src = "figs/general_conf_shaping_S_T_GS.png" alt = "general_conf_shaping_S_T_GS.png" / >
< / p >
2020-12-02 19:01:04 +01:00
< p > < span class = "figure-number" > Figure 33: < / span > Generalized Plant to shape \(S\), \(T\) and \(GS\)< / p >
2020-12-02 11:00:11 +01:00
< / div >
2020-12-03 01:07:02 +01:00
< 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 >
2020-12-02 11:00:11 +01:00
< div class = "org-src-container" >
2020-12-04 23:38:01 +01:00
< label class = "org-src-name" > < span class = "listing-number" > Listing 5: < / span > General Plant definition corresponding to Figure < a href = "#orgac6cf8c" > 33< / a > < / label > < pre class = "src src-matlab" id = "org2f62087" > P = [W1 < span class = "org-type" > -< / span > W1
2020-12-02 11:00:11 +01:00
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 >
2020-11-30 19:42:57 +01:00
< details > < summary > Shaping of S, T, KS and GS< / summary >
2020-12-04 23:38:01 +01:00
< div id = "org8522b11" class = "figure" >
2020-11-30 19:42:57 +01:00
< p > < img src = "figs/general_conf_shaping_S_T_KS_GS.png" alt = "general_conf_shaping_S_T_KS_GS.png" / >
< / p >
2020-12-02 19:01:04 +01:00
< p > < span class = "figure-number" > Figure 34: < / span > Generalized Plant to shape \(S\), \(T\), \(KS\) and \(GS\)< / p >
2020-11-30 17:44:13 +01:00
< / div >
2020-12-03 01:07:02 +01:00
< p >
Weighting functions:
< / p >
2020-11-30 19:42:57 +01:00
< 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 >
2020-12-03 01:07:02 +01:00
< div class = "org-src-container" >
2020-12-04 23:38:01 +01:00
< label class = "org-src-name" > < span class = "listing-number" > Listing 6: < / span > General Plant definition corresponding to Figure < a href = "#org8522b11" > 34< / a > < / label > < pre class = "src src-matlab" id = "org2659ca4" > 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
2020-12-03 01:07:02 +01:00
0 0 W2
1 < span class = "org-type" > -< / span > G< span class = "org-type" > *< / span > W3 < span class = "org-type" > -< / span > G];
< / pre >
< / div >
2020-11-30 19:42:57 +01:00
< / details >
2020-12-04 23:38:01 +01:00
< div class = "important" id = "org1e367a3" >
2020-12-01 18:49:40 +01:00
< p >
2020-12-03 01:07:02 +01:00
When shaping multiple closed-loop transfer functions, one should be very careful about the three following points that are further discussed:
2020-12-01 18:49:40 +01:00
< / p >
< ul class = "org-ul" >
2020-12-03 01:07:02 +01:00
< 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 >
2020-12-01 18:49:40 +01:00
< li > The size of the obtained controller may be very large and not implementable in practice< / li >
< / ul >
2020-12-03 11:51:44 +01:00
< / div >
2020-12-04 23:38:01 +01:00
< div class = "warning" id = "orgecababb" >
2020-12-01 18:49:40 +01:00
< p >
Mathematical relations are linking the closed-loop transfer functions.
2020-12-03 01:07:02 +01:00
For instance, the sensitivity function \(S(s)\) and the complementary sensitivity function \(T(s)\) are linked by the following well known relation:
2020-12-01 18:49:40 +01:00
< / 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 >
2020-12-03 01:07:02 +01:00
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:
2020-12-01 18:49:40 +01:00
< / 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*}
2020-12-03 01:07:02 +01:00
< p >
This means that the Sensitivity function cannot be shaped at frequencies where the loop gain is small.
< / p >
2020-12-01 18:49:40 +01:00
< p >
Similar relationship can be found for \(T\), \(KS\) and \(GS\).
< / p >
2020-12-04 23:38:01 +01:00
< div class = "exercice" id = "org3997190" >
2020-12-01 18:49:40 +01:00
< 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" >
2020-12-03 01:07:02 +01:00
< 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 >
2020-12-01 18:49:40 +01:00
< / ol >
< / details >
< details > < summary > Answer< / summary >
< p >
2020-12-04 23:38:01 +01:00
The obtained constrains are shown in Figure < a href = "#org4cb06d0" > 35< / a > .
2020-12-01 18:49:40 +01:00
< / p >
< / details >
< / div >
< p >
2020-12-03 01:07:02 +01:00
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.
2020-12-01 18:49:40 +01:00
< / p >
< p >
Therefore the weighting functions should only focus on certainty frequency range depending on the transfer function being shaped.
2020-12-04 23:38:01 +01:00
These regions are summarized in Figure < a href = "#org4cb06d0" > 35< / a > .
2020-12-01 18:49:40 +01:00
< / p >
2020-12-04 23:38:01 +01:00
< div id = "org4cb06d0" class = "figure" >
2020-12-01 18:49:40 +01:00
< p > < img src = "figs/h-infinity-4-blocs-constrains.png" alt = "h-infinity-4-blocs-constrains.png" / >
< / p >
2020-12-03 01:07:02 +01:00
< 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 >
2020-12-01 18:49:40 +01:00
< / div >
2020-12-04 23:38:01 +01:00
< div class = "warning" id = "org44a21af" >
2020-12-01 18:49:40 +01:00
< p >
2020-12-03 01:07:02 +01:00
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.
2020-12-01 18:49:40 +01:00
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.
2020-12-03 01:07:02 +01:00
Then, the \(\mathcal{H}_\infty\) synthesis usually generate a controller with a very high order that is not implementable in practice.
2020-12-01 18:49:40 +01:00
< / 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 >
2020-11-30 19:42:57 +01:00
< / div >
2020-11-30 17:44:13 +01:00
< / div >
< / div >
2020-12-04 23:38:01 +01:00
< div id = "outline-container-org34cdfb9" class = "outline-2" >
< h2 id = "org34cdfb9" > < span class = "section-number-2" > 6< / span > Mixed-Sensitivity \(\mathcal{H}_\infty\) Control - Example< / h2 >
2020-11-30 19:42:57 +01:00
< div class = "outline-text-2" id = "text-6" >
< p >
2020-12-04 23:38:01 +01:00
< a id = "orgfcbbd2c" > < / a >
2020-12-03 11:51:44 +01:00
< / p >
< p >
Let’ s now apply the \(\mathcal{H}_\infty\) Shaping control procedure on a practical example.
< / p >
< p >
2020-12-04 23:38:01 +01:00
In Section < a href = "#orgd7cf964" > 6.1< / a > the control problem is presented.
The design procedure used to apply the \(\mathcal{H}_\infty\) Mixed Sensitivity synthesis is described in Section < a href = "#orgec70b10" > 6.2< / a > .
2020-12-03 11:51:44 +01:00
< / p >
< p >
2020-12-04 23:38:01 +01:00
The important step of interpreting the specifications as wanted shape of closed-loop transfer functions is performed in Section < a href = "#org49e6b72" > 6.3< / a > .
2020-12-03 11:51:44 +01:00
< / p >
< p >
2020-12-04 23:38:01 +01:00
Finally, the shaping of closed-loop transfer functions is performed in Sections < a href = "#org8988616" > 6.4< / a > , < a href = "#org0c6745c" > 6.5< / a > and < a href = "#orgcc490a3" > 6.6< / a > .
2020-11-30 19:42:57 +01:00
< / p >
< / div >
2020-12-01 18:49:40 +01:00
2020-12-04 23:38:01 +01:00
< div id = "outline-container-org77cb7c8" class = "outline-3" >
< h3 id = "org77cb7c8" > < span class = "section-number-3" > 6.1< / span > Control Problem< / h3 >
2020-12-02 11:00:11 +01:00
< div class = "outline-text-3" id = "text-6-1" >
2020-12-03 11:51:44 +01:00
< p >
2020-12-04 23:38:01 +01:00
< a id = "orgd7cf964" > < / a >
2020-12-03 11:51:44 +01:00
< / p >
< p >
2020-12-04 23:38:01 +01:00
Let’ s consider our usual < i > test system< / i > shown in Figure < a href = "#org297cd59" > 36< / a > .
2020-12-03 11:51:44 +01:00
< / p >
2020-12-04 23:38:01 +01:00
< div id = "org297cd59" class = "figure" >
2020-12-03 11:51:44 +01:00
< p > < img src = "figs/ex_test_system.png" alt = "ex_test_system.png" / >
< / p >
< p > < span class = "figure-number" > Figure 36: < / span > Test System consisting of a payload with a mass \(m\) on top of an active system with a stiffness \(k\), damping \(c\) and an actuator. A feedback controller \(K(s)\) is added to position / isolate the payload.< / p >
< / div >
2020-12-04 23:38:01 +01:00
< div class = "important" id = "org131909c" >
2020-12-03 11:51:44 +01:00
< p >
The control specifications are:
< / p >
2020-12-02 11:00:11 +01:00
< ul class = "org-ul" >
2020-12-03 11:51:44 +01:00
< li > The displacement \(y\) should follow reference inputs \(r\) with negligible static error after 0.1s< / li >
< li > Reject disturbances \(d\) in less than 0.1s< / li >
2020-12-03 12:13:53 +01:00
< li > Limit the effect of measurement noise \(n\) on the output displacement \(y\)< / li >
2020-12-03 11:51:44 +01:00
< li > Obtain a Robust System with good stability margins< / li >
2020-12-02 11:00:11 +01:00
< / ul >
2020-12-03 11:51:44 +01:00
< / div >
2020-12-02 11:00:11 +01:00
2020-12-03 11:51:44 +01:00
< p >
The considered inputs are:
< / p >
2020-12-02 11:00:11 +01:00
< ul class = "org-ul" >
2020-12-03 11:51:44 +01:00
< li > disturbances \(d\) as step inputs with an amplitude of \(5\,\mu m\)< / li >
< li > reference inputs with are ramp inputs with a slope of \(100\,\mu m/s\) and a time duration of \(0.2\,s\)< / li >
< li > measurement noise \(n\) with a large spectral density at high frequency (increasing starting from 100Hz)< / li >
2020-12-02 11:00:11 +01:00
< / ul >
2020-12-03 11:51:44 +01:00
< / div >
< / div >
2020-12-02 11:00:11 +01:00
2020-12-04 23:38:01 +01:00
< div id = "outline-container-orgb525282" class = "outline-3" >
< h3 id = "orgb525282" > < span class = "section-number-3" > 6.2< / span > Control Design Procedure< / h3 >
2020-12-03 11:51:44 +01:00
< div class = "outline-text-3" id = "text-6-2" >
< p >
2020-12-04 23:38:01 +01:00
< a id = "orgec70b10" > < / a >
2020-12-03 11:51:44 +01:00
< / p >
2020-12-02 11:00:11 +01:00
2020-12-03 11:51:44 +01:00
< p >
Here is the general design procedure that will be followed:
< / p >
< ol class = "org-ol" >
< li > Compute the model of the plant< / li >
2020-12-03 12:13:53 +01:00
< li > Write the control system as a general control problem< / li >
2020-12-03 11:51:44 +01:00
< li > Translate the specifications into the wanted shape of closed-loop transfer functions< / li >
2020-12-03 12:13:53 +01:00
< li > Chose the suitable weighted general plant to shape the wanted quantities< / li >
2020-12-03 11:51:44 +01:00
< li > Shape sequentially the chosen closed-loop transfer functions< / li >
< / ol >
2020-12-02 11:00:11 +01:00
2020-12-03 11:51:44 +01:00
< p >
2020-12-04 23:38:01 +01:00
Let’ s first convert the system of Figure < a href = "#org297cd59" > 36< / a > into the classical feedback architecture of Figure < a href = "#org9c41cb2" > 37< / a > .
2020-12-03 11:51:44 +01:00
< / p >
2020-12-04 23:38:01 +01:00
< div id = "org9c41cb2" class = "figure" >
2020-12-03 11:51:44 +01:00
< p > < img src = "figs/ex_test_system_feedback.png" alt = "ex_test_system_feedback.png" / >
< / p >
< p > < span class = "figure-number" > Figure 37: < / span > Block diagram corresponding to the example system< / p >
< / div >
< p >
The two transfer functions present in the system are derived and defined below:
< / p >
< div class = "org-src-container" >
< pre class = "src src-matlab" > < span class = "linenr" > 1: < / span > k = 1e6; < span class = "org-comment" > % Stiffness [N/m]< / span >
< span class = "linenr" > 2: < / span > c = 4e2; < span class = "org-comment" > % Damping [N/(m/s)]< / span >
< span class = "linenr" > 3: < / span > m = 10; < span class = "org-comment" > % Mass [kg]< / span >
< span class = "linenr" > 4: < / span >
< span class = "linenr" > 5: < / span > < span class = "org-comment" > % Control Plant< / span >
< span class = "linenr" > 6: < / span > G = 1< span class = "org-type" > /< / span > (m< span class = "org-type" > *< / span > s< span class = "org-type" > ^< / span > 2 < span class = "org-type" > +< / span > c< span class = "org-type" > *< / span > s < span class = "org-type" > +< / span > k);
< span class = "linenr" > 7: < / span > < span class = "org-comment" > % Disturbance dynamics< / span >
< span class = "linenr" > 8: < / span > Gd = (c< span class = "org-type" > *< / span > s < span class = "org-type" > +< / span > k)< span class = "org-type" > /< / span > (m< span class = "org-type" > *< / span > s< span class = "org-type" > ^< / span > 2 < span class = "org-type" > +< / span > c< span class = "org-type" > *< / span > s < span class = "org-type" > +< / span > k);
2020-12-02 11:00:11 +01:00
< / pre >
2020-11-30 17:44:13 +01:00
< / div >
2020-12-03 11:51:44 +01:00
< p >
We also define the inputs signals that will be used for time domain simulations.
2020-12-04 23:38:01 +01:00
They are graphically shown in Figure < a href = "#org48d6048" > 38< / a > .
2020-12-03 11:51:44 +01:00
< / p >
2020-12-02 11:00:11 +01:00
< div class = "org-src-container" >
2020-12-03 11:51:44 +01:00
< pre class = "src src-matlab" > < span class = "linenr" > 9: < / span > < span class = "org-comment" > % Time Vector< / span >
< span class = "linenr" > 10: < / span > t = 0< span class = "org-type" > :< / span > 1e< span class = "org-type" > -< / span > 4< span class = "org-type" > :< / span > 0.5;
< span class = "linenr" > 11: < / span >
< span class = "linenr" > 12: < / span > < span class = "org-comment" > % Reference Input< / span >
< span class = "linenr" > 13: < / span > r = zeros(size(t));
< span class = "linenr" > 14: < / span > r(t< span class = "org-type" > > < / span > 0.05 < span class = "org-type" > & < / span > t< span class = "org-type" > < =< / span > 0.25) = 1e< span class = "org-type" > -< / span > 4< span class = "org-type" > *< / span > (t(t< span class = "org-type" > > < / span > 0.05 < span class = "org-type" > & < / span > t< span class = "org-type" > < =< / span > 0.25)< span class = "org-type" > -< / span > 0.05);
< span class = "linenr" > 15: < / span > r(t< span class = "org-type" > > < / span > 0.25) = 2e< span class = "org-type" > -< / span > 5;
< span class = "linenr" > 16: < / span >
< span class = "linenr" > 17: < / span > < span class = "org-comment" > % Measurement Noise< / span >
< span class = "linenr" > 18: < / span > Fs = 1e3; < span class = "org-comment" > % Sampling Frequency [Hz]< / span >
< span class = "linenr" > 19: < / span > Ts = 1< span class = "org-type" > /< / span > Fs; < span class = "org-comment" > % Sampling Time [s]< / span >
< span class = "linenr" > 20: < / span > n = sqrt(Fs< span class = "org-type" > /< / span > 2)< span class = "org-type" > *< / span > randn(1, length(t)); < span class = "org-comment" > % Signal with an ASD equal to one< / span >
< span class = "linenr" > 21: < / span > n = lsim(1e< span class = "org-type" > -< / span > 6< span class = "org-type" > *< / span > (s < span class = "org-type" > +< / span > 2< span class = "org-type" > *< / span > < span class = "org-constant" > pi< / span > < span class = "org-type" > *< / span > 1e2)< span class = "org-type" > ^< / span > 2< span class = "org-type" > /< / span > (s < span class = "org-type" > +< / span > 2< span class = "org-type" > *< / span > < span class = "org-constant" > pi< / span > < span class = "org-type" > *< / span > 1e3)< span class = "org-type" > ^< / span > 2< span class = "org-type" > /< / span > (1< span class = "org-type" > +< / span > s< span class = "org-type" > /< / span > 2< span class = "org-type" > /< / span > < span class = "org-constant" > pi< / span > < span class = "org-type" > /< / span > 500), n, t)< span class = "org-type" > '< / span > ; < span class = "org-comment" > % Shaped noise< / span >
< span class = "linenr" > 22: < / span >
< span class = "linenr" > 23: < / span > < span class = "org-comment" > % Disturbance< / span >
< span class = "linenr" > 24: < / span > d = zeros(size(t));
< span class = "linenr" > 25: < / span > d(t< span class = "org-type" > > < / span > 0.3) = 5e< span class = "org-type" > -< / span > 6;
< / pre >
< / div >
2020-12-02 11:00:11 +01:00
2020-12-04 23:38:01 +01:00
< div id = "org48d6048" class = "figure" >
2020-12-03 11:51:44 +01:00
< p > < img src = "figs/ex_inputs_signals.png" alt = "ex_inputs_signals.png" / >
< / p >
< p > < span class = "figure-number" > Figure 38: < / span > Time domain inputs signals< / p >
< / div >
< p >
2020-12-04 23:38:01 +01:00
We also define the generalized plant corresponding to the system and that will be used for time domain simulations (Figure < a href = "#org32424d3" > 39< / a > ).
2020-12-03 11:51:44 +01:00
< / p >
2020-12-02 11:00:11 +01:00
2020-12-04 23:38:01 +01:00
< div id = "org32424d3" class = "figure" >
2020-12-03 11:51:44 +01:00
< p > < img src = "figs/ex_general_plant_sim.png" alt = "ex_general_plant_sim.png" / >
< / p >
< p > < span class = "figure-number" > Figure 39: < / span > Generalized plant that will be used for simulations< / p >
< / div >
< p >
2020-12-04 23:38:01 +01:00
The Generalized plant of Figure < a href = "#org32424d3" > 39< / a > is defined on Matlab as follows:
2020-12-03 11:51:44 +01:00
< / p >
< div class = "org-src-container" >
< pre class = "src src-matlab" > < span class = "linenr" > 26: < / span > Psim = [0 0 Gd G
< span class = "linenr" > 27: < / span > 0 0 0 1
< span class = "linenr" > 28: < / span > 1 < span class = "org-type" > -< / span > 1 < span class = "org-type" > -< / span > Gd < span class = "org-type" > -< / span > G];
< span class = "linenr" > 29: < / span >
< span class = "linenr" > 30: < / span > Psim.InputName = {< span class = "org-string" > 'r'< / span > , < span class = "org-string" > 'n'< / span > , < span class = "org-string" > 'd'< / span > , < span class = "org-string" > 'u'< / span > };
< span class = "linenr" > 31: < / span > Psim.OutputName = {< span class = "org-string" > 'y'< / span > , < span class = "org-string" > 'u'< / span > , < span class = "org-string" > 'e'< / span > };
< / pre >
< / div >
2020-12-02 11:00:11 +01:00
2020-12-03 11:51:44 +01:00
< p >
Time domain simulations will be performed by first computing the closed-loop system using the < code > lft< / code > command and then using the < code > lsim< / code > command on the closed-loop system:
< / p >
< div class = "org-src-container" >
< pre class = "src src-matlab" > < span class = "linenr" > 32: < / span > < span class = "org-comment" > % Compute the closed-Loop System, K is the controller< / span >
< span class = "linenr" > 33: < / span > P_CL = lft(Psim, K);
< span class = "linenr" > 34: < / span >
< span class = "linenr" > 35: < / span > < span class = "org-comment" > % Time simulation of the closed-loop system with specified inputs< / span >
< span class = "linenr" > 36: < / span > z = lsim(P_CL, [r; n; d], t);
< span class = "linenr" > 37: < / span > < span class = "org-comment" > % The two outputs are< / span >
< span class = "linenr" > 38: < / span > y = z(< span class = "org-type" > :< / span > ,1); < span class = "org-comment" > % Output Motion [m]< / span >
< span class = "linenr" > 39: < / span > u = z(< span class = "org-type" > :< / span > ,2); < span class = "org-comment" > % Input usage [N]< / span >
2020-12-02 11:00:11 +01:00
< / pre >
< / div >
< / div >
2020-12-01 18:49:40 +01:00
< / div >
2020-12-04 23:38:01 +01:00
< div id = "outline-container-org8b275d3" class = "outline-3" >
< h3 id = "org8b275d3" > < span class = "section-number-3" > 6.3< / span > Modern Interpretation of control specifications< / h3 >
2020-12-03 11:51:44 +01:00
< div class = "outline-text-3" id = "text-6-3" >
< p >
2020-12-04 23:38:01 +01:00
< a id = "org49e6b72" > < / a >
2020-12-03 11:51:44 +01:00
< / p >
2020-12-02 11:00:11 +01:00
2020-12-04 23:38:01 +01:00
< div class = "exercice" id = "org672e443" >
2020-12-03 11:51:44 +01:00
< ol class = "org-ol" >
< li > Translate the control specifications into wanted shape of closed-loop transfer functions< / li >
< li > Conclude and the closed-loop transfer functions to be shaped< / li >
2020-12-03 13:25:07 +01:00
< li > Chose a general configuration architecture that allows to shape these transfer function< / li >
2020-12-03 11:51:44 +01:00
< li > Using Matlab, define the generalized plant< / li >
< / ol >
< details > < summary > Hint< / summary >
< ol class = "org-ol" >
2020-12-04 23:38:01 +01:00
< li > Make use of Table < a href = "#org43d2a07" > 9< / a > < / li >
< li > Make use of Table < a href = "#org43d2a07" > 9< / a > < / li >
< li > See Section < a href = "#org5149495" > 5.4< / a > < / li >
< li > See Section < a href = "#org5149495" > 5.4< / a > < / li >
2020-12-03 11:51:44 +01:00
< / ol >
< / details >
< / div >
< p >
2020-12-04 23:38:01 +01:00
After converting the control specifications into wanted shape of closed-loop transfer functions, we might come up with the Table < a href = "#org2bee8ac" > 10< / a > .
2020-12-03 11:51:44 +01:00
< / p >
< p >
In such case, we want to shape \(S\), \(GS\) and \(T\).
< / p >
2020-12-04 23:38:01 +01:00
< table id = "org2bee8ac" border = "2" cellspacing = "0" cellpadding = "6" rules = "groups" frame = "hsides" >
2020-12-03 11:51:44 +01:00
< caption class = "t-above" > < span class = "table-number" > Table 10:< / span > Control Specifications and associated wanted shape of the closed-loop transfer functions< / caption >
2020-12-02 11:00:11 +01:00
< colgroup >
< col class = "org-left" / >
2020-12-03 11:51:44 +01:00
< col class = "org-center" / >
2020-12-02 11:00:11 +01:00
< col class = "org-left" / >
< / colgroup >
< thead >
< tr >
2020-12-04 23:38:01 +01:00
< th scope = "col" class = "org-left" > < b > Specification< / b > < / th >
< th scope = "col" class = "org-center" > < b > TF< / b > < / th >
< th scope = "col" class = "org-left" > < b > Wanted Shape< / b > < / th >
2020-12-02 11:00:11 +01:00
< / tr >
< / thead >
< tbody >
< tr >
2020-12-03 11:51:44 +01:00
< td class = "org-left" > Follow Step Reference< / td >
< td class = "org-center" > \(S\)< / td >
< td class = "org-left" > +40dB of slope at low frequency< / td >
2020-12-02 11:00:11 +01:00
< / tr >
< tr >
2020-12-03 11:51:44 +01:00
< td class = "org-left" > Reject Disturbances< / td >
< td class = "org-center" > \(S\), \(GS\)< / td >
< td class = "org-left" > Small gain< / td >
2020-12-02 11:00:11 +01:00
< / tr >
< tr >
2020-12-03 11:51:44 +01:00
< td class = "org-left" > Reject measurement noise< / td >
< td class = "org-center" > \(T\)< / td >
< td class = "org-left" > Small high frequency (> 100Hz) gain< / td >
2020-12-02 11:00:11 +01:00
< / tr >
< tr >
2020-12-03 11:51:44 +01:00
< td class = "org-left" > Robust System< / td >
< td class = "org-center" > \(S\)< / td >
< td class = "org-left" > Small \(\Vert S \Vert_\infty\)< / td >
2020-12-02 11:00:11 +01:00
< / tr >
< / tbody >
< / table >
2020-12-03 11:51:44 +01:00
< p >
2020-12-04 23:38:01 +01:00
To do so, we use to generalized plant shown in Figure < a href = "#org15b7411" > 40< / a > for the synthesis where the three closed-loop tranfert functions from \(w\) to \([z_1\,,z_2\,,z_3]\) are respectively \(S\), \(GS\) and \(T\).
2020-12-03 11:51:44 +01:00
< / p >
2020-12-02 11:00:11 +01:00
2020-12-03 11:51:44 +01:00
< p >
This generalized plant is defined on Matlab as follows:
2020-12-02 11:00:11 +01:00
< / p >
2020-12-03 11:51:44 +01:00
< div class = "org-src-container" >
< pre class = "src src-matlab" > < span class = "linenr" > 40: < / span > P = [1 < span class = "org-type" > -< / span > 1
< span class = "linenr" > 41: < / span > G < span class = "org-type" > -< / span > G
< span class = "linenr" > 42: < / span > 0 1
< span class = "linenr" > 43: < / span > G < span class = "org-type" > -< / span > G];
< / pre >
2020-12-01 18:49:40 +01:00
< / div >
2020-12-02 11:00:11 +01:00
2020-12-04 23:38:01 +01:00
< div id = "org15b7411" class = "figure" >
2020-12-03 11:51:44 +01:00
< p > < img src = "figs/ex_general_plant.png" alt = "ex_general_plant.png" / >
< / p >
< p > < span class = "figure-number" > Figure 40: < / span > Generalized plant chosen for the shaping of \(S\), \(GS\) \(T\)< / p >
< / div >
< p >
However, to performed the \(\mathcal{H}_\infty\) loop shaping, we have to include < b > weighting function< / b > to the Generalized plant.
2020-12-04 23:38:01 +01:00
We obtain the < b > weighted generalized plant< / b > in Figure < a href = "#orgab2958a" > 41< / a > , and that is computed using Matlab as follows:
2020-12-03 11:51:44 +01:00
< / p >
2020-12-02 11:00:11 +01:00
< div class = "org-src-container" >
2020-12-03 11:51:44 +01:00
< pre class = "src src-matlab" > < span class = "linenr" > 44: < / span > Pw = blkdiag(W1, W2, W3, 1)< span class = "org-type" > *< / span > P;
2020-12-02 11:00:11 +01:00
< / pre >
< / div >
2020-12-03 11:51:44 +01:00
2020-12-04 23:38:01 +01:00
< div id = "orgab2958a" class = "figure" >
2020-12-03 11:51:44 +01:00
< p > < img src = "figs/ex_general_weighted_plant.png" alt = "ex_general_weighted_plant.png" / >
< / p >
< p > < span class = "figure-number" > Figure 41: < / span > Generalized weighted plant used for the \(\mathcal{H}_\infty\) Synthesis< / p >
2020-12-02 11:00:11 +01:00
< / div >
2020-12-03 11:51:44 +01:00
< p >
2020-12-03 13:25:07 +01:00
Finlay, performing the \(\mathcal{H}_\infty\) Shaping of \(S\), \(GS\) and \(T\) is as simple as ruining the < code > hinfsyn< / code > command:
2020-12-03 11:51:44 +01:00
< / p >
< div class = "org-src-container" >
< pre class = "src src-matlab" > < span class = "linenr" > 45: < / span > K = hinfsyn(Pw, 1, 1);
< / pre >
2020-12-02 11:00:11 +01:00
< / div >
2020-12-03 13:25:07 +01:00
2020-12-02 11:00:11 +01:00
< p >
2020-12-03 13:25:07 +01:00
Now let’ s shape the three closed-loop transfer functions sequentially:
2020-12-02 11:00:11 +01:00
< / p >
2020-12-03 11:51:44 +01:00
< ul class = "org-ul" >
2020-12-04 23:38:01 +01:00
< li > \(S\) is shaped in Section < a href = "#org8988616" > 6.4< / a > < / li >
< li > \(GS\) is shaped in Section < a href = "#org0c6745c" > 6.5< / a > < / li >
< li > \(T\) is shaped in Section < a href = "#orgcc490a3" > 6.6< / a > < / li >
2020-12-03 11:51:44 +01:00
< / ul >
< / div >
< / div >
2020-12-02 11:00:11 +01:00
2020-12-04 23:38:01 +01:00
< div id = "outline-container-orgc183526" class = "outline-3" >
< h3 id = "orgc183526" > < span class = "section-number-3" > 6.4< / span > Step 1 - Shaping of \(S\)< / h3 >
2020-12-03 11:51:44 +01:00
< div class = "outline-text-3" id = "text-6-4" >
2020-12-02 11:00:11 +01:00
< p >
2020-12-04 23:38:01 +01:00
< a id = "org8988616" > < / a >
2020-12-02 11:00:11 +01:00
< / p >
2020-12-03 11:51:44 +01:00
< p >
Let’ s first shape the Sensitivity function as it is usually the most important of the < i > Gang of four< / i > closed-loop transfer functions.
To do so, we have to create a weight \(W_1(s)\) that defines the wanted upper bound on \(|S(j\omega)|\):
< / p >
< ul class = "org-ul" >
< li > small low frequency gain: \(|S(j\cdot 0)| = 10^{-3}\)< / li >
< li > minimum crossover frequency of \(\approx 10Hz\): \(|S(j2\pi 10)| < \frac{1}{\sqrt{2}}\)< / li >
< li > small maximum peak magnitude for robustness properties: \(\|S\|_\infty < 2 \ ) < / li >
< / ul >
< p >
The weighting function is design using the < code > generateWeigh< / code > function and its inverse shape can be seen in Figure
< / p >
2020-12-02 11:00:11 +01:00
< div class = "org-src-container" >
2020-12-03 11:51:44 +01:00
< pre class = "src src-matlab" > < span class = "linenr" > 46: < / span > W1 = generateWeight(< span class = "org-string" > 'G0'< / span > , 1e3, ...
< span class = "linenr" > 47: < / span > < span class = "org-string" > 'G1'< / span > , 1< span class = "org-type" > /< / span > 2, ...
< span class = "linenr" > 48: < / span > < span class = "org-string" > 'Gc'< / span > , sqrt(2), < span class = "org-string" > 'wc'< / span > , 2< span class = "org-type" > *< / span > < span class = "org-constant" > pi< / span > < span class = "org-type" > *< / span > 10, ...
< span class = "linenr" > 49: < / span > < span class = "org-string" > 'n'< / span > , 1);
2020-12-02 11:00:11 +01:00
< / pre >
< / div >
2020-12-03 11:51:44 +01:00
< p >
To not constrain \(GS\) and \(T\) for the shaping of \(S\), \(W_2\) and \(W_3\) are first taken as very small gains:
< / p >
2020-12-02 11:00:11 +01:00
< div class = "org-src-container" >
2020-12-03 11:51:44 +01:00
< pre class = "src src-matlab" > < span class = "linenr" > 50: < / span > W2 = tf(1e< span class = "org-type" > -< / span > 8);
< span class = "linenr" > 51: < / span > W3 = tf(1e< span class = "org-type" > -< / span > 8);
2020-12-02 11:00:11 +01:00
< / pre >
< / div >
2020-12-03 11:51:44 +01:00
< p >
2020-12-04 23:38:01 +01:00
The \(\mathcal{H}_\infty\) synthesis is performed and the obtained closed-loop transfer functions \(S\), \(GS\), and \(T\) and compared with the upper bounds set by the weighting functions in Figure < a href = "#org14375f5" > 42< / a > .
2020-12-03 11:51:44 +01:00
< / p >
2020-12-02 11:00:11 +01:00
< div class = "org-src-container" >
2020-12-03 13:25:07 +01:00
< pre class = "src src-matlab" > < span class = "linenr" > 52: < / span > Pw = blkdiag(W1, W2, W3, 1)< span class = "org-type" > *< / span > P;
< span class = "linenr" > 53: < / span > K1 = hinfsyn(Pw, 1, 1, < span class = "org-string" > 'Display'< / span > , < span class = "org-string" > 'on'< / span > );
2020-12-02 11:00:11 +01:00
< / pre >
< / div >
2020-12-04 23:38:01 +01:00
< pre class = "example" id = "org8f5ea45" >
2020-12-03 11:51:44 +01:00
Test bounds: 0.5 < = gamma < = 0.51
gamma X> =0 Y> =0 rho(XY)< 1 p/f
5.05e-01 0.0e+00 0.0e+00 5.511e-14 p
Limiting gains...
5.05e-01 0.0e+00 0.0e+00 1.867e-14 p
Best performance (actual): 0.502
2020-12-02 11:00:11 +01:00
< / pre >
2020-12-04 23:38:01 +01:00
< div id = "org14375f5" class = "figure" >
2020-12-03 11:51:44 +01:00
< p > < img src = "figs/ex_results_1.png" alt = "ex_results_1.png" / >
< / p >
< p > < span class = "figure-number" > Figure 42: < / span > Obtained Shape Closed-Loop transfer functions (dashed black lines indicate inverse magnitude of the weighting functions)< / p >
< / div >
2020-12-02 11:00:11 +01:00
2020-12-03 11:51:44 +01:00
< p >
2020-12-04 23:38:01 +01:00
Time domain simulation is then performed and the obtained output displacement and control inputs are shown in Figure < a href = "#org303651f" > 43< / a > .
2020-12-03 11:51:44 +01:00
< / p >
2020-12-02 11:00:11 +01:00
2020-12-03 11:51:44 +01:00
< p >
We can see:
< / p >
< ul class = "org-ul" >
< li > we are not able to follow the ramp input. This have to be solved by modifying the weighting function \(W_1(s)\)< / li >
2020-12-04 23:38:01 +01:00
< li > we have poor rejection of disturbances. This we be solve by shaping \(GS\) in Section < a href = "#org0c6745c" > 6.5< / a > < / li >
< li > we have quite large effect of the measurement noise. This will be solved by shaping \(T\) in Section < a href = "#orgcc490a3" > 6.6< / a > < / li >
2020-12-03 11:51:44 +01:00
< / ul >
2020-12-02 11:00:11 +01:00
2020-12-04 23:38:01 +01:00
< div id = "org303651f" class = "figure" >
2020-12-03 11:51:44 +01:00
< p > < img src = "figs/ex_time_domain_1.png" alt = "ex_time_domain_1.png" / >
< / p >
< p > < span class = "figure-number" > Figure 43: < / span > Time domain simulation results< / p >
2020-12-02 11:00:11 +01:00
< / div >
2020-12-03 11:51:44 +01:00
< p >
2020-12-04 23:38:01 +01:00
Remember that in order to follow ramp inputs, the sensitivity function should have a slope of +40dB/dec at low frequency (Table < a href = "#org43d2a07" > 9< / a > ).
2020-12-03 11:51:44 +01:00
< / p >
2020-12-02 11:00:11 +01:00
2020-12-03 11:51:44 +01:00
< p >
To do so, let’ s modify \(W_1\) to impose a slope of +40dB/dec at low frequency.
This can simple be done by using a second order weight:
< / p >
2020-12-02 11:00:11 +01:00
< div class = "org-src-container" >
2020-12-03 13:25:07 +01:00
< pre class = "src src-matlab" > < span class = "linenr" > 54: < / span > W1 = generateWeight(< span class = "org-string" > 'G0'< / span > , 1e3, ...
< span class = "linenr" > 55: < / span > < span class = "org-string" > 'G1'< / span > , 1< span class = "org-type" > /< / span > 2, ...
< span class = "linenr" > 56: < / span > < span class = "org-string" > 'Gc'< / span > , sqrt(2), < span class = "org-string" > 'wc'< / span > , 2< span class = "org-type" > *< / span > < span class = "org-constant" > pi< / span > < span class = "org-type" > *< / span > 15, ...
< span class = "linenr" > 57: < / span > < span class = "org-string" > 'n'< / span > , 2);
2020-12-02 11:00:11 +01:00
< / pre >
< / div >
< p >
2020-12-04 23:38:01 +01:00
The \(\mathcal{H}_\infty\) synthesis is performed using the new weights and the obtained closed-loop shaped are shown in figure < a href = "#org26754aa" > 44< / a > .
2020-12-02 11:00:11 +01:00
< / p >
2020-12-03 11:51:44 +01:00
< p >
2020-12-04 23:38:01 +01:00
The time domain signals are shown in Figure < a href = "#org85de1fb" > 45< / a > and it is confirmed that the ramps are now follows without static errors.
2020-12-03 11:51:44 +01:00
< / p >
2020-12-02 11:00:11 +01:00
2020-12-03 11:51:44 +01:00
2020-12-04 23:38:01 +01:00
< div id = "org26754aa" class = "figure" >
2020-12-03 11:51:44 +01:00
< p > < img src = "figs/ex_results_1b.png" alt = "ex_results_1b.png" / >
< / p >
< p > < span class = "figure-number" > Figure 44: < / span > Obtained Shape Closed-Loop transfer functions< / p >
2020-12-02 11:00:11 +01:00
< / div >
2020-12-03 11:51:44 +01:00
2020-12-04 23:38:01 +01:00
< div id = "org85de1fb" class = "figure" >
2020-12-03 11:51:44 +01:00
< p > < img src = "figs/ex_time_domain_1b.png" alt = "ex_time_domain_1b.png" / >
< / p >
< p > < span class = "figure-number" > Figure 45: < / span > Time domain simulation results< / p >
< / div >
< / div >
2020-12-02 11:00:11 +01:00
< / div >
2020-12-04 23:38:01 +01:00
< div id = "outline-container-org5ddc09e" class = "outline-3" >
< h3 id = "org5ddc09e" > < span class = "section-number-3" > 6.5< / span > Step 2 - Shaping of \(GS\)< / h3 >
2020-12-03 11:51:44 +01:00
< div class = "outline-text-3" id = "text-6-5" >
< p >
2020-12-04 23:38:01 +01:00
< a id = "org0c6745c" > < / a >
2020-12-03 11:51:44 +01:00
< / p >
2020-12-02 11:00:11 +01:00
2020-12-03 11:51:44 +01:00
< p >
2020-12-04 23:38:01 +01:00
Looking at Figure < a href = "#org1e75634" > 46< / a > , it is clear that the rejection of disturbances is not satisfactory.
This can also be seen by the large peak of \(GS\) in Figure < a href = "#org26754aa" > 44< / a > .
2020-12-03 11:51:44 +01:00
< / p >
2020-12-02 11:00:11 +01:00
2020-12-03 11:51:44 +01:00
< p >
This poor rejection of disturbances is actually due to the fact that the obtain controller has at notch at the resonance frequency of the plant.
< / p >
2020-12-02 11:00:11 +01:00
2020-12-03 11:51:44 +01:00
< p >
To overcome this issue, we can simply increase the magnitude of \(W_2\) to limit the peak magnitude of \(GS\)
Let’ s take \(W_2\) as a simple constant gain:
< / p >
2020-12-02 11:00:11 +01:00
< div class = "org-src-container" >
2020-12-03 13:25:07 +01:00
< pre class = "src src-matlab" > < span class = "linenr" > 58: < / span > W2 = tf(4e5);
2020-12-02 11:00:11 +01:00
< / pre >
< / div >
2020-12-03 11:51:44 +01:00
< p >
2020-12-04 23:38:01 +01:00
The \(\mathcal{H}_\infty\) Synthesis is performed and the obtained closed-loop transfer functions are shown in Figure < a href = "#org1e75634" > 46< / a > .
2020-12-03 11:51:44 +01:00
< / p >
2020-12-02 11:00:11 +01:00
2020-12-04 23:38:01 +01:00
< div id = "org1e75634" class = "figure" >
2020-12-03 11:51:44 +01:00
< p > < img src = "figs/ex_results_2.png" alt = "ex_results_2.png" / >
< / p >
< p > < span class = "figure-number" > Figure 46: < / span > Obtained Shape Closed-Loop transfer functions< / p >
2020-12-02 11:00:11 +01:00
< / div >
2020-12-03 11:51:44 +01:00
< p >
2020-12-04 23:38:01 +01:00
Time domain simulation results are shown in Figure < a href = "#org38da0ab" > 47< / a > .
2020-12-03 11:51:44 +01:00
If is shown that indeed, the disturbance rejection performance are much better and only very small oscillation is obtained.
< / p >
2020-12-04 23:38:01 +01:00
< div id = "org38da0ab" class = "figure" >
2020-12-03 11:51:44 +01:00
< p > < img src = "figs/ex_time_domain_2.png" alt = "ex_time_domain_2.png" / >
< / p >
< p > < span class = "figure-number" > Figure 47: < / span > Time domain simulation results< / p >
2020-12-02 11:00:11 +01:00
< / div >
< / div >
< / div >
2020-12-04 23:38:01 +01:00
< div id = "outline-container-org55212fe" class = "outline-3" >
< h3 id = "org55212fe" > < span class = "section-number-3" > 6.6< / span > Step 3 - Shaping of \(T\)< / h3 >
2020-12-03 11:51:44 +01:00
< div class = "outline-text-3" id = "text-6-6" >
< p >
2020-12-04 23:38:01 +01:00
< a id = "orgcc490a3" > < / a >
2020-12-03 11:51:44 +01:00
< / p >
< p >
Finally, we want to limit the effect of the noise on the displacement output.
< / p >
2020-12-02 11:00:11 +01:00
< p >
2020-12-03 11:51:44 +01:00
To do so, \(T\) is shaped such that its high frequency gain is reduced.
2020-12-02 11:00:11 +01:00
< / p >
2020-12-03 11:51:44 +01:00
< p >
This is done by increasing the high frequency gain of the weighting function \(W_3\) until the \(\mathcal{H}_\infty\) synthesis gives \(\gamma \approx 1\).
< / p >
< p >
The final weighting function \(W_3\) is defined as follows:
< / p >
2020-12-02 11:00:11 +01:00
< div class = "org-src-container" >
2020-12-03 13:25:07 +01:00
< pre class = "src src-matlab" > < span class = "linenr" > 59: < / span > W3 = generateWeight(< span class = "org-string" > 'G0'< / span > , 1e< span class = "org-type" > -< / span > 1, ...
< span class = "linenr" > 60: < / span > < span class = "org-string" > 'G1'< / span > , 1e4, ...
< span class = "linenr" > 61: < / span > < span class = "org-string" > 'Gc'< / span > , 1, < span class = "org-string" > 'wc'< / span > , 2< span class = "org-type" > *< / span > < span class = "org-constant" > pi< / span > < span class = "org-type" > *< / span > 70, ...
< span class = "linenr" > 62: < / span > < span class = "org-string" > 'n'< / span > , 2);
2020-12-02 11:00:11 +01:00
< / pre >
< / div >
2020-12-03 11:51:44 +01:00
< p >
The \(\mathcal{H}_\infty\) synthesis is performed and \(\gamma\) is closed to one.
2020-12-04 23:38:01 +01:00
The obtained closed-loop transfer functions are shown in Figure < a href = "#orgf35a73c" > 48< / a > and we can obverse that:
2020-12-03 11:51:44 +01:00
< / p >
< ul class = "org-ul" >
< li > The high frequency gain of \(T\) is indeed reduced< / li >
< li > This comes as the expense of a large magnitude both \(GS\) and \(S\).
This means we will probably have slightly less good disturbance rejection and tracking performances.< / li >
< / ul >
2020-12-02 11:00:11 +01:00
2020-12-03 11:51:44 +01:00
2020-12-04 23:38:01 +01:00
< div id = "orgf35a73c" class = "figure" >
2020-12-03 11:51:44 +01:00
< p > < img src = "figs/ex_results_3.png" alt = "ex_results_3.png" / >
< / p >
< p > < span class = "figure-number" > Figure 48: < / span > Obtained Shape Closed-Loop transfer functions< / p >
2020-12-02 11:00:11 +01:00
< / div >
2020-12-03 11:51:44 +01:00
< p >
2020-12-04 23:38:01 +01:00
The time domain simulation signals are shown in Figure < a href = "#org194cffb" > 49< / a > .
2020-12-03 11:51:44 +01:00
We can indeed see a slightly less good disturbance rejection.
However, the vibrations induced by the sensor noise is well reduced.
2020-12-04 23:38:01 +01:00
This can be seen when zooming on the output signal in Figure < a href = "#org29f99a4" > 50< / a > .
2020-12-03 11:51:44 +01:00
< / p >
2020-12-02 11:00:11 +01:00
2020-12-04 23:38:01 +01:00
< div id = "org194cffb" class = "figure" >
2020-12-03 11:51:44 +01:00
< p > < img src = "figs/ex_time_domain_3.png" alt = "ex_time_domain_3.png" / >
< / p >
< p > < span class = "figure-number" > Figure 49: < / span > Time domain simulation results< / p >
< / div >
2020-12-02 11:00:11 +01:00
2020-12-04 23:38:01 +01:00
< div id = "org29f99a4" class = "figure" >
2020-12-03 11:51:44 +01:00
< p > < img src = "figs/ex_time_domaim_3_zoom.png" alt = "ex_time_domaim_3_zoom.png" / >
< / p >
< p > < span class = "figure-number" > Figure 50: < / span > Zoom on the output signal< / p >
2020-12-02 11:00:11 +01:00
< / div >
< / div >
< / div >
2020-12-04 23:38:01 +01:00
< div id = "outline-container-org06be7c7" class = "outline-3" >
< h3 id = "org06be7c7" > < span class = "section-number-3" > 6.7< / span > Conclusion and Discussion< / h3 >
2020-12-03 11:51:44 +01:00
< div class = "outline-text-3" id = "text-6-7" >
< p >
Hopefully this practical example will help you apply the \(\mathcal{H}_\infty\) Shaping synthesis on other control problems.
< / p >
< p >
As an exercise, plot and analyze the evolution of the controller and loop gain transfer functions during the 3 synthesis steps.
< / p >
< p >
If the large input usage is considered to be not acceptable, the shaping of \(KS\) could be included in the synthesis and all the < i > Gang of four< / i > closed-loop transfer function shapes.
< / p >
2020-12-02 11:00:11 +01:00
< / div >
2020-12-01 18:49:40 +01:00
< / div >
< / div >
2020-12-04 23:38:01 +01:00
< div id = "outline-container-org8c77df4" class = "outline-2" >
< h2 id = "org8c77df4" > < span class = "section-number-2" > 7< / span > Conclusion< / h2 >
2020-11-30 17:44:13 +01:00
< div class = "outline-text-2" id = "text-7" >
< p >
2020-12-04 23:38:01 +01:00
< a id = "org4fb23e8" > < / a >
2020-12-03 11:51:44 +01:00
< / p >
< p >
Hopefully, this document gave you a glimpse on how useful and powerful the \(\mathcal{H}_\infty\) loop shaping synthesis can be.
One of the true power of \(\mathcal{H}_\infty\) synthesis is that is can easily be applied to multi-input multi-output systems!
If you want to know more about the “ \(\mathcal{H}_\infty\) and robust control world” some resources are given below.
2020-12-01 18:49:40 +01:00
< / p >
< / div >
< / div >
2020-12-04 23:38:01 +01:00
< div id = "outline-container-org2806a3c" class = "outline-2" >
< h2 id = "org2806a3c" > Resources< / h2 >
< div class = "outline-text-2" id = "text-org2806a3c" >
2020-12-03 11:51:44 +01:00
< p >
2020-12-03 12:13:53 +01:00
For a complete treatment of multivariable robust control, I would highly recommend this book < a href = "#citeproc_bib_item_3" > [3]< / a > .
If you want to nice reference book in French, look at < a href = "#citeproc_bib_item_4" > [4]< / a > .
2020-12-03 11:51:44 +01:00
< / p >
< p >
You can also look at the very good lectures below.
< / p >
2020-12-01 18:49:40 +01:00
< p >
2020-12-04 23:38:01 +01:00
< div class = "yt" > < iframe width = "100%" height = "100%" src = "https://www.youtube.com/embed/?listType=playlist&list=PLn8PRpmsu08qFLMfgTEzR8DxOPE7fBiin" frameborder = "0" allowfullscreen > Robust Control - Brian Douglas< / iframe > < / div >
2020-11-25 19:35:11 +01:00
< / p >
< p >
2020-12-04 23:38:01 +01:00
< div class = "yt" > < iframe width = "100%" height = "100%" src = "https://www.youtube.com/embed/?listType=playlist&list=PLsjPUqcL7ZIFHCObUU_9xPUImZ203gB4o" frameborder = "0" allowfullscreen > Control Bootcamp - Steve Brunton< / iframe > < / div >
2020-11-25 19:35:11 +01:00
< / p >
2020-12-02 19:01:04 +01:00
< style > . csl-left-margin { float : left ; padding-right : 0 em ; } . csl-right-inline { margin : 0 0 0 1.7999999999999998 em ; } < / 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– < a href = "https://doi.org/10.2514/2.4883" > https://doi.org/10.2514/2.4883< / a > .< / div >
< / div >
2020-12-03 11:51:44 +01:00
< div class = "csl-entry" > < a name = "citeproc_bib_item_2" > < / a >
< div class = "csl-left-margin" > [2]< / div > < div class = "csl-right-inline" > J. E. Bibel and D. S. Malyevac, “Guidelines for the selection of weighting functions for H-infinity control,” NAVAL SURFACE WARFARE CENTER DAHLGREN DIV VA, 1992.< / div >
< / div >
< div class = "csl-entry" > < a name = "citeproc_bib_item_3" > < / a >
< div class = "csl-left-margin" > [3]< / div > < div class = "csl-right-inline" > S. Skogestad and I. Postlethwaite, < i > Multivariable Feedback Control: Analysis and Design< / i > . John Wiley, 2007.< / div >
< / div >
< div class = "csl-entry" > < a name = "citeproc_bib_item_4" > < / a >
< div class = "csl-left-margin" > [4]< / div > < div class = "csl-right-inline" > G. Duc and S. Font, < i > Commande H infinie et mu-analyse-des outils pour la robustesse< / i > . Lavoisier, 1999.< / div >
< / div >
2020-12-02 19:01:04 +01:00
< / div >
2020-11-25 19:35:11 +01:00
< / div >
< / div >
< / div >
< div id = "postamble" class = "status" >
< p class = "author" > Author: Dehaeze Thomas< / p >
2020-12-04 23:38:01 +01:00
< p class = "date" > Created: 2020-12-04 ven. 23:00< / p >
2020-11-25 19:35:11 +01:00
< / div >
< / body >
< / html >
