2019-03-22 12:03:59 +01:00
<?xml version="1.0" encoding="utf-8"?>
2020-01-29 17:52:04 +01:00
<?xml version="1.0" encoding="utf-8"?>
2019-03-22 12:03:59 +01:00
< !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-03-03 15:53:02 +01:00
<!-- 2020 - 03 - 02 lun. 17:57 -->
2019-03-22 12:03:59 +01:00
< meta http-equiv = "Content-Type" content = "text/html;charset=utf-8" / >
< meta name = "viewport" content = "width=device-width, initial-scale=1" / >
< title > Identification of the Stewart Platform using Simscape< / title >
< meta name = "generator" content = "Org mode" / >
2020-01-29 17:52:04 +01:00
< meta name = "author" content = "Dehaeze Thomas" / >
2019-03-22 12:03:59 +01:00
< style type = "text/css" >
<!-- /* --> <![CDATA[/*> <!-- */
.title { text-align: center;
margin-bottom: .2em; }
.subtitle { text-align: center;
font-size: medium;
font-weight: bold;
margin-top:0; }
.todo { font-family: monospace; color: red; }
.done { font-family: monospace; color: green; }
.priority { font-family: monospace; color: orange; }
.tag { background-color: #eee; font-family: monospace;
padding: 2px; font-size: 80%; font-weight: normal; }
.timestamp { color: #bebebe; }
.timestamp-kwd { color: #5f9ea0; }
.org-right { margin-left: auto; margin-right: 0px; text-align: right; }
.org-left { margin-left: 0px; margin-right: auto; text-align: left; }
.org-center { margin-left: auto; margin-right: auto; text-align: center; }
.underline { text-decoration: underline; }
#postamble p, #preamble p { font-size: 90%; margin: .2em; }
p.verse { margin-left: 3%; }
pre {
border: 1px solid #ccc;
box-shadow: 3px 3px 3px #eee;
padding: 8pt;
font-family: monospace;
overflow: auto;
margin: 1.2em;
}
pre.src {
position: relative;
overflow: visible;
padding-top: 1.2em;
}
pre.src:before {
display: none;
position: absolute;
background-color: white;
top: -10px;
right: 10px;
padding: 3px;
border: 1px solid black;
}
pre.src:hover:before { display: inline;}
/* Languages per Org manual */
pre.src-asymptote:before { content: 'Asymptote'; }
pre.src-awk:before { content: 'Awk'; }
pre.src-C:before { content: 'C'; }
/* pre.src-C++ doesn't work in CSS */
pre.src-clojure:before { content: 'Clojure'; }
pre.src-css:before { content: 'CSS'; }
pre.src-D:before { content: 'D'; }
pre.src-ditaa:before { content: 'ditaa'; }
pre.src-dot:before { content: 'Graphviz'; }
pre.src-calc:before { content: 'Emacs Calc'; }
pre.src-emacs-lisp:before { content: 'Emacs Lisp'; }
pre.src-fortran:before { content: 'Fortran'; }
pre.src-gnuplot:before { content: 'gnuplot'; }
pre.src-haskell:before { content: 'Haskell'; }
pre.src-hledger:before { content: 'hledger'; }
pre.src-java:before { content: 'Java'; }
pre.src-js:before { content: 'Javascript'; }
pre.src-latex:before { content: 'LaTeX'; }
pre.src-ledger:before { content: 'Ledger'; }
pre.src-lisp:before { content: 'Lisp'; }
pre.src-lilypond:before { content: 'Lilypond'; }
pre.src-lua:before { content: 'Lua'; }
pre.src-matlab:before { content: 'MATLAB'; }
pre.src-mscgen:before { content: 'Mscgen'; }
pre.src-ocaml:before { content: 'Objective Caml'; }
pre.src-octave:before { content: 'Octave'; }
pre.src-org:before { content: 'Org mode'; }
pre.src-oz:before { content: 'OZ'; }
pre.src-plantuml:before { content: 'Plantuml'; }
pre.src-processing:before { content: 'Processing.js'; }
pre.src-python:before { content: 'Python'; }
pre.src-R:before { content: 'R'; }
pre.src-ruby:before { content: 'Ruby'; }
pre.src-sass:before { content: 'Sass'; }
pre.src-scheme:before { content: 'Scheme'; }
pre.src-screen:before { content: 'Gnu Screen'; }
pre.src-sed:before { content: 'Sed'; }
pre.src-sh:before { content: 'shell'; }
pre.src-sql:before { content: 'SQL'; }
pre.src-sqlite:before { content: 'SQLite'; }
/* additional languages in org.el's org-babel-load-languages alist */
pre.src-forth:before { content: 'Forth'; }
pre.src-io:before { content: 'IO'; }
pre.src-J:before { content: 'J'; }
pre.src-makefile:before { content: 'Makefile'; }
pre.src-maxima:before { content: 'Maxima'; }
pre.src-perl:before { content: 'Perl'; }
pre.src-picolisp:before { content: 'Pico Lisp'; }
pre.src-scala:before { content: 'Scala'; }
pre.src-shell:before { content: 'Shell Script'; }
pre.src-ebnf2ps:before { content: 'ebfn2ps'; }
/* additional language identifiers per "defun org-babel-execute"
in ob-*.el */
pre.src-cpp:before { content: 'C++'; }
pre.src-abc:before { content: 'ABC'; }
pre.src-coq:before { content: 'Coq'; }
pre.src-groovy:before { content: 'Groovy'; }
/* additional language identifiers from org-babel-shell-names in
ob-shell.el: ob-shell is the only babel language using a lambda to put
the execution function name together. */
pre.src-bash:before { content: 'bash'; }
pre.src-csh:before { content: 'csh'; }
pre.src-ash:before { content: 'ash'; }
pre.src-dash:before { content: 'dash'; }
pre.src-ksh:before { content: 'ksh'; }
pre.src-mksh:before { content: 'mksh'; }
pre.src-posh:before { content: 'posh'; }
/* Additional Emacs modes also supported by the LaTeX listings package */
pre.src-ada:before { content: 'Ada'; }
pre.src-asm:before { content: 'Assembler'; }
pre.src-caml:before { content: 'Caml'; }
pre.src-delphi:before { content: 'Delphi'; }
pre.src-html:before { content: 'HTML'; }
pre.src-idl:before { content: 'IDL'; }
pre.src-mercury:before { content: 'Mercury'; }
pre.src-metapost:before { content: 'MetaPost'; }
pre.src-modula-2:before { content: 'Modula-2'; }
pre.src-pascal:before { content: 'Pascal'; }
pre.src-ps:before { content: 'PostScript'; }
pre.src-prolog:before { content: 'Prolog'; }
pre.src-simula:before { content: 'Simula'; }
pre.src-tcl:before { content: 'tcl'; }
pre.src-tex:before { content: 'TeX'; }
pre.src-plain-tex:before { content: 'Plain TeX'; }
pre.src-verilog:before { content: 'Verilog'; }
pre.src-vhdl:before { content: 'VHDL'; }
pre.src-xml:before { content: 'XML'; }
pre.src-nxml:before { content: 'XML'; }
/* add a generic configuration mode; LaTeX export needs an additional
(add-to-list 'org-latex-listings-langs '(conf " ")) in .emacs */
pre.src-conf:before { content: 'Configuration File'; }
table { border-collapse:collapse; }
caption.t-above { caption-side: top; }
caption.t-bottom { caption-side: bottom; }
td, th { vertical-align:top; }
th.org-right { text-align: center; }
th.org-left { text-align: center; }
th.org-center { text-align: center; }
td.org-right { text-align: right; }
td.org-left { text-align: left; }
td.org-center { text-align: center; }
dt { font-weight: bold; }
.footpara { display: inline; }
.footdef { margin-bottom: 1em; }
.figure { padding: 1em; }
.figure p { text-align: center; }
.equation-container {
display: table;
text-align: center;
width: 100%;
}
.equation {
vertical-align: middle;
}
.equation-label {
display: table-cell;
text-align: right;
vertical-align: middle;
}
.inlinetask {
padding: 10px;
border: 2px solid gray;
margin: 10px;
background: #ffffcc;
}
#org-div-home-and-up
{ text-align: right; font-size: 70%; white-space: nowrap; }
textarea { overflow-x: auto; }
.linenr { font-size: smaller }
.code-highlighted { background-color: #ffff00; }
.org-info-js_info-navigation { border-style: none; }
#org-info-js_console-label
{ font-size: 10px; font-weight: bold; white-space: nowrap; }
.org-info-js_search-highlight
{ background-color: #ffff00; color: #000000; font-weight: bold; }
.org-svg { width: 90%; }
/*]]>*/-->
< / style >
2019-08-26 11:58:44 +02:00
< link rel = "stylesheet" type = "text/css" href = "./css/htmlize.css" / >
< link rel = "stylesheet" type = "text/css" href = "./css/readtheorg.css" / >
< script src = "./js/jquery.min.js" > < / script >
< script src = "./js/bootstrap.min.js" > < / script >
< script src = "./js/jquery.stickytableheaders.min.js" > < / script >
< script src = "./js/readtheorg.js" > < / script >
2019-03-22 12:03:59 +01:00
< script type = "text/javascript" >
2020-02-27 14:23:09 +01:00
// @license magnet:?xt=urn:btih:1f739d935676111cfff4b4693e3816e664797050& dn=gpl-3.0.txt GPL-v3-or-Later
2019-03-22 12:03:59 +01:00
<!-- /* --> <![CDATA[/*> <!-- */
2020-02-27 14:23:09 +01:00
function CodeHighlightOn(elem, id)
{
var target = document.getElementById(id);
if(null != target) {
elem.cacheClassElem = elem.className;
elem.cacheClassTarget = target.className;
target.className = "code-highlighted";
elem.className = "code-highlighted";
}
}
function CodeHighlightOff(elem, id)
{
var target = document.getElementById(id);
if(elem.cacheClassElem)
elem.className = elem.cacheClassElem;
if(elem.cacheClassTarget)
target.className = elem.cacheClassTarget;
}
/*]]>*///-->
// @license-end
2019-03-22 12:03:59 +01:00
< / script >
2020-01-29 17:52:04 +01:00
< script >
2020-02-11 15:27:39 +01:00
MathJax = {
tex: { macros: {
bm: ["\\boldsymbol{#1}",1],
}
2020-01-29 17:52:04 +01:00
}
2020-02-11 15:27:39 +01:00
};
< / script >
< script type = "text/javascript"
src="https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js">< / script >
2019-03-22 12:03:59 +01:00
< / head >
< body >
2019-08-26 11:58:44 +02:00
< 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" >
2019-03-22 12:03:59 +01:00
< h1 class = "title" > Identification of the Stewart Platform using Simscape< / h1 >
< div id = "table-of-contents" >
< h2 > Table of Contents< / h2 >
< div id = "text-table-of-contents" >
< ul >
2020-02-13 15:44:48 +01:00
< li > < a href = "#orgcb2f4c2" > 1. Modal Analysis of the Stewart Platform< / a >
2020-01-29 17:52:04 +01:00
< ul >
2020-02-13 15:44:48 +01:00
< li > < a href = "#org66d09e9" > 1.1. Initialize the Stewart Platform< / a > < / li >
< li > < a href = "#org8b1c587" > 1.2. Identification< / a > < / li >
< li > < a href = "#orge68adea" > 1.3. Coordinate transformation< / a > < / li >
< li > < a href = "#org4973ae1" > 1.4. Analysis< / a > < / li >
< li > < a href = "#orge7b97c8" > 1.5. Visualizing the modes< / a > < / li >
2020-01-29 17:52:04 +01:00
< / ul >
< / li >
2020-02-27 14:23:09 +01:00
< li > < a href = "#org2891722" > 2. Transmissibility Analysis< / a >
< ul >
2020-03-03 15:53:02 +01:00
< li > < a href = "#org55d2544" > 2.1. Initialize the Stewart platform< / a > < / li >
2020-02-27 14:23:09 +01:00
< li > < a href = "#org5338f20" > 2.2. Transmissibility< / a > < / li >
< / ul >
< / li >
< li > < a href = "#orgc94edbd" > 3. Compliance Analysis< / a >
< ul >
2020-03-03 15:53:02 +01:00
< li > < a href = "#org499fd6a" > 3.1. Initialize the Stewart platform< / a > < / li >
2020-02-27 14:23:09 +01:00
< li > < a href = "#org1177029" > 3.2. Compliance< / a > < / li >
< / ul >
< / li >
< li > < a href = "#org68ca336" > 4. Functions< / a >
< ul >
< li > < a href = "#org487c4d4" > 4.1. Compute the Transmissibility< / a >
< ul >
2020-03-03 15:53:02 +01:00
< li > < a href = "#org3cf1d13" > Function description< / a > < / li >
< li > < a href = "#org726b57d" > Optional Parameters< / a > < / li >
2020-02-27 14:23:09 +01:00
< li > < a href = "#org4629501" > Identification of the Transmissibility Matrix< / a > < / li >
2020-03-03 15:53:02 +01:00
< li > < a href = "#org1019eaf" > Computation of the Frobenius norm< / a > < / li >
2020-02-27 14:23:09 +01:00
< / ul >
< / li >
< li > < a href = "#org50e35a6" > 4.2. Compute the Compliance< / a >
< ul >
2020-03-03 15:53:02 +01:00
< li > < a href = "#orgf1e6c32" > Function description< / a > < / li >
< li > < a href = "#orgda14a2f" > Optional Parameters< / a > < / li >
2020-02-27 14:23:09 +01:00
< li > < a href = "#orgef06b63" > Identification of the Compliance Matrix< / a > < / li >
2020-03-03 15:53:02 +01:00
< li > < a href = "#orgc21ec39" > Computation of the Frobenius norm< / a > < / li >
2020-02-27 14:23:09 +01:00
< / ul >
< / li >
< / ul >
< / li >
2019-03-22 12:03:59 +01:00
< / ul >
< / div >
< / div >
2020-02-27 14:23:09 +01:00
< p >
In this document, we discuss the various methods to identify the behavior of the Stewart platform.
< / p >
< ul class = "org-ul" >
< li > < a href = "#org7981e88" > 1< / a > < / li >
< li > < a href = "#orga989615" > 2< / a > < / li >
< li > < a href = "#org4579374" > 3< / a > < / li >
< / ul >
2020-02-13 15:44:48 +01:00
< div id = "outline-container-orgcb2f4c2" class = "outline-2" >
< h2 id = "orgcb2f4c2" > < span class = "section-number-2" > 1< / span > Modal Analysis of the Stewart Platform< / h2 >
2020-02-11 15:50:52 +01:00
< div class = "outline-text-2" id = "text-1" >
2020-02-27 14:23:09 +01:00
< p >
< a id = "org7981e88" > < / a >
< / p >
2020-01-29 17:52:04 +01:00
< / div >
2020-02-13 15:44:48 +01:00
< div id = "outline-container-org66d09e9" class = "outline-3" >
< h3 id = "org66d09e9" > < span class = "section-number-3" > 1.1< / span > Initialize the Stewart Platform< / h3 >
< div class = "outline-text-3" id = "text-1-1" >
2019-08-26 11:58:44 +02:00
< div class = "org-src-container" >
2020-02-11 15:27:39 +01:00
< pre class = "src src-matlab" > stewart = initializeStewartPlatform();
stewart = initializeFramesPositions(stewart);
2020-01-29 17:52:04 +01:00
stewart = generateGeneralConfiguration(stewart);
stewart = computeJointsPose(stewart);
stewart = initializeStrutDynamics(stewart);
2020-02-13 15:44:48 +01:00
stewart = initializeJointDynamics(stewart, < span class = "org-string" > 'type_F'< / span > , < span class = "org-string" > 'universal_p'< / span > , < span class = "org-string" > 'type_M'< / span > , < span class = "org-string" > 'spherical_p'< / span > );
2020-01-29 17:52:04 +01:00
stewart = initializeCylindricalPlatforms(stewart);
stewart = initializeCylindricalStruts(stewart);
stewart = computeJacobian(stewart);
stewart = initializeStewartPose(stewart);
2020-02-13 15:44:48 +01:00
stewart = initializeInertialSensor(stewart);
2019-03-22 12:03:59 +01:00
< / pre >
< / div >
< div class = "org-src-container" >
2020-02-13 15:44:48 +01:00
< pre class = "src src-matlab" > ground = initializeGround(< span class = "org-string" > 'type'< / span > , < span class = "org-string" > 'none'< / span > );
payload = initializePayload(< span class = "org-string" > 'type'< / span > , < span class = "org-string" > 'none'< / span > );
2020-02-28 17:35:44 +01:00
controller = initializeController(< span class = "org-string" > 'type'< / span > , < span class = "org-string" > 'open-loop'< / span > );
2020-01-29 17:52:04 +01:00
< / pre >
< / div >
< / div >
< / div >
2020-02-13 15:44:48 +01:00
< div id = "outline-container-org8b1c587" class = "outline-3" >
< h3 id = "org8b1c587" > < span class = "section-number-3" > 1.2< / span > Identification< / h3 >
< div class = "outline-text-3" id = "text-1-2" >
2020-01-29 17:52:04 +01:00
< div class = "org-src-container" >
< pre class = "src src-matlab" > < span class = "org-matlab-cellbreak" > < span class = "org-comment" > %% Options for Linearized< / span > < / span >
options = linearizeOptions;
options.SampleTime = 0;
< span class = "org-matlab-cellbreak" > < span class = "org-comment" > %% Name of the Simulink File< / span > < / span >
2020-02-13 15:44:48 +01:00
mdl = < span class = "org-string" > 'stewart_platform_model'< / span > ;
2020-01-29 17:52:04 +01:00
< span class = "org-matlab-cellbreak" > < span class = "org-comment" > %% Input/Output definition< / span > < / span >
clear io; io_i = 1;
2020-02-13 15:44:48 +01:00
io(io_i) = linio([mdl, < span class = "org-string" > '/Controller'< / span > ], 1, < span class = "org-string" > 'openinput'< / span > ); io_i = io_i < span class = "org-type" > +< / span > 1; < span class = "org-comment" > % Actuator Force Inputs [N]< / span >
io(io_i) = linio([mdl, < span class = "org-string" > '/Relative Motion Sensor'< / span > ], 1, < span class = "org-string" > 'openoutput'< / span > ); io_i = io_i < span class = "org-type" > +< / span > 1; < span class = "org-comment" > % Position/Orientation of {B} w.r.t. {A}< / span >
io(io_i) = linio([mdl, < span class = "org-string" > '/Relative Motion Sensor'< / span > ], 2, < span class = "org-string" > 'openoutput'< / span > ); io_i = io_i < span class = "org-type" > +< / span > 1; < span class = "org-comment" > % Velocity of {B} w.r.t. {A}< / span >
2020-01-29 17:52:04 +01:00
< span class = "org-matlab-cellbreak" > < span class = "org-comment" > %% Run the linearization< / span > < / span >
G = linearize(mdl, io);
< span class = "org-comment" > % G.InputName = {'tau1', 'tau2', 'tau3', 'tau4', 'tau5', 'tau6'};< / span >
< span class = "org-comment" > % G.OutputName = {'Xdx', 'Xdy', 'Xdz', 'Xrx', 'Xry', 'Xrz', 'Vdx', 'Vdy', 'Vdz', 'Vrx', 'Vry', 'Vrz'};< / span >
< / pre >
< / div >
2019-03-22 12:03:59 +01:00
< p >
2020-01-29 17:52:04 +01:00
Let’ s check the size of < code > G< / code > :
2019-03-22 12:03:59 +01:00
< / p >
< div class = "org-src-container" >
2020-01-29 17:52:04 +01:00
< pre class = "src src-matlab" > size(G)
2019-08-26 11:58:44 +02:00
< / pre >
< / div >
2020-01-29 17:52:04 +01:00
< pre class = "example" >
size(G)
State-space model with 12 outputs, 6 inputs, and 18 states.
'org_babel_eoe'
ans =
'org_babel_eoe'
< / pre >
< p >
We expect to have only 12 states (corresponding to the 6dof of the mobile platform).
< / p >
2019-08-26 11:58:44 +02:00
< div class = "org-src-container" >
2020-01-29 17:52:04 +01:00
< pre class = "src src-matlab" > Gm = minreal(G);
2019-03-22 12:03:59 +01:00
< / pre >
< / div >
2020-01-29 17:52:04 +01:00
< pre class = "example" >
Gm = minreal(G);
6 states removed.
< / pre >
< p >
And indeed, we obtain 12 states.
< / p >
2019-03-22 12:03:59 +01:00
< / div >
< / div >
2020-02-11 15:27:39 +01:00
< div id = "outline-container-orge68adea" class = "outline-3" >
2020-02-13 15:44:48 +01:00
< h3 id = "orge68adea" > < span class = "section-number-3" > 1.3< / span > Coordinate transformation< / h3 >
< div class = "outline-text-3" id = "text-1-3" >
2020-01-29 17:52:04 +01:00
< p >
We can perform the following transformation using the < code > ss2ss< / code > command.
< / p >
2019-03-22 12:03:59 +01:00
< div class = "org-src-container" >
2020-01-29 17:52:04 +01:00
< pre class = "src src-matlab" > Gt = ss2ss(Gm, Gm.C);
2019-03-22 12:03:59 +01:00
< / pre >
< / div >
2020-01-29 17:52:04 +01:00
< p >
Then, the < code > C< / code > matrix of < code > Gt< / code > is the unity matrix which means that the states of the state space model are equal to the measurements \(\bm{Y}\).
< / p >
< p >
The measurements are the 6 displacement and 6 velocities of mobile platform with respect to \(\{B\}\).
< / p >
< p >
We could perform the transformation by hand:
< / p >
2019-03-22 12:03:59 +01:00
< div class = "org-src-container" >
2020-01-29 17:52:04 +01:00
< pre class = "src src-matlab" > At = Gm.C< span class = "org-type" > *< / span > Gm.A< span class = "org-type" > *< / span > pinv(Gm.C);
Bt = Gm.C< span class = "org-type" > *< / span > Gm.B;
Ct = eye(12);
Dt = zeros(12, 6);
Gt = ss(At, Bt, Ct, Dt);
2019-03-22 12:03:59 +01:00
< / pre >
< / div >
< / div >
< / div >
2020-02-11 15:27:39 +01:00
< div id = "outline-container-org4973ae1" class = "outline-3" >
2020-02-13 15:44:48 +01:00
< h3 id = "org4973ae1" > < span class = "section-number-3" > 1.4< / span > Analysis< / h3 >
< div class = "outline-text-3" id = "text-1-4" >
2019-03-22 12:03:59 +01:00
< div class = "org-src-container" >
2020-01-29 17:52:04 +01:00
< pre class = "src src-matlab" > [V,D] = eig(Gt.A);
2019-03-22 12:03:59 +01:00
< / pre >
< / div >
2020-01-29 17:52:04 +01:00
< table border = "2" cellspacing = "0" cellpadding = "6" rules = "groups" frame = "hsides" >
< colgroup >
< col class = "org-right" / >
< col class = "org-right" / >
< col class = "org-right" / >
< / colgroup >
< thead >
< tr >
< th scope = "col" class = "org-right" > Mode Number< / th >
< th scope = "col" class = "org-right" > Resonance Frequency [Hz]< / th >
< th scope = "col" class = "org-right" > Damping Ratio [%]< / th >
< / tr >
< / thead >
< tbody >
< tr >
< td class = "org-right" > 1.0< / td >
2020-02-13 15:44:48 +01:00
< td class = "org-right" > 780.6< / td >
< td class = "org-right" > 0.4< / td >
2020-01-29 17:52:04 +01:00
< / tr >
< tr >
< td class = "org-right" > 2.0< / td >
2020-02-13 15:44:48 +01:00
< td class = "org-right" > 780.6< / td >
< td class = "org-right" > 0.3< / td >
2020-01-29 17:52:04 +01:00
< / tr >
< tr >
< td class = "org-right" > 3.0< / td >
2020-02-13 15:44:48 +01:00
< td class = "org-right" > 903.9< / td >
< td class = "org-right" > 0.3< / td >
2020-01-29 17:52:04 +01:00
< / tr >
< tr >
< td class = "org-right" > 4.0< / td >
2020-02-13 15:44:48 +01:00
< td class = "org-right" > 1061.4< / td >
< td class = "org-right" > 0.3< / td >
2020-01-29 17:52:04 +01:00
< / tr >
< tr >
< td class = "org-right" > 5.0< / td >
2020-02-13 15:44:48 +01:00
< td class = "org-right" > 1061.4< / td >
< td class = "org-right" > 0.2< / td >
2020-01-29 17:52:04 +01:00
< / tr >
< tr >
< td class = "org-right" > 6.0< / td >
2020-02-13 15:44:48 +01:00
< td class = "org-right" > 1269.6< / td >
< td class = "org-right" > 0.2< / td >
2020-01-29 17:52:04 +01:00
< / tr >
< / tbody >
< / table >
< / div >
< / div >
2020-02-11 15:27:39 +01:00
< div id = "outline-container-orge7b97c8" class = "outline-3" >
2020-02-13 15:44:48 +01:00
< h3 id = "orge7b97c8" > < span class = "section-number-3" > 1.5< / span > Visualizing the modes< / h3 >
< div class = "outline-text-3" id = "text-1-5" >
2020-01-29 17:52:04 +01:00
< p >
To visualize the i’ th mode, we may excite the system using the inputs \(U_i\) such that \(B U_i\) is co-linear to \(\xi_i\) (the mode we want to excite).
< / p >
< p >
\[ U(t) = e^{\alpha t} ( ) \]
< / p >
< p >
Let’ s first sort the modes and just take the modes corresponding to a eigenvalue with a positive imaginary part.
< / p >
2019-03-22 12:03:59 +01:00
< div class = "org-src-container" >
2020-01-29 17:52:04 +01:00
< pre class = "src src-matlab" > ws = imag(diag(D));
[ws,I] = sort(ws)
ws = ws(7< span class = "org-type" > :< / span > end); I = I(7< span class = "org-type" > :< / span > end);
2019-03-22 12:03:59 +01:00
< / pre >
< / div >
2020-01-29 17:52:04 +01:00
< div class = "org-src-container" >
< pre class = "src src-matlab" > < span class = "org-keyword" > for< / span > < span class = "org-variable-name" > < span class = "org-constant" > i< / span > < / span > = < span class = "org-constant" > 1:length(ws)< / span >
< / pre >
2019-03-22 12:03:59 +01:00
< / div >
< div class = "org-src-container" >
2020-01-29 17:52:04 +01:00
< pre class = "src src-matlab" > i_mode = I(< span class = "org-constant" > i< / span > ); < span class = "org-comment" > % the argument is the i'th mode< / span >
2019-03-22 12:03:59 +01:00
< /pre>
< / div >
< div class = "org-src-container" >
2020-01-29 17:52:04 +01:00
< pre class = "src src-matlab" > lambda_i = D(i_mode, i_mode);
xi_i = V(< span class = "org-type" > :< / span > ,i_mode);
a_i = real(lambda_i);
b_i = imag(lambda_i);
2019-03-22 12:03:59 +01:00
< / pre >
< / div >
2020-01-29 17:52:04 +01:00
< p >
Let do 10 periods of the mode.
< / p >
2019-03-22 12:03:59 +01:00
< div class = "org-src-container" >
2020-01-29 17:52:04 +01:00
< pre class = "src src-matlab" > t = linspace(0, 10< span class = "org-type" > /< / span > (imag(lambda_i)< span class = "org-type" > /< / span > 2< span class = "org-type" > /< / span > < span class = "org-constant" > pi< / span > ), 1000);
U_i = pinv(Gt.B) < span class = "org-type" > *< / span > real(xi_i < span class = "org-type" > *< / span > lambda_i < span class = "org-type" > *< / span > (cos(b_i < span class = "org-type" > *< / span > t) < span class = "org-type" > +< / span > 1< span class = "org-constant" > i< / span > < span class = "org-type" > *< / span > sin(b_i < span class = "org-type" > *< / span > t)));
2019-03-22 12:03:59 +01:00
< / pre >
< / div >
2020-01-29 17:52:04 +01:00
< div class = "org-src-container" >
< pre class = "src src-matlab" > U = timeseries(U_i, t);
< / pre >
2019-03-22 12:03:59 +01:00
< / div >
2020-01-29 17:52:04 +01:00
< p >
Simulation:
< / p >
< div class = "org-src-container" >
< pre class = "src src-matlab" > load(< span class = "org-string" > 'mat/conf_simscape.mat'< / span > );
< span class = "org-matlab-simulink-keyword" > set_param< / span > (< span class = "org-variable-name" > conf_simscape< / span > , < span class = "org-string" > 'StopTime'< / span > , num2str(t(< span class = "org-variable-name" > end< / span > )));
< span class = "org-matlab-simulink-keyword" > sim< / span > (mdl);
< / pre >
2019-03-22 12:03:59 +01:00
< / div >
< p >
2020-01-29 17:52:04 +01:00
Save the movie of the mode shape.
2019-03-22 12:03:59 +01:00
< / p >
2020-01-29 17:52:04 +01:00
< div class = "org-src-container" >
< pre class = "src src-matlab" > smwritevideo(mdl, sprintf(< span class = "org-string" > 'figs/mode%i'< / span > , < span class = "org-constant" > i< / span > ), ...
< span class = "org-string" > 'PlaybackSpeedRatio'< / span > , 1< span class = "org-type" > /< / span > (b_i< span class = "org-type" > /< / span > 2< span class = "org-type" > /< / span > < span class = "org-constant" > pi< / span > ), ...
< span class = "org-string" > 'FrameRate'< / span > , 30, ...
< span class = "org-string" > 'FrameSize'< / span > , [800, 400]);
< / pre >
< / div >
2019-03-22 12:03:59 +01:00
< div class = "org-src-container" >
2020-01-29 17:52:04 +01:00
< pre class = "src src-matlab" > < span class = "org-keyword" > end< / span >
2019-03-22 12:03:59 +01:00
< / pre >
< / div >
2020-01-29 17:52:04 +01:00
2020-02-11 15:27:39 +01:00
< div id = "orgb15855a" class = "figure" >
2020-01-29 17:52:04 +01:00
< p > < img src = "figs/mode1.gif" alt = "mode1.gif" / >
< / p >
< p > < span class = "figure-number" > Figure 1: < / span > Identified mode - 1< / p >
2019-03-22 12:03:59 +01:00
< / div >
2020-01-29 17:52:04 +01:00
2020-02-11 15:27:39 +01:00
< div id = "org1816e59" class = "figure" >
2020-01-29 17:52:04 +01:00
< p > < img src = "figs/mode3.gif" alt = "mode3.gif" / >
< / p >
< p > < span class = "figure-number" > Figure 2: < / span > Identified mode - 3< / p >
2019-03-22 12:03:59 +01:00
< / div >
2020-01-29 17:52:04 +01:00
2020-02-11 15:27:39 +01:00
< div id = "org01c8dca" class = "figure" >
2020-01-29 17:52:04 +01:00
< p > < img src = "figs/mode5.gif" alt = "mode5.gif" / >
2019-03-22 12:03:59 +01:00
< / p >
2020-01-29 17:52:04 +01:00
< p > < span class = "figure-number" > Figure 3: < / span > Identified mode - 5< / p >
< / div >
< / div >
< / div >
2019-03-22 12:03:59 +01:00
< / div >
2020-02-27 14:23:09 +01:00
< div id = "outline-container-org2891722" class = "outline-2" >
< h2 id = "org2891722" > < span class = "section-number-2" > 2< / span > Transmissibility Analysis< / h2 >
< div class = "outline-text-2" id = "text-2" >
< p >
< a id = "orga989615" > < / a >
< / p >
< / div >
2020-03-03 15:53:02 +01:00
< div id = "outline-container-org55d2544" class = "outline-3" >
< h3 id = "org55d2544" > < span class = "section-number-3" > 2.1< / span > Initialize the Stewart platform< / h3 >
2020-02-27 14:23:09 +01:00
< div class = "outline-text-3" id = "text-2-1" >
< div class = "org-src-container" >
< pre class = "src src-matlab" > stewart = initializeStewartPlatform();
stewart = initializeFramesPositions(stewart, < span class = "org-string" > 'H'< / span > , 90e< span class = "org-type" > -< / span > 3, < span class = "org-string" > 'MO_B'< / span > , 45e< span class = "org-type" > -< / span > 3);
stewart = generateGeneralConfiguration(stewart);
stewart = computeJointsPose(stewart);
stewart = initializeStrutDynamics(stewart);
stewart = initializeJointDynamics(stewart, < span class = "org-string" > 'type_F'< / span > , < span class = "org-string" > 'universal_p'< / span > , < span class = "org-string" > 'type_M'< / span > , < span class = "org-string" > 'spherical_p'< / span > );
stewart = initializeCylindricalPlatforms(stewart);
stewart = initializeCylindricalStruts(stewart);
stewart = computeJacobian(stewart);
stewart = initializeStewartPose(stewart);
stewart = initializeInertialSensor(stewart, < span class = "org-string" > 'type'< / span > , < span class = "org-string" > 'accelerometer'< / span > , < span class = "org-string" > 'freq'< / span > , 5e3);
< / pre >
< / div >
< p >
We set the rotation point of the ground to be at the same point at frames \(\{A\}\) and \(\{B\}\).
< / p >
< div class = "org-src-container" >
< pre class = "src src-matlab" > ground = initializeGround(< span class = "org-string" > 'type'< / span > , < span class = "org-string" > 'rigid'< / span > , < span class = "org-string" > 'rot_point'< / span > , stewart.platform_F.FO_A);
payload = initializePayload(< span class = "org-string" > 'type'< / span > , < span class = "org-string" > 'rigid'< / span > );
2020-02-28 17:35:44 +01:00
controller = initializeController(< span class = "org-string" > 'type'< / span > , < span class = "org-string" > 'open-loop'< / span > );
2020-02-27 14:23:09 +01:00
< / pre >
< / div >
< / div >
< / div >
< div id = "outline-container-org5338f20" class = "outline-3" >
< h3 id = "org5338f20" > < span class = "section-number-3" > 2.2< / span > Transmissibility< / h3 >
< div class = "outline-text-3" id = "text-2-2" >
< div class = "org-src-container" >
< pre class = "src src-matlab" > < span class = "org-matlab-cellbreak" > < span class = "org-comment" > %% Options for Linearized< / span > < / span >
options = linearizeOptions;
options.SampleTime = 0;
< span class = "org-matlab-cellbreak" > < span class = "org-comment" > %% Name of the Simulink File< / span > < / span >
mdl = < span class = "org-string" > 'stewart_platform_model'< / span > ;
< span class = "org-matlab-cellbreak" > < span class = "org-comment" > %% Input/Output definition< / span > < / span >
clear io; io_i = 1;
io(io_i) = linio([mdl, < span class = "org-string" > '/Disturbances/D_w'< / span > ], 1, < span class = "org-string" > 'openinput'< / span > ); io_i = io_i < span class = "org-type" > +< / span > 1; < span class = "org-comment" > % Base Motion [m, rad]< / span >
io(io_i) = linio([mdl, < span class = "org-string" > '/Absolute Motion Sensor'< / span > ], 1, < span class = "org-string" > 'openoutput'< / span > ); io_i = io_i < span class = "org-type" > +< / span > 1; < span class = "org-comment" > % Absolute Motion [m, rad]< / span >
< span class = "org-matlab-cellbreak" > < span class = "org-comment" > %% Run the linearization< / span > < / span >
T = linearize(mdl, io, options);
T.InputName = {< span class = "org-string" > 'Wdx'< / span > , < span class = "org-string" > 'Wdy'< / span > , < span class = "org-string" > 'Wdz'< / span > , < span class = "org-string" > 'Wrx'< / span > , < span class = "org-string" > 'Wry'< / span > , < span class = "org-string" > 'Wrz'< / span > };
T.OutputName = {< span class = "org-string" > 'Edx'< / span > , < span class = "org-string" > 'Edy'< / span > , < span class = "org-string" > 'Edz'< / span > , < span class = "org-string" > 'Erx'< / span > , < span class = "org-string" > 'Ery'< / span > , < span class = "org-string" > 'Erz'< / span > };
< / pre >
< / div >
< div class = "org-src-container" >
< pre class = "src src-matlab" > freqs = logspace(1, 4, 1000);
< span class = "org-type" > figure< / span > ;
< span class = "org-keyword" > for< / span > < span class = "org-variable-name" > ix< / span > = < span class = "org-constant" > 1:6< / span >
< span class = "org-keyword" > for< / span > < span class = "org-variable-name" > iy< / span > = < span class = "org-constant" > 1:6< / span >
subplot(6, 6, (ix< span class = "org-type" > -< / span > 1)< span class = "org-type" > *< / span > 6 < span class = "org-type" > +< / span > iy);
hold on;
plot(freqs, abs(squeeze(freqresp(T(ix, iy), freqs, < span class = "org-string" > 'Hz'< / span > ))), < span class = "org-string" > 'k-'< / span > );
< span class = "org-type" > set< / span > (< span class = "org-variable-name" > gca< / span > , < span class = "org-string" > 'XScale'< / span > , < span class = "org-string" > 'log'< / span > ); < span class = "org-type" > set< / span > (< span class = "org-variable-name" > gca< / span > , < span class = "org-string" > 'YScale'< / span > , < span class = "org-string" > 'log'< / span > );
ylim([1e< span class = "org-type" > -< / span > 5, 10]);
xlim([freqs(1), freqs(end)]);
< span class = "org-keyword" > if< / span > ix < span class = "org-type" > < < / span > 6
xticklabels({});
< span class = "org-keyword" > end< / span >
< span class = "org-keyword" > if< / span > iy < span class = "org-type" > > < / span > 1
yticklabels({});
< span class = "org-keyword" > end< / span >
< span class = "org-keyword" > end< / span >
< span class = "org-keyword" > end< / span >
< / pre >
< / div >
< p >
From < a class = 'org-ref-reference' href = "#preumont07_six_axis_singl_stage_activ" > preumont07_six_axis_singl_stage_activ< / a > , one can use the Frobenius norm of the transmissibility matrix to obtain a scalar indicator of the transmissibility performance of the system:
< / p >
\begin{align*}
\| \bm{T}(\omega) \| & = \sqrt{\text{Trace}[\bm{T}(\omega) \bm{T}(\omega)^H]}\\
& = \sqrt{\Sigma_{i=1}^6 \Sigma_{j=1}^6 |T_{ij}|^2}
\end{align*}
< div class = "org-src-container" >
< pre class = "src src-matlab" > freqs = logspace(1, 4, 1000);
T_norm = zeros(length(freqs), 1);
< span class = "org-keyword" > for< / span > < span class = "org-variable-name" > < span class = "org-constant" > i< / span > < / span > = < span class = "org-constant" > 1:length(freqs)< / span >
T_norm(< span class = "org-constant" > i< / span > ) = sqrt(trace(freqresp(T, freqs(< span class = "org-constant" > i< / span > ), < span class = "org-string" > 'Hz'< / span > )< span class = "org-type" > *< / span > freqresp(T, freqs(< span class = "org-constant" > i< / span > ), < span class = "org-string" > 'Hz'< / span > )< span class = "org-type" > '< / span > ));
< span class = "org-keyword" > end< / span >
< / pre >
< / div >
< p >
And we normalize by a factor \(\sqrt{6}\) to obtain a performance metric comparable to the transmissibility of a one-axis isolator:
\[ \Gamma(\omega) = \|\bm{T}(\omega)\| / \sqrt{6} \]
< / p >
< div class = "org-src-container" >
< pre class = "src src-matlab" > Gamma = T_norm< span class = "org-type" > /< / span > sqrt(6);
< / pre >
< / div >
< div class = "org-src-container" >
< pre class = "src src-matlab" > < span class = "org-type" > figure< / span > ;
plot(freqs, Gamma)
< span class = "org-type" > set< / span > (< span class = "org-variable-name" > gca< / span > , < span class = "org-string" > 'XScale'< / span > , < span class = "org-string" > 'log'< / span > ); < span class = "org-type" > set< / span > (< span class = "org-variable-name" > gca< / span > , < span class = "org-string" > 'YScale'< / span > , < span class = "org-string" > 'log'< / span > );
< / pre >
< / div >
< / div >
< / div >
< / div >
< div id = "outline-container-orgc94edbd" class = "outline-2" >
< h2 id = "orgc94edbd" > < span class = "section-number-2" > 3< / span > Compliance Analysis< / h2 >
< div class = "outline-text-2" id = "text-3" >
< p >
< a id = "org4579374" > < / a >
< / p >
< / div >
2020-03-03 15:53:02 +01:00
< div id = "outline-container-org499fd6a" class = "outline-3" >
< h3 id = "org499fd6a" > < span class = "section-number-3" > 3.1< / span > Initialize the Stewart platform< / h3 >
2020-02-27 14:23:09 +01:00
< div class = "outline-text-3" id = "text-3-1" >
< div class = "org-src-container" >
< pre class = "src src-matlab" > stewart = initializeStewartPlatform();
stewart = initializeFramesPositions(stewart, < span class = "org-string" > 'H'< / span > , 90e< span class = "org-type" > -< / span > 3, < span class = "org-string" > 'MO_B'< / span > , 45e< span class = "org-type" > -< / span > 3);
stewart = generateGeneralConfiguration(stewart);
stewart = computeJointsPose(stewart);
stewart = initializeStrutDynamics(stewart);
stewart = initializeJointDynamics(stewart, < span class = "org-string" > 'type_F'< / span > , < span class = "org-string" > 'universal_p'< / span > , < span class = "org-string" > 'type_M'< / span > , < span class = "org-string" > 'spherical_p'< / span > );
stewart = initializeCylindricalPlatforms(stewart);
stewart = initializeCylindricalStruts(stewart);
stewart = computeJacobian(stewart);
stewart = initializeStewartPose(stewart);
stewart = initializeInertialSensor(stewart, < span class = "org-string" > 'type'< / span > , < span class = "org-string" > 'accelerometer'< / span > , < span class = "org-string" > 'freq'< / span > , 5e3);
< / pre >
< / div >
< p >
We set the rotation point of the ground to be at the same point at frames \(\{A\}\) and \(\{B\}\).
< / p >
< div class = "org-src-container" >
< pre class = "src src-matlab" > ground = initializeGround(< span class = "org-string" > 'type'< / span > , < span class = "org-string" > 'none'< / span > );
payload = initializePayload(< span class = "org-string" > 'type'< / span > , < span class = "org-string" > 'rigid'< / span > );
2020-02-28 17:35:44 +01:00
controller = initializeController(< span class = "org-string" > 'type'< / span > , < span class = "org-string" > 'open-loop'< / span > );
2020-02-27 14:23:09 +01:00
< / pre >
< / div >
< / div >
< / div >
< div id = "outline-container-org1177029" class = "outline-3" >
< h3 id = "org1177029" > < span class = "section-number-3" > 3.2< / span > Compliance< / h3 >
< div class = "outline-text-3" id = "text-3-2" >
< div class = "org-src-container" >
< pre class = "src src-matlab" > < span class = "org-matlab-cellbreak" > < span class = "org-comment" > %% Options for Linearized< / span > < / span >
options = linearizeOptions;
options.SampleTime = 0;
< span class = "org-matlab-cellbreak" > < span class = "org-comment" > %% Name of the Simulink File< / span > < / span >
mdl = < span class = "org-string" > 'stewart_platform_model'< / span > ;
< span class = "org-matlab-cellbreak" > < span class = "org-comment" > %% Input/Output definition< / span > < / span >
clear io; io_i = 1;
io(io_i) = linio([mdl, < span class = "org-string" > '/Disturbances/F_ext'< / span > ], 1, < span class = "org-string" > 'openinput'< / span > ); io_i = io_i < span class = "org-type" > +< / span > 1; < span class = "org-comment" > % Base Motion [m, rad]< / span >
io(io_i) = linio([mdl, < span class = "org-string" > '/Absolute Motion Sensor'< / span > ], 1, < span class = "org-string" > 'openoutput'< / span > ); io_i = io_i < span class = "org-type" > +< / span > 1; < span class = "org-comment" > % Absolute Motion [m, rad]< / span >
< span class = "org-matlab-cellbreak" > < span class = "org-comment" > %% Run the linearization< / span > < / span >
C = linearize(mdl, io, options);
C.InputName = {< span class = "org-string" > 'Fdx'< / span > , < span class = "org-string" > 'Fdy'< / span > , < span class = "org-string" > 'Fdz'< / span > , < span class = "org-string" > 'Mdx'< / span > , < span class = "org-string" > 'Mdy'< / span > , < span class = "org-string" > 'Mdz'< / span > };
C.OutputName = {< span class = "org-string" > 'Edx'< / span > , < span class = "org-string" > 'Edy'< / span > , < span class = "org-string" > 'Edz'< / span > , < span class = "org-string" > 'Erx'< / span > , < span class = "org-string" > 'Ery'< / span > , < span class = "org-string" > 'Erz'< / span > };
< / pre >
< / div >
< div class = "org-src-container" >
< pre class = "src src-matlab" > freqs = logspace(1, 4, 1000);
< span class = "org-type" > figure< / span > ;
< span class = "org-keyword" > for< / span > < span class = "org-variable-name" > ix< / span > = < span class = "org-constant" > 1:6< / span >
< span class = "org-keyword" > for< / span > < span class = "org-variable-name" > iy< / span > = < span class = "org-constant" > 1:6< / span >
subplot(6, 6, (ix< span class = "org-type" > -< / span > 1)< span class = "org-type" > *< / span > 6 < span class = "org-type" > +< / span > iy);
hold on;
plot(freqs, abs(squeeze(freqresp(C(ix, iy), freqs, < span class = "org-string" > 'Hz'< / span > ))), < span class = "org-string" > 'k-'< / span > );
< span class = "org-type" > set< / span > (< span class = "org-variable-name" > gca< / span > , < span class = "org-string" > 'XScale'< / span > , < span class = "org-string" > 'log'< / span > ); < span class = "org-type" > set< / span > (< span class = "org-variable-name" > gca< / span > , < span class = "org-string" > 'YScale'< / span > , < span class = "org-string" > 'log'< / span > );
ylim([1e< span class = "org-type" > -< / span > 10, 1e< span class = "org-type" > -< / span > 3]);
xlim([freqs(1), freqs(end)]);
< span class = "org-keyword" > if< / span > ix < span class = "org-type" > < < / span > 6
xticklabels({});
< span class = "org-keyword" > end< / span >
< span class = "org-keyword" > if< / span > iy < span class = "org-type" > > < / span > 1
yticklabels({});
< span class = "org-keyword" > end< / span >
< span class = "org-keyword" > end< / span >
< span class = "org-keyword" > end< / span >
< / pre >
< / div >
< p >
We can try to use the Frobenius norm to obtain a scalar value representing the 6-dof compliance of the Stewart platform.
< / p >
< div class = "org-src-container" >
< pre class = "src src-matlab" > freqs = logspace(1, 4, 1000);
C_norm = zeros(length(freqs), 1);
< span class = "org-keyword" > for< / span > < span class = "org-variable-name" > < span class = "org-constant" > i< / span > < / span > = < span class = "org-constant" > 1:length(freqs)< / span >
C_norm(< span class = "org-constant" > i< / span > ) = sqrt(trace(freqresp(C, freqs(< span class = "org-constant" > i< / span > ), < span class = "org-string" > 'Hz'< / span > )< span class = "org-type" > *< / span > freqresp(C, freqs(< span class = "org-constant" > i< / span > ), < span class = "org-string" > 'Hz'< / span > )< span class = "org-type" > '< / span > ));
< span class = "org-keyword" > end< / span >
< / pre >
< / div >
< div class = "org-src-container" >
< pre class = "src src-matlab" > < span class = "org-type" > figure< / span > ;
plot(freqs, C_norm)
< span class = "org-type" > set< / span > (< span class = "org-variable-name" > gca< / span > , < span class = "org-string" > 'XScale'< / span > , < span class = "org-string" > 'log'< / span > ); < span class = "org-type" > set< / span > (< span class = "org-variable-name" > gca< / span > , < span class = "org-string" > 'YScale'< / span > , < span class = "org-string" > 'log'< / span > );
< / pre >
< / div >
< / div >
< / div >
< / div >
< div id = "outline-container-org68ca336" class = "outline-2" >
< h2 id = "org68ca336" > < span class = "section-number-2" > 4< / span > Functions< / h2 >
< div class = "outline-text-2" id = "text-4" >
< / div >
< div id = "outline-container-org487c4d4" class = "outline-3" >
< h3 id = "org487c4d4" > < span class = "section-number-3" > 4.1< / span > Compute the Transmissibility< / h3 >
< div class = "outline-text-3" id = "text-4-1" >
< p >
< a id = "orgbca579c" > < / a >
< / p >
< / div >
2020-03-03 15:53:02 +01:00
< div id = "outline-container-org3cf1d13" class = "outline-4" >
< h4 id = "org3cf1d13" > Function description< / h4 >
< div class = "outline-text-4" id = "text-org3cf1d13" >
2020-02-27 14:23:09 +01:00
< div class = "org-src-container" >
< pre class = "src src-matlab" > < span class = "org-keyword" > function< / span > < span class = "org-variable-name" > [T, T_norm, freqs]< / span > = < span class = "org-function-name" > computeTransmissibility< / span > (< span class = "org-variable-name" > args< / span > )
< span class = "org-comment" > % computeTransmissibility -< / span >
< span class = "org-comment" > %< / span >
< span class = "org-comment" > % Syntax: [T, T_norm, freqs] = computeTransmissibility(args)< / span >
< span class = "org-comment" > %< / span >
< span class = "org-comment" > % Inputs:< / span >
< span class = "org-comment" > % - args - Structure with the following fields:< / span >
< span class = "org-comment" > % - plots [true/false] - Should plot the transmissilibty matrix and its Frobenius norm< / span >
< span class = "org-comment" > % - freqs [] - Frequency vector to estimate the Frobenius norm< / span >
< span class = "org-comment" > %< / span >
< span class = "org-comment" > % Outputs:< / span >
< span class = "org-comment" > % - T [6x6 ss] - Transmissibility matrix< / span >
< span class = "org-comment" > % - T_norm [length(freqs)x1] - Frobenius norm of the Transmissibility matrix< / span >
< span class = "org-comment" > % - freqs [length(freqs)x1] - Frequency vector in [Hz]< / span >
< / pre >
< / div >
< / div >
< / div >
2020-03-03 15:53:02 +01:00
< div id = "outline-container-org726b57d" class = "outline-4" >
< h4 id = "org726b57d" > Optional Parameters< / h4 >
< div class = "outline-text-4" id = "text-org726b57d" >
2020-02-27 14:23:09 +01:00
< div class = "org-src-container" >
< pre class = "src src-matlab" > arguments
args.plots logical {mustBeNumericOrLogical} = < span class = "org-constant" > false< / span >
args.freqs double {mustBeNumeric, mustBeNonnegative} = logspace(1,4,1000)
< span class = "org-keyword" > end< / span >
< / pre >
< / div >
< div class = "org-src-container" >
< pre class = "src src-matlab" > freqs = args.freqs;
< / pre >
< / div >
< / div >
< / div >
< div id = "outline-container-org4629501" class = "outline-4" >
< h4 id = "org4629501" > Identification of the Transmissibility Matrix< / h4 >
< div class = "outline-text-4" id = "text-org4629501" >
< div class = "org-src-container" >
< pre class = "src src-matlab" > < span class = "org-matlab-cellbreak" > < span class = "org-comment" > %% Options for Linearized< / span > < / span >
options = linearizeOptions;
options.SampleTime = 0;
< span class = "org-matlab-cellbreak" > < span class = "org-comment" > %% Name of the Simulink File< / span > < / span >
mdl = < span class = "org-string" > 'stewart_platform_model'< / span > ;
< span class = "org-matlab-cellbreak" > < span class = "org-comment" > %% Input/Output definition< / span > < / span >
clear io; io_i = 1;
io(io_i) = linio([mdl, < span class = "org-string" > '/Disturbances/D_w'< / span > ], 1, < span class = "org-string" > 'openinput'< / span > ); io_i = io_i < span class = "org-type" > +< / span > 1; < span class = "org-comment" > % Base Motion [m, rad]< / span >
2020-02-28 17:35:44 +01:00
io(io_i) = linio([mdl, < span class = "org-string" > '/Absolute Motion Sensor'< / span > ], 1, < span class = "org-string" > 'output'< / span > ); io_i = io_i < span class = "org-type" > +< / span > 1; < span class = "org-comment" > % Absolute Motion [m, rad]< / span >
2020-02-27 14:23:09 +01:00
< span class = "org-matlab-cellbreak" > < span class = "org-comment" > %% Run the linearization< / span > < / span >
T = linearize(mdl, io, options);
T.InputName = {< span class = "org-string" > 'Wdx'< / span > , < span class = "org-string" > 'Wdy'< / span > , < span class = "org-string" > 'Wdz'< / span > , < span class = "org-string" > 'Wrx'< / span > , < span class = "org-string" > 'Wry'< / span > , < span class = "org-string" > 'Wrz'< / span > };
T.OutputName = {< span class = "org-string" > 'Edx'< / span > , < span class = "org-string" > 'Edy'< / span > , < span class = "org-string" > 'Edz'< / span > , < span class = "org-string" > 'Erx'< / span > , < span class = "org-string" > 'Ery'< / span > , < span class = "org-string" > 'Erz'< / span > };
< / pre >
< / div >
< p >
If wanted, the 6x6 transmissibility matrix is plotted.
< / p >
< div class = "org-src-container" >
< pre class = "src src-matlab" > p_handle = zeros(6< span class = "org-type" > *< / span > 6,1);
< span class = "org-keyword" > if< / span > args.plots
fig = < span class = "org-type" > figure< / span > ;
< span class = "org-keyword" > for< / span > < span class = "org-variable-name" > ix< / span > = < span class = "org-constant" > 1:6< / span >
< span class = "org-keyword" > for< / span > < span class = "org-variable-name" > iy< / span > = < span class = "org-constant" > 1:6< / span >
p_handle((ix< span class = "org-type" > -< / span > 1)< span class = "org-type" > *< / span > 6 < span class = "org-type" > +< / span > iy) = subplot(6, 6, (ix< span class = "org-type" > -< / span > 1)< span class = "org-type" > *< / span > 6 < span class = "org-type" > +< / span > iy);
hold on;
plot(freqs, abs(squeeze(freqresp(T(ix, iy), freqs, < span class = "org-string" > 'Hz'< / span > ))), < span class = "org-string" > 'k-'< / span > );
< span class = "org-type" > set< / span > (< span class = "org-variable-name" > gca< / span > , < span class = "org-string" > 'XScale'< / span > , < span class = "org-string" > 'log'< / span > ); < span class = "org-type" > set< / span > (< span class = "org-variable-name" > gca< / span > , < span class = "org-string" > 'YScale'< / span > , < span class = "org-string" > 'log'< / span > );
< span class = "org-keyword" > if< / span > ix < span class = "org-type" > < < / span > 6
xticklabels({});
< span class = "org-keyword" > end< / span >
< span class = "org-keyword" > if< / span > iy < span class = "org-type" > > < / span > 1
yticklabels({});
< span class = "org-keyword" > end< / span >
< span class = "org-keyword" > end< / span >
< span class = "org-keyword" > end< / span >
linkaxes(p_handle, < span class = "org-string" > 'xy'< / span > )
xlim([freqs(1), freqs(end)]);
ylim([1e< span class = "org-type" > -< / span > 5, 1e2]);
han = < span class = "org-type" > axes< / span > (fig, < span class = "org-string" > 'visible'< / span > , < span class = "org-string" > 'off'< / span > );
han.XLabel.Visible = < span class = "org-string" > 'on'< / span > ;
han.YLabel.Visible = < span class = "org-string" > 'on'< / span > ;
2020-02-28 17:35:44 +01:00
xlabel(han, < span class = "org-string" > 'Frequency [Hz]'< / span > );
ylabel(han, < span class = "org-string" > 'Transmissibility [m/m]'< / span > );
2020-02-27 14:23:09 +01:00
< span class = "org-keyword" > end< / span >
< / pre >
< / div >
< / div >
< / div >
2020-03-03 15:53:02 +01:00
< div id = "outline-container-org1019eaf" class = "outline-4" >
< h4 id = "org1019eaf" > Computation of the Frobenius norm< / h4 >
< div class = "outline-text-4" id = "text-org1019eaf" >
2020-02-27 14:23:09 +01:00
< div class = "org-src-container" >
< pre class = "src src-matlab" > T_norm = zeros(length(freqs), 1);
< span class = "org-keyword" > for< / span > < span class = "org-variable-name" > < span class = "org-constant" > i< / span > < / span > = < span class = "org-constant" > 1:length(freqs)< / span >
T_norm(< span class = "org-constant" > i< / span > ) = sqrt(trace(freqresp(T, freqs(< span class = "org-constant" > i< / span > ), < span class = "org-string" > 'Hz'< / span > )< span class = "org-type" > *< / span > freqresp(T, freqs(< span class = "org-constant" > i< / span > ), < span class = "org-string" > 'Hz'< / span > )< span class = "org-type" > '< / span > ));
< span class = "org-keyword" > end< / span >
< / pre >
< / div >
< div class = "org-src-container" >
< pre class = "src src-matlab" > T_norm = T_norm< span class = "org-type" > /< / span > sqrt(6);
< / pre >
< / div >
< div class = "org-src-container" >
< pre class = "src src-matlab" > < span class = "org-keyword" > if< / span > args.plots
< span class = "org-type" > figure< / span > ;
plot(freqs, T_norm)
< span class = "org-type" > set< / span > (< span class = "org-variable-name" > gca< / span > , < span class = "org-string" > 'XScale'< / span > , < span class = "org-string" > 'log'< / span > ); < span class = "org-type" > set< / span > (< span class = "org-variable-name" > gca< / span > , < span class = "org-string" > 'YScale'< / span > , < span class = "org-string" > 'log'< / span > );
xlabel(< span class = "org-string" > 'Frequency [Hz]'< / span > );
ylabel(< span class = "org-string" > 'Transmissibility - Frobenius Norm'< / span > );
< span class = "org-keyword" > end< / span >
< / pre >
< / div >
< / div >
< / div >
< / div >
< div id = "outline-container-org50e35a6" class = "outline-3" >
< h3 id = "org50e35a6" > < span class = "section-number-3" > 4.2< / span > Compute the Compliance< / h3 >
< div class = "outline-text-3" id = "text-4-2" >
< p >
< a id = "org0a73574" > < / a >
< / p >
< / div >
2020-03-03 15:53:02 +01:00
< div id = "outline-container-orgf1e6c32" class = "outline-4" >
< h4 id = "orgf1e6c32" > Function description< / h4 >
< div class = "outline-text-4" id = "text-orgf1e6c32" >
2020-02-27 14:23:09 +01:00
< div class = "org-src-container" >
< pre class = "src src-matlab" > < span class = "org-keyword" > function< / span > < span class = "org-variable-name" > [C, C_norm, freqs]< / span > = < span class = "org-function-name" > computeCompliance< / span > (< span class = "org-variable-name" > args< / span > )
< span class = "org-comment" > % computeCompliance -< / span >
< span class = "org-comment" > %< / span >
< span class = "org-comment" > % Syntax: [C, C_norm, freqs] = computeCompliance(args)< / span >
< span class = "org-comment" > %< / span >
< span class = "org-comment" > % Inputs:< / span >
< span class = "org-comment" > % - args - Structure with the following fields:< / span >
< span class = "org-comment" > % - plots [true/false] - Should plot the transmissilibty matrix and its Frobenius norm< / span >
< span class = "org-comment" > % - freqs [] - Frequency vector to estimate the Frobenius norm< / span >
< span class = "org-comment" > %< / span >
< span class = "org-comment" > % Outputs:< / span >
< span class = "org-comment" > % - C [6x6 ss] - Compliance matrix< / span >
< span class = "org-comment" > % - C_norm [length(freqs)x1] - Frobenius norm of the Compliance matrix< / span >
< span class = "org-comment" > % - freqs [length(freqs)x1] - Frequency vector in [Hz]< / span >
< / pre >
< / div >
< / div >
< / div >
2020-03-03 15:53:02 +01:00
< div id = "outline-container-orgda14a2f" class = "outline-4" >
< h4 id = "orgda14a2f" > Optional Parameters< / h4 >
< div class = "outline-text-4" id = "text-orgda14a2f" >
2020-02-27 14:23:09 +01:00
< div class = "org-src-container" >
< pre class = "src src-matlab" > arguments
args.plots logical {mustBeNumericOrLogical} = < span class = "org-constant" > false< / span >
args.freqs double {mustBeNumeric, mustBeNonnegative} = logspace(1,4,1000)
< span class = "org-keyword" > end< / span >
< / pre >
< / div >
< div class = "org-src-container" >
< pre class = "src src-matlab" > freqs = args.freqs;
< / pre >
< / div >
< / div >
< / div >
< div id = "outline-container-orgef06b63" class = "outline-4" >
< h4 id = "orgef06b63" > Identification of the Compliance Matrix< / h4 >
< div class = "outline-text-4" id = "text-orgef06b63" >
< div class = "org-src-container" >
< pre class = "src src-matlab" > < span class = "org-matlab-cellbreak" > < span class = "org-comment" > %% Options for Linearized< / span > < / span >
options = linearizeOptions;
options.SampleTime = 0;
< span class = "org-matlab-cellbreak" > < span class = "org-comment" > %% Name of the Simulink File< / span > < / span >
mdl = < span class = "org-string" > 'stewart_platform_model'< / span > ;
< span class = "org-matlab-cellbreak" > < span class = "org-comment" > %% Input/Output definition< / span > < / span >
clear io; io_i = 1;
io(io_i) = linio([mdl, < span class = "org-string" > '/Disturbances/F_ext'< / span > ], 1, < span class = "org-string" > 'openinput'< / span > ); io_i = io_i < span class = "org-type" > +< / span > 1; < span class = "org-comment" > % External forces [N, N*m]< / span >
2020-02-28 17:35:44 +01:00
io(io_i) = linio([mdl, < span class = "org-string" > '/Absolute Motion Sensor'< / span > ], 1, < span class = "org-string" > 'output'< / span > ); io_i = io_i < span class = "org-type" > +< / span > 1; < span class = "org-comment" > % Absolute Motion [m, rad]< / span >
2020-02-27 14:23:09 +01:00
< span class = "org-matlab-cellbreak" > < span class = "org-comment" > %% Run the linearization< / span > < / span >
C = linearize(mdl, io, options);
C.InputName = {< span class = "org-string" > 'Fdx'< / span > , < span class = "org-string" > 'Fdy'< / span > , < span class = "org-string" > 'Fdz'< / span > , < span class = "org-string" > 'Mdx'< / span > , < span class = "org-string" > 'Mdy'< / span > , < span class = "org-string" > 'Mdz'< / span > };
C.OutputName = {< span class = "org-string" > 'Edx'< / span > , < span class = "org-string" > 'Edy'< / span > , < span class = "org-string" > 'Edz'< / span > , < span class = "org-string" > 'Erx'< / span > , < span class = "org-string" > 'Ery'< / span > , < span class = "org-string" > 'Erz'< / span > };
< / pre >
< / div >
< p >
If wanted, the 6x6 transmissibility matrix is plotted.
< / p >
< div class = "org-src-container" >
< pre class = "src src-matlab" > p_handle = zeros(6< span class = "org-type" > *< / span > 6,1);
< span class = "org-keyword" > if< / span > args.plots
fig = < span class = "org-type" > figure< / span > ;
< span class = "org-keyword" > for< / span > < span class = "org-variable-name" > ix< / span > = < span class = "org-constant" > 1:6< / span >
< span class = "org-keyword" > for< / span > < span class = "org-variable-name" > iy< / span > = < span class = "org-constant" > 1:6< / span >
p_handle((ix< span class = "org-type" > -< / span > 1)< span class = "org-type" > *< / span > 6 < span class = "org-type" > +< / span > iy) = subplot(6, 6, (ix< span class = "org-type" > -< / span > 1)< span class = "org-type" > *< / span > 6 < span class = "org-type" > +< / span > iy);
hold on;
plot(freqs, abs(squeeze(freqresp(C(ix, iy), freqs, < span class = "org-string" > 'Hz'< / span > ))), < span class = "org-string" > 'k-'< / span > );
< span class = "org-type" > set< / span > (< span class = "org-variable-name" > gca< / span > , < span class = "org-string" > 'XScale'< / span > , < span class = "org-string" > 'log'< / span > ); < span class = "org-type" > set< / span > (< span class = "org-variable-name" > gca< / span > , < span class = "org-string" > 'YScale'< / span > , < span class = "org-string" > 'log'< / span > );
< span class = "org-keyword" > if< / span > ix < span class = "org-type" > < < / span > 6
xticklabels({});
< span class = "org-keyword" > end< / span >
< span class = "org-keyword" > if< / span > iy < span class = "org-type" > > < / span > 1
yticklabels({});
< span class = "org-keyword" > end< / span >
< span class = "org-keyword" > end< / span >
< span class = "org-keyword" > end< / span >
linkaxes(p_handle, < span class = "org-string" > 'xy'< / span > )
xlim([freqs(1), freqs(end)]);
han = < span class = "org-type" > axes< / span > (fig, < span class = "org-string" > 'visible'< / span > , < span class = "org-string" > 'off'< / span > );
han.XLabel.Visible = < span class = "org-string" > 'on'< / span > ;
han.YLabel.Visible = < span class = "org-string" > 'on'< / span > ;
xlabel(han, < span class = "org-string" > 'Frequency [Hz]'< / span > );
ylabel(han, < span class = "org-string" > 'Compliance [m/N, rad/(N*m)]'< / span > );
< span class = "org-keyword" > end< / span >
< / pre >
< / div >
< / div >
< / div >
2020-03-03 15:53:02 +01:00
< div id = "outline-container-orgc21ec39" class = "outline-4" >
< h4 id = "orgc21ec39" > Computation of the Frobenius norm< / h4 >
< div class = "outline-text-4" id = "text-orgc21ec39" >
2020-02-27 14:23:09 +01:00
< div class = "org-src-container" >
< pre class = "src src-matlab" > freqs = args.freqs;
C_norm = zeros(length(freqs), 1);
< span class = "org-keyword" > for< / span > < span class = "org-variable-name" > < span class = "org-constant" > i< / span > < / span > = < span class = "org-constant" > 1:length(freqs)< / span >
C_norm(< span class = "org-constant" > i< / span > ) = sqrt(trace(freqresp(C, freqs(< span class = "org-constant" > i< / span > ), < span class = "org-string" > 'Hz'< / span > )< span class = "org-type" > *< / span > freqresp(C, freqs(< span class = "org-constant" > i< / span > ), < span class = "org-string" > 'Hz'< / span > )< span class = "org-type" > '< / span > ));
< span class = "org-keyword" > end< / span >
< / pre >
< / div >
< div class = "org-src-container" >
< pre class = "src src-matlab" > < span class = "org-keyword" > if< / span > args.plots
< span class = "org-type" > figure< / span > ;
plot(freqs, C_norm)
< span class = "org-type" > set< / span > (< span class = "org-variable-name" > gca< / span > , < span class = "org-string" > 'XScale'< / span > , < span class = "org-string" > 'log'< / span > ); < span class = "org-type" > set< / span > (< span class = "org-variable-name" > gca< / span > , < span class = "org-string" > 'YScale'< / span > , < span class = "org-string" > 'log'< / span > );
xlabel(< span class = "org-string" > 'Frequency [Hz]'< / span > );
ylabel(< span class = "org-string" > 'Compliance - Frobenius Norm'< / span > );
< span class = "org-keyword" > end< / span >
< / pre >
< / div >
< / div >
< / div >
< / div >
< / div >
2019-03-22 12:03:59 +01:00
< / div >
< div id = "postamble" class = "status" >
2020-01-29 17:52:04 +01:00
< p class = "author" > Author: Dehaeze Thomas< / p >
2020-03-03 15:53:02 +01:00
< p class = "date" > Created: 2020-03-02 lun. 17:57< / p >
2019-03-22 12:03:59 +01:00
< / div >
< / body >
< / html >
