tdehaeze/stewart-simscape
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Compare commits

base: tdehaeze:36b236958a04e76cf78d1bb791b92c6737ed4b53
Branches Tags
tdehaeze:master
...
compare: tdehaeze:ebb928b8900196c629388f98e5bdf9027c04b83f
Branches Tags
tdehaeze:master

4 Commits
36b236958a ... ebb928b890

Author SHA1 Message Date
Thomas Dehaeze
ebb928b890 Update doc 2020-08-05 13:28:14 +02:00
Thomas Dehaeze
08f3f2faea Study: estimation of the required joint stroke 2020-08-05 13:27:08 +02:00
Thomas Dehaeze
fbabac3c5c Minor update of header 2020-08-05 13:26:06 +02:00
Thomas Dehaeze
c330fe9475 Add flexible elements analysis 2020-08-05 13:25:24 +02:00
43 changed files with 13230 additions and 5352 deletions
Show Stats Expand all files Collapse all files

687
docs/bibliography.html
View File

File diff suppressed because it is too large Load Diff

441
docs/control-active-damping.html
View File

@ -1,240 +1,27 @@
<?xml version="1.0" encoding="utf-8"?> <?xml version="1.0" encoding="utf-8"?>
<?xml version="1.0" encoding="utf-8"?>
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"> "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en"> <html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en">
<head> <head>
<!-- 2020-03-13 ven. 10:34 --> <!-- 2020-08-05 mer. 13:27 -->
<meta http-equiv="Content-Type" content="text/html;charset=utf-8" /> <meta http-equiv="Content-Type" content="text/html;charset=utf-8" />
<meta name="viewport" content="width=device-width, initial-scale=1" />
<title>Stewart Platform - Decentralized Active Damping</title> <title>Stewart Platform - Decentralized Active Damping</title>
<meta name="generator" content="Org mode" /> <meta name="generator" content="Org mode" />
<meta name="author" content="Dehaeze Thomas" /> <meta name="author" content="Dehaeze Thomas" />
<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>
<link rel="stylesheet" type="text/css" href="./css/htmlize.css"/> <link rel="stylesheet" type="text/css" href="./css/htmlize.css"/>
<link rel="stylesheet" type="text/css" href="./css/readtheorg.css"/> <link rel="stylesheet" type="text/css" href="./css/readtheorg.css"/>
<script src="./js/jquery.min.js"></script> <script src="./js/jquery.min.js"></script>
<script src="./js/bootstrap.min.js"></script> <script src="./js/bootstrap.min.js"></script>
<script src="./js/jquery.stickytableheaders.min.js"></script> <script src="./js/jquery.stickytableheaders.min.js"></script>
<script src="./js/readtheorg.js"></script> <script src="./js/readtheorg.js"></script>
<script type="text/javascript"> <script>MathJax = {
// @license magnet:?xt=urn:btih:1f739d935676111cfff4b4693e3816e664797050&dn=gpl-3.0.txt GPL-v3-or-Later tex: {
<!--/*--><![CDATA[/*><!--*/ tags: 'ams',
function CodeHighlightOn(elem, id) macros: {bm: ["\\boldsymbol{#1}",1],}
{
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
</script>
<script>
MathJax = {
tex: { macros: {
bm: ["\\boldsymbol{#1}",1],
}
} }
}; };
</script> </script>
<script type="text/javascript" <script type="text/javascript" src="https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js"></script>
src="https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js"></script>
</head> </head>
<body> <body>
<div id="org-div-home-and-up"> <div id="org-div-home-and-up">
@ -250,25 +37,25 @@
<li><a href="#orgc22d5d6">1. Inertial Control</a> <li><a href="#orgc22d5d6">1. Inertial Control</a>
<ul> <ul>
<li><a href="#org1671c0b">1.1. Identification of the Dynamics</a></li> <li><a href="#org1671c0b">1.1. Identification of the Dynamics</a></li>
<li><a href="#org89b6ab8">1.2. Effect of the Flexible Joint stiffness and Actuator amplification on the Dynamics</a></li> <li><a href="#orgdae44ba">1.2. Effect of the Flexible Joint stiffness and Actuator amplification on the Dynamics</a></li>
<li><a href="#orgf4665ef">1.3. Obtained Damping</a></li> <li><a href="#org89e2002">1.3. Obtained Damping</a></li>
<li><a href="#orgf2dd409">1.4. Conclusion</a></li> <li><a href="#org3904320">1.4. Conclusion</a></li>
</ul> </ul>
</li> </li>
<li><a href="#org89e426a">2. Integral Force Feedback</a> <li><a href="#org89e426a">2. Integral Force Feedback</a>
<ul> <ul>
<li><a href="#orgbcaaa33">2.1. Identification of the Dynamics with perfect Joints</a></li> <li><a href="#orgcb85703">2.1. Identification of the Dynamics with perfect Joints</a></li>
<li><a href="#org422d0e7">2.2. Effect of the Flexible Joint stiffness and Actuator amplification on the Dynamics</a></li> <li><a href="#org4ca24f7">2.2. Effect of the Flexible Joint stiffness and Actuator amplification on the Dynamics</a></li>
<li><a href="#orgbf1f2d6">2.3. Obtained Damping</a></li> <li><a href="#org11e5ee2">2.3. Obtained Damping</a></li>
<li><a href="#orgb9ae491">2.4. Conclusion</a></li> <li><a href="#orgca67baa">2.4. Conclusion</a></li>
</ul> </ul>
</li> </li>
<li><a href="#org47a29be">3. Direct Velocity Feedback</a> <li><a href="#org47a29be">3. Direct Velocity Feedback</a>
<ul> <ul>
<li><a href="#orge88ed78">3.1. Identification of the Dynamics with perfect Joints</a></li> <li><a href="#orgc82a6a7">3.1. Identification of the Dynamics with perfect Joints</a></li>
<li><a href="#org8ebebbc">3.2. Effect of the Flexible Joint stiffness and Actuator amplification on the Dynamics</a></li> <li><a href="#org92d6cb1">3.2. Effect of the Flexible Joint stiffness and Actuator amplification on the Dynamics</a></li>
<li><a href="#org9dac8fd">3.3. Obtained Damping</a></li> <li><a href="#org7497409">3.3. Obtained Damping</a></li>
<li><a href="#org8c078af">3.4. Conclusion</a></li> <li><a href="#org61c422b">3.4. Conclusion</a></li>
</ul> </ul>
</li> </li>
<li><a href="#orgc84bb75">4. Compliance and Transmissibility Comparison</a> <li><a href="#orgc84bb75">4. Compliance and Transmissibility Comparison</a>
@ -315,43 +102,43 @@ To run the script, open the Simulink Project, and type <code>run active_damping_
<div class="outline-text-3" id="text-1-1"> <div class="outline-text-3" id="text-1-1">
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab">stewart = initializeStewartPlatform(); <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 = initializeFramesPositions(stewart, 'H', 90e-3, 'MO_B', 45e-3);
stewart = generateGeneralConfiguration(stewart); stewart = generateGeneralConfiguration(stewart);
stewart = computeJointsPose(stewart); stewart = computeJointsPose(stewart);
stewart = initializeStrutDynamics(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 = initializeJointDynamics(stewart, 'type_F', 'universal_p', 'type_M', 'spherical_p');
stewart = initializeCylindricalPlatforms(stewart); stewart = initializeCylindricalPlatforms(stewart);
stewart = initializeCylindricalStruts(stewart); stewart = initializeCylindricalStruts(stewart);
stewart = computeJacobian(stewart); stewart = computeJacobian(stewart);
stewart = initializeStewartPose(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); stewart = initializeInertialSensor(stewart, 'type', 'accelerometer', 'freq', 5e3);
</pre> </pre>
</div> </div>
<div class="org-src-container"> <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); <pre class="src src-matlab">ground = initializeGround('type', 'rigid', 'rot_point', stewart.platform_F.FO_A);
payload = initializePayload(<span class="org-string">'type'</span>, <span class="org-string">'none'</span>); payload = initializePayload('type', 'none');
controller = initializeController(<span class="org-string">'type'</span>, <span class="org-string">'open-loop'</span>); controller = initializeController('type', 'open-loop');
</pre> </pre>
</div> </div>
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab"><span class="org-matlab-cellbreak"><span class="org-comment">%% Options for Linearized</span></span> <pre class="src src-matlab">%% Options for Linearized
options = linearizeOptions; options = linearizeOptions;
options.SampleTime = 0; options.SampleTime = 0;
<span class="org-matlab-cellbreak"><span class="org-comment">%% Name of the Simulink File</span></span> %% Name of the Simulink File
mdl = <span class="org-string">'stewart_platform_model'</span>; mdl = 'stewart_platform_model';
<span class="org-matlab-cellbreak"><span class="org-comment">%% Input/Output definition</span></span> %% Input/Output definition
clear io; io_i = 1; clear io; io_i = 1;
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, '/Controller'], 1, 'openinput'); io_i = io_i + 1; % Actuator Force Inputs [N]
io(io_i) = linio([mdl, <span class="org-string">'/Stewart Platform'</span>], 1, <span class="org-string">'openoutput'</span>, [], <span class="org-string">'Vm'</span>); io_i = io_i <span class="org-type">+</span> 1; <span class="org-comment">% Absolute velocity of each leg [m/s]</span> io(io_i) = linio([mdl, '/Stewart Platform'], 1, 'openoutput', [], 'Vm'); io_i = io_i + 1; % Absolute velocity of each leg [m/s]
<span class="org-matlab-cellbreak"><span class="org-comment">%% Run the linearization</span></span> %% Run the linearization
G = linearize(mdl, io, options); G = linearize(mdl, io, options);
G.InputName = {<span class="org-string">'F1'</span>, <span class="org-string">'F2'</span>, <span class="org-string">'F3'</span>, <span class="org-string">'F4'</span>, <span class="org-string">'F5'</span>, <span class="org-string">'F6'</span>}; G.InputName = {'F1', 'F2', 'F3', 'F4', 'F5', 'F6'};
G.OutputName = {<span class="org-string">'Vm1'</span>, <span class="org-string">'Vm2'</span>, <span class="org-string">'Vm3'</span>, <span class="org-string">'Vm4'</span>, <span class="org-string">'Vm5'</span>, <span class="org-string">'Vm6'</span>}; G.OutputName = {'Vm1', 'Vm2', 'Vm3', 'Vm4', 'Vm5', 'Vm6'};
</pre> </pre>
</div> </div>
@ -367,17 +154,17 @@ The transfer function from actuator forces to force sensors is shown in Figure <
</div> </div>
</div> </div>
<div id="outline-container-org89b6ab8" class="outline-3"> <div id="outline-container-orgdae44ba" class="outline-3">
<h3 id="org89b6ab8"><span class="section-number-3">1.2</span> Effect of the Flexible Joint stiffness and Actuator amplification on the Dynamics</h3> <h3 id="orgdae44ba"><span class="section-number-3">1.2</span> Effect of the Flexible Joint stiffness and Actuator amplification on the Dynamics</h3>
<div class="outline-text-3" id="text-1-2"> <div class="outline-text-3" id="text-1-2">
<p> <p>
We add some stiffness and damping in the flexible joints and we re-identify the dynamics. We add some stiffness and damping in the flexible joints and we re-identify the dynamics.
</p> </p>
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab">stewart = initializeJointDynamics(stewart, <span class="org-string">'type_F'</span>, <span class="org-string">'universal'</span>, <span class="org-string">'type_M'</span>, <span class="org-string">'spherical'</span>); <pre class="src src-matlab">stewart = initializeJointDynamics(stewart, 'type_F', 'universal', 'type_M', 'spherical');
Gf = linearize(mdl, io, options); Gf = linearize(mdl, io, options);
Gf.InputName = {<span class="org-string">'F1'</span>, <span class="org-string">'F2'</span>, <span class="org-string">'F3'</span>, <span class="org-string">'F4'</span>, <span class="org-string">'F5'</span>, <span class="org-string">'F6'</span>}; Gf.InputName = {'F1', 'F2', 'F3', 'F4', 'F5', 'F6'};
Gf.OutputName = {<span class="org-string">'Vm1'</span>, <span class="org-string">'Vm2'</span>, <span class="org-string">'Vm3'</span>, <span class="org-string">'Vm4'</span>, <span class="org-string">'Vm5'</span>, <span class="org-string">'Vm6'</span>}; Gf.OutputName = {'Vm1', 'Vm2', 'Vm3', 'Vm4', 'Vm5', 'Vm6'};
</pre> </pre>
</div> </div>
@ -387,8 +174,8 @@ We now use the amplified actuators and re-identify the dynamics
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab">stewart = initializeAmplifiedStrutDynamics(stewart); <pre class="src src-matlab">stewart = initializeAmplifiedStrutDynamics(stewart);
Ga = linearize(mdl, io, options); Ga = linearize(mdl, io, options);
Ga.InputName = {<span class="org-string">'F1'</span>, <span class="org-string">'F2'</span>, <span class="org-string">'F3'</span>, <span class="org-string">'F4'</span>, <span class="org-string">'F5'</span>, <span class="org-string">'F6'</span>}; Ga.InputName = {'F1', 'F2', 'F3', 'F4', 'F5', 'F6'};
Ga.OutputName = {<span class="org-string">'Vm1'</span>, <span class="org-string">'Vm2'</span>, <span class="org-string">'Vm3'</span>, <span class="org-string">'Vm4'</span>, <span class="org-string">'Vm5'</span>, <span class="org-string">'Vm6'</span>}; Ga.OutputName = {'Vm1', 'Vm2', 'Vm3', 'Vm4', 'Vm5', 'Vm6'};
</pre> </pre>
</div> </div>
@ -404,8 +191,8 @@ The new dynamics from force actuator to force sensor is shown in Figure <a href=
</div> </div>
</div> </div>
<div id="outline-container-orgf4665ef" class="outline-3"> <div id="outline-container-org89e2002" class="outline-3">
<h3 id="orgf4665ef"><span class="section-number-3">1.3</span> Obtained Damping</h3> <h3 id="org89e2002"><span class="section-number-3">1.3</span> Obtained Damping</h3>
<div class="outline-text-3" id="text-1-3"> <div class="outline-text-3" id="text-1-3">
<p> <p>
The control is a performed in a decentralized manner. The control is a performed in a decentralized manner.
@ -430,8 +217,8 @@ The root locus is shown in figure <a href="#org9cabaee">3</a>.
</div> </div>
</div> </div>
<div id="outline-container-orgf2dd409" class="outline-3"> <div id="outline-container-org3904320" class="outline-3">
<h3 id="orgf2dd409"><span class="section-number-3">1.4</span> Conclusion</h3> <h3 id="org3904320"><span class="section-number-3">1.4</span> Conclusion</h3>
<div class="outline-text-3" id="text-1-4"> <div class="outline-text-3" id="text-1-4">
<div class="important"> <div class="important">
<p> <p>
@ -462,31 +249,31 @@ To run the script, open the Simulink Project, and type <code>run active_damping_
</div> </div>
</div> </div>
<div id="outline-container-orgbcaaa33" class="outline-3"> <div id="outline-container-orgcb85703" class="outline-3">
<h3 id="orgbcaaa33"><span class="section-number-3">2.1</span> Identification of the Dynamics with perfect Joints</h3> <h3 id="orgcb85703"><span class="section-number-3">2.1</span> Identification of the Dynamics with perfect Joints</h3>
<div class="outline-text-3" id="text-2-1"> <div class="outline-text-3" id="text-2-1">
<p> <p>
We first initialize the Stewart platform without joint stiffness. We first initialize the Stewart platform without joint stiffness.
</p> </p>
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab">stewart = initializeStewartPlatform(); <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 = initializeFramesPositions(stewart, 'H', 90e-3, 'MO_B', 45e-3);
stewart = generateGeneralConfiguration(stewart); stewart = generateGeneralConfiguration(stewart);
stewart = computeJointsPose(stewart); stewart = computeJointsPose(stewart);
stewart = initializeStrutDynamics(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 = initializeJointDynamics(stewart, 'type_F', 'universal_p', 'type_M', 'spherical_p');
stewart = initializeCylindricalPlatforms(stewart); stewart = initializeCylindricalPlatforms(stewart);
stewart = initializeCylindricalStruts(stewart); stewart = initializeCylindricalStruts(stewart);
stewart = computeJacobian(stewart); stewart = computeJacobian(stewart);
stewart = initializeStewartPose(stewart); stewart = initializeStewartPose(stewart);
stewart = initializeInertialSensor(stewart, <span class="org-string">'type'</span>, <span class="org-string">'none'</span>); stewart = initializeInertialSensor(stewart, 'type', 'none');
</pre> </pre>
</div> </div>
<div class="org-src-container"> <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); <pre class="src src-matlab">ground = initializeGround('type', 'rigid', 'rot_point', stewart.platform_F.FO_A);
payload = initializePayload(<span class="org-string">'type'</span>, <span class="org-string">'none'</span>); payload = initializePayload('type', 'none');
controller = initializeController(<span class="org-string">'type'</span>, <span class="org-string">'open-loop'</span>); controller = initializeController('type', 'open-loop');
</pre> </pre>
</div> </div>
@ -494,18 +281,18 @@ controller = initializeController(<span class="org-string">'type'</span>, <span
And we identify the dynamics from force actuators to force sensors. And we identify the dynamics from force actuators to force sensors.
</p> </p>
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab"><span class="org-matlab-cellbreak"><span class="org-comment">%% Name of the Simulink File</span></span> <pre class="src src-matlab">%% Name of the Simulink File
mdl = <span class="org-string">'stewart_platform_model'</span>; mdl = 'stewart_platform_model';
<span class="org-matlab-cellbreak"><span class="org-comment">%% Input/Output definition</span></span> %% Input/Output definition
clear io; io_i = 1; clear io; io_i = 1;
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, '/Controller'], 1, 'openinput'); io_i = io_i + 1; % Actuator Force Inputs [N]
io(io_i) = linio([mdl, <span class="org-string">'/Stewart Platform'</span>], 1, <span class="org-string">'openoutput'</span>, [], <span class="org-string">'Taum'</span>); io_i = io_i <span class="org-type">+</span> 1; <span class="org-comment">% Force Sensor Outputs [N]</span> io(io_i) = linio([mdl, '/Stewart Platform'], 1, 'openoutput', [], 'Taum'); io_i = io_i + 1; % Force Sensor Outputs [N]
<span class="org-matlab-cellbreak"><span class="org-comment">%% Run the linearization</span></span> %% Run the linearization
G = linearize(mdl, io); G = linearize(mdl, io);
G.InputName = {<span class="org-string">'F1'</span>, <span class="org-string">'F2'</span>, <span class="org-string">'F3'</span>, <span class="org-string">'F4'</span>, <span class="org-string">'F5'</span>, <span class="org-string">'F6'</span>}; G.InputName = {'F1', 'F2', 'F3', 'F4', 'F5', 'F6'};
G.OutputName = {<span class="org-string">'Fm1'</span>, <span class="org-string">'Fm2'</span>, <span class="org-string">'Fm3'</span>, <span class="org-string">'Fm4'</span>, <span class="org-string">'Fm5'</span>, <span class="org-string">'Fm6'</span>}; G.OutputName = {'Fm1', 'Fm2', 'Fm3', 'Fm4', 'Fm5', 'Fm6'};
</pre> </pre>
</div> </div>
@ -521,17 +308,17 @@ The transfer function from actuator forces to force sensors is shown in Figure <
</div> </div>
</div> </div>
<div id="outline-container-org422d0e7" class="outline-3"> <div id="outline-container-org4ca24f7" class="outline-3">
<h3 id="org422d0e7"><span class="section-number-3">2.2</span> Effect of the Flexible Joint stiffness and Actuator amplification on the Dynamics</h3> <h3 id="org4ca24f7"><span class="section-number-3">2.2</span> Effect of the Flexible Joint stiffness and Actuator amplification on the Dynamics</h3>
<div class="outline-text-3" id="text-2-2"> <div class="outline-text-3" id="text-2-2">
<p> <p>
We add some stiffness and damping in the flexible joints and we re-identify the dynamics. We add some stiffness and damping in the flexible joints and we re-identify the dynamics.
</p> </p>
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab">stewart = initializeJointDynamics(stewart, <span class="org-string">'type_F'</span>, <span class="org-string">'universal'</span>, <span class="org-string">'type_M'</span>, <span class="org-string">'spherical'</span>); <pre class="src src-matlab">stewart = initializeJointDynamics(stewart, 'type_F', 'universal', 'type_M', 'spherical');
Gf = linearize(mdl, io); Gf = linearize(mdl, io);
Gf.InputName = {<span class="org-string">'F1'</span>, <span class="org-string">'F2'</span>, <span class="org-string">'F3'</span>, <span class="org-string">'F4'</span>, <span class="org-string">'F5'</span>, <span class="org-string">'F6'</span>}; Gf.InputName = {'F1', 'F2', 'F3', 'F4', 'F5', 'F6'};
Gf.OutputName = {<span class="org-string">'Fm1'</span>, <span class="org-string">'Fm2'</span>, <span class="org-string">'Fm3'</span>, <span class="org-string">'Fm4'</span>, <span class="org-string">'Fm5'</span>, <span class="org-string">'Fm6'</span>}; Gf.OutputName = {'Fm1', 'Fm2', 'Fm3', 'Fm4', 'Fm5', 'Fm6'};
</pre> </pre>
</div> </div>
@ -541,8 +328,8 @@ We now use the amplified actuators and re-identify the dynamics
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab">stewart = initializeAmplifiedStrutDynamics(stewart); <pre class="src src-matlab">stewart = initializeAmplifiedStrutDynamics(stewart);
Ga = linearize(mdl, io); Ga = linearize(mdl, io);
Ga.InputName = {<span class="org-string">'F1'</span>, <span class="org-string">'F2'</span>, <span class="org-string">'F3'</span>, <span class="org-string">'F4'</span>, <span class="org-string">'F5'</span>, <span class="org-string">'F6'</span>}; Ga.InputName = {'F1', 'F2', 'F3', 'F4', 'F5', 'F6'};
Ga.OutputName = {<span class="org-string">'Fm1'</span>, <span class="org-string">'Fm2'</span>, <span class="org-string">'Fm3'</span>, <span class="org-string">'Fm4'</span>, <span class="org-string">'Fm5'</span>, <span class="org-string">'Fm6'</span>}; Ga.OutputName = {'Fm1', 'Fm2', 'Fm3', 'Fm4', 'Fm5', 'Fm6'};
</pre> </pre>
</div> </div>
@ -558,8 +345,8 @@ The new dynamics from force actuator to force sensor is shown in Figure <a href=
</div> </div>
</div> </div>
<div id="outline-container-orgbf1f2d6" class="outline-3"> <div id="outline-container-org11e5ee2" class="outline-3">
<h3 id="orgbf1f2d6"><span class="section-number-3">2.3</span> Obtained Damping</h3> <h3 id="org11e5ee2"><span class="section-number-3">2.3</span> Obtained Damping</h3>
<div class="outline-text-3" id="text-2-3"> <div class="outline-text-3" id="text-2-3">
<p> <p>
The control is a performed in a decentralized manner. The control is a performed in a decentralized manner.
@ -591,8 +378,8 @@ The root locus is shown in figure <a href="#orgc8981ba">6</a> and the obtained p
</div> </div>
</div> </div>
<div id="outline-container-orgb9ae491" class="outline-3"> <div id="outline-container-orgca67baa" class="outline-3">
<h3 id="orgb9ae491"><span class="section-number-3">2.4</span> Conclusion</h3> <h3 id="orgca67baa"><span class="section-number-3">2.4</span> Conclusion</h3>
<div class="outline-text-3" id="text-2-4"> <div class="outline-text-3" id="text-2-4">
<div class="important"> <div class="important">
<p> <p>
@ -624,31 +411,31 @@ To run the script, open the Simulink Project, and type <code>run active_damping_
</div> </div>
</div> </div>
<div id="outline-container-orge88ed78" class="outline-3"> <div id="outline-container-orgc82a6a7" class="outline-3">
<h3 id="orge88ed78"><span class="section-number-3">3.1</span> Identification of the Dynamics with perfect Joints</h3> <h3 id="orgc82a6a7"><span class="section-number-3">3.1</span> Identification of the Dynamics with perfect Joints</h3>
<div class="outline-text-3" id="text-3-1"> <div class="outline-text-3" id="text-3-1">
<p> <p>
We first initialize the Stewart platform without joint stiffness. We first initialize the Stewart platform without joint stiffness.
</p> </p>
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab">stewart = initializeStewartPlatform(); <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 = initializeFramesPositions(stewart, 'H', 90e-3, 'MO_B', 45e-3);
stewart = generateGeneralConfiguration(stewart); stewart = generateGeneralConfiguration(stewart);
stewart = computeJointsPose(stewart); stewart = computeJointsPose(stewart);
stewart = initializeStrutDynamics(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 = initializeJointDynamics(stewart, 'type_F', 'universal_p', 'type_M', 'spherical_p');
stewart = initializeCylindricalPlatforms(stewart); stewart = initializeCylindricalPlatforms(stewart);
stewart = initializeCylindricalStruts(stewart); stewart = initializeCylindricalStruts(stewart);
stewart = computeJacobian(stewart); stewart = computeJacobian(stewart);
stewart = initializeStewartPose(stewart); stewart = initializeStewartPose(stewart);
stewart = initializeInertialSensor(stewart, <span class="org-string">'type'</span>, <span class="org-string">'none'</span>); stewart = initializeInertialSensor(stewart, 'type', 'none');
</pre> </pre>
</div> </div>
<div class="org-src-container"> <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); <pre class="src src-matlab">ground = initializeGround('type', 'rigid', 'rot_point', stewart.platform_F.FO_A);
payload = initializePayload(<span class="org-string">'type'</span>, <span class="org-string">'none'</span>); payload = initializePayload('type', 'none');
controller = initializeController(<span class="org-string">'type'</span>, <span class="org-string">'open-loop'</span>); controller = initializeController('type', 'open-loop');
</pre> </pre>
</div> </div>
@ -656,22 +443,22 @@ controller = initializeController(<span class="org-string">'type'</span>, <span
And we identify the dynamics from force actuators to force sensors. And we identify the dynamics from force actuators to force sensors.
</p> </p>
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab"><span class="org-matlab-cellbreak"><span class="org-comment">%% Options for Linearized</span></span> <pre class="src src-matlab">%% Options for Linearized
options = linearizeOptions; options = linearizeOptions;
options.SampleTime = 0; options.SampleTime = 0;
<span class="org-matlab-cellbreak"><span class="org-comment">%% Name of the Simulink File</span></span> %% Name of the Simulink File
mdl = <span class="org-string">'stewart_platform_model'</span>; mdl = 'stewart_platform_model';
<span class="org-matlab-cellbreak"><span class="org-comment">%% Input/Output definition</span></span> %% Input/Output definition
clear io; io_i = 1; clear io; io_i = 1;
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, '/Controller'], 1, 'openinput'); io_i = io_i + 1; % Actuator Force Inputs [N]
io(io_i) = linio([mdl, <span class="org-string">'/Stewart Platform'</span>], 1, <span class="org-string">'openoutput'</span>, [], <span class="org-string">'dLm'</span>); io_i = io_i <span class="org-type">+</span> 1; <span class="org-comment">% Relative Displacement Outputs [m]</span> io(io_i) = linio([mdl, '/Stewart Platform'], 1, 'openoutput', [], 'dLm'); io_i = io_i + 1; % Relative Displacement Outputs [m]
<span class="org-matlab-cellbreak"><span class="org-comment">%% Run the linearization</span></span> %% Run the linearization
G = linearize(mdl, io, options); G = linearize(mdl, io, options);
G.InputName = {<span class="org-string">'F1'</span>, <span class="org-string">'F2'</span>, <span class="org-string">'F3'</span>, <span class="org-string">'F4'</span>, <span class="org-string">'F5'</span>, <span class="org-string">'F6'</span>}; G.InputName = {'F1', 'F2', 'F3', 'F4', 'F5', 'F6'};
G.OutputName = {<span class="org-string">'Dm1'</span>, <span class="org-string">'Dm2'</span>, <span class="org-string">'Dm3'</span>, <span class="org-string">'Dm4'</span>, <span class="org-string">'Dm5'</span>, <span class="org-string">'Dm6'</span>}; G.OutputName = {'Dm1', 'Dm2', 'Dm3', 'Dm4', 'Dm5', 'Dm6'};
</pre> </pre>
</div> </div>
@ -688,17 +475,17 @@ The transfer function from actuator forces to relative motion sensors is shown i
</div> </div>
<div id="outline-container-org8ebebbc" class="outline-3"> <div id="outline-container-org92d6cb1" class="outline-3">
<h3 id="org8ebebbc"><span class="section-number-3">3.2</span> Effect of the Flexible Joint stiffness and Actuator amplification on the Dynamics</h3> <h3 id="org92d6cb1"><span class="section-number-3">3.2</span> Effect of the Flexible Joint stiffness and Actuator amplification on the Dynamics</h3>
<div class="outline-text-3" id="text-3-2"> <div class="outline-text-3" id="text-3-2">
<p> <p>
We add some stiffness and damping in the flexible joints and we re-identify the dynamics. We add some stiffness and damping in the flexible joints and we re-identify the dynamics.
</p> </p>
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab">stewart = initializeJointDynamics(stewart, <span class="org-string">'type_F'</span>, <span class="org-string">'universal'</span>, <span class="org-string">'type_M'</span>, <span class="org-string">'spherical'</span>); <pre class="src src-matlab">stewart = initializeJointDynamics(stewart, 'type_F', 'universal', 'type_M', 'spherical');
Gf = linearize(mdl, io, options); Gf = linearize(mdl, io, options);
Gf.InputName = {<span class="org-string">'F1'</span>, <span class="org-string">'F2'</span>, <span class="org-string">'F3'</span>, <span class="org-string">'F4'</span>, <span class="org-string">'F5'</span>, <span class="org-string">'F6'</span>}; Gf.InputName = {'F1', 'F2', 'F3', 'F4', 'F5', 'F6'};
Gf.OutputName = {<span class="org-string">'Dm1'</span>, <span class="org-string">'Dm2'</span>, <span class="org-string">'Dm3'</span>, <span class="org-string">'Dm4'</span>, <span class="org-string">'Dm5'</span>, <span class="org-string">'Dm6'</span>}; Gf.OutputName = {'Dm1', 'Dm2', 'Dm3', 'Dm4', 'Dm5', 'Dm6'};
</pre> </pre>
</div> </div>
@ -708,8 +495,8 @@ We now use the amplified actuators and re-identify the dynamics
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab">stewart = initializeAmplifiedStrutDynamics(stewart); <pre class="src src-matlab">stewart = initializeAmplifiedStrutDynamics(stewart);
Ga = linearize(mdl, io, options); Ga = linearize(mdl, io, options);
Ga.InputName = {<span class="org-string">'F1'</span>, <span class="org-string">'F2'</span>, <span class="org-string">'F3'</span>, <span class="org-string">'F4'</span>, <span class="org-string">'F5'</span>, <span class="org-string">'F6'</span>}; Ga.InputName = {'F1', 'F2', 'F3', 'F4', 'F5', 'F6'};
Ga.OutputName = {<span class="org-string">'Dm1'</span>, <span class="org-string">'Dm2'</span>, <span class="org-string">'Dm3'</span>, <span class="org-string">'Dm4'</span>, <span class="org-string">'Dm5'</span>, <span class="org-string">'Dm6'</span>}; Ga.OutputName = {'Dm1', 'Dm2', 'Dm3', 'Dm4', 'Dm5', 'Dm6'};
</pre> </pre>
</div> </div>
@ -725,8 +512,8 @@ The new dynamics from force actuator to relative motion sensor is shown in Figur
</div> </div>
</div> </div>
<div id="outline-container-org9dac8fd" class="outline-3"> <div id="outline-container-org7497409" class="outline-3">
<h3 id="org9dac8fd"><span class="section-number-3">3.3</span> Obtained Damping</h3> <h3 id="org7497409"><span class="section-number-3">3.3</span> Obtained Damping</h3>
<div class="outline-text-3" id="text-3-3"> <div class="outline-text-3" id="text-3-3">
<p> <p>
The control is a performed in a decentralized manner. The control is a performed in a decentralized manner.
@ -751,8 +538,8 @@ The root locus is shown in figure <a href="#org5e168d0">10</a>.
</div> </div>
</div> </div>
<div id="outline-container-org8c078af" class="outline-3"> <div id="outline-container-org61c422b" class="outline-3">
<h3 id="org8c078af"><span class="section-number-3">3.4</span> Conclusion</h3> <h3 id="org61c422b"><span class="section-number-3">3.4</span> Conclusion</h3>
<div class="outline-text-3" id="text-3-4"> <div class="outline-text-3" id="text-3-4">
<div class="important"> <div class="important">
<p> <p>
@ -776,16 +563,16 @@ We first initialize the Stewart platform without joint stiffness.
</p> </p>
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab">stewart = initializeStewartPlatform(); <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 = initializeFramesPositions(stewart, 'H', 90e-3, 'MO_B', 45e-3);
stewart = generateGeneralConfiguration(stewart); stewart = generateGeneralConfiguration(stewart);
stewart = computeJointsPose(stewart); stewart = computeJointsPose(stewart);
stewart = initializeStrutDynamics(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 = initializeJointDynamics(stewart, 'type_F', 'universal_p', 'type_M', 'spherical_p');
stewart = initializeCylindricalPlatforms(stewart); stewart = initializeCylindricalPlatforms(stewart);
stewart = initializeCylindricalStruts(stewart); stewart = initializeCylindricalStruts(stewart);
stewart = computeJacobian(stewart); stewart = computeJacobian(stewart);
stewart = initializeStewartPose(stewart); stewart = initializeStewartPose(stewart);
stewart = initializeInertialSensor(stewart, <span class="org-string">'type'</span>, <span class="org-string">'none'</span>); stewart = initializeInertialSensor(stewart, 'type', 'none');
</pre> </pre>
</div> </div>
@ -793,9 +580,9 @@ stewart = initializeInertialSensor(stewart, <span class="org-string">'type'</spa
The rotation point of the ground is located at the origin of frame \(\{A\}\). The rotation point of the ground is located at the origin of frame \(\{A\}\).
</p> </p>
<div class="org-src-container"> <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); <pre class="src src-matlab">ground = initializeGround('type', 'rigid', 'rot_point', stewart.platform_F.FO_A);
payload = initializePayload(<span class="org-string">'type'</span>, <span class="org-string">'none'</span>); payload = initializePayload('type', 'none');
controller = initializeController(<span class="org-string">'type'</span>, <span class="org-string">'open-loop'</span>); controller = initializeController('type', 'open-loop');
</pre> </pre>
</div> </div>
</div> </div>
@ -808,7 +595,7 @@ controller = initializeController(<span class="org-string">'type'</span>, <span
Let&rsquo;s first identify the transmissibility and compliance in the open-loop case. Let&rsquo;s first identify the transmissibility and compliance in the open-loop case.
</p> </p>
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab">controller = initializeController(<span class="org-string">'type'</span>, <span class="org-string">'open-loop'</span>); <pre class="src src-matlab">controller = initializeController('type', 'open-loop');
[T_ol, T_norm_ol, freqs] = computeTransmissibility(); [T_ol, T_norm_ol, freqs] = computeTransmissibility();
[C_ol, C_norm_ol, freqs] = computeCompliance(); [C_ol, C_norm_ol, freqs] = computeCompliance();
</pre> </pre>
@ -818,11 +605,11 @@ Let&rsquo;s first identify the transmissibility and compliance in the open-loop
Now, let&rsquo;s identify the transmissibility and compliance for the Integral Force Feedback architecture. Now, let&rsquo;s identify the transmissibility and compliance for the Integral Force Feedback architecture.
</p> </p>
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab">controller = initializeController(<span class="org-string">'type'</span>, <span class="org-string">'iff'</span>); <pre class="src src-matlab">controller = initializeController('type', 'iff');
K_iff = (1e4<span class="org-type">/</span>s)<span class="org-type">*</span>eye(6); K_iff = (1e4/s)*eye(6);
[T_iff, T_norm_iff, <span class="org-type">~</span>] = computeTransmissibility(); [T_iff, T_norm_iff, ~] = computeTransmissibility();
[C_iff, C_norm_iff, <span class="org-type">~</span>] = computeCompliance(); [C_iff, C_norm_iff, ~] = computeCompliance();
</pre> </pre>
</div> </div>
@ -830,11 +617,11 @@ K_iff = (1e4<span class="org-type">/</span>s)<span class="org-type">*</span>eye(
And for the Direct Velocity Feedback. And for the Direct Velocity Feedback.
</p> </p>
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab">controller = initializeController(<span class="org-string">'type'</span>, <span class="org-string">'dvf'</span>); <pre class="src src-matlab">controller = initializeController('type', 'dvf');
K_dvf = 1e4<span class="org-type">*</span>s<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>5000)<span class="org-type">*</span>eye(6); K_dvf = 1e4*s/(1+s/2/pi/5000)*eye(6);
[T_dvf, T_norm_dvf, <span class="org-type">~</span>] = computeTransmissibility(); [T_dvf, T_norm_dvf, ~] = computeTransmissibility();
[C_dvf, C_norm_dvf, <span class="org-type">~</span>] = computeCompliance(); [C_dvf, C_norm_dvf, ~] = computeCompliance();
</pre> </pre>
</div> </div>
</div> </div>
@ -869,7 +656,7 @@ K_dvf = 1e4<span class="org-type">*</span>s<span class="org-type">/</span>(1<spa
</div> </div>
<div id="postamble" class="status"> <div id="postamble" class="status">
<p class="author">Author: Dehaeze Thomas</p> <p class="author">Author: Dehaeze Thomas</p>
<p class="date">Created: 2020-03-13 ven. 10:34</p> <p class="date">Created: 2020-08-05 mer. 13:27</p>
</div> </div>
</body> </body>
</html> </html>

724
docs/control-tracking.html
View File

File diff suppressed because it is too large Load Diff

759
docs/control-vibration-isolation.html
View File

File diff suppressed because it is too large Load Diff

628
docs/cubic-configuration.html
View File

File diff suppressed because it is too large Load Diff

348
docs/dynamics-study.html
View File

@ -1,239 +1,27 @@
<?xml version="1.0" encoding="utf-8"?> <?xml version="1.0" encoding="utf-8"?>
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"> "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en"> <html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en">
<head> <head>
<!-- 2020-03-02 lun. 17:57 --> <!-- 2020-08-05 mer. 13:27 -->
<meta http-equiv="Content-Type" content="text/html;charset=utf-8" /> <meta http-equiv="Content-Type" content="text/html;charset=utf-8" />
<meta name="viewport" content="width=device-width, initial-scale=1" />
<title>Stewart Platform - Dynamics Study</title> <title>Stewart Platform - Dynamics Study</title>
<meta name="generator" content="Org mode" /> <meta name="generator" content="Org mode" />
<meta name="author" content="Dehaeze Thomas" /> <meta name="author" content="Dehaeze Thomas" />
<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>
<link rel="stylesheet" type="text/css" href="./css/htmlize.css"/> <link rel="stylesheet" type="text/css" href="./css/htmlize.css"/>
<link rel="stylesheet" type="text/css" href="./css/readtheorg.css"/> <link rel="stylesheet" type="text/css" href="./css/readtheorg.css"/>
<script src="./js/jquery.min.js"></script> <script src="./js/jquery.min.js"></script>
<script src="./js/bootstrap.min.js"></script> <script src="./js/bootstrap.min.js"></script>
<script src="./js/jquery.stickytableheaders.min.js"></script> <script src="./js/jquery.stickytableheaders.min.js"></script>
<script src="./js/readtheorg.js"></script> <script src="./js/readtheorg.js"></script>
<script type="text/javascript"> <script>MathJax = {
// @license magnet:?xt=urn:btih:1f739d935676111cfff4b4693e3816e664797050&dn=gpl-3.0.txt GPL-v3-or-Later tex: {
<!--/*--><![CDATA[/*><!--*/ tags: 'ams',
function CodeHighlightOn(elem, id) macros: {bm: ["\\boldsymbol{#1}",1],}
{
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
</script>
<script>
MathJax = {
tex: { macros: {
bm: ["\\boldsymbol{#1}",1],
}
} }
}; };
</script> </script>
<script type="text/javascript" <script type="text/javascript" src="https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js"></script>
src="https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js"></script>
</head> </head>
<body> <body>
<div id="org-div-home-and-up"> <div id="org-div-home-and-up">
@ -250,13 +38,13 @@
<ul> <ul>
<li><a href="#org4509b7d">1.1. Comparison with fixed support</a></li> <li><a href="#org4509b7d">1.1. Comparison with fixed support</a></li>
<li><a href="#org8662186">1.2. Comparison with a flexible support</a></li> <li><a href="#org8662186">1.2. Comparison with a flexible support</a></li>
<li><a href="#orgbb930ae">1.3. Conclusion</a></li> <li><a href="#org55e0dad">1.3. Conclusion</a></li>
</ul> </ul>
</li> </li>
<li><a href="#org81ab204">2. Comparison of the static transfer function and the Compliance matrix</a> <li><a href="#org81ab204">2. Comparison of the static transfer function and the Compliance matrix</a>
<ul> <ul>
<li><a href="#orge7e7242">2.1. Analysis</a></li> <li><a href="#orge7e7242">2.1. Analysis</a></li>
<li><a href="#org5acc4c0">2.2. Conclusion</a></li> <li><a href="#org9ee3939">2.2. Conclusion</a></li>
</ul> </ul>
</li> </li>
</ul> </ul>
@ -279,16 +67,16 @@ Let&rsquo;s generate a Stewart platform.
</p> </p>
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab">stewart = initializeStewartPlatform(); <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 = initializeFramesPositions(stewart, 'H', 90e-3, 'MO_B', 45e-3);
stewart = generateGeneralConfiguration(stewart); stewart = generateGeneralConfiguration(stewart);
stewart = computeJointsPose(stewart); stewart = computeJointsPose(stewart);
stewart = initializeStrutDynamics(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 = initializeJointDynamics(stewart, 'type_F', 'universal_p', 'type_M', 'spherical_p');
stewart = initializeCylindricalPlatforms(stewart); stewart = initializeCylindricalPlatforms(stewart);
stewart = initializeCylindricalStruts(stewart); stewart = initializeCylindricalStruts(stewart);
stewart = computeJacobian(stewart); stewart = computeJacobian(stewart);
stewart = initializeStewartPose(stewart); stewart = initializeStewartPose(stewart);
stewart = initializeInertialSensor(stewart, <span class="org-string">'type'</span>, <span class="org-string">'none'</span>); stewart = initializeInertialSensor(stewart, 'type', 'none');
</pre> </pre>
</div> </div>
@ -297,9 +85,9 @@ We don&rsquo;t put any flexibility below the Stewart platform such that <b>its b
We also don&rsquo;t put any payload on top of the Stewart platform. We also don&rsquo;t put any payload on top of the Stewart platform.
</p> </p>
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab">ground = initializeGround(<span class="org-string">'type'</span>, <span class="org-string">'none'</span>); <pre class="src src-matlab">ground = initializeGround('type', 'none');
payload = initializePayload(<span class="org-string">'type'</span>, <span class="org-string">'none'</span>); payload = initializePayload('type', 'none');
controller = initializeController(<span class="org-string">'type'</span>, <span class="org-string">'open-loop'</span>); controller = initializeController('type', 'open-loop');
</pre> </pre>
</div> </div>
@ -307,22 +95,22 @@ controller = initializeController(<span class="org-string">'type'</span>, <span
The transfer function from actuator forces \(\bm{\tau}\) to the relative displacement of the mobile platform \(\mathcal{\bm{X}}\) is extracted. The transfer function from actuator forces \(\bm{\tau}\) to the relative displacement of the mobile platform \(\mathcal{\bm{X}}\) is extracted.
</p> </p>
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab"><span class="org-matlab-cellbreak"><span class="org-comment">%% Options for Linearized</span></span> <pre class="src src-matlab">%% Options for Linearized
options = linearizeOptions; options = linearizeOptions;
options.SampleTime = 0; options.SampleTime = 0;
<span class="org-matlab-cellbreak"><span class="org-comment">%% Name of the Simulink File</span></span> %% Name of the Simulink File
mdl = <span class="org-string">'stewart_platform_model'</span>; mdl = 'stewart_platform_model';
<span class="org-matlab-cellbreak"><span class="org-comment">%% Input/Output definition</span></span> %% Input/Output definition
clear io; io_i = 1; clear io; io_i = 1;
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, '/Controller'], 1, 'openinput'); io_i = io_i + 1; % Actuator Force Inputs [N]
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, '/Relative Motion Sensor'], 1, 'openoutput'); io_i = io_i + 1; % Position/Orientation of {B} w.r.t. {A}
<span class="org-matlab-cellbreak"><span class="org-comment">%% Run the linearization</span></span> %% Run the linearization
G = linearize(mdl, io, options); G = linearize(mdl, io, options);
G.InputName = {<span class="org-string">'F1'</span>, <span class="org-string">'F2'</span>, <span class="org-string">'F3'</span>, <span class="org-string">'F4'</span>, <span class="org-string">'F5'</span>, <span class="org-string">'F6'</span>}; G.InputName = {'F1', 'F2', 'F3', 'F4', 'F5', 'F6'};
G.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>}; G.OutputName = {'Edx', 'Edy', 'Edz', 'Erx', 'Ery', 'Erz'};
</pre> </pre>
</div> </div>
@ -330,8 +118,8 @@ G.OutputName = {<span class="org-string">'Edx'</span>, <span class="org-string">
Using the Jacobian matrix, we compute the transfer function from force/torques applied by the actuators on the frame \(\{B\}\) fixed to the mobile platform: Using the Jacobian matrix, we compute the transfer function from force/torques applied by the actuators on the frame \(\{B\}\) fixed to the mobile platform:
</p> </p>
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab">Gc = minreal(G<span class="org-type">*</span>inv(stewart.kinematics.J<span class="org-type">'</span>)); <pre class="src src-matlab">Gc = minreal(G*inv(stewart.kinematics.J'));
Gc.InputName = {<span class="org-string">'Fnx'</span>, <span class="org-string">'Fny'</span>, <span class="org-string">'Fnz'</span>, <span class="org-string">'Mnx'</span>, <span class="org-string">'Mny'</span>, <span class="org-string">'Mnz'</span>}; Gc.InputName = {'Fnx', 'Fny', 'Fnz', 'Mnx', 'Mny', 'Mnz'};
</pre> </pre>
</div> </div>
@ -339,15 +127,15 @@ Gc.InputName = {<span class="org-string">'Fnx'</span>, <span class="org-string">
We also extract the transfer function from external forces \(\bm{\mathcal{F}}_{\text{ext}}\) on the frame \(\{B\}\) fixed to the mobile platform to the relative displacement \(\mathcal{\bm{X}}\) of \(\{B\}\) with respect to frame \(\{A\}\): We also extract the transfer function from external forces \(\bm{\mathcal{F}}_{\text{ext}}\) on the frame \(\{B\}\) fixed to the mobile platform to the relative displacement \(\mathcal{\bm{X}}\) of \(\{B\}\) with respect to frame \(\{A\}\):
</p> </p>
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab"><span class="org-matlab-cellbreak"><span class="org-comment">%% Input/Output definition</span></span> <pre class="src src-matlab">%% Input/Output definition
clear io; io_i = 1; clear io; io_i = 1;
io(io_i) = linio([mdl, <span class="org-string">'/Disturbances'</span>], 1, <span class="org-string">'openinput'</span>, [], <span class="org-string">'F_ext'</span>); io_i = io_i <span class="org-type">+</span> 1; <span class="org-comment">% External forces/torques applied on {B}</span> io(io_i) = linio([mdl, '/Disturbances'], 1, 'openinput', [], 'F_ext'); io_i = io_i + 1; % External forces/torques applied on {B}
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, '/Relative Motion Sensor'], 1, 'openoutput'); io_i = io_i + 1; % Position/Orientation of {B} w.r.t. {A}
<span class="org-matlab-cellbreak"><span class="org-comment">%% Run the linearization</span></span> %% Run the linearization
Gd = linearize(mdl, io, options); Gd = linearize(mdl, io, options);
Gd.InputName = {<span class="org-string">'Fex'</span>, <span class="org-string">'Fey'</span>, <span class="org-string">'Fez'</span>, <span class="org-string">'Mex'</span>, <span class="org-string">'Mey'</span>, <span class="org-string">'Mez'</span>}; Gd.InputName = {'Fex', 'Fey', 'Fez', 'Mex', 'Mey', 'Mez'};
Gd.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>}; Gd.OutputName = {'Edx', 'Edy', 'Edz', 'Erx', 'Ery', 'Erz'};
</pre> </pre>
</div> </div>
@ -382,7 +170,7 @@ This can be understood from figure <a href="#org8bd3e63">2</a> where \(\mathcal{
We now add a flexible support under the Stewart platform. We now add a flexible support under the Stewart platform.
</p> </p>
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab">ground = initializeGround(<span class="org-string">'type'</span>, <span class="org-string">'flexible'</span>); <pre class="src src-matlab">ground = initializeGround('type', 'flexible');
</pre> </pre>
</div> </div>
@ -390,28 +178,28 @@ We now add a flexible support under the Stewart platform.
And we perform again the identification. And we perform again the identification.
</p> </p>
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab"><span class="org-matlab-cellbreak"><span class="org-comment">%% Input/Output definition</span></span> <pre class="src src-matlab">%% Input/Output definition
clear io; io_i = 1; clear io; io_i = 1;
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, '/Controller'], 1, 'openinput'); io_i = io_i + 1; % Actuator Force Inputs [N]
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, '/Relative Motion Sensor'], 1, 'openoutput'); io_i = io_i + 1; % Position/Orientation of {B} w.r.t. {A}
<span class="org-matlab-cellbreak"><span class="org-comment">%% Run the linearization</span></span> %% Run the linearization
G = linearize(mdl, io, options); G = linearize(mdl, io, options);
G.InputName = {<span class="org-string">'F1'</span>, <span class="org-string">'F2'</span>, <span class="org-string">'F3'</span>, <span class="org-string">'F4'</span>, <span class="org-string">'F5'</span>, <span class="org-string">'F6'</span>}; G.InputName = {'F1', 'F2', 'F3', 'F4', 'F5', 'F6'};
G.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>}; G.OutputName = {'Edx', 'Edy', 'Edz', 'Erx', 'Ery', 'Erz'};
Gc = minreal(G<span class="org-type">*</span>inv(stewart.kinematics.J<span class="org-type">'</span>)); Gc = minreal(G*inv(stewart.kinematics.J'));
Gc.InputName = {<span class="org-string">'Fnx'</span>, <span class="org-string">'Fny'</span>, <span class="org-string">'Fnz'</span>, <span class="org-string">'Mnx'</span>, <span class="org-string">'Mny'</span>, <span class="org-string">'Mnz'</span>}; Gc.InputName = {'Fnx', 'Fny', 'Fnz', 'Mnx', 'Mny', 'Mnz'};
<span class="org-matlab-cellbreak"><span class="org-comment">%% Input/Output definition</span></span> %% Input/Output definition
clear io; io_i = 1; clear io; io_i = 1;
io(io_i) = linio([mdl, <span class="org-string">'/Disturbances'</span>], 1, <span class="org-string">'openinput'</span>, [], <span class="org-string">'F_ext'</span>); io_i = io_i <span class="org-type">+</span> 1; <span class="org-comment">% External forces/torques applied on {B}</span> io(io_i) = linio([mdl, '/Disturbances'], 1, 'openinput', [], 'F_ext'); io_i = io_i + 1; % External forces/torques applied on {B}
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, '/Relative Motion Sensor'], 1, 'openoutput'); io_i = io_i + 1; % Position/Orientation of {B} w.r.t. {A}
<span class="org-matlab-cellbreak"><span class="org-comment">%% Run the linearization</span></span> %% Run the linearization
Gd = linearize(mdl, io, options); Gd = linearize(mdl, io, options);
Gd.InputName = {<span class="org-string">'Fex'</span>, <span class="org-string">'Fey'</span>, <span class="org-string">'Fez'</span>, <span class="org-string">'Mex'</span>, <span class="org-string">'Mey'</span>, <span class="org-string">'Mez'</span>}; Gd.InputName = {'Fex', 'Fey', 'Fez', 'Mex', 'Mey', 'Mez'};
Gd.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>}; Gd.OutputName = {'Edx', 'Edy', 'Edz', 'Erx', 'Ery', 'Erz'};
</pre> </pre>
</div> </div>
@ -442,8 +230,8 @@ And thus \(\mathcal{F}_{x}\) and \(\mathcal{F}_{x,\text{ext}}\) have clearly <b>
</div> </div>
<div id="outline-container-orgbb930ae" class="outline-3"> <div id="outline-container-org55e0dad" class="outline-3">
<h3 id="orgbb930ae"><span class="section-number-3">1.3</span> Conclusion</h3> <h3 id="org55e0dad"><span class="section-number-3">1.3</span> Conclusion</h3>
<div class="outline-text-3" id="text-1-3"> <div class="outline-text-3" id="text-1-3">
<div class="important"> <div class="important">
<p> <p>
@ -471,16 +259,16 @@ Initialization of the Stewart platform.
</p> </p>
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab">stewart = initializeStewartPlatform(); <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 = initializeFramesPositions(stewart, 'H', 90e-3, 'MO_B', 45e-3);
stewart = generateGeneralConfiguration(stewart); stewart = generateGeneralConfiguration(stewart);
stewart = computeJointsPose(stewart); stewart = computeJointsPose(stewart);
stewart = initializeStrutDynamics(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 = initializeJointDynamics(stewart, 'type_F', 'universal_p', 'type_M', 'spherical_p');
stewart = initializeCylindricalPlatforms(stewart); stewart = initializeCylindricalPlatforms(stewart);
stewart = initializeCylindricalStruts(stewart); stewart = initializeCylindricalStruts(stewart);
stewart = computeJacobian(stewart); stewart = computeJacobian(stewart);
stewart = initializeStewartPose(stewart); stewart = initializeStewartPose(stewart);
stewart = initializeInertialSensor(stewart, <span class="org-string">'type'</span>, <span class="org-string">'none'</span>); stewart = initializeInertialSensor(stewart, 'type', 'none');
</pre> </pre>
</div> </div>
@ -488,9 +276,9 @@ stewart = initializeInertialSensor(stewart, <span class="org-string">'type'</spa
No flexibility below the Stewart platform and no payload. No flexibility below the Stewart platform and no payload.
</p> </p>
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab">ground = initializeGround(<span class="org-string">'type'</span>, <span class="org-string">'none'</span>); <pre class="src src-matlab">ground = initializeGround('type', 'none');
payload = initializePayload(<span class="org-string">'type'</span>, <span class="org-string">'none'</span>); payload = initializePayload('type', 'none');
controller = initializeController(<span class="org-string">'type'</span>, <span class="org-string">'open-loop'</span>); controller = initializeController('type', 'open-loop');
</pre> </pre>
</div> </div>
@ -498,28 +286,28 @@ controller = initializeController(<span class="org-string">'type'</span>, <span
Estimation of the transfer function from \(\mathcal{\bm{F}}\) to \(\mathcal{\bm{X}}\): Estimation of the transfer function from \(\mathcal{\bm{F}}\) to \(\mathcal{\bm{X}}\):
</p> </p>
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab"><span class="org-matlab-cellbreak"><span class="org-comment">%% Options for Linearized</span></span> <pre class="src src-matlab">%% Options for Linearized
options = linearizeOptions; options = linearizeOptions;
options.SampleTime = 0; options.SampleTime = 0;
<span class="org-matlab-cellbreak"><span class="org-comment">%% Name of the Simulink File</span></span> %% Name of the Simulink File
mdl = <span class="org-string">'stewart_platform_model'</span>; mdl = 'stewart_platform_model';
<span class="org-matlab-cellbreak"><span class="org-comment">%% Input/Output definition</span></span> %% Input/Output definition
clear io; io_i = 1; clear io; io_i = 1;
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, '/Controller'], 1, 'openinput'); io_i = io_i + 1; % Actuator Force Inputs [N]
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, '/Relative Motion Sensor'], 1, 'openoutput'); io_i = io_i + 1; % Position/Orientation of {B} w.r.t. {A}
<span class="org-matlab-cellbreak"><span class="org-comment">%% Run the linearization</span></span> %% Run the linearization
G = linearize(mdl, io, options); G = linearize(mdl, io, options);
G.InputName = {<span class="org-string">'F1'</span>, <span class="org-string">'F2'</span>, <span class="org-string">'F3'</span>, <span class="org-string">'F4'</span>, <span class="org-string">'F5'</span>, <span class="org-string">'F6'</span>}; G.InputName = {'F1', 'F2', 'F3', 'F4', 'F5', 'F6'};
G.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>}; G.OutputName = {'Edx', 'Edy', 'Edz', 'Erx', 'Ery', 'Erz'};
</pre> </pre>
</div> </div>
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab">Gc = minreal(G<span class="org-type">*</span>inv(stewart.kinematics.J<span class="org-type">'</span>)); <pre class="src src-matlab">Gc = minreal(G*inv(stewart.kinematics.J'));
Gc.InputName = {<span class="org-string">'Fnx'</span>, <span class="org-string">'Fny'</span>, <span class="org-string">'Fnz'</span>, <span class="org-string">'Mnx'</span>, <span class="org-string">'Mny'</span>, <span class="org-string">'Mnz'</span>}; Gc.InputName = {'Fnx', 'Fny', 'Fnz', 'Mnx', 'Mny', 'Mnz'};
</pre> </pre>
</div> </div>
@ -677,8 +465,8 @@ And now at the Compliance matrix.
</div> </div>
</div> </div>
<div id="outline-container-org5acc4c0" class="outline-3"> <div id="outline-container-org9ee3939" class="outline-3">
<h3 id="org5acc4c0"><span class="section-number-3">2.2</span> Conclusion</h3> <h3 id="org9ee3939"><span class="section-number-3">2.2</span> Conclusion</h3>
<div class="outline-text-3" id="text-2-2"> <div class="outline-text-3" id="text-2-2">
<div class="important"> <div class="important">
<p> <p>
@ -692,7 +480,7 @@ The low frequency transfer function matrix from \(\mathcal{\bm{F}}\) to \(\mathc
</div> </div>
<div id="postamble" class="status"> <div id="postamble" class="status">
<p class="author">Author: Dehaeze Thomas</p> <p class="author">Author: Dehaeze Thomas</p>
<p class="date">Created: 2020-03-02 lun. 17:57</p> <p class="date">Created: 2020-08-05 mer. 13:27</p>
</div> </div>
</body> </body>
</html> </html>

2694
docs/figs/flexible_elements_effect_dvf.pdf Normal file
View File

File diff suppressed because it is too large Load Diff

BIN
docs/figs/flexible_elements_effect_dvf.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 205 KiB

2761
docs/figs/flexible_elements_effect_iff.pdf Normal file
View File

File diff suppressed because it is too large Load Diff

BIN
docs/figs/flexible_elements_effect_iff.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 210 KiB

472
docs/flexible-stewart-platform.html Normal file
View File

@ -0,0 +1,472 @@
<?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-08-05 mer. 13:27 -->
<meta http-equiv="Content-Type" content="text/html;charset=utf-8" />
<title>Stewart Platform with Flexible Elements</title>
<meta name="generator" content="Org mode" />
<meta name="author" content="Dehaeze Thomas" />
<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>
</head>
<body>
<div id="org-div-home-and-up">
<a accesskey="h" href="./index.html"> UP </a>
|
<a accesskey="H" href="./index.html"> HOME </a>
</div><div id="content">
<h1 class="title">Stewart Platform with Flexible Elements</h1>
<div id="table-of-contents">
<h2>Table of Contents</h2>
<div id="text-table-of-contents">
<ul>
<li><a href="#orgbdb2a68">1. Simscape Model</a>
<ul>
<li><a href="#org6768ff7">1.1. Flexible APA</a></li>
<li><a href="#org3650a90">1.2. Flexible Joint</a></li>
<li><a href="#org75c496c">1.3. Identification</a></li>
<li><a href="#org52d500c">1.4. No Flexible Elements</a></li>
<li><a href="#org6800cf5">1.5. Flexible joints</a></li>
<li><a href="#orgd80e541">1.6. Flexible APA</a></li>
<li><a href="#org1609aa1">1.7. Flexible Joints and APA</a></li>
<li><a href="#orge9b9e81">1.8. Direct Velocity Feedback</a></li>
<li><a href="#org265a0a3">1.9. Integral Force Feedback</a></li>
</ul>
</li>
</ul>
</div>
</div>
<div id="outline-container-orgbdb2a68" class="outline-2">
<h2 id="orgbdb2a68"><span class="section-number-2">1</span> Simscape Model</h2>
<div class="outline-text-2" id="text-1">
</div>
<div id="outline-container-org6768ff7" class="outline-3">
<h3 id="org6768ff7"><span class="section-number-3">1.1</span> Flexible APA</h3>
<div class="outline-text-3" id="text-1-1">
<div class="org-src-container">
<pre class="src src-matlab">apa = load('./mat/APA300ML.mat', 'int_xyz', 'int_i', 'n_xyz', 'n_i', 'nodes', 'M', 'K');
</pre>
</div>
<table border="2" cellspacing="0" cellpadding="6" rules="groups" frame="hsides">
<colgroup>
<col class="org-left" />
<col class="org-right" />
</colgroup>
<tbody>
<tr>
<td class="org-left">Total number of Nodes</td>
<td class="org-right">7</td>
</tr>
<tr>
<td class="org-left">Number of interface Nodes</td>
<td class="org-right">7</td>
</tr>
<tr>
<td class="org-left">Number of Modes</td>
<td class="org-right">6</td>
</tr>
<tr>
<td class="org-left">Size of M and K matrices</td>
<td class="org-right">48</td>
</tr>
</tbody>
</table>
<table border="2" cellspacing="0" cellpadding="6" rules="groups" frame="hsides">
<caption class="t-above"><span class="table-number">Table 1:</span> Coordinates of the interface nodes</caption>
<colgroup>
<col class="org-right" />
<col class="org-right" />
<col class="org-right" />
<col class="org-right" />
<col class="org-right" />
</colgroup>
<thead>
<tr>
<th scope="col" class="org-right">Node i</th>
<th scope="col" class="org-right">Node Number</th>
<th scope="col" class="org-right">x [m]</th>
<th scope="col" class="org-right">y [m]</th>
<th scope="col" class="org-right">z [m]</th>
</tr>
</thead>
<tbody>
<tr>
<td class="org-right">1.0</td>
<td class="org-right">53917.0</td>
<td class="org-right">0.0</td>
<td class="org-right">-0.015</td>
<td class="org-right">0.0</td>
</tr>
<tr>
<td class="org-right">2.0</td>
<td class="org-right">53918.0</td>
<td class="org-right">0.0</td>
<td class="org-right">0.015</td>
<td class="org-right">0.0</td>
</tr>
<tr>
<td class="org-right">3.0</td>
<td class="org-right">53919.0</td>
<td class="org-right">-0.0325</td>
<td class="org-right">0.0</td>
<td class="org-right">0.0</td>
</tr>
<tr>
<td class="org-right">4.0</td>
<td class="org-right">53920.0</td>
<td class="org-right">-0.0125</td>
<td class="org-right">0.0</td>
<td class="org-right">0.0</td>
</tr>
<tr>
<td class="org-right">5.0</td>
<td class="org-right">53921.0</td>
<td class="org-right">-0.0075</td>
<td class="org-right">0.0</td>
<td class="org-right">0.0</td>
</tr>
<tr>
<td class="org-right">6.0</td>
<td class="org-right">53922.0</td>
<td class="org-right">0.0125</td>
<td class="org-right">0.0</td>
<td class="org-right">0.0</td>
</tr>
<tr>
<td class="org-right">7.0</td>
<td class="org-right">53923.0</td>
<td class="org-right">0.0325</td>
<td class="org-right">0.0</td>
<td class="org-right">0.0</td>
</tr>
</tbody>
</table>
</div>
</div>
<div id="outline-container-org3650a90" class="outline-3">
<h3 id="org3650a90"><span class="section-number-3">1.2</span> Flexible Joint</h3>
<div class="outline-text-3" id="text-1-2">
<div class="org-src-container">
<pre class="src src-matlab">flex_joint = load('./mat/flexor_ID16.mat', 'int_xyz', 'int_i', 'n_xyz', 'n_i', 'nodes', 'M', 'K');
</pre>
</div>
<table border="2" cellspacing="0" cellpadding="6" rules="groups" frame="hsides">
<colgroup>
<col class="org-left" />
<col class="org-right" />
</colgroup>
<tbody>
<tr>
<td class="org-left">Total number of Nodes</td>
<td class="org-right">2</td>
</tr>
<tr>
<td class="org-left">Number of interface Nodes</td>
<td class="org-right">2</td>
</tr>
<tr>
<td class="org-left">Number of Modes</td>
<td class="org-right">6</td>
</tr>
<tr>
<td class="org-left">Size of M and K matrices</td>
<td class="org-right">18</td>
</tr>
</tbody>
</table>
<table border="2" cellspacing="0" cellpadding="6" rules="groups" frame="hsides">
<caption class="t-above"><span class="table-number">Table 2:</span> Coordinates of the interface nodes</caption>
<colgroup>
<col class="org-right" />
<col class="org-right" />
<col class="org-right" />
<col class="org-right" />
<col class="org-right" />
</colgroup>
<thead>
<tr>
<th scope="col" class="org-right">Node i</th>
<th scope="col" class="org-right">Node Number</th>
<th scope="col" class="org-right">x [m]</th>
<th scope="col" class="org-right">y [m]</th>
<th scope="col" class="org-right">z [m]</th>
</tr>
</thead>
<tbody>
<tr>
<td class="org-right">1.0</td>
<td class="org-right">181278.0</td>
<td class="org-right">0.0</td>
<td class="org-right">0.0</td>
<td class="org-right">0.0</td>
</tr>
<tr>
<td class="org-right">2.0</td>
<td class="org-right">181279.0</td>
<td class="org-right">0.0</td>
<td class="org-right">0.0</td>
<td class="org-right">-0.0</td>
</tr>
</tbody>
</table>
<table border="2" cellspacing="0" cellpadding="6" rules="groups" frame="hsides">
<colgroup>
<col class="org-left" />
<col class="org-right" />
</colgroup>
<thead>
<tr>
<th scope="col" class="org-left"><b>Caracteristic</b></th>
<th scope="col" class="org-right"><b>Value</b></th>
</tr>
</thead>
<tbody>
<tr>
<td class="org-left">Axial Stiffness [N/um]</td>
<td class="org-right">119</td>
</tr>
<tr>
<td class="org-left">Bending Stiffness [Nm/rad]</td>
<td class="org-right">33</td>
</tr>
<tr>
<td class="org-left">Bending Stiffness [Nm/rad]</td>
<td class="org-right">33</td>
</tr>
<tr>
<td class="org-left">Torsion Stiffness [Nm/rad]</td>
<td class="org-right">236</td>
</tr>
</tbody>
</table>
</div>
</div>
<div id="outline-container-org75c496c" class="outline-3">
<h3 id="org75c496c"><span class="section-number-3">1.3</span> Identification</h3>
<div class="outline-text-3" id="text-1-3">
<p>
And we identify the dynamics from force actuators to force sensors.
</p>
<div class="org-src-container">
<pre class="src src-matlab">%% Options for Linearized
options = linearizeOptions;
options.SampleTime = 0;
%% Name of the Simulink File
mdl = 'stewart_platform_model';
%% Input/Output definition
clear io; io_i = 1;
io(io_i) = linio([mdl, '/Controller'], 1, 'openinput'); io_i = io_i + 1; % Actuator Force Inputs [N]
io(io_i) = linio([mdl, '/Stewart Platform'], 1, 'openoutput', [], 'dLm'); io_i = io_i + 1; % Relative Displacement Outputs [m]
io(io_i) = linio([mdl, '/Stewart Platform'], 1, 'openoutput', [], 'Taum'); io_i = io_i + 1; % Force Sensors [N]
</pre>
</div>
<div class="org-src-container">
<pre class="src src-matlab">ground = initializeGround('type', 'none');
payload = initializePayload('type', 'rigid', 'm', 50);
controller = initializeController('type', 'open-loop');
</pre>
</div>
<div class="org-src-container">
<pre class="src src-matlab">disturbances = initializeDisturbances();
references = initializeReferences(stewart);
</pre>
</div>
</div>
</div>
<div id="outline-container-org52d500c" class="outline-3">
<h3 id="org52d500c"><span class="section-number-3">1.4</span> No Flexible Elements</h3>
<div class="outline-text-3" id="text-1-4">
<div class="org-src-container">
<pre class="src src-matlab">stewart = initializeStewartPlatform();
stewart = initializeFramesPositions(stewart);
stewart = generateGeneralConfiguration(stewart);
stewart = computeJointsPose(stewart);
% stewart = initializeStrutDynamics(stewart, 'K', 1.8e6*ones(6,1));
stewart = initializeAmplifiedStrutDynamics(stewart, 'Kr', 0.9e6*ones(6,1), 'Ka', 0.9e6*ones(6,1));
stewart = initializeJointDynamics(stewart, 'Kf_M', 33*ones(6,1), 'Kt_M', 235*ones(6,1), 'Kf_F', 33*ones(6,1), 'Kt_F', 235*ones(6,1));
stewart = initializeCylindricalPlatforms(stewart);
stewart = initializeCylindricalStruts(stewart);
stewart = computeJacobian(stewart);
stewart = initializeStewartPose(stewart);
stewart = initializeInertialSensor(stewart);
</pre>
</div>
<div class="org-src-container">
<pre class="src src-matlab">%% Run the linearization
G = linearize(mdl, io, options);
G.InputName = {'F1', 'F2', 'F3', 'F4', 'F5', 'F6'};
G.OutputName = {'Dm1', 'Dm2', 'Dm3', 'Dm4', 'Dm5', 'Dm6', 'Fm1', 'Fm2', 'Fm3', 'Fm4', 'Fm5', 'Fm6'};
</pre>
</div>
</div>
</div>
<div id="outline-container-org6800cf5" class="outline-3">
<h3 id="org6800cf5"><span class="section-number-3">1.5</span> Flexible joints</h3>
<div class="outline-text-3" id="text-1-5">
<div class="org-src-container">
<pre class="src src-matlab">stewart = initializeStewartPlatform();
stewart = initializeFramesPositions(stewart);
stewart = generateGeneralConfiguration(stewart);
stewart = computeJointsPose(stewart);
stewart = initializeAmplifiedStrutDynamics(stewart, 'Kr', 0.9e6*ones(6,1), 'Ka', 0.9e6*ones(6,1));
stewart = initializeJointDynamics(stewart, 'type_F', 'flexible', 'K_F', flex_joint.K, 'M_F', flex_joint.M, 'n_xyz_F', flex_joint.n_xyz, 'xi_F', 0.1, 'step_file_F', 'mat/flexor_ID16.STEP', 'type_M', 'flexible', 'K_M', flex_joint.K, 'M_M', flex_joint.M, 'n_xyz_M', flex_joint.n_xyz, 'xi_M', 0.1, 'step_file_M', 'mat/flexor_ID16.STEP');
stewart = initializeCylindricalPlatforms(stewart);
stewart = initializeCylindricalStruts(stewart);
stewart = computeJacobian(stewart);
stewart = initializeStewartPose(stewart);
stewart = initializeInertialSensor(stewart);
</pre>
</div>
<div class="org-src-container">
<pre class="src src-matlab">%% Run the linearization
Gj = linearize(mdl, io, options);
Gj.InputName = {'F1', 'F2', 'F3', 'F4', 'F5', 'F6'};
Gj.OutputName = {'Dm1', 'Dm2', 'Dm3', 'Dm4', 'Dm5', 'Dm6', 'Fm1', 'Fm2', 'Fm3', 'Fm4', 'Fm5', 'Fm6'};
</pre>
</div>
</div>
</div>
<div id="outline-container-orgd80e541" class="outline-3">
<h3 id="orgd80e541"><span class="section-number-3">1.6</span> Flexible APA</h3>
<div class="outline-text-3" id="text-1-6">
<div class="org-src-container">
<pre class="src src-matlab">stewart = initializeStewartPlatform();
stewart = initializeFramesPositions(stewart);
stewart = generateGeneralConfiguration(stewart);
stewart = computeJointsPose(stewart);
stewart = initializeFlexibleStrutDynamics(stewart, 'H', 0.03, 'K', apa.K, 'M', apa.M, 'n_xyz', apa.n_xyz, 'xi', 0.1, 'step_file', 'mat/APA300ML.STEP');
stewart = initializeJointDynamics(stewart, 'Kf_M', 33*ones(6,1), 'Kt_M', 235, 'Kf_F', 33*ones(6,1), 'Kt_F', 235);
stewart = initializeCylindricalPlatforms(stewart);
stewart = initializeCylindricalStruts(stewart, 'type_F', 'none', 'type_M', 'none');
stewart = computeJacobian(stewart);
stewart = initializeStewartPose(stewart);
stewart = initializeInertialSensor(stewart);
</pre>
</div>
<div class="org-src-container">
<pre class="src src-matlab">%% Run the linearization
Ga = -linearize(mdl, io, options);
Ga.InputName = {'F1', 'F2', 'F3', 'F4', 'F5', 'F6'};
Ga.OutputName = {'Dm1', 'Dm2', 'Dm3', 'Dm4', 'Dm5', 'Dm6', 'Fm1', 'Fm2', 'Fm3', 'Fm4', 'Fm5', 'Fm6'};
</pre>
</div>
</div>
</div>
<div id="outline-container-org1609aa1" class="outline-3">
<h3 id="org1609aa1"><span class="section-number-3">1.7</span> Flexible Joints and APA</h3>
<div class="outline-text-3" id="text-1-7">
<div class="org-src-container">
<pre class="src src-matlab">stewart = initializeStewartPlatform();
stewart = initializeFramesPositions(stewart);
stewart = generateGeneralConfiguration(stewart);
stewart = computeJointsPose(stewart);
stewart = initializeFlexibleStrutDynamics(stewart, 'H', 0.03, 'K', apa.K, 'M', apa.M, 'n_xyz', apa.n_xyz, 'xi', 0.1, 'step_file', 'mat/APA300ML.STEP');
stewart = initializeJointDynamics(stewart, 'type_F', 'flexible', 'K_F', flex_joint.K, 'M_F', flex_joint.M, 'n_xyz_F', flex_joint.n_xyz, 'xi_F', 0.1, 'step_file_F', 'mat/flexor_ID16.STEP', 'type_M', 'flexible', 'K_M', flex_joint.K, 'M_M', flex_joint.M, 'n_xyz_M', flex_joint.n_xyz, 'xi_M', 0.1, 'step_file_M', 'mat/flexor_ID16.STEP');
stewart = initializeCylindricalPlatforms(stewart);
stewart = initializeCylindricalStruts(stewart, 'type_F', 'none', 'type_M', 'none');
stewart = computeJacobian(stewart);
stewart = initializeStewartPose(stewart);
stewart = initializeInertialSensor(stewart);
</pre>
</div>
<div class="org-src-container">
<pre class="src src-matlab">Gf = -linearize(mdl, io, options);
Gf.InputName = {'F1', 'F2', 'F3', 'F4', 'F5', 'F6'};
Gf.OutputName = {'Dm1', 'Dm2', 'Dm3', 'Dm4', 'Dm5', 'Dm6', 'Fm1', 'Fm2', 'Fm3', 'Fm4', 'Fm5', 'Fm6'};
</pre>
</div>
</div>
</div>
<div id="outline-container-orge9b9e81" class="outline-3">
<h3 id="orge9b9e81"><span class="section-number-3">1.8</span> Direct Velocity Feedback</h3>
<div class="outline-text-3" id="text-1-8">
<div id="org2d35259" class="figure">
<p><img src="figs/flexible_elements_effect_dvf.png" alt="flexible_elements_effect_dvf.png" />
</p>
<p><span class="figure-number">Figure 1: </span>Change of the DVF plant dynamics with the added flexible elements</p>
</div>
</div>
</div>
<div id="outline-container-org265a0a3" class="outline-3">
<h3 id="org265a0a3"><span class="section-number-3">1.9</span> Integral Force Feedback</h3>
<div class="outline-text-3" id="text-1-9">
<div id="org81cc646" class="figure">
<p><img src="figs/flexible_elements_effect_iff.png" alt="flexible_elements_effect_iff.png" />
</p>
<p><span class="figure-number">Figure 2: </span>Change of the IFF plant dynamics with the added flexible elements</p>
</div>
</div>
</div>
</div>
</div>
<div id="postamble" class="status">
<p class="author">Author: Dehaeze Thomas</p>
<p class="date">Created: 2020-08-05 mer. 13:27</p>
</div>
</body>
</html>

711
docs/identification.html
View File

File diff suppressed because it is too large Load Diff

216
docs/index.html
View File

@ -1,229 +1,19 @@
<?xml version="1.0" encoding="utf-8"?> <?xml version="1.0" encoding="utf-8"?>
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"> "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en"> <html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en">
<head> <head>
<!-- 2020-03-13 ven. 10:34 --> <!-- 2020-08-05 mer. 13:27 -->
<meta http-equiv="Content-Type" content="text/html;charset=utf-8" /> <meta http-equiv="Content-Type" content="text/html;charset=utf-8" />
<meta name="viewport" content="width=device-width, initial-scale=1" />
<title>Stewart Platforms</title> <title>Stewart Platforms</title>
<meta name="generator" content="Org mode" /> <meta name="generator" content="Org mode" />
<meta name="author" content="Dehaeze Thomas" /> <meta name="author" content="Dehaeze Thomas" />
<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>
<link rel="stylesheet" type="text/css" href="./css/htmlize.css"/> <link rel="stylesheet" type="text/css" href="./css/htmlize.css"/>
<link rel="stylesheet" type="text/css" href="./css/readtheorg.css"/> <link rel="stylesheet" type="text/css" href="./css/readtheorg.css"/>
<script src="./js/jquery.min.js"></script> <script src="./js/jquery.min.js"></script>
<script src="./js/bootstrap.min.js"></script> <script src="./js/bootstrap.min.js"></script>
<script src="./js/jquery.stickytableheaders.min.js"></script> <script src="./js/jquery.stickytableheaders.min.js"></script>
<script src="./js/readtheorg.js"></script> <script src="./js/readtheorg.js"></script>
<script type="text/javascript">
// @license magnet:?xt=urn:btih:1f739d935676111cfff4b4693e3816e664797050&dn=gpl-3.0.txt GPL-v3-or-Later
<!--/*--><![CDATA[/*><!--*/
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
</script>
</head> </head>
<body> <body>
<div id="org-div-home-and-up"> <div id="org-div-home-and-up">
@ -270,7 +60,7 @@ Such project is briefly presented <a href="simulink-project.html">here</a>.
<h2 id="org38b9089"><span class="section-number-2">2</span> Stewart Platform Architecture Definition (<a href="stewart-architecture.html">link</a>)</h2> <h2 id="org38b9089"><span class="section-number-2">2</span> Stewart Platform Architecture Definition (<a href="stewart-architecture.html">link</a>)</h2>
<div class="outline-text-2" id="text-2"> <div class="outline-text-2" id="text-2">
<p> <p>
The way the Stewart Platform is defined <a href="stewart-architecture.html">here</a>. The way the Stewart Platform is defined is explained <a href="stewart-architecture.html">here</a>.
</p> </p>
<p> <p>
@ -416,7 +206,7 @@ Many text books, PhD thesis and articles related to parallel robots and Stewart
</div> </div>
<div id="postamble" class="status"> <div id="postamble" class="status">
<p class="author">Author: Dehaeze Thomas</p> <p class="author">Author: Dehaeze Thomas</p>
<p class="date">Created: 2020-03-13 ven. 10:34</p> <p class="date">Created: 2020-08-05 mer. 13:27</p>
</div> </div>
</body> </body>
</html> </html>

645
docs/kinematic-study.html
View File

@ -1,239 +1,27 @@
<?xml version="1.0" encoding="utf-8"?> <?xml version="1.0" encoding="utf-8"?>
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"> "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en"> <html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en">
<head> <head>
<!-- 2020-03-02 lun. 17:57 --> <!-- 2020-08-05 mer. 13:27 -->
<meta http-equiv="Content-Type" content="text/html;charset=utf-8" /> <meta http-equiv="Content-Type" content="text/html;charset=utf-8" />
<meta name="viewport" content="width=device-width, initial-scale=1" />
<title>Kinematic Study of the Stewart Platform</title> <title>Kinematic Study of the Stewart Platform</title>
<meta name="generator" content="Org mode" /> <meta name="generator" content="Org mode" />
<meta name="author" content="Dehaeze Thomas" /> <meta name="author" content="Dehaeze Thomas" />
<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>
<link rel="stylesheet" type="text/css" href="./css/htmlize.css"/> <link rel="stylesheet" type="text/css" href="./css/htmlize.css"/>
<link rel="stylesheet" type="text/css" href="./css/readtheorg.css"/> <link rel="stylesheet" type="text/css" href="./css/readtheorg.css"/>
<script src="./js/jquery.min.js"></script> <script src="./js/jquery.min.js"></script>
<script src="./js/bootstrap.min.js"></script> <script src="./js/bootstrap.min.js"></script>
<script src="./js/jquery.stickytableheaders.min.js"></script> <script src="./js/jquery.stickytableheaders.min.js"></script>
<script src="./js/readtheorg.js"></script> <script src="./js/readtheorg.js"></script>
<script type="text/javascript"> <script>MathJax = {
// @license magnet:?xt=urn:btih:1f739d935676111cfff4b4693e3816e664797050&dn=gpl-3.0.txt GPL-v3-or-Later tex: {
<!--/*--><![CDATA[/*><!--*/ tags: 'ams',
function CodeHighlightOn(elem, id) macros: {bm: ["\\boldsymbol{#1}",1],}
{
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
</script>
<script>
MathJax = {
tex: { macros: {
bm: ["\\boldsymbol{#1}",1],
}
} }
}; };
</script> </script>
<script type="text/javascript" <script type="text/javascript" src="https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js"></script>
src="https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js"></script>
</head> </head>
<body> <body>
<div id="org-div-home-and-up"> <div id="org-div-home-and-up">
@ -267,14 +55,14 @@
</li> </li>
<li><a href="#org86b4b35">4. Estimation of the range validity of the approximate inverse kinematics</a> <li><a href="#org86b4b35">4. Estimation of the range validity of the approximate inverse kinematics</a>
<ul> <ul>
<li><a href="#org7423428">4.1. Stewart architecture definition</a></li> <li><a href="#orga78aa66">4.1. Stewart architecture definition</a></li>
<li><a href="#orgd83ccf3">4.2. Comparison for &ldquo;pure&rdquo; translations</a></li> <li><a href="#orgd83ccf3">4.2. Comparison for &ldquo;pure&rdquo; translations</a></li>
<li><a href="#org4871c83">4.3. Conclusion</a></li> <li><a href="#org4871c83">4.3. Conclusion</a></li>
</ul> </ul>
</li> </li>
<li><a href="#org63255f9">5. Estimated required actuator stroke from specified platform mobility</a> <li><a href="#org63255f9">5. Estimated required actuator stroke from specified platform mobility</a>
<ul> <ul>
<li><a href="#org3e1d400">5.1. Stewart architecture definition</a></li> <li><a href="#orgadaa219">5.1. Stewart architecture definition</a></li>
<li><a href="#orgde50dd3">5.2. Wanted translations and rotations</a></li> <li><a href="#orgde50dd3">5.2. Wanted translations and rotations</a></li>
<li><a href="#org24e45ca">5.3. Needed stroke for &ldquo;pure&rdquo; rotations or translations</a></li> <li><a href="#org24e45ca">5.3. Needed stroke for &ldquo;pure&rdquo; rotations or translations</a></li>
<li><a href="#orgf6ba90c">5.4. Needed stroke for &ldquo;combined&rdquo; rotations or translations</a></li> <li><a href="#orgf6ba90c">5.4. Needed stroke for &ldquo;combined&rdquo; rotations or translations</a></li>
@ -282,36 +70,41 @@
</li> </li>
<li><a href="#orgbbbf7b3">6. Estimated platform mobility from specified actuator stroke</a> <li><a href="#orgbbbf7b3">6. Estimated platform mobility from specified actuator stroke</a>
<ul> <ul>
<li><a href="#org53d6532">6.1. Stewart architecture definition</a></li> <li><a href="#org6a6a5df">6.1. Stewart architecture definition</a></li>
<li><a href="#org2c6819e">6.2. Pure translations</a></li> <li><a href="#org2c6819e">6.2. Pure translations</a></li>
</ul> </ul>
</li> </li>
<li><a href="#orgc4916dc">7. Functions</a> <li><a href="#orgad495dd">7. Estimation of the Joint required Stroke</a>
<ul> <ul>
<li><a href="#org26e8b28">7.1. <code>computeJacobian</code>: Compute the Jacobian Matrix</a> <li><a href="#orgae20178">7.1. Example of the initialization of a Stewart Platform</a></li>
</ul>
</li>
<li><a href="#orgc4916dc">8. Functions</a>
<ul> <ul>
<li><a href="#orgd0d007d">Function description</a></li> <li><a href="#org26e8b28">8.1. <code>computeJacobian</code>: Compute the Jacobian Matrix</a>
<li><a href="#orge1b5b04">Check the <code>stewart</code> structure elements</a></li> <ul>
<li><a href="#orgcde905e">Function description</a></li>
<li><a href="#org5be121e">Check the <code>stewart</code> structure elements</a></li>
<li><a href="#org0cd57b5">Compute Jacobian Matrix</a></li> <li><a href="#org0cd57b5">Compute Jacobian Matrix</a></li>
<li><a href="#orge21dcfc">Compute Stiffness Matrix</a></li> <li><a href="#orge21dcfc">Compute Stiffness Matrix</a></li>
<li><a href="#orgae76071">Compute Compliance Matrix</a></li> <li><a href="#orgae76071">Compute Compliance Matrix</a></li>
<li><a href="#org78f18d7">Populate the <code>stewart</code> structure</a></li> <li><a href="#org78f18d7">Populate the <code>stewart</code> structure</a></li>
</ul> </ul>
</li> </li>
<li><a href="#orgb82066f">7.2. <code>inverseKinematics</code>: Compute Inverse Kinematics</a> <li><a href="#orgb82066f">8.2. <code>inverseKinematics</code>: Compute Inverse Kinematics</a>
<ul> <ul>
<li><a href="#org89930b7">Theory</a></li> <li><a href="#org89930b7">Theory</a></li>
<li><a href="#org755b2ae">Function description</a></li> <li><a href="#orgb66d0e9">Function description</a></li>
<li><a href="#org867b3a0">Optional Parameters</a></li> <li><a href="#org0aeb7ad">Optional Parameters</a></li>
<li><a href="#org318eb5f">Check the <code>stewart</code> structure elements</a></li> <li><a href="#orga54645b">Check the <code>stewart</code> structure elements</a></li>
<li><a href="#org0d64c23">Compute</a></li> <li><a href="#org0d64c23">Compute</a></li>
</ul> </ul>
</li> </li>
<li><a href="#orgf5d8f0b">7.3. <code>forwardKinematicsApprox</code>: Compute the Approximate Forward Kinematics</a> <li><a href="#orgf5d8f0b">8.3. <code>forwardKinematicsApprox</code>: Compute the Approximate Forward Kinematics</a>
<ul> <ul>
<li><a href="#orgba3bc64">Function description</a></li> <li><a href="#orgc074bc3">Function description</a></li>
<li><a href="#org7af7974">Optional Parameters</a></li> <li><a href="#org9a855b1">Optional Parameters</a></li>
<li><a href="#org2ba5e64">Check the <code>stewart</code> structure elements</a></li> <li><a href="#orgdc0187a">Check the <code>stewart</code> structure elements</a></li>
<li><a href="#orge5ade24">Computation</a></li> <li><a href="#orge5ade24">Computation</a></li>
</ul> </ul>
</li> </li>
@ -322,7 +115,7 @@
</div> </div>
<p> <p>
The kinematic analysis of a parallel manipulator is well described in <a class='org-ref-reference' href="#taghirad13_paral">taghirad13_paral</a>: The kinematic analysis of a parallel manipulator is well described in (<a href="#citeproc_bib_item_1">Taghirad 2013</a>):
</p> </p>
<blockquote> <blockquote>
<p> <p>
@ -349,7 +142,7 @@ The current document is divided in the following sections:
<a id="orgc45d118"></a> <a id="orgc45d118"></a>
</p> </p>
<p> <p>
From <a class='org-ref-reference' href="#taghirad13_paral">taghirad13_paral</a>: From (<a href="#citeproc_bib_item_1">Taghirad 2013</a>):
</p> </p>
<blockquote> <blockquote>
<p> <p>
@ -478,6 +271,7 @@ As explain in <a href="stewart-architecture.html">this</a> document, each Actuat
<ul class="org-ul"> <ul class="org-ul">
<li>A spring with a stiffness \(k_{i}\)</li> <li>A spring with a stiffness \(k_{i}\)</li>
<li>A dashpot with a damping \(c_{i}\)</li> <li>A dashpot with a damping \(c_{i}\)</li>
<li>A force source \(\tau_i\)</li>
</ul> </ul>
<p> <p>
@ -657,15 +451,15 @@ This will also gives us the range for which the approximate forward kinematic is
</p> </p>
</div> </div>
<div id="outline-container-org7423428" class="outline-3"> <div id="outline-container-orga78aa66" class="outline-3">
<h3 id="org7423428"><span class="section-number-3">4.1</span> Stewart architecture definition</h3> <h3 id="orga78aa66"><span class="section-number-3">4.1</span> Stewart architecture definition</h3>
<div class="outline-text-3" id="text-4-1"> <div class="outline-text-3" id="text-4-1">
<p> <p>
We first define some general Stewart architecture. We first define some general Stewart architecture.
</p> </p>
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab">stewart = initializeStewartPlatform(); <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 = initializeFramesPositions(stewart, 'H', 90e-3, 'MO_B', 45e-3);
stewart = generateGeneralConfiguration(stewart); stewart = generateGeneralConfiguration(stewart);
stewart = computeJointsPose(stewart); stewart = computeJointsPose(stewart);
stewart = initializeStewartPose(stewart); stewart = initializeStewartPose(stewart);
@ -692,16 +486,16 @@ The estimate required strut stroke for both the approximate and exact solutions
The relative strut length displacement is shown in Figure <a href="#org02d8e34">2</a>. The relative strut length displacement is shown in Figure <a href="#org02d8e34">2</a>.
</p> </p>
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab">Xrs = logspace(<span class="org-type">-</span>6, <span class="org-type">-</span>1, 100); <span class="org-comment">% Wanted X translation of the mobile platform [m]</span> <pre class="src src-matlab">Xrs = logspace(-6, -1, 100); % Wanted X translation of the mobile platform [m]
Ls_approx = zeros(6, length(Xrs)); Ls_approx = zeros(6, length(Xrs));
Ls_exact = zeros(6, length(Xrs)); Ls_exact = zeros(6, length(Xrs));
<span class="org-keyword">for</span> <span class="org-variable-name"><span class="org-constant">i</span></span> = <span class="org-constant">1:length(Xrs)</span> for i = 1:length(Xrs)
Xr = Xrs(<span class="org-constant">i</span>); Xr = Xrs(i);
L_approx(<span class="org-type">:</span>, <span class="org-constant">i</span>) = stewart.kinematics.J<span class="org-type">*</span>[Xr; 0; 0; 0; 0; 0;]; L_approx(:, i) = stewart.kinematics.J*[Xr; 0; 0; 0; 0; 0;];
[<span class="org-type">~</span>, L_exact(<span class="org-type">:</span>, <span class="org-constant">i</span>)] = inverseKinematics(stewart, <span class="org-string">'AP'</span>, [Xr; 0; 0]); [~, L_exact(:, i)] = inverseKinematics(stewart, 'AP', [Xr; 0; 0]);
<span class="org-keyword">end</span> end
</pre> </pre>
</div> </div>
@ -758,15 +552,15 @@ This is what is analyzed in this section.
</p> </p>
</div> </div>
<div id="outline-container-org3e1d400" class="outline-3"> <div id="outline-container-orgadaa219" class="outline-3">
<h3 id="org3e1d400"><span class="section-number-3">5.1</span> Stewart architecture definition</h3> <h3 id="orgadaa219"><span class="section-number-3">5.1</span> Stewart architecture definition</h3>
<div class="outline-text-3" id="text-5-1"> <div class="outline-text-3" id="text-5-1">
<p> <p>
Let&rsquo;s first define the Stewart platform architecture that we want to study. Let&rsquo;s first define the Stewart platform architecture that we want to study.
</p> </p>
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab">stewart = initializeStewartPlatform(); <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 = initializeFramesPositions(stewart, 'H', 90e-3, 'MO_B', 45e-3);
stewart = generateGeneralConfiguration(stewart); stewart = generateGeneralConfiguration(stewart);
stewart = computeJointsPose(stewart); stewart = computeJointsPose(stewart);
stewart = initializeStewartPose(stewart); stewart = initializeStewartPose(stewart);
@ -787,12 +581,12 @@ stewart = computeJacobian(stewart);
Let&rsquo;s now define the wanted extreme translations and rotations. Let&rsquo;s now define the wanted extreme translations and rotations.
</p> </p>
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab">Tx_max = 50e<span class="org-type">-</span>6; <span class="org-comment">% Translation [m]</span> <pre class="src src-matlab">Tx_max = 50e-6; % Translation [m]
Ty_max = 50e<span class="org-type">-</span>6; <span class="org-comment">% Translation [m]</span> Ty_max = 50e-6; % Translation [m]
Tz_max = 50e<span class="org-type">-</span>6; <span class="org-comment">% Translation [m]</span> Tz_max = 50e-6; % Translation [m]
Rx_max = 30e<span class="org-type">-</span>6; <span class="org-comment">% Rotation [rad]</span> Rx_max = 30e-6; % Rotation [rad]
Ry_max = 30e<span class="org-type">-</span>6; <span class="org-comment">% Rotation [rad]</span> Ry_max = 30e-6; % Rotation [rad]
Rz_max = 0; <span class="org-comment">% Rotation [rad]</span> Rz_max = 0; % Rotation [rad]
</pre> </pre>
</div> </div>
</div> </div>
@ -807,12 +601,12 @@ We do that using either the Inverse Kinematic solution or the Jacobian matrix as
</p> </p>
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab">LTx = stewart.kinematics.J<span class="org-type">*</span>[Tx_max 0 0 0 0 0]<span class="org-type">'</span>; <pre class="src src-matlab">LTx = stewart.kinematics.J*[Tx_max 0 0 0 0 0]';
LTy = stewart.kinematics.J<span class="org-type">*</span>[0 Ty_max 0 0 0 0]<span class="org-type">'</span>; LTy = stewart.kinematics.J*[0 Ty_max 0 0 0 0]';
LTz = stewart.kinematics.J<span class="org-type">*</span>[0 0 Tz_max 0 0 0]<span class="org-type">'</span>; LTz = stewart.kinematics.J*[0 0 Tz_max 0 0 0]';
LRx = stewart.kinematics.J<span class="org-type">*</span>[0 0 0 Rx_max 0 0]<span class="org-type">'</span>; LRx = stewart.kinematics.J*[0 0 0 Rx_max 0 0]';
LRy = stewart.kinematics.J<span class="org-type">*</span>[0 0 0 0 Ry_max 0]<span class="org-type">'</span>; LRy = stewart.kinematics.J*[0 0 0 0 Ry_max 0]';
LRz = stewart.kinematics.J<span class="org-type">*</span>[0 0 0 0 0 Rz_max]<span class="org-type">'</span>; LRz = stewart.kinematics.J*[0 0 0 0 0 Rz_max]';
</pre> </pre>
</div> </div>
@ -845,7 +639,7 @@ To do so, we may estimate the required actuator stroke for all possible combinat
Let&rsquo;s first generate all the possible combination of maximum translation and rotations. Let&rsquo;s first generate all the possible combination of maximum translation and rotations.
</p> </p>
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab">Ps = [2<span class="org-type">*</span>(dec2bin(0<span class="org-type">:</span>5<span class="org-type">^</span>2<span class="org-type">-</span>1,5)<span class="org-type">-</span><span class="org-string">'0'</span>)<span class="org-type">-</span>1, zeros(5<span class="org-type">^</span>2, 1)]<span class="org-type">.*</span>[Tx_max Ty_max Tz_max Rx_max Ry_max Rz_max]; <pre class="src src-matlab">Ps = [2*(dec2bin(0:5^2-1,5)-'0')-1, zeros(5^2, 1)].*[Tx_max Ty_max Tz_max Rx_max Ry_max Rz_max];
</pre> </pre>
</div> </div>
@ -1110,29 +904,29 @@ For all possible combination, we compute the required actuator stroke using the
<pre class="src src-matlab">L_min = 0; <pre class="src src-matlab">L_min = 0;
L_max = 0; L_max = 0;
<span class="org-keyword">for</span> <span class="org-variable-name"><span class="org-constant">i</span></span> = <span class="org-constant">1:size(Ps,1)</span> for i = 1:size(Ps,1)
Rx = [1 0 0; Rx = [1 0 0;
0 cos(Ps(<span class="org-constant">i</span>, 4)) <span class="org-type">-</span>sin(Ps(<span class="org-constant">i</span>, 4)); 0 cos(Ps(i, 4)) -sin(Ps(i, 4));
0 sin(Ps(<span class="org-constant">i</span>, 4)) cos(Ps(<span class="org-constant">i</span>, 4))]; 0 sin(Ps(i, 4)) cos(Ps(i, 4))];
Ry = [ cos(Ps(<span class="org-constant">i</span>, 5)) 0 sin(Ps(<span class="org-constant">i</span>, 5)); Ry = [ cos(Ps(i, 5)) 0 sin(Ps(i, 5));
0 1 0; 0 1 0;
<span class="org-type">-</span>sin(Ps(<span class="org-constant">i</span>, 5)) 0 cos(Ps(<span class="org-constant">i</span>, 5))]; -sin(Ps(i, 5)) 0 cos(Ps(i, 5))];
Rz = [cos(Ps(<span class="org-constant">i</span>, 6)) <span class="org-type">-</span>sin(Ps(<span class="org-constant">i</span>, 6)) 0; Rz = [cos(Ps(i, 6)) -sin(Ps(i, 6)) 0;
sin(Ps(<span class="org-constant">i</span>, 6)) cos(Ps(<span class="org-constant">i</span>, 6)) 0; sin(Ps(i, 6)) cos(Ps(i, 6)) 0;
0 0 1]; 0 0 1];
ARB = Rz<span class="org-type">*</span>Ry<span class="org-type">*</span>Rx; ARB = Rz*Ry*Rx;
[<span class="org-type">~</span>, Ls] = inverseKinematics(stewart, <span class="org-string">'AP'</span>, Ps(<span class="org-constant">i</span>, 1<span class="org-type">:</span>3)<span class="org-type">'</span>, <span class="org-string">'ARB'</span>, ARB); [~, Ls] = inverseKinematics(stewart, 'AP', Ps(i, 1:3)', 'ARB', ARB);
<span class="org-keyword">if</span> min(Ls) <span class="org-type">&lt;</span> L_min if min(Ls) &lt; L_min
L_min = min(Ls) L_min = min(Ls)
<span class="org-keyword">end</span> end
<span class="org-keyword">if</span> max(Ls) <span class="org-type">&gt;</span> L_max if max(Ls) &gt; L_max
L_max = max(Ls) L_max = max(Ls)
<span class="org-keyword">end</span> end
<span class="org-keyword">end</span> end
</pre> </pre>
</div> </div>
@ -1178,15 +972,15 @@ However, for small displacements, we can use the Jacobian as an approximate solu
</p> </p>
</div> </div>
<div id="outline-container-org53d6532" class="outline-3"> <div id="outline-container-org6a6a5df" class="outline-3">
<h3 id="org53d6532"><span class="section-number-3">6.1</span> Stewart architecture definition</h3> <h3 id="org6a6a5df"><span class="section-number-3">6.1</span> Stewart architecture definition</h3>
<div class="outline-text-3" id="text-6-1"> <div class="outline-text-3" id="text-6-1">
<p> <p>
Let&rsquo;s first define the Stewart platform architecture that we want to study. Let&rsquo;s first define the Stewart platform architecture that we want to study.
</p> </p>
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab">stewart = initializeStewartPlatform(); <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 = initializeFramesPositions(stewart, 'H', 90e-3, 'MO_B', 45e-3);
stewart = generateGeneralConfiguration(stewart); stewart = generateGeneralConfiguration(stewart);
stewart = computeJointsPose(stewart); stewart = computeJointsPose(stewart);
stewart = initializeStewartPose(stewart); stewart = initializeStewartPose(stewart);
@ -1202,8 +996,8 @@ stewart = computeJacobian(stewart);
Let&rsquo;s now define the actuator stroke. Let&rsquo;s now define the actuator stroke.
</p> </p>
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab">L_min = <span class="org-type">-</span>50e<span class="org-type">-</span>6; <span class="org-comment">% [m]</span> <pre class="src src-matlab">L_min = -50e-6; % [m]
L_max = 50e<span class="org-type">-</span>6; <span class="org-comment">% [m]</span> L_max = 50e-6; % [m]
</pre> </pre>
</div> </div>
</div> </div>
@ -1231,21 +1025,21 @@ To obtain the mobility &ldquo;volume&rdquo; attainable by the Stewart platform w
For each possible value of \((\theta, \phi)\), we compute the maximum radius \(r\) attainable with the constraint that the stroke of each actuator should be between <code>L_min</code> and <code>L_max</code>. For each possible value of \((\theta, \phi)\), we compute the maximum radius \(r\) attainable with the constraint that the stroke of each actuator should be between <code>L_min</code> and <code>L_max</code>.
</p> </p>
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab">thetas = linspace(0, <span class="org-constant">pi</span>, 50); <pre class="src src-matlab">thetas = linspace(0, pi, 50);
phis = linspace(0, 2<span class="org-type">*</span><span class="org-constant">pi</span>, 50); phis = linspace(0, 2*pi, 50);
rs = zeros(length(thetas), length(phis)); rs = zeros(length(thetas), length(phis));
<span class="org-keyword">for</span> <span class="org-variable-name"><span class="org-constant">i</span></span> = <span class="org-constant">1:length(thetas)</span> for i = 1:length(thetas)
<span class="org-keyword">for</span> <span class="org-variable-name"><span class="org-constant">j</span></span> = <span class="org-constant">1:length(phis)</span> for j = 1:length(phis)
Tx = sin(thetas(<span class="org-constant">i</span>))<span class="org-type">*</span>cos(phis(<span class="org-constant">j</span>)); Tx = sin(thetas(i))*cos(phis(j));
Ty = sin(thetas(<span class="org-constant">i</span>))<span class="org-type">*</span>sin(phis(<span class="org-constant">j</span>)); Ty = sin(thetas(i))*sin(phis(j));
Tz = cos(thetas(<span class="org-constant">i</span>)); Tz = cos(thetas(i));
dL = stewart.kinematics.J<span class="org-type">*</span>[Tx; Ty; Tz; 0; 0; 0;]; <span class="org-comment">% dL required for 1m displacement in theta/phi direction</span> dL = stewart.kinematics.J*[Tx; Ty; Tz; 0; 0; 0;]; % dL required for 1m displacement in theta/phi direction
rs(<span class="org-constant">i</span>, <span class="org-constant">j</span>) = max([dL(dL<span class="org-type">&lt;</span>0)<span class="org-type">*</span>L_min; dL(dL<span class="org-type">&gt;</span>0)<span class="org-type">*</span>L_max]); rs(i, j) = max([dL(dL&lt;0)*L_min; dL(dL&gt;0)*L_max]);
<span class="org-keyword">end</span> end
<span class="org-keyword">end</span> end
</pre> </pre>
</div> </div>
@ -1291,16 +1085,77 @@ We can also approximate the mobility by a sphere with a radius equal to the mini
</div> </div>
</div> </div>
<div id="outline-container-orgc4916dc" class="outline-2"> <div id="outline-container-orgad495dd" class="outline-2">
<h2 id="orgc4916dc"><span class="section-number-2">7</span> Functions</h2> <h2 id="orgad495dd"><span class="section-number-2">7</span> Estimation of the Joint required Stroke</h2>
<div class="outline-text-2" id="text-7"> <div class="outline-text-2" id="text-7">
</div>
<div id="outline-container-orgae20178" class="outline-3">
<h3 id="orgae20178"><span class="section-number-3">7.1</span> Example of the initialization of a Stewart Platform</h3>
<div class="outline-text-3" id="text-7-1">
<p>
Let&rsquo;s first define the Stewart Platform Geometry.
</p>
<div class="org-src-container">
<pre class="src src-matlab">stewart = initializeStewartPlatform();
stewart = initializeFramesPositions(stewart, 'H', 90e-3, 'MO_B', 150e-3);
stewart = generateGeneralConfiguration(stewart);
stewart = computeJointsPose(stewart);
As_init = stewart.geometry.As;
</pre>
</div>
<div class="org-src-container">
<pre class="src src-matlab">Tx_max = 50e-6; % Translation [m]
Ty_max = 50e-6; % Translation [m]
Tz_max = 50e-6; % Translation [m]
</pre>
</div>
<div class="org-src-container">
<pre class="src src-matlab">Ps = [2*(dec2bin(0:3^2-2,3)-'0')-1].*[Tx_max Ty_max Tz_max];
</pre>
</div>
<div class="org-src-container">
<pre class="src src-matlab">flex_ang = zeros(size(Ps, 1), 6);
for Ps_i = 1:size(Ps, 1)
stewart.geometry.FO_M = [0; 0; 90e-3] + Ps(Ps_i, :)';
stewart = generateGeneralConfiguration(stewart);
stewart = computeJointsPose(stewart);
flex_ang(Ps_i, :) = acos(sum(As_init.*stewart.geometry.As));
end
</pre>
</div>
<p>
And the maximum bending of the flexible joints is: (in [mrad])
</p>
<div class="org-src-container">
<pre class="src src-matlab">1e3*max(max(abs(flex_ang)))
</pre>
</div>
<pre class="example">
0.90937
</pre>
</div>
</div>
</div>
<div id="outline-container-orgc4916dc" class="outline-2">
<h2 id="orgc4916dc"><span class="section-number-2">8</span> Functions</h2>
<div class="outline-text-2" id="text-8">
<p> <p>
<a id="orgf9a6042"></a> <a id="orgf9a6042"></a>
</p> </p>
</div> </div>
<div id="outline-container-org26e8b28" class="outline-3"> <div id="outline-container-org26e8b28" class="outline-3">
<h3 id="org26e8b28"><span class="section-number-3">7.1</span> <code>computeJacobian</code>: Compute the Jacobian Matrix</h3> <h3 id="org26e8b28"><span class="section-number-3">8.1</span> <code>computeJacobian</code>: Compute the Jacobian Matrix</h3>
<div class="outline-text-3" id="text-7-1"> <div class="outline-text-3" id="text-8-1">
<p> <p>
<a id="org2387f19"></a> <a id="org2387f19"></a>
</p> </p>
@ -1310,42 +1165,42 @@ This Matlab function is accessible <a href="../src/computeJacobian.m">here</a>.
</p> </p>
</div> </div>
<div id="outline-container-orgd0d007d" class="outline-4"> <div id="outline-container-orgcde905e" class="outline-4">
<h4 id="orgd0d007d">Function description</h4> <h4 id="orgcde905e">Function description</h4>
<div class="outline-text-4" id="text-orgd0d007d"> <div class="outline-text-4" id="text-orgcde905e">
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab"><span class="org-keyword">function</span> <span class="org-variable-name">[stewart]</span> = <span class="org-function-name">computeJacobian</span>(<span class="org-variable-name">stewart</span>) <pre class="src src-matlab">function [stewart] = computeJacobian(stewart)
<span class="org-comment">% computeJacobian -</span> % computeJacobian -
<span class="org-comment">%</span> %
<span class="org-comment">% Syntax: [stewart] = computeJacobian(stewart)</span> % Syntax: [stewart] = computeJacobian(stewart)
<span class="org-comment">%</span> %
<span class="org-comment">% Inputs:</span> % Inputs:
<span class="org-comment">% - stewart - With at least the following fields:</span> % - stewart - With at least the following fields:
<span class="org-comment">% - geometry.As [3x6] - The 6 unit vectors for each strut expressed in {A}</span> % - geometry.As [3x6] - The 6 unit vectors for each strut expressed in {A}
<span class="org-comment">% - geometry.Ab [3x6] - The 6 position of the joints bi expressed in {A}</span> % - geometry.Ab [3x6] - The 6 position of the joints bi expressed in {A}
<span class="org-comment">% - actuators.K [6x1] - Total stiffness of the actuators</span> % - actuators.K [6x1] - Total stiffness of the actuators
<span class="org-comment">%</span> %
<span class="org-comment">% Outputs:</span> % Outputs:
<span class="org-comment">% - stewart - With the 3 added field:</span> % - stewart - With the 3 added field:
<span class="org-comment">% - kinematics.J [6x6] - The Jacobian Matrix</span> % - kinematics.J [6x6] - The Jacobian Matrix
<span class="org-comment">% - kinematics.K [6x6] - The Stiffness Matrix</span> % - kinematics.K [6x6] - The Stiffness Matrix
<span class="org-comment">% - kinematics.C [6x6] - The Compliance Matrix</span> % - kinematics.C [6x6] - The Compliance Matrix
</pre> </pre>
</div> </div>
</div> </div>
</div> </div>
<div id="outline-container-orge1b5b04" class="outline-4"> <div id="outline-container-org5be121e" class="outline-4">
<h4 id="orge1b5b04">Check the <code>stewart</code> structure elements</h4> <h4 id="org5be121e">Check the <code>stewart</code> structure elements</h4>
<div class="outline-text-4" id="text-orge1b5b04"> <div class="outline-text-4" id="text-org5be121e">
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab">assert(isfield(stewart.geometry, <span class="org-string">'As'</span>), <span class="org-string">'stewart.geometry should have attribute As'</span>) <pre class="src src-matlab">assert(isfield(stewart.geometry, 'As'), 'stewart.geometry should have attribute As')
As = stewart.geometry.As; As = stewart.geometry.As;
assert(isfield(stewart.geometry, <span class="org-string">'Ab'</span>), <span class="org-string">'stewart.geometry should have attribute Ab'</span>) assert(isfield(stewart.geometry, 'Ab'), 'stewart.geometry should have attribute Ab')
Ab = stewart.geometry.Ab; Ab = stewart.geometry.Ab;
assert(isfield(stewart.actuators, <span class="org-string">'K'</span>), <span class="org-string">'stewart.actuators should have attribute K'</span>) assert(isfield(stewart.actuators, 'K'), 'stewart.actuators should have attribute K')
Ki = stewart.actuators.K; Ki = stewart.actuators.K;
</pre> </pre>
</div> </div>
@ -1357,7 +1212,7 @@ Ki = stewart.actuators.K;
<h4 id="org0cd57b5">Compute Jacobian Matrix</h4> <h4 id="org0cd57b5">Compute Jacobian Matrix</h4>
<div class="outline-text-4" id="text-org0cd57b5"> <div class="outline-text-4" id="text-org0cd57b5">
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab">J = [As<span class="org-type">'</span> , cross(Ab, As)<span class="org-type">'</span>]; <pre class="src src-matlab">J = [As' , cross(Ab, As)'];
</pre> </pre>
</div> </div>
</div> </div>
@ -1367,7 +1222,7 @@ Ki = stewart.actuators.K;
<h4 id="orge21dcfc">Compute Stiffness Matrix</h4> <h4 id="orge21dcfc">Compute Stiffness Matrix</h4>
<div class="outline-text-4" id="text-orge21dcfc"> <div class="outline-text-4" id="text-orge21dcfc">
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab">K = J<span class="org-type">'*</span>diag(Ki)<span class="org-type">*</span>J; <pre class="src src-matlab">K = J'*diag(Ki)*J;
</pre> </pre>
</div> </div>
</div> </div>
@ -1398,8 +1253,8 @@ stewart.kinematics.C = C;
<div id="outline-container-orgb82066f" class="outline-3"> <div id="outline-container-orgb82066f" class="outline-3">
<h3 id="orgb82066f"><span class="section-number-3">7.2</span> <code>inverseKinematics</code>: Compute Inverse Kinematics</h3> <h3 id="orgb82066f"><span class="section-number-3">8.2</span> <code>inverseKinematics</code>: Compute Inverse Kinematics</h3>
<div class="outline-text-3" id="text-7-2"> <div class="outline-text-3" id="text-8-2">
<p> <p>
<a id="orgb8859d7"></a> <a id="orgb8859d7"></a>
</p> </p>
@ -1445,57 +1300,57 @@ Otherwise, when the limbs&rsquo; lengths derived yield complex numbers, then the
</div> </div>
</div> </div>
<div id="outline-container-org755b2ae" class="outline-4"> <div id="outline-container-orgb66d0e9" class="outline-4">
<h4 id="org755b2ae">Function description</h4> <h4 id="orgb66d0e9">Function description</h4>
<div class="outline-text-4" id="text-org755b2ae"> <div class="outline-text-4" id="text-orgb66d0e9">
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab"><span class="org-keyword">function</span> <span class="org-variable-name">[Li, dLi]</span> = <span class="org-function-name">inverseKinematics</span>(<span class="org-variable-name">stewart</span>, <span class="org-variable-name">args</span>) <pre class="src src-matlab">function [Li, dLi] = inverseKinematics(stewart, args)
<span class="org-comment">% inverseKinematics - Compute the needed length of each strut to have the wanted position and orientation of {B} with respect to {A}</span> % inverseKinematics - Compute the needed length of each strut to have the wanted position and orientation of {B} with respect to {A}
<span class="org-comment">%</span> %
<span class="org-comment">% Syntax: [stewart] = inverseKinematics(stewart)</span> % Syntax: [stewart] = inverseKinematics(stewart)
<span class="org-comment">%</span> %
<span class="org-comment">% Inputs:</span> % Inputs:
<span class="org-comment">% - stewart - A structure with the following fields</span> % - stewart - A structure with the following fields
<span class="org-comment">% - geometry.Aa [3x6] - The positions ai expressed in {A}</span> % - geometry.Aa [3x6] - The positions ai expressed in {A}
<span class="org-comment">% - geometry.Bb [3x6] - The positions bi expressed in {B}</span> % - geometry.Bb [3x6] - The positions bi expressed in {B}
<span class="org-comment">% - geometry.l [6x1] - Length of each strut</span> % - geometry.l [6x1] - Length of each strut
<span class="org-comment">% - args - Can have the following fields:</span> % - args - Can have the following fields:
<span class="org-comment">% - AP [3x1] - The wanted position of {B} with respect to {A}</span> % - AP [3x1] - The wanted position of {B} with respect to {A}
<span class="org-comment">% - ARB [3x3] - The rotation matrix that gives the wanted orientation of {B} with respect to {A}</span> % - ARB [3x3] - The rotation matrix that gives the wanted orientation of {B} with respect to {A}
<span class="org-comment">%</span> %
<span class="org-comment">% Outputs:</span> % Outputs:
<span class="org-comment">% - Li [6x1] - The 6 needed length of the struts in [m] to have the wanted pose of {B} w.r.t. {A}</span> % - Li [6x1] - The 6 needed length of the struts in [m] to have the wanted pose of {B} w.r.t. {A}
<span class="org-comment">% - dLi [6x1] - The 6 needed displacement of the struts from the initial position in [m] to have the wanted pose of {B} w.r.t. {A}</span> % - dLi [6x1] - The 6 needed displacement of the struts from the initial position in [m] to have the wanted pose of {B} w.r.t. {A}
</pre> </pre>
</div> </div>
</div> </div>
</div> </div>
<div id="outline-container-org867b3a0" class="outline-4"> <div id="outline-container-org0aeb7ad" class="outline-4">
<h4 id="org867b3a0">Optional Parameters</h4> <h4 id="org0aeb7ad">Optional Parameters</h4>
<div class="outline-text-4" id="text-org867b3a0"> <div class="outline-text-4" id="text-org0aeb7ad">
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab">arguments <pre class="src src-matlab">arguments
stewart stewart
args.AP (3,1) double {mustBeNumeric} = zeros(3,1) args.AP (3,1) double {mustBeNumeric} = zeros(3,1)
args.ARB (3,3) double {mustBeNumeric} = eye(3) args.ARB (3,3) double {mustBeNumeric} = eye(3)
<span class="org-keyword">end</span> end
</pre> </pre>
</div> </div>
</div> </div>
</div> </div>
<div id="outline-container-org318eb5f" class="outline-4"> <div id="outline-container-orga54645b" class="outline-4">
<h4 id="org318eb5f">Check the <code>stewart</code> structure elements</h4> <h4 id="orga54645b">Check the <code>stewart</code> structure elements</h4>
<div class="outline-text-4" id="text-org318eb5f"> <div class="outline-text-4" id="text-orga54645b">
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab">assert(isfield(stewart.geometry, <span class="org-string">'Aa'</span>), <span class="org-string">'stewart.geometry should have attribute Aa'</span>) <pre class="src src-matlab">assert(isfield(stewart.geometry, 'Aa'), 'stewart.geometry should have attribute Aa')
Aa = stewart.geometry.Aa; Aa = stewart.geometry.Aa;
assert(isfield(stewart.geometry, <span class="org-string">'Bb'</span>), <span class="org-string">'stewart.geometry should have attribute Bb'</span>) assert(isfield(stewart.geometry, 'Bb'), 'stewart.geometry should have attribute Bb')
Bb = stewart.geometry.Bb; Bb = stewart.geometry.Bb;
assert(isfield(stewart.geometry, <span class="org-string">'l'</span>), <span class="org-string">'stewart.geometry should have attribute l'</span>) assert(isfield(stewart.geometry, 'l'), 'stewart.geometry should have attribute l')
l = stewart.geometry.l; l = stewart.geometry.l;
</pre> </pre>
</div> </div>
@ -1507,12 +1362,12 @@ l = stewart.geometry.l;
<h4 id="org0d64c23">Compute</h4> <h4 id="org0d64c23">Compute</h4>
<div class="outline-text-4" id="text-org0d64c23"> <div class="outline-text-4" id="text-org0d64c23">
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab">Li = sqrt(args.AP<span class="org-type">'*</span>args.AP <span class="org-type">+</span> diag(Bb<span class="org-type">'*</span>Bb) <span class="org-type">+</span> diag(Aa<span class="org-type">'*</span>Aa) <span class="org-type">-</span> (2<span class="org-type">*</span>args.AP<span class="org-type">'*</span>Aa)<span class="org-type">'</span> <span class="org-type">+</span> (2<span class="org-type">*</span>args.AP<span class="org-type">'*</span>(args.ARB<span class="org-type">*</span>Bb))<span class="org-type">'</span> <span class="org-type">-</span> diag(2<span class="org-type">*</span>(args.ARB<span class="org-type">*</span>Bb)<span class="org-type">'*</span>Aa)); <pre class="src src-matlab">Li = sqrt(args.AP'*args.AP + diag(Bb'*Bb) + diag(Aa'*Aa) - (2*args.AP'*Aa)' + (2*args.AP'*(args.ARB*Bb))' - diag(2*(args.ARB*Bb)'*Aa));
</pre> </pre>
</div> </div>
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab">dLi = Li<span class="org-type">-</span>l; <pre class="src src-matlab">dLi = Li-l;
</pre> </pre>
</div> </div>
</div> </div>
@ -1520,8 +1375,8 @@ l = stewart.geometry.l;
</div> </div>
<div id="outline-container-orgf5d8f0b" class="outline-3"> <div id="outline-container-orgf5d8f0b" class="outline-3">
<h3 id="orgf5d8f0b"><span class="section-number-3">7.3</span> <code>forwardKinematicsApprox</code>: Compute the Approximate Forward Kinematics</h3> <h3 id="orgf5d8f0b"><span class="section-number-3">8.3</span> <code>forwardKinematicsApprox</code>: Compute the Approximate Forward Kinematics</h3>
<div class="outline-text-3" id="text-7-3"> <div class="outline-text-3" id="text-8-3">
<p> <p>
<a id="orgdb31434"></a> <a id="orgdb31434"></a>
</p> </p>
@ -1531,48 +1386,48 @@ This Matlab function is accessible <a href="../src/forwardKinematicsApprox.m">he
</p> </p>
</div> </div>
<div id="outline-container-orgba3bc64" class="outline-4"> <div id="outline-container-orgc074bc3" class="outline-4">
<h4 id="orgba3bc64">Function description</h4> <h4 id="orgc074bc3">Function description</h4>
<div class="outline-text-4" id="text-orgba3bc64"> <div class="outline-text-4" id="text-orgc074bc3">
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab"><span class="org-keyword">function</span> <span class="org-variable-name">[P, R]</span> = <span class="org-function-name">forwardKinematicsApprox</span>(<span class="org-variable-name">stewart</span>, <span class="org-variable-name">args</span>) <pre class="src src-matlab">function [P, R] = forwardKinematicsApprox(stewart, args)
<span class="org-comment">% forwardKinematicsApprox - Computed the approximate pose of {B} with respect to {A} from the length of each strut and using</span> % forwardKinematicsApprox - Computed the approximate pose of {B} with respect to {A} from the length of each strut and using
<span class="org-comment">% the Jacobian Matrix</span> % the Jacobian Matrix
<span class="org-comment">%</span> %
<span class="org-comment">% Syntax: [P, R] = forwardKinematicsApprox(stewart, args)</span> % Syntax: [P, R] = forwardKinematicsApprox(stewart, args)
<span class="org-comment">%</span> %
<span class="org-comment">% Inputs:</span> % Inputs:
<span class="org-comment">% - stewart - A structure with the following fields</span> % - stewart - A structure with the following fields
<span class="org-comment">% - kinematics.J [6x6] - The Jacobian Matrix</span> % - kinematics.J [6x6] - The Jacobian Matrix
<span class="org-comment">% - args - Can have the following fields:</span> % - args - Can have the following fields:
<span class="org-comment">% - dL [6x1] - Displacement of each strut [m]</span> % - dL [6x1] - Displacement of each strut [m]
<span class="org-comment">%</span> %
<span class="org-comment">% Outputs:</span> % Outputs:
<span class="org-comment">% - P [3x1] - The estimated position of {B} with respect to {A}</span> % - P [3x1] - The estimated position of {B} with respect to {A}
<span class="org-comment">% - R [3x3] - The estimated rotation matrix that gives the orientation of {B} with respect to {A}</span> % - R [3x3] - The estimated rotation matrix that gives the orientation of {B} with respect to {A}
</pre> </pre>
</div> </div>
</div> </div>
</div> </div>
<div id="outline-container-org7af7974" class="outline-4"> <div id="outline-container-org9a855b1" class="outline-4">
<h4 id="org7af7974">Optional Parameters</h4> <h4 id="org9a855b1">Optional Parameters</h4>
<div class="outline-text-4" id="text-org7af7974"> <div class="outline-text-4" id="text-org9a855b1">
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab">arguments <pre class="src src-matlab">arguments
stewart stewart
args.dL (6,1) double {mustBeNumeric} = zeros(6,1) args.dL (6,1) double {mustBeNumeric} = zeros(6,1)
<span class="org-keyword">end</span> end
</pre> </pre>
</div> </div>
</div> </div>
</div> </div>
<div id="outline-container-org2ba5e64" class="outline-4"> <div id="outline-container-orgdc0187a" class="outline-4">
<h4 id="org2ba5e64">Check the <code>stewart</code> structure elements</h4> <h4 id="orgdc0187a">Check the <code>stewart</code> structure elements</h4>
<div class="outline-text-4" id="text-org2ba5e64"> <div class="outline-text-4" id="text-orgdc0187a">
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab">assert(isfield(stewart.kinematics, <span class="org-string">'J'</span>), <span class="org-string">'stewart.kinematics should have attribute J'</span>) <pre class="src src-matlab">assert(isfield(stewart.kinematics, 'J'), 'stewart.kinematics should have attribute J')
J = stewart.kinematics.J; J = stewart.kinematics.J;
</pre> </pre>
</div> </div>
@ -1588,7 +1443,7 @@ position and orientation of {B} with respect to {A} using the following formula:
\[ d \bm{\mathcal{X}} = \bm{J}^{-1} d\bm{\mathcal{L}} \] \[ d \bm{\mathcal{X}} = \bm{J}^{-1} d\bm{\mathcal{L}} \]
</p> </p>
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab">X = J<span class="org-type">\</span>args.dL; <pre class="src src-matlab">X = J\args.dL;
</pre> </pre>
</div> </div>
@ -1596,7 +1451,7 @@ position and orientation of {B} with respect to {A} using the following formula:
The position vector corresponds to the first 3 elements. The position vector corresponds to the first 3 elements.
</p> </p>
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab">P = X(1<span class="org-type">:</span>3); <pre class="src src-matlab">P = X(1:3);
</pre> </pre>
</div> </div>
@ -1605,8 +1460,8 @@ The next 3 elements are the orientation of {B} with respect to {A} expressed
using the screw axis. using the screw axis.
</p> </p>
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab">theta = norm(X(4<span class="org-type">:</span>6)); <pre class="src src-matlab">theta = norm(X(4:6));
s = X(4<span class="org-type">:</span>6)<span class="org-type">/</span>theta; s = X(4:6)/theta;
</pre> </pre>
</div> </div>
@ -1614,9 +1469,9 @@ s = X(4<span class="org-type">:</span>6)<span class="org-type">/</span>theta;
We then compute the corresponding rotation matrix. We then compute the corresponding rotation matrix.
</p> </p>
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab">R = [s(1)<span class="org-type">^</span>2<span class="org-type">*</span>(1<span class="org-type">-</span>cos(theta)) <span class="org-type">+</span> cos(theta) , s(1)<span class="org-type">*</span>s(2)<span class="org-type">*</span>(1<span class="org-type">-</span>cos(theta)) <span class="org-type">-</span> s(3)<span class="org-type">*</span>sin(theta), s(1)<span class="org-type">*</span>s(3)<span class="org-type">*</span>(1<span class="org-type">-</span>cos(theta)) <span class="org-type">+</span> s(2)<span class="org-type">*</span>sin(theta); <pre class="src src-matlab">R = [s(1)^2*(1-cos(theta)) + cos(theta) , s(1)*s(2)*(1-cos(theta)) - s(3)*sin(theta), s(1)*s(3)*(1-cos(theta)) + s(2)*sin(theta);
s<span class="org-type">(2)*s(1)*(1-cos(theta)) + s(3)*sin(theta), s(2)^2*(1-cos(theta)) + cos(theta), s(2)*s(3)*(1-cos(theta)) - s(1)*sin(theta);</span> s(2)*s(1)*(1-cos(theta)) + s(3)*sin(theta), s(2)^2*(1-cos(theta)) + cos(theta), s(2)*s(3)*(1-cos(theta)) - s(1)*sin(theta);
s<span class="org-type">(3)*s(1)*(1-cos(theta)) - s(2)*sin(theta), s(3)*s(2)*(1-cos(theta)) + s(1)*sin(theta), s(3)^2*(1-cos(theta)) + cos(theta)];</span> s(3)*s(1)*(1-cos(theta)) - s(2)*sin(theta), s(3)*s(2)*(1-cos(theta)) + s(1)*sin(theta), s(3)^2*(1-cos(theta)) + cos(theta)];
</pre> </pre>
</div> </div>
</div> </div>
@ -1626,14 +1481,16 @@ We then compute the corresponding rotation matrix.
<p> <p>
<h1 class='org-ref-bib-h1'>Bibliography</h1>
<ul class='org-ref-bib'><li><a id="taghirad13_paral">[taghirad13_paral]</a> <a name="taghirad13_paral"></a>Taghirad, Parallel robots : mechanics and control, CRC Press (2013).</li>
</ul>
</p> </p>
<style>.csl-entry{text-indent: -1.5em; margin-left: 1.5em;}</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>Taghirad, Hamid. 2013. <i>Parallel Robots : Mechanics and Control</i>. Boca Raton, FL: CRC Press.</div>
</div>
</div> </div>
<div id="postamble" class="status"> <div id="postamble" class="status">
<p class="author">Author: Dehaeze Thomas</p> <p class="author">Author: Dehaeze Thomas</p>
<p class="date">Created: 2020-03-02 lun. 17:57</p> <p class="date">Created: 2020-08-05 mer. 13:27</p>
</div> </div>
</body> </body>
</html> </html>

470
docs/simscape-model.html
View File

@ -1,239 +1,27 @@
<?xml version="1.0" encoding="utf-8"?> <?xml version="1.0" encoding="utf-8"?>
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"> "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en"> <html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en">
<head> <head>
<!-- 2020-03-11 mer. 18:59 --> <!-- 2020-08-05 mer. 13:27 -->
<meta http-equiv="Content-Type" content="text/html;charset=utf-8" /> <meta http-equiv="Content-Type" content="text/html;charset=utf-8" />
<meta name="viewport" content="width=device-width, initial-scale=1" />
<title>Stewart Platform - Simscape Model</title> <title>Stewart Platform - Simscape Model</title>
<meta name="generator" content="Org mode" /> <meta name="generator" content="Org mode" />
<meta name="author" content="Dehaeze Thomas" /> <meta name="author" content="Dehaeze Thomas" />
<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>
<link rel="stylesheet" type="text/css" href="./css/htmlize.css"/> <link rel="stylesheet" type="text/css" href="./css/htmlize.css"/>
<link rel="stylesheet" type="text/css" href="./css/readtheorg.css"/> <link rel="stylesheet" type="text/css" href="./css/readtheorg.css"/>
<script src="./js/jquery.min.js"></script> <script src="./js/jquery.min.js"></script>
<script src="./js/bootstrap.min.js"></script> <script src="./js/bootstrap.min.js"></script>
<script src="./js/jquery.stickytableheaders.min.js"></script> <script src="./js/jquery.stickytableheaders.min.js"></script>
<script src="./js/readtheorg.js"></script> <script src="./js/readtheorg.js"></script>
<script type="text/javascript"> <script>MathJax = {
// @license magnet:?xt=urn:btih:1f739d935676111cfff4b4693e3816e664797050&dn=gpl-3.0.txt GPL-v3-or-Later tex: {
<!--/*--><![CDATA[/*><!--*/ tags: 'ams',
function CodeHighlightOn(elem, id) macros: {bm: ["\\boldsymbol{#1}",1],}
{
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
</script>
<script>
MathJax = {
tex: { macros: {
bm: ["\\boldsymbol{#1}",1],
}
} }
}; };
</script> </script>
<script type="text/javascript" <script type="text/javascript" src="https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js"></script>
src="https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js"></script>
</head> </head>
<body> <body>
<div id="org-div-home-and-up"> <div id="org-div-home-and-up">
@ -255,16 +43,16 @@
<ul> <ul>
<li><a href="#org3535b6d">6.1. Payload</a> <li><a href="#org3535b6d">6.1. Payload</a>
<ul> <ul>
<li><a href="#org1211163">Function description</a></li> <li><a href="#orgd38089d">Function description</a></li>
<li><a href="#org0d8dc7e">Optional Parameters</a></li> <li><a href="#org5518a84">Optional Parameters</a></li>
<li><a href="#orgeeb8d35">Add Payload Type</a></li> <li><a href="#orgeeb8d35">Add Payload Type</a></li>
<li><a href="#org6d52ffc">Add Stiffness, Damping and Mass properties of the Payload</a></li> <li><a href="#org6d52ffc">Add Stiffness, Damping and Mass properties of the Payload</a></li>
</ul> </ul>
</li> </li>
<li><a href="#orgaaed406">6.2. Ground</a> <li><a href="#orgaaed406">6.2. Ground</a>
<ul> <ul>
<li><a href="#org0bee981">Function description</a></li> <li><a href="#org7732939">Function description</a></li>
<li><a href="#orgeaeb9aa">Optional Parameters</a></li> <li><a href="#org480f36e">Optional Parameters</a></li>
<li><a href="#orgef7035d">Add Ground Type</a></li> <li><a href="#orgef7035d">Add Ground Type</a></li>
<li><a href="#org95633e8">Add Stiffness and Damping properties of the Ground</a></li> <li><a href="#org95633e8">Add Stiffness and Damping properties of the Ground</a></li>
<li><a href="#org14ff2fc">Rotation Point</a></li> <li><a href="#org14ff2fc">Rotation Point</a></li>
@ -274,8 +62,8 @@
</li> </li>
<li><a href="#orgae6907a">7. Initialize Disturbances</a> <li><a href="#orgae6907a">7. Initialize Disturbances</a>
<ul> <ul>
<li><a href="#org0eae33e">Function Declaration and Documentation</a></li> <li><a href="#orge2fa859">Function Declaration and Documentation</a></li>
<li><a href="#orge03b19d">Optional Parameters</a></li> <li><a href="#org6adb628">Optional Parameters</a></li>
<li><a href="#org30dc07c">Structure initialization</a></li> <li><a href="#org30dc07c">Structure initialization</a></li>
<li><a href="#org0755155">Ground Motion</a></li> <li><a href="#org0755155">Ground Motion</a></li>
<li><a href="#org7617a55">Direct Forces</a></li> <li><a href="#org7617a55">Direct Forces</a></li>
@ -283,8 +71,8 @@
</li> </li>
<li><a href="#orgd45a07f">8. Initialize References</a> <li><a href="#orgd45a07f">8. Initialize References</a>
<ul> <ul>
<li><a href="#org7f187c4">Function Declaration and Documentation</a></li> <li><a href="#orge5deaa1">Function Declaration and Documentation</a></li>
<li><a href="#org28b782e">Optional Parameters</a></li> <li><a href="#orgeebb364">Optional Parameters</a></li>
<li><a href="#orgc274320">8.1. Compute the corresponding strut length</a></li> <li><a href="#orgc274320">8.1. Compute the corresponding strut length</a></li>
<li><a href="#org36ac3fa">References</a></li> <li><a href="#org36ac3fa">References</a></li>
</ul> </ul>
@ -351,7 +139,7 @@ Basically, the configuration is stored in a mat file <code>conf_simscape.mat</co
It is automatically loaded when the Simulink project is open. It can be loaded manually with the command: It is automatically loaded when the Simulink project is open. It can be loaded manually with the command:
</p> </p>
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab">load(<span class="org-string">'mat/conf_simscape.mat'</span>); <pre class="src src-matlab">load('mat/conf_simscape.mat');
</pre> </pre>
</div> </div>
@ -359,7 +147,7 @@ It is automatically loaded when the Simulink project is open. It can be loaded m
It is however possible to modify specific parameters just for one simulation using the <code>set_param</code> command: It is however possible to modify specific parameters just for one simulation using the <code>set_param</code> command:
</p> </p>
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab"><span class="org-matlab-simulink-keyword">set_param</span>(<span class="org-variable-name">conf_simscape</span>, <span class="org-string">'StopTime'</span>, 1); <pre class="src src-matlab">set_param(conf_simscape, 'StopTime', 1);
</pre> </pre>
</div> </div>
</div> </div>
@ -510,50 +298,50 @@ This Matlab function is accessible <a href="../src/initializePayload.m">here</a>
</p> </p>
</div> </div>
<div id="outline-container-org1211163" class="outline-4"> <div id="outline-container-orgd38089d" class="outline-4">
<h4 id="org1211163">Function description</h4> <h4 id="orgd38089d">Function description</h4>
<div class="outline-text-4" id="text-org1211163"> <div class="outline-text-4" id="text-orgd38089d">
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab"><span class="org-keyword">function</span> <span class="org-variable-name">[payload]</span> = <span class="org-function-name">initializePayload</span>(<span class="org-variable-name">args</span>) <pre class="src src-matlab">function [payload] = initializePayload(args)
<span class="org-comment">% initializePayload - Initialize the Payload that can then be used for simulations and analysis</span> % initializePayload - Initialize the Payload that can then be used for simulations and analysis
<span class="org-comment">%</span> %
<span class="org-comment">% Syntax: [payload] = initializePayload(args)</span> % Syntax: [payload] = initializePayload(args)
<span class="org-comment">%</span> %
<span class="org-comment">% Inputs:</span> % Inputs:
<span class="org-comment">% - args - Structure with the following fields:</span> % - args - Structure with the following fields:
<span class="org-comment">% - type - 'none', 'rigid', 'flexible', 'cartesian'</span> % - type - 'none', 'rigid', 'flexible', 'cartesian'
<span class="org-comment">% - h [1x1] - Height of the CoM of the payload w.r.t {M} [m]</span> % - h [1x1] - Height of the CoM of the payload w.r.t {M} [m]
<span class="org-comment">% This also the position where K and C are defined</span> % This also the position where K and C are defined
<span class="org-comment">% - K [6x1] - Stiffness of the Payload [N/m, N/rad]</span> % - K [6x1] - Stiffness of the Payload [N/m, N/rad]
<span class="org-comment">% - C [6x1] - Damping of the Payload [N/(m/s), N/(rad/s)]</span> % - C [6x1] - Damping of the Payload [N/(m/s), N/(rad/s)]
<span class="org-comment">% - m [1x1] - Mass of the Payload [kg]</span> % - m [1x1] - Mass of the Payload [kg]
<span class="org-comment">% - I [3x3] - Inertia matrix for the Payload [kg*m2]</span> % - I [3x3] - Inertia matrix for the Payload [kg*m2]
<span class="org-comment">%</span> %
<span class="org-comment">% Outputs:</span> % Outputs:
<span class="org-comment">% - payload - Struture with the following properties:</span> % - payload - Struture with the following properties:
<span class="org-comment">% - type - 1 (none), 2 (rigid), 3 (flexible)</span> % - type - 1 (none), 2 (rigid), 3 (flexible)
<span class="org-comment">% - h [1x1] - Height of the CoM of the payload w.r.t {M} [m]</span> % - h [1x1] - Height of the CoM of the payload w.r.t {M} [m]
<span class="org-comment">% - K [6x1] - Stiffness of the Payload [N/m, N/rad]</span> % - K [6x1] - Stiffness of the Payload [N/m, N/rad]
<span class="org-comment">% - C [6x1] - Stiffness of the Payload [N/(m/s), N/(rad/s)]</span> % - C [6x1] - Stiffness of the Payload [N/(m/s), N/(rad/s)]
<span class="org-comment">% - m [1x1] - Mass of the Payload [kg]</span> % - m [1x1] - Mass of the Payload [kg]
<span class="org-comment">% - I [3x3] - Inertia matrix for the Payload [kg*m2]</span> % - I [3x3] - Inertia matrix for the Payload [kg*m2]
</pre> </pre>
</div> </div>
</div> </div>
</div> </div>
<div id="outline-container-org0d8dc7e" class="outline-4"> <div id="outline-container-org5518a84" class="outline-4">
<h4 id="org0d8dc7e">Optional Parameters</h4> <h4 id="org5518a84">Optional Parameters</h4>
<div class="outline-text-4" id="text-org0d8dc7e"> <div class="outline-text-4" id="text-org5518a84">
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab">arguments <pre class="src src-matlab">arguments
args.type char {mustBeMember(args.type,{<span class="org-string">'none'</span>, <span class="org-string">'rigid'</span>, <span class="org-string">'flexible'</span>, <span class="org-string">'cartesian'</span>})} = <span class="org-string">'none'</span> args.type char {mustBeMember(args.type,{'none', 'rigid', 'flexible', 'cartesian'})} = 'none'
args.K (6,1) double {mustBeNumeric, mustBeNonnegative} = 1e8<span class="org-type">*</span>ones(6,1) args.K (6,1) double {mustBeNumeric, mustBeNonnegative} = 1e8*ones(6,1)
args.C (6,1) double {mustBeNumeric, mustBeNonnegative} = 1e1<span class="org-type">*</span>ones(6,1) args.C (6,1) double {mustBeNumeric, mustBeNonnegative} = 1e1*ones(6,1)
args.h (1,1) double {mustBeNumeric, mustBeNonnegative} = 100e<span class="org-type">-</span>3 args.h (1,1) double {mustBeNumeric, mustBeNonnegative} = 100e-3
args.m (1,1) double {mustBeNumeric, mustBeNonnegative} = 10 args.m (1,1) double {mustBeNumeric, mustBeNonnegative} = 10
args.I (3,3) double {mustBeNumeric, mustBeNonnegative} = 1<span class="org-type">*</span>eye(3) args.I (3,3) double {mustBeNumeric, mustBeNonnegative} = 1*eye(3)
<span class="org-keyword">end</span> end
</pre> </pre>
</div> </div>
</div> </div>
@ -563,16 +351,16 @@ This Matlab function is accessible <a href="../src/initializePayload.m">here</a>
<h4 id="orgeeb8d35">Add Payload Type</h4> <h4 id="orgeeb8d35">Add Payload Type</h4>
<div class="outline-text-4" id="text-orgeeb8d35"> <div class="outline-text-4" id="text-orgeeb8d35">
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab"><span class="org-keyword">switch</span> <span class="org-constant">args.type</span> <pre class="src src-matlab">switch args.type
<span class="org-keyword">case</span> <span class="org-string">'none'</span> case 'none'
payload.type = 1; payload.type = 1;
<span class="org-keyword">case</span> <span class="org-string">'rigid'</span> case 'rigid'
payload.type = 2; payload.type = 2;
<span class="org-keyword">case</span> <span class="org-string">'flexible'</span> case 'flexible'
payload.type = 3; payload.type = 3;
<span class="org-keyword">case</span> <span class="org-string">'cartesian'</span> case 'cartesian'
payload.type = 4; payload.type = 4;
<span class="org-keyword">end</span> end
</pre> </pre>
</div> </div>
</div> </div>
@ -606,42 +394,42 @@ This Matlab function is accessible <a href="../src/initializeGround.m">here</a>.
</p> </p>
</div> </div>
<div id="outline-container-org0bee981" class="outline-4"> <div id="outline-container-org7732939" class="outline-4">
<h4 id="org0bee981">Function description</h4> <h4 id="org7732939">Function description</h4>
<div class="outline-text-4" id="text-org0bee981"> <div class="outline-text-4" id="text-org7732939">
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab"><span class="org-keyword">function</span> <span class="org-variable-name">[ground]</span> = <span class="org-function-name">initializeGround</span>(<span class="org-variable-name">args</span>) <pre class="src src-matlab">function [ground] = initializeGround(args)
<span class="org-comment">% initializeGround - Initialize the Ground that can then be used for simulations and analysis</span> % initializeGround - Initialize the Ground that can then be used for simulations and analysis
<span class="org-comment">%</span> %
<span class="org-comment">% Syntax: [ground] = initializeGround(args)</span> % Syntax: [ground] = initializeGround(args)
<span class="org-comment">%</span> %
<span class="org-comment">% Inputs:</span> % Inputs:
<span class="org-comment">% - args - Structure with the following fields:</span> % - args - Structure with the following fields:
<span class="org-comment">% - type - 'none', 'solid', 'flexible'</span> % - type - 'none', 'solid', 'flexible'
<span class="org-comment">% - rot_point [3x1] - Rotation point for the ground motion [m]</span> % - rot_point [3x1] - Rotation point for the ground motion [m]
<span class="org-comment">% - K [3x1] - Translation Stiffness of the Ground [N/m]</span> % - K [3x1] - Translation Stiffness of the Ground [N/m]
<span class="org-comment">% - C [3x1] - Translation Damping of the Ground [N/(m/s)]</span> % - C [3x1] - Translation Damping of the Ground [N/(m/s)]
<span class="org-comment">%</span> %
<span class="org-comment">% Outputs:</span> % Outputs:
<span class="org-comment">% - ground - Struture with the following properties:</span> % - ground - Struture with the following properties:
<span class="org-comment">% - type - 1 (none), 2 (rigid), 3 (flexible)</span> % - type - 1 (none), 2 (rigid), 3 (flexible)
<span class="org-comment">% - K [3x1] - Translation Stiffness of the Ground [N/m]</span> % - K [3x1] - Translation Stiffness of the Ground [N/m]
<span class="org-comment">% - C [3x1] - Translation Damping of the Ground [N/(m/s)]</span> % - C [3x1] - Translation Damping of the Ground [N/(m/s)]
</pre> </pre>
</div> </div>
</div> </div>
</div> </div>
<div id="outline-container-orgeaeb9aa" class="outline-4"> <div id="outline-container-org480f36e" class="outline-4">
<h4 id="orgeaeb9aa">Optional Parameters</h4> <h4 id="org480f36e">Optional Parameters</h4>
<div class="outline-text-4" id="text-orgeaeb9aa"> <div class="outline-text-4" id="text-org480f36e">
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab">arguments <pre class="src src-matlab">arguments
args.type char {mustBeMember(args.type,{<span class="org-string">'none'</span>, <span class="org-string">'rigid'</span>, <span class="org-string">'flexible'</span>})} = <span class="org-string">'none'</span> args.type char {mustBeMember(args.type,{'none', 'rigid', 'flexible'})} = 'none'
args.rot_point (3,1) double {mustBeNumeric} = zeros(3,1) args.rot_point (3,1) double {mustBeNumeric} = zeros(3,1)
args.K (3,1) double {mustBeNumeric, mustBeNonnegative} = 1e8<span class="org-type">*</span>ones(3,1) args.K (3,1) double {mustBeNumeric, mustBeNonnegative} = 1e8*ones(3,1)
args.C (3,1) double {mustBeNumeric, mustBeNonnegative} = 1e1<span class="org-type">*</span>ones(3,1) args.C (3,1) double {mustBeNumeric, mustBeNonnegative} = 1e1*ones(3,1)
<span class="org-keyword">end</span> end
</pre> </pre>
</div> </div>
</div> </div>
@ -651,14 +439,14 @@ This Matlab function is accessible <a href="../src/initializeGround.m">here</a>.
<h4 id="orgef7035d">Add Ground Type</h4> <h4 id="orgef7035d">Add Ground Type</h4>
<div class="outline-text-4" id="text-orgef7035d"> <div class="outline-text-4" id="text-orgef7035d">
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab"><span class="org-keyword">switch</span> <span class="org-constant">args.type</span> <pre class="src src-matlab">switch args.type
<span class="org-keyword">case</span> <span class="org-string">'none'</span> case 'none'
ground.type = 1; ground.type = 1;
<span class="org-keyword">case</span> <span class="org-string">'rigid'</span> case 'rigid'
ground.type = 2; ground.type = 2;
<span class="org-keyword">case</span> <span class="org-string">'flexible'</span> case 'flexible'
ground.type = 3; ground.type = 3;
<span class="org-keyword">end</span> end
</pre> </pre>
</div> </div>
</div> </div>
@ -694,33 +482,33 @@ ground.C = args.C;
</p> </p>
</div> </div>
<div id="outline-container-org0eae33e" class="outline-3"> <div id="outline-container-orge2fa859" class="outline-3">
<h3 id="org0eae33e">Function Declaration and Documentation</h3> <h3 id="orge2fa859">Function Declaration and Documentation</h3>
<div class="outline-text-3" id="text-org0eae33e"> <div class="outline-text-3" id="text-orge2fa859">
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab"><span class="org-keyword">function</span> <span class="org-variable-name">[disturbances]</span> = <span class="org-function-name">initializeDisturbances</span>(<span class="org-variable-name">args</span>) <pre class="src src-matlab">function [disturbances] = initializeDisturbances(args)
<span class="org-comment">% initializeDisturbances - Initialize the disturbances</span> % initializeDisturbances - Initialize the disturbances
<span class="org-comment">%</span> %
<span class="org-comment">% Syntax: [disturbances] = initializeDisturbances(args)</span> % Syntax: [disturbances] = initializeDisturbances(args)
<span class="org-comment">%</span> %
<span class="org-comment">% Inputs:</span> % Inputs:
<span class="org-comment">% - args -</span> % - args -
</pre> </pre>
</div> </div>
</div> </div>
</div> </div>
<div id="outline-container-orge03b19d" class="outline-3"> <div id="outline-container-org6adb628" class="outline-3">
<h3 id="orge03b19d">Optional Parameters</h3> <h3 id="org6adb628">Optional Parameters</h3>
<div class="outline-text-3" id="text-orge03b19d"> <div class="outline-text-3" id="text-org6adb628">
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab">arguments <pre class="src src-matlab">arguments
args.Fd double {mustBeNumeric, mustBeReal} = zeros(6,1) args.Fd double {mustBeNumeric, mustBeReal} = zeros(6,1)
args.Fd_t double {mustBeNumeric, mustBeReal} = 0 args.Fd_t double {mustBeNumeric, mustBeReal} = 0
args.Dw double {mustBeNumeric, mustBeReal} = zeros(6,1) args.Dw double {mustBeNumeric, mustBeReal} = zeros(6,1)
args.Dw_t double {mustBeNumeric, mustBeReal} = 0 args.Dw_t double {mustBeNumeric, mustBeReal} = 0
<span class="org-keyword">end</span> end
</pre> </pre>
</div> </div>
</div> </div>
@ -766,32 +554,32 @@ ground.C = args.C;
</p> </p>
</div> </div>
<div id="outline-container-org7f187c4" class="outline-3"> <div id="outline-container-orge5deaa1" class="outline-3">
<h3 id="org7f187c4">Function Declaration and Documentation</h3> <h3 id="orge5deaa1">Function Declaration and Documentation</h3>
<div class="outline-text-3" id="text-org7f187c4"> <div class="outline-text-3" id="text-orge5deaa1">
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab"><span class="org-keyword">function</span> <span class="org-variable-name">[references]</span> = <span class="org-function-name">initializeReferences</span>(<span class="org-variable-name">stewart</span>, <span class="org-variable-name">args</span>) <pre class="src src-matlab">function [references] = initializeReferences(stewart, args)
<span class="org-comment">% initializeReferences - Initialize the references</span> % initializeReferences - Initialize the references
<span class="org-comment">%</span> %
<span class="org-comment">% Syntax: [references] = initializeReferences(args)</span> % Syntax: [references] = initializeReferences(args)
<span class="org-comment">%</span> %
<span class="org-comment">% Inputs:</span> % Inputs:
<span class="org-comment">% - args -</span> % - args -
</pre> </pre>
</div> </div>
</div> </div>
</div> </div>
<div id="outline-container-org28b782e" class="outline-3"> <div id="outline-container-orgeebb364" class="outline-3">
<h3 id="org28b782e">Optional Parameters</h3> <h3 id="orgeebb364">Optional Parameters</h3>
<div class="outline-text-3" id="text-org28b782e"> <div class="outline-text-3" id="text-orgeebb364">
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab">arguments <pre class="src src-matlab">arguments
stewart stewart
args.t double {mustBeNumeric, mustBeReal} = 0 args.t double {mustBeNumeric, mustBeReal} = 0
args.r double {mustBeNumeric, mustBeReal} = zeros(6, 1) args.r double {mustBeNumeric, mustBeReal} = zeros(6, 1)
<span class="org-keyword">end</span> end
</pre> </pre>
</div> </div>
</div> </div>
@ -803,20 +591,20 @@ ground.C = args.C;
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab">rL = zeros(6, length(args.t)); <pre class="src src-matlab">rL = zeros(6, length(args.t));
<span class="org-keyword">for</span> <span class="org-variable-name"><span class="org-constant">i</span></span> = <span class="org-constant">1:length(args.t)</span> for i = 1:length(args.t)
R = [cos(args.r(6,<span class="org-constant">i</span>)) <span class="org-type">-</span>sin(args.r(6,<span class="org-constant">i</span>)) 0; R = [cos(args.r(6,i)) -sin(args.r(6,i)) 0;
sin(args.r(6,<span class="org-constant">i</span>)) cos(args.r(6,<span class="org-constant">i</span>)) 0; sin(args.r(6,i)) cos(args.r(6,i)) 0;
0 0 1] <span class="org-type">*</span> ... 0 0 1] * ...
[cos(args.r(5,<span class="org-constant">i</span>)) 0 sin(args.r(5,<span class="org-constant">i</span>)); [cos(args.r(5,i)) 0 sin(args.r(5,i));
0 1 0; 0 1 0;
<span class="org-type">-</span>sin(args.r(5,<span class="org-constant">i</span>)) 0 cos(args.r(5,<span class="org-constant">i</span>))] <span class="org-type">*</span> ... -sin(args.r(5,i)) 0 cos(args.r(5,i))] * ...
[1 0 0; [1 0 0;
0 cos(args.r(4,<span class="org-constant">i</span>)) <span class="org-type">-</span>sin(args.r(4,<span class="org-constant">i</span>)); 0 cos(args.r(4,i)) -sin(args.r(4,i));
0 sin(args.r(4,<span class="org-constant">i</span>)) cos(args.r(4,<span class="org-constant">i</span>))]; 0 sin(args.r(4,i)) cos(args.r(4,i))];
[Li, dLi] = inverseKinematics(stewart, <span class="org-string">'AP'</span>, [args.r(1,<span class="org-constant">i</span>); args.r(2,<span class="org-constant">i</span>); args.r(3,<span class="org-constant">i</span>)], <span class="org-string">'ARB'</span>, R); [Li, dLi] = inverseKinematics(stewart, 'AP', [args.r(1,i); args.r(2,i); args.r(3,i)], 'ARB', R);
rL(<span class="org-type">:</span>, <span class="org-constant">i</span>) = dLi; rL(:, i) = dLi;
<span class="org-keyword">end</span> end
</pre> </pre>
</div> </div>
</div> </div>
@ -836,7 +624,7 @@ references.rL = timeseries(rL, args.t);
</div> </div>
<div id="postamble" class="status"> <div id="postamble" class="status">
<p class="author">Author: Dehaeze Thomas</p> <p class="author">Author: Dehaeze Thomas</p>
<p class="date">Created: 2020-03-11 mer. 18:59</p> <p class="date">Created: 2020-08-05 mer. 13:27</p>
</div> </div>
</body> </body>
</html> </html>

235
docs/simulink-project.html
View File

@ -1,229 +1,19 @@
<?xml version="1.0" encoding="utf-8"?> <?xml version="1.0" encoding="utf-8"?>
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"> "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en"> <html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en">
<head> <head>
<!-- 2020-03-02 lun. 17:57 --> <!-- 2020-08-05 mer. 13:27 -->
<meta http-equiv="Content-Type" content="text/html;charset=utf-8" /> <meta http-equiv="Content-Type" content="text/html;charset=utf-8" />
<meta name="viewport" content="width=device-width, initial-scale=1" />
<title>Simulink Project for the Stewart Simscape folder</title> <title>Simulink Project for the Stewart Simscape folder</title>
<meta name="generator" content="Org mode" /> <meta name="generator" content="Org mode" />
<meta name="author" content="Dehaeze Thomas" /> <meta name="author" content="Dehaeze Thomas" />
<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>
<link rel="stylesheet" type="text/css" href="./css/htmlize.css"/> <link rel="stylesheet" type="text/css" href="./css/htmlize.css"/>
<link rel="stylesheet" type="text/css" href="./css/readtheorg.css"/> <link rel="stylesheet" type="text/css" href="./css/readtheorg.css"/>
<script src="./js/jquery.min.js"></script> <script src="./js/jquery.min.js"></script>
<script src="./js/bootstrap.min.js"></script> <script src="./js/bootstrap.min.js"></script>
<script src="./js/jquery.stickytableheaders.min.js"></script> <script src="./js/jquery.stickytableheaders.min.js"></script>
<script src="./js/readtheorg.js"></script> <script src="./js/readtheorg.js"></script>
<script type="text/javascript">
// @license magnet:?xt=urn:btih:1f739d935676111cfff4b4693e3816e664797050&dn=gpl-3.0.txt GPL-v3-or-Later
<!--/*--><![CDATA[/*><!--*/
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
</script>
</head> </head>
<body> <body>
<div id="org-div-home-and-up"> <div id="org-div-home-and-up">
@ -232,7 +22,6 @@
<a accesskey="H" href="./index.html"> HOME </a> <a accesskey="H" href="./index.html"> HOME </a>
</div><div id="content"> </div><div id="content">
<h1 class="title">Simulink Project for the Stewart Simscape folder</h1> <h1 class="title">Simulink Project for the Stewart Simscape folder</h1>
<p> <p>
A Simulink Project is used for the study of Stewart platforms using Simscape. A Simulink Project is used for the study of Stewart platforms using Simscape.
</p> </p>
@ -260,7 +49,7 @@ The project can be opened using the <code>simulinkproject</code> function:
</p> </p>
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab">simulinkproject(<span class="org-string">'../'</span>); <pre class="src src-matlab">simulinkproject('../');
</pre> </pre>
</div> </div>
@ -272,16 +61,16 @@ The startup script is defined below and is exported to the <code>project_startup
<pre class="src src-matlab">project = simulinkproject; <pre class="src src-matlab">project = simulinkproject;
projectRoot = project.RootFolder; projectRoot = project.RootFolder;
myCacheFolder = fullfile(projectRoot, <span class="org-string">'.SimulinkCache'</span>); myCacheFolder = fullfile(projectRoot, '.SimulinkCache');
myCodeFolder = fullfile(projectRoot, <span class="org-string">'.SimulinkCode'</span>); myCodeFolder = fullfile(projectRoot, '.SimulinkCode');
Simulink.fileGenControl(<span class="org-string">'set'</span>,... Simulink.fileGenControl('set',...
<span class="org-string">'CacheFolder'</span>, myCacheFolder,... 'CacheFolder', myCacheFolder,...
<span class="org-string">'CodeGenFolder'</span>, myCodeFolder,... 'CodeGenFolder', myCodeFolder,...
<span class="org-string">'createDir'</span>, <span class="org-constant">true</span>); 'createDir', true);
<span class="org-matlab-cellbreak"><span class="org-comment">%% Load the Simscape Configuration</span></span> %% Load the Simscape Configuration
load(<span class="org-string">'mat/conf_simscape.mat'</span>); load('mat/conf_simscape.mat');
</pre> </pre>
</div> </div>
@ -289,7 +78,7 @@ load(<span class="org-string">'mat/conf_simscape.mat'</span>);
When the project closes, it runs the <code>project_shutdown.m</code> script defined below. When the project closes, it runs the <code>project_shutdown.m</code> script defined below.
</p> </p>
<div class="org-src-container"> <div class="org-src-container">
<pre class="src src-matlab">Simulink.fileGenControl(<span class="org-string">'reset'</span>); <pre class="src src-matlab">Simulink.fileGenControl('reset');
</pre> </pre>
</div> </div>
@ -299,7 +88,7 @@ The project also permits to automatically add defined folder to the path when th
</div> </div>
<div id="postamble" class="status"> <div id="postamble" class="status">
<p class="author">Author: Dehaeze Thomas</p> <p class="author">Author: Dehaeze Thomas</p>
<p class="date">Created: 2020-03-02 lun. 17:57</p> <p class="date">Created: 2020-08-05 mer. 13:27</p>
</div> </div>
</body> </body>
</html> </html>

226
docs/static-analysis.html
View File

@ -1,239 +1,27 @@
<?xml version="1.0" encoding="utf-8"?> <?xml version="1.0" encoding="utf-8"?>
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"> "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en"> <html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en">
<head> <head>
<!-- 2020-03-02 lun. 17:57 --> <!-- 2020-08-05 mer. 13:27 -->
<meta http-equiv="Content-Type" content="text/html;charset=utf-8" /> <meta http-equiv="Content-Type" content="text/html;charset=utf-8" />
<meta name="viewport" content="width=device-width, initial-scale=1" />
<title>Stewart Platform - Static Analysis</title> <title>Stewart Platform - Static Analysis</title>
<meta name="generator" content="Org mode" /> <meta name="generator" content="Org mode" />
<meta name="author" content="Dehaeze Thomas" /> <meta name="author" content="Dehaeze Thomas" />
<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>
<link rel="stylesheet" type="text/css" href="./css/htmlize.css"/> <link rel="stylesheet" type="text/css" href="./css/htmlize.css"/>
<link rel="stylesheet" type="text/css" href="./css/readtheorg.css"/> <link rel="stylesheet" type="text/css" href="./css/readtheorg.css"/>
<script src="./js/jquery.min.js"></script> <script src="./js/jquery.min.js"></script>
<script src="./js/bootstrap.min.js"></script> <script src="./js/bootstrap.min.js"></script>
<script src="./js/jquery.stickytableheaders.min.js"></script> <script src="./js/jquery.stickytableheaders.min.js"></script>
<script src="./js/readtheorg.js"></script> <script src="./js/readtheorg.js"></script>
<script type="text/javascript"> <script>MathJax = {
// @license magnet:?xt=urn:btih:1f739d935676111cfff4b4693e3816e664797050&dn=gpl-3.0.txt GPL-v3-or-Later tex: {
<!--/*--><![CDATA[/*><!--*/ tags: 'ams',
function CodeHighlightOn(elem, id) macros: {bm: ["\\boldsymbol{#1}",1],}
{
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
</script>
<script>
MathJax = {
tex: { macros: {
bm: ["\\boldsymbol{#1}",1],
}
} }
}; };
</script> </script>
<script type="text/javascript" <script type="text/javascript" src="https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js"></script>
src="https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js"></script>
</head> </head>
<body> <body>
<div id="org-div-home-and-up"> <div id="org-div-home-and-up">
@ -281,7 +69,7 @@ Thus, the system is uncoupled if \(G\) and \(K\) are diagonal.
</div> </div>
<div id="postamble" class="status"> <div id="postamble" class="status">
<p class="author">Author: Dehaeze Thomas</p> <p class="author">Author: Dehaeze Thomas</p>
<p class="date">Created: 2020-03-02 lun. 17:57</p> <p class="date">Created: 2020-08-05 mer. 13:27</p>
</div> </div>
</body> </body>
</html> </html>

1975
docs/stewart-architecture.html
View File

File diff suppressed because it is too large Load Diff

1755
mat/APA300ML.STEP Normal file
View File

File diff suppressed because it is too large Load Diff

BIN
mat/APA300ML.mat Normal file
View File

Binary file not shown.

2147
mat/flexor_ID16.STEP Normal file
View File

File diff suppressed because it is too large Load Diff

BIN
mat/flexor_ID16.mat Normal file
View File

Binary file not shown.

BIN
matlab/stewart_platform_model.slx
View File

Binary file not shown.

2
org/bibliography.org
View File

@ -25,7 +25,7 @@
#+PROPERTY: header-args:matlab+ :mkdirp yes #+PROPERTY: header-args:matlab+ :mkdirp yes
#+PROPERTY: header-args:matlab+ :output-dir figs #+PROPERTY: header-args:matlab+ :output-dir figs
#+PROPERTY: header-args:latex :headers '("\\usepackage{tikz}" "\\usepackage{import}" "\\import{$HOME/Cloud/thesis/latex/org/}{config.tex}") #+PROPERTY: header-args:latex :headers '("\\usepackage{tikz}" "\\usepackage{import}" "\\import{$HOME/Cloud/tikz/org/}{config.tex}")
#+PROPERTY: header-args:latex+ :imagemagick t :fit yes #+PROPERTY: header-args:latex+ :imagemagick t :fit yes
#+PROPERTY: header-args:latex+ :iminoptions -scale 100% -density 150 #+PROPERTY: header-args:latex+ :iminoptions -scale 100% -density 150
#+PROPERTY: header-args:latex+ :imoutoptions -quality 100 #+PROPERTY: header-args:latex+ :imoutoptions -quality 100

2
org/control-active-damping.org
View File

@ -25,7 +25,7 @@
#+PROPERTY: header-args:matlab+ :mkdirp yes #+PROPERTY: header-args:matlab+ :mkdirp yes
#+PROPERTY: header-args:matlab+ :output-dir figs #+PROPERTY: header-args:matlab+ :output-dir figs
#+PROPERTY: header-args:latex :headers '("\\usepackage{tikz}" "\\usepackage{import}" "\\import{$HOME/Cloud/thesis/latex/org/}{config.tex}") #+PROPERTY: header-args:latex :headers '("\\usepackage{tikz}" "\\usepackage{import}" "\\import{$HOME/Cloud/tikz/org/}{config.tex}")
#+PROPERTY: header-args:latex+ :imagemagick t :fit yes #+PROPERTY: header-args:latex+ :imagemagick t :fit yes
#+PROPERTY: header-args:latex+ :iminoptions -scale 100% -density 150 #+PROPERTY: header-args:latex+ :iminoptions -scale 100% -density 150
#+PROPERTY: header-args:latex+ :imoutoptions -quality 100 #+PROPERTY: header-args:latex+ :imoutoptions -quality 100

2
org/control-tracking.org
View File

@ -25,7 +25,7 @@
#+PROPERTY: header-args:matlab+ :mkdirp yes #+PROPERTY: header-args:matlab+ :mkdirp yes
#+PROPERTY: header-args:matlab+ :output-dir figs #+PROPERTY: header-args:matlab+ :output-dir figs
#+PROPERTY: header-args:latex :headers '("\\usepackage{tikz}" "\\usepackage{import}" "\\import{$HOME/Cloud/thesis/latex/org/}{config.tex}") #+PROPERTY: header-args:latex :headers '("\\usepackage{tikz}" "\\usepackage{import}" "\\import{$HOME/Cloud/tikz/org/}{config.tex}")
#+PROPERTY: header-args:latex+ :imagemagick t :fit yes #+PROPERTY: header-args:latex+ :imagemagick t :fit yes
#+PROPERTY: header-args:latex+ :iminoptions -scale 100% -density 150 #+PROPERTY: header-args:latex+ :iminoptions -scale 100% -density 150
#+PROPERTY: header-args:latex+ :imoutoptions -quality 100 #+PROPERTY: header-args:latex+ :imoutoptions -quality 100

2
org/control-vibration-isolation.org
View File

@ -25,7 +25,7 @@
#+PROPERTY: header-args:matlab+ :mkdirp yes #+PROPERTY: header-args:matlab+ :mkdirp yes
#+PROPERTY: header-args:matlab+ :output-dir figs #+PROPERTY: header-args:matlab+ :output-dir figs
#+PROPERTY: header-args:latex :headers '("\\usepackage{tikz}" "\\usepackage{import}" "\\import{$HOME/Cloud/thesis/latex/org/}{config.tex}") #+PROPERTY: header-args:latex :headers '("\\usepackage{tikz}" "\\usepackage{import}" "\\import{$HOME/Cloud/tikz/org/}{config.tex}")
#+PROPERTY: header-args:latex+ :imagemagick t :fit yes #+PROPERTY: header-args:latex+ :imagemagick t :fit yes
#+PROPERTY: header-args:latex+ :iminoptions -scale 100% -density 150 #+PROPERTY: header-args:latex+ :iminoptions -scale 100% -density 150
#+PROPERTY: header-args:latex+ :imoutoptions -quality 100 #+PROPERTY: header-args:latex+ :imoutoptions -quality 100

2
org/cubic-configuration.org
View File

@ -25,7 +25,7 @@
#+PROPERTY: header-args:matlab+ :mkdirp yes #+PROPERTY: header-args:matlab+ :mkdirp yes
#+PROPERTY: header-args:matlab+ :output-dir figs #+PROPERTY: header-args:matlab+ :output-dir figs
#+PROPERTY: header-args:latex :headers '("\\usepackage{tikz}" "\\usepackage{import}" "\\import{$HOME/Cloud/thesis/latex/org/}{config.tex}") #+PROPERTY: header-args:latex :headers '("\\usepackage{tikz}" "\\usepackage{import}" "\\import{$HOME/Cloud/tikz/org/}{config.tex}")
#+PROPERTY: header-args:latex+ :imagemagick t :fit yes #+PROPERTY: header-args:latex+ :imagemagick t :fit yes
#+PROPERTY: header-args:latex+ :iminoptions -scale 100% -density 150 #+PROPERTY: header-args:latex+ :iminoptions -scale 100% -density 150
#+PROPERTY: header-args:latex+ :imoutoptions -quality 100 #+PROPERTY: header-args:latex+ :imoutoptions -quality 100

2
org/dynamics-study.org
View File

@ -25,7 +25,7 @@
#+PROPERTY: header-args:matlab+ :mkdirp yes #+PROPERTY: header-args:matlab+ :mkdirp yes
#+PROPERTY: header-args:matlab+ :output-dir figs #+PROPERTY: header-args:matlab+ :output-dir figs
#+PROPERTY: header-args:latex :headers '("\\usepackage{tikz}" "\\usepackage{import}" "\\import{$HOME/Cloud/thesis/latex/org/}{config.tex}") #+PROPERTY: header-args:latex :headers '("\\usepackage{tikz}" "\\usepackage{import}" "\\import{$HOME/Cloud/tikz/org/}{config.tex}")
#+PROPERTY: header-args:latex+ :imagemagick t :fit yes #+PROPERTY: header-args:latex+ :imagemagick t :fit yes
#+PROPERTY: header-args:latex+ :iminoptions -scale 100% -density 150 #+PROPERTY: header-args:latex+ :iminoptions -scale 100% -density 150
#+PROPERTY: header-args:latex+ :imoutoptions -quality 100 #+PROPERTY: header-args:latex+ :imoutoptions -quality 100

362
org/flexible-stewart-platform.org Normal file
View File

@ -0,0 +1,362 @@
#+TITLE: Stewart Platform with Flexible Elements
:DRAWER:
#+STARTUP: overview
#+LANGUAGE: en
#+EMAIL: dehaeze.thomas@gmail.com
#+AUTHOR: Dehaeze Thomas
#+HTML_LINK_HOME: ./index.html
#+HTML_LINK_UP: ./index.html
#+HTML_HEAD: <link rel="stylesheet" type="text/css" href="./css/htmlize.css"/>
#+HTML_HEAD: <link rel="stylesheet" type="text/css" href="./css/readtheorg.css"/>
#+HTML_HEAD: <script src="./js/jquery.min.js"></script>
#+HTML_HEAD: <script src="./js/bootstrap.min.js"></script>
#+HTML_HEAD: <script src="./js/jquery.stickytableheaders.min.js"></script>
#+HTML_HEAD: <script src="./js/readtheorg.js"></script>
#+PROPERTY: header-args:matlab :session *MATLAB*
#+PROPERTY: header-args:matlab+ :comments org
#+PROPERTY: header-args:matlab+ :exports both
#+PROPERTY: header-args:matlab+ :results none
#+PROPERTY: header-args:matlab+ :eval no-export
#+PROPERTY: header-args:matlab+ :noweb yes
#+PROPERTY: header-args:matlab+ :mkdirp yes
#+PROPERTY: header-args:matlab+ :output-dir figs
#+PROPERTY: header-args:latex :headers '("\\usepackage{tikz}" "\\usepackage{import}" "\\import{$HOME/Cloud/tikz/org/}{config.tex}")
#+PROPERTY: header-args:latex+ :imagemagick t :fit yes
#+PROPERTY: header-args:latex+ :iminoptions -scale 100% -density 150
#+PROPERTY: header-args:latex+ :imoutoptions -quality 100
#+PROPERTY: header-args:latex+ :results file raw replace
#+PROPERTY: header-args:latex+ :buffer no
#+PROPERTY: header-args:latex+ :eval no-export
#+PROPERTY: header-args:latex+ :exports results
#+PROPERTY: header-args:latex+ :mkdirp yes
#+PROPERTY: header-args:latex+ :output-dir figs
#+PROPERTY: header-args:latex+ :post pdf2svg(file=*this*, ext="png")
:END:
* Simscape Model
** Matlab Init :noexport:ignore:
#+begin_src matlab :tangle no :exports none :results silent :noweb yes :var current_dir=(file-name-directory buffer-file-name)
<<matlab-dir>>
#+end_src
#+begin_src matlab :exports none :results silent :noweb yes
<<matlab-init>>
#+end_src
#+begin_src matlab :results none :exports none
simulinkproject('../');
#+end_src
** Flexible APA
#+begin_src matlab
apa = load('./mat/APA300ML.mat', 'int_xyz', 'int_i', 'n_xyz', 'n_i', 'nodes', 'M', 'K');
#+end_src
#+begin_src matlab :exports results :results value table replace :tangle no
data2orgtable([length(apa.n_i); length(apa.int_i); size(apa.M,1) - 6*length(apa.int_i); size(apa.M,1)], {'Total number of Nodes', 'Number of interface Nodes', 'Number of Modes', 'Size of M and K matrices'}, {}, ' %.0f ');
#+end_src
#+RESULTS:
| Total number of Nodes | 7 |
| Number of interface Nodes | 7 |
| Number of Modes | 6 |
| Size of M and K matrices | 48 |
#+begin_src matlab :exports results :results value table replace :tangle no :post addhdr(*this*)
data2orgtable([[1:length(apa.int_i)]', apa.int_i, apa.int_xyz], {}, {'Node i', 'Node Number', 'x [m]', 'y [m]', 'z [m]'}, ' %f ');
#+end_src
#+caption: Coordinates of the interface nodes
#+RESULTS:
| Node i | Node Number | x [m] | y [m] | z [m] |
|--------+-------------+---------+--------+-------|
| 1.0 | 53917.0 | 0.0 | -0.015 | 0.0 |
| 2.0 | 53918.0 | 0.0 | 0.015 | 0.0 |
| 3.0 | 53919.0 | -0.0325 | 0.0 | 0.0 |
| 4.0 | 53920.0 | -0.0125 | 0.0 | 0.0 |
| 5.0 | 53921.0 | -0.0075 | 0.0 | 0.0 |
| 6.0 | 53922.0 | 0.0125 | 0.0 | 0.0 |
| 7.0 | 53923.0 | 0.0325 | 0.0 | 0.0 |
** Flexible Joint
#+begin_src matlab
flex_joint = load('./mat/flexor_ID16.mat', 'int_xyz', 'int_i', 'n_xyz', 'n_i', 'nodes', 'M', 'K');
#+end_src
#+begin_src matlab :exports results :results value table replace :tangle no
data2orgtable([length(flex_joint.n_i); length(flex_joint.int_i); size(flex_joint.M,1) - 6*length(flex_joint.int_i); size(flex_joint.M,1)], {'Total number of Nodes', 'Number of interface Nodes', 'Number of Modes', 'Size of M and K matrices'}, {}, ' %.0f ');
#+end_src
#+RESULTS:
| Total number of Nodes | 2 |
| Number of interface Nodes | 2 |
| Number of Modes | 6 |
| Size of M and K matrices | 18 |
#+begin_src matlab :exports results :results value table replace :tangle no :post addhdr(*this*)
data2orgtable([[1:length(flex_joint.int_i)]', flex_joint.int_i, flex_joint.int_xyz], {}, {'Node i', 'Node Number', 'x [m]', 'y [m]', 'z [m]'}, ' %f ');
#+end_src
#+caption: Coordinates of the interface nodes
#+RESULTS:
| Node i | Node Number | x [m] | y [m] | z [m] |
|--------+-------------+-------+-------+-------|
| 1.0 | 181278.0 | 0.0 | 0.0 | 0.0 |
| 2.0 | 181279.0 | 0.0 | 0.0 | -0.0 |
#+begin_src matlab :exports results :results value table replace :tangle no :post addhdr(*this*)
data2orgtable([1e-6*flex_joint.K(3,3), flex_joint.K(4,4), flex_joint.K(5,5), flex_joint.K(6,6)]', {'Axial Stiffness [N/um]', 'Bending Stiffness [Nm/rad]', 'Bending Stiffness [Nm/rad]', 'Torsion Stiffness [Nm/rad]'}, {'*Caracteristic*', '*Value*'}, ' %0.f ');
#+end_src
#+RESULTS:
| *Caracteristic* | *Value* |
|----------------------------+---------|
| Axial Stiffness [N/um] | 119 |
| Bending Stiffness [Nm/rad] | 33 |
| Bending Stiffness [Nm/rad] | 33 |
| Torsion Stiffness [Nm/rad] | 236 |
** Identification
And we identify the dynamics from force actuators to force sensors.
#+begin_src matlab
%% Options for Linearized
options = linearizeOptions;
options.SampleTime = 0;
%% Name of the Simulink File
mdl = 'stewart_platform_model';
%% Input/Output definition
clear io; io_i = 1;
io(io_i) = linio([mdl, '/Controller'], 1, 'openinput'); io_i = io_i + 1; % Actuator Force Inputs [N]
io(io_i) = linio([mdl, '/Stewart Platform'], 1, 'openoutput', [], 'dLm'); io_i = io_i + 1; % Relative Displacement Outputs [m]
io(io_i) = linio([mdl, '/Stewart Platform'], 1, 'openoutput', [], 'Taum'); io_i = io_i + 1; % Force Sensors [N]
#+end_src
#+begin_src matlab
ground = initializeGround('type', 'none');
payload = initializePayload('type', 'rigid', 'm', 50);
controller = initializeController('type', 'open-loop');
#+end_src
#+begin_src matlab
disturbances = initializeDisturbances();
references = initializeReferences(stewart);
#+end_src
** No Flexible Elements
#+begin_src matlab
stewart = initializeStewartPlatform();
stewart = initializeFramesPositions(stewart);
stewart = generateGeneralConfiguration(stewart);
stewart = computeJointsPose(stewart);
% stewart = initializeStrutDynamics(stewart, 'K', 1.8e6*ones(6,1));
stewart = initializeAmplifiedStrutDynamics(stewart, 'Kr', 0.9e6*ones(6,1), 'Ka', 0.9e6*ones(6,1));
stewart = initializeJointDynamics(stewart, 'Kf_M', 33*ones(6,1), 'Kt_M', 235*ones(6,1), 'Kf_F', 33*ones(6,1), 'Kt_F', 235*ones(6,1));
stewart = initializeCylindricalPlatforms(stewart);
stewart = initializeCylindricalStruts(stewart);
stewart = computeJacobian(stewart);
stewart = initializeStewartPose(stewart);
stewart = initializeInertialSensor(stewart);
#+end_src
#+begin_src matlab
%% Run the linearization
G = linearize(mdl, io, options);
G.InputName = {'F1', 'F2', 'F3', 'F4', 'F5', 'F6'};
G.OutputName = {'Dm1', 'Dm2', 'Dm3', 'Dm4', 'Dm5', 'Dm6', 'Fm1', 'Fm2', 'Fm3', 'Fm4', 'Fm5', 'Fm6'};
#+end_src
** Flexible joints
#+begin_src matlab
stewart = initializeStewartPlatform();
stewart = initializeFramesPositions(stewart);
stewart = generateGeneralConfiguration(stewart);
stewart = computeJointsPose(stewart);
stewart = initializeAmplifiedStrutDynamics(stewart, 'Kr', 0.9e6*ones(6,1), 'Ka', 0.9e6*ones(6,1));
stewart = initializeJointDynamics(stewart, 'type_F', 'flexible', 'K_F', flex_joint.K, 'M_F', flex_joint.M, 'n_xyz_F', flex_joint.n_xyz, 'xi_F', 0.1, 'step_file_F', 'mat/flexor_ID16.STEP', 'type_M', 'flexible', 'K_M', flex_joint.K, 'M_M', flex_joint.M, 'n_xyz_M', flex_joint.n_xyz, 'xi_M', 0.1, 'step_file_M', 'mat/flexor_ID16.STEP');
stewart = initializeCylindricalPlatforms(stewart);
stewart = initializeCylindricalStruts(stewart);
stewart = computeJacobian(stewart);
stewart = initializeStewartPose(stewart);
stewart = initializeInertialSensor(stewart);
#+end_src
#+begin_src matlab
%% Run the linearization
Gj = linearize(mdl, io, options);
Gj.InputName = {'F1', 'F2', 'F3', 'F4', 'F5', 'F6'};
Gj.OutputName = {'Dm1', 'Dm2', 'Dm3', 'Dm4', 'Dm5', 'Dm6', 'Fm1', 'Fm2', 'Fm3', 'Fm4', 'Fm5', 'Fm6'};
#+end_src
** Flexible APA
#+begin_src matlab
stewart = initializeStewartPlatform();
stewart = initializeFramesPositions(stewart);
stewart = generateGeneralConfiguration(stewart);
stewart = computeJointsPose(stewart);
stewart = initializeFlexibleStrutDynamics(stewart, 'H', 0.03, 'K', apa.K, 'M', apa.M, 'n_xyz', apa.n_xyz, 'xi', 0.1, 'step_file', 'mat/APA300ML.STEP');
stewart = initializeJointDynamics(stewart, 'Kf_M', 33*ones(6,1), 'Kt_M', 235, 'Kf_F', 33*ones(6,1), 'Kt_F', 235);
stewart = initializeCylindricalPlatforms(stewart);
stewart = initializeCylindricalStruts(stewart, 'type_F', 'none', 'type_M', 'none');
stewart = computeJacobian(stewart);
stewart = initializeStewartPose(stewart);
stewart = initializeInertialSensor(stewart);
#+end_src
#+begin_src matlab
%% Run the linearization
Ga = -linearize(mdl, io, options);
Ga.InputName = {'F1', 'F2', 'F3', 'F4', 'F5', 'F6'};
Ga.OutputName = {'Dm1', 'Dm2', 'Dm3', 'Dm4', 'Dm5', 'Dm6', 'Fm1', 'Fm2', 'Fm3', 'Fm4', 'Fm5', 'Fm6'};
#+end_src
** Flexible Joints and APA
#+begin_src matlab
stewart = initializeStewartPlatform();
stewart = initializeFramesPositions(stewart);
stewart = generateGeneralConfiguration(stewart);
stewart = computeJointsPose(stewart);
stewart = initializeFlexibleStrutDynamics(stewart, 'H', 0.03, 'K', apa.K, 'M', apa.M, 'n_xyz', apa.n_xyz, 'xi', 0.1, 'step_file', 'mat/APA300ML.STEP');
stewart = initializeJointDynamics(stewart, 'type_F', 'flexible', 'K_F', flex_joint.K, 'M_F', flex_joint.M, 'n_xyz_F', flex_joint.n_xyz, 'xi_F', 0.1, 'step_file_F', 'mat/flexor_ID16.STEP', 'type_M', 'flexible', 'K_M', flex_joint.K, 'M_M', flex_joint.M, 'n_xyz_M', flex_joint.n_xyz, 'xi_M', 0.1, 'step_file_M', 'mat/flexor_ID16.STEP');
stewart = initializeCylindricalPlatforms(stewart);
stewart = initializeCylindricalStruts(stewart, 'type_F', 'none', 'type_M', 'none');
stewart = computeJacobian(stewart);
stewart = initializeStewartPose(stewart);
stewart = initializeInertialSensor(stewart);
#+end_src
#+begin_src matlab
Gf = -linearize(mdl, io, options);
Gf.InputName = {'F1', 'F2', 'F3', 'F4', 'F5', 'F6'};
Gf.OutputName = {'Dm1', 'Dm2', 'Dm3', 'Dm4', 'Dm5', 'Dm6', 'Fm1', 'Fm2', 'Fm3', 'Fm4', 'Fm5', 'Fm6'};
#+end_src
** Direct Velocity Feedback
#+begin_src matlab :exports none
freqs = logspace(0, 3, 1000);
figure;
ax1 = subplot(2, 1, 1);
hold on;
for i = 1:6
plot(freqs, abs(squeeze(freqresp(G(i,i), freqs, 'Hz'))), 'color', [0 0.4470 0.7410 0.2]);
end
for i = 1:6
plot(freqs, abs(squeeze(freqresp(Gj(i,i), freqs, 'Hz'))), 'color', [0.8500 0.3250 0.0980 0.2]);
end
for i = 1:6
plot(freqs, abs(squeeze(freqresp(44*Ga(i,i), freqs, 'Hz'))), 'color', [0.9290 0.6940 0.1250 0.2]);
end
for i = 1:6
plot(freqs, abs(squeeze(freqresp(44*Gf(i,i), freqs, 'Hz'))), 'color', [0.4940 0.1840 0.5560 0.2]);
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude [m/N]'); set(gca, 'XTickLabel',[]);
ax2 = subplot(2, 1, 2);
hold on;
for i = 1:6
plot(freqs, 180/pi*angle(squeeze(freqresp(G(i,i), freqs, 'Hz'))), 'color', [0 0.4470 0.7410 0.2]);
end
for i = 1:6
plot(freqs, 180/pi*angle(squeeze(freqresp(Gj(i,i), freqs, 'Hz'))), 'color', [0.8500 0.3250 0.0980 0.2]);
end
for i = 1:6
plot(freqs, 180/pi*angle(squeeze(freqresp(Ga(i,i), freqs, 'Hz'))), 'color', [0.9290 0.6940 0.1250 0.2]);
end
for i = 1:6
plot(freqs, 180/pi*angle(squeeze(freqresp(Gf(i,i), freqs, 'Hz'))), 'color', [0.4940 0.1840 0.5560 0.2]);
end
h = zeros(4, 1);
h(1) = plot(NaN, NaN, 'color', [0 0.4470 0.7410 0.2]);
h(2) = plot(NaN, NaN, 'color', [0.8500 0.3250 0.0980 0.2]);
h(3) = plot(NaN, NaN, 'color', [0.9290 0.6940 0.1250 0.2]);
h(4) = plot(NaN, NaN, 'color', [0.4940 0.1840 0.5560 0.2]);
legend(h, 'No flexible', 'Flexible Joints', 'Flexible APA', 'All Flexible');
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
ylabel('Phase [deg]'); xlabel('Frequency [Hz]');
ylim([-180, 180]);
yticks([-180, -90, 0, 90, 180]);
linkaxes([ax1,ax2],'x');
#+end_src
#+begin_src matlab :tangle no :exports results :results file replace
exportFig('figs/flexible_elements_effect_dvf.pdf', 'width', 'full', 'height', 'full');
#+end_src
#+name: fig:flexible_elements_effect_dvf
#+caption: Change of the DVF plant dynamics with the added flexible elements
#+RESULTS:
[[file:figs/flexible_elements_effect_dvf.png]]
** Integral Force Feedback
#+begin_src matlab :exports none
freqs = logspace(0, 3, 1000);
figure;
ax1 = subplot(2, 1, 1);
hold on;
for i = 1:6
plot(freqs, abs(squeeze(freqresp(G(6+i,i), freqs, 'Hz'))), 'color', [0 0.4470 0.7410 0.2]);
end
for i = 1:6
plot(freqs, abs(squeeze(freqresp(Gj(6+i,i), freqs, 'Hz'))), 'color', [0.8500 0.3250 0.0980 0.2]);
end
for i = 1:6
plot(freqs, abs(squeeze(freqresp(1e9*Ga(6+i,i), freqs, 'Hz'))), 'color', [0.9290 0.6940 0.1250 0.2]);
end
for i = 1:6
plot(freqs, abs(squeeze(freqresp(1e9*Gf(6+i,i), freqs, 'Hz'))), 'color', [0.4940 0.1840 0.5560 0.2]);
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude [m/N]'); set(gca, 'XTickLabel',[]);
ax2 = subplot(2, 1, 2);
hold on;
for i = 1:6
plot(freqs, 180/pi*angle(squeeze(freqresp(G(6+i,i), freqs, 'Hz'))), 'color', [0 0.4470 0.7410 0.2]);
end
for i = 1:6
plot(freqs, 180/pi*angle(squeeze(freqresp(Gj(6+i,i), freqs, 'Hz'))), 'color', [0.8500 0.3250 0.0980 0.2]);
end
for i = 1:6
plot(freqs, 180/pi*angle(squeeze(freqresp(Ga(6+i,i), freqs, 'Hz'))), 'color', [0.9290 0.6940 0.1250 0.2]);
end
for i = 1:6
plot(freqs, 180/pi*angle(squeeze(freqresp(Gf(6+i,i), freqs, 'Hz'))), 'color', [0.4940 0.1840 0.5560 0.2]);
end
h = zeros(4, 1);
h(1) = plot(NaN, NaN, 'color', [0 0.4470 0.7410 0.2]);
h(2) = plot(NaN, NaN, 'color', [0.8500 0.3250 0.0980 0.2]);
h(3) = plot(NaN, NaN, 'color', [0.9290 0.6940 0.1250 0.2]);
h(4) = plot(NaN, NaN, 'color', [0.4940 0.1840 0.5560 0.2]);
legend(h, 'No flexible', 'Flexible Joints', 'Flexible APA', 'All Flexible');
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
ylabel('Phase [deg]'); xlabel('Frequency [Hz]');
ylim([-180, 180]);
yticks([-180, -90, 0, 90, 180]);
linkaxes([ax1,ax2],'x');
#+end_src
#+begin_src matlab :tangle no :exports results :results file replace
exportFig('figs/flexible_elements_effect_iff.pdf', 'width', 'full', 'height', 'full');
#+end_src
#+name: fig:flexible_elements_effect_iff
#+caption: Change of the IFF plant dynamics with the added flexible elements
#+RESULTS:
[[file:figs/flexible_elements_effect_iff.png]]

2
org/identification.org
View File

@ -25,7 +25,7 @@
#+PROPERTY: header-args:matlab+ :mkdirp yes #+PROPERTY: header-args:matlab+ :mkdirp yes
#+PROPERTY: header-args:matlab+ :output-dir figs #+PROPERTY: header-args:matlab+ :output-dir figs
#+PROPERTY: header-args:latex :headers '("\\usepackage{tikz}" "\\usepackage{import}" "\\import{$HOME/Cloud/thesis/latex/org/}{config.tex}") #+PROPERTY: header-args:latex :headers '("\\usepackage{tikz}" "\\usepackage{import}" "\\import{$HOME/Cloud/tikz/org/}{config.tex}")
#+PROPERTY: header-args:latex+ :imagemagick t :fit yes #+PROPERTY: header-args:latex+ :imagemagick t :fit yes
#+PROPERTY: header-args:latex+ :iminoptions -scale 100% -density 150 #+PROPERTY: header-args:latex+ :iminoptions -scale 100% -density 150
#+PROPERTY: header-args:latex+ :imoutoptions -quality 100 #+PROPERTY: header-args:latex+ :imoutoptions -quality 100

4
org/index.org
View File

@ -7,7 +7,7 @@
#+HTML_HEAD: <script src="./js/jquery.stickytableheaders.min.js"></script> #+HTML_HEAD: <script src="./js/jquery.stickytableheaders.min.js"></script>
#+HTML_HEAD: <script src="./js/readtheorg.js"></script> #+HTML_HEAD: <script src="./js/readtheorg.js"></script>
#+PROPERTY: header-args:latex :headers '("\\usepackage{tikz}" "\\usepackage{import}" "\\import{$HOME/Cloud/thesis/latex/org/}{config.tex}") #+PROPERTY: header-args:latex :headers '("\\usepackage{tikz}" "\\usepackage{import}" "\\import{$HOME/Cloud/tikz/org/}{config.tex}")
#+PROPERTY: header-args:latex+ :imagemagick t :fit yes #+PROPERTY: header-args:latex+ :imagemagick t :fit yes
#+PROPERTY: header-args:latex+ :iminoptions -scale 100% -density 150 #+PROPERTY: header-args:latex+ :iminoptions -scale 100% -density 150
#+PROPERTY: header-args:latex+ :imoutoptions -quality 100 #+PROPERTY: header-args:latex+ :imoutoptions -quality 100
@ -28,7 +28,7 @@ The project is managed with a *Simulink Project*.
Such project is briefly presented [[file:simulink-project.org][here]]. Such project is briefly presented [[file:simulink-project.org][here]].
* Stewart Platform Architecture Definition ([[file:stewart-architecture.org][link]]) * Stewart Platform Architecture Definition ([[file:stewart-architecture.org][link]])
The way the Stewart Platform is defined [[file:stewart-architecture.org][here]]. The way the Stewart Platform is defined is explained [[file:stewart-architecture.org][here]].
All the geometrical parameters are defined including: All the geometrical parameters are defined including:
- Definition of the location of the frames - Definition of the location of the frames

61
org/kinematic-study.org
View File

@ -25,7 +25,7 @@
#+PROPERTY: header-args:matlab+ :mkdirp yes #+PROPERTY: header-args:matlab+ :mkdirp yes
#+PROPERTY: header-args:matlab+ :output-dir figs #+PROPERTY: header-args:matlab+ :output-dir figs
#+PROPERTY: header-args:latex :headers '("\\usepackage{tikz}" "\\usepackage{import}" "\\import{$HOME/Cloud/thesis/latex/org/}{config.tex}") #+PROPERTY: header-args:latex :headers '("\\usepackage{tikz}" "\\usepackage{import}" "\\import{$HOME/Cloud/tikz/org/}{config.tex}")
#+PROPERTY: header-args:latex+ :imagemagick t :fit yes #+PROPERTY: header-args:latex+ :imagemagick t :fit yes
#+PROPERTY: header-args:latex+ :iminoptions -scale 100% -density 150 #+PROPERTY: header-args:latex+ :iminoptions -scale 100% -density 150
#+PROPERTY: header-args:latex+ :imoutoptions -quality 100 #+PROPERTY: header-args:latex+ :imoutoptions -quality 100
@ -130,6 +130,7 @@ The amount of these deflections are a function of the applied wrench as well as
As explain in [[file:stewart-architecture.org][this]] document, each Actuator is modeled by 3 elements in parallel: As explain in [[file:stewart-architecture.org][this]] document, each Actuator is modeled by 3 elements in parallel:
- A spring with a stiffness $k_{i}$ - A spring with a stiffness $k_{i}$
- A dashpot with a damping $c_{i}$ - A dashpot with a damping $c_{i}$
- A force source $\tau_i$
The stiffness of the actuator $k_i$ links the applied actuator force $\delta \tau_i$ and the corresponding small deflection $\delta l_i$: The stiffness of the actuator $k_i$ links the applied actuator force $\delta \tau_i$ and the corresponding small deflection $\delta l_i$:
\begin{equation*} \begin{equation*}
@ -612,6 +613,64 @@ data2orgtable([1e6*L_min, 1e6*L_max, 1e6*(min(min(rs)))], {}, {'=L_min= [$\mu m$
*** TODO Do that by slice :noexport: *** TODO Do that by slice :noexport:
using this function https://fr.mathworks.com/help/matlab/ref/contour3.html using this function https://fr.mathworks.com/help/matlab/ref/contour3.html
* Estimation of the Joint required Stroke
** Introduction :ignore:
** Matlab Init :noexport:ignore:
#+begin_src matlab :tangle no :exports none :results silent :noweb yes :var current_dir=(file-name-directory buffer-file-name)
<<matlab-dir>>
#+end_src
#+begin_src matlab :exports none :results silent :noweb yes
<<matlab-init>>
#+end_src
#+begin_src matlab :results none :exports none
simulinkproject('../');
#+end_src
** Example of the initialization of a Stewart Platform
Let's first define the Stewart Platform Geometry.
#+begin_src matlab
stewart = initializeStewartPlatform();
stewart = initializeFramesPositions(stewart, 'H', 90e-3, 'MO_B', 150e-3);
stewart = generateGeneralConfiguration(stewart);
stewart = computeJointsPose(stewart);
As_init = stewart.geometry.As;
#+end_src
#+begin_src matlab
Tx_max = 50e-6; % Translation [m]
Ty_max = 50e-6; % Translation [m]
Tz_max = 50e-6; % Translation [m]
#+end_src
#+begin_src matlab
Ps = [2*(dec2bin(0:3^2-2,3)-'0')-1].*[Tx_max Ty_max Tz_max];
#+end_src
#+begin_src matlab
flex_ang = zeros(size(Ps, 1), 6);
for Ps_i = 1:size(Ps, 1)
stewart.geometry.FO_M = [0; 0; 90e-3] + Ps(Ps_i, :)';
stewart = generateGeneralConfiguration(stewart);
stewart = computeJointsPose(stewart);
flex_ang(Ps_i, :) = acos(sum(As_init.*stewart.geometry.As));
end
#+end_src
And the maximum bending of the flexible joints is: (in [mrad])
#+begin_src matlab :results replace value
1e3*max(max(abs(flex_ang)))
#+end_src
#+RESULTS:
: 0.90937
* Functions * Functions
<<sec:functions>> <<sec:functions>>
** =computeJacobian=: Compute the Jacobian Matrix ** =computeJacobian=: Compute the Jacobian Matrix

2
org/simscape-model.org
View File

@ -25,7 +25,7 @@
#+PROPERTY: header-args:matlab+ :mkdirp yes #+PROPERTY: header-args:matlab+ :mkdirp yes
#+PROPERTY: header-args:matlab+ :output-dir figs #+PROPERTY: header-args:matlab+ :output-dir figs
#+PROPERTY: header-args:latex :headers '("\\usepackage{tikz}" "\\usepackage{import}" "\\import{$HOME/Cloud/thesis/latex/org/}{config.tex}") #+PROPERTY: header-args:latex :headers '("\\usepackage{tikz}" "\\usepackage{import}" "\\import{$HOME/Cloud/tikz/org/}{config.tex}")
#+PROPERTY: header-args:latex+ :imagemagick t :fit yes #+PROPERTY: header-args:latex+ :imagemagick t :fit yes
#+PROPERTY: header-args:latex+ :iminoptions -scale 100% -density 150 #+PROPERTY: header-args:latex+ :iminoptions -scale 100% -density 150
#+PROPERTY: header-args:latex+ :imoutoptions -quality 100 #+PROPERTY: header-args:latex+ :imoutoptions -quality 100

2
org/simulink-project.org
View File

@ -25,7 +25,7 @@
#+PROPERTY: header-args:matlab+ :mkdirp yes #+PROPERTY: header-args:matlab+ :mkdirp yes
#+PROPERTY: header-args:matlab+ :output-dir figs #+PROPERTY: header-args:matlab+ :output-dir figs
#+PROPERTY: header-args:latex :headers '("\\usepackage{tikz}" "\\usepackage{import}" "\\import{$HOME/Cloud/thesis/latex/org/}{config.tex}") #+PROPERTY: header-args:latex :headers '("\\usepackage{tikz}" "\\usepackage{import}" "\\import{$HOME/Cloud/tikz/org/}{config.tex}")
#+PROPERTY: header-args:latex+ :imagemagick t :fit yes #+PROPERTY: header-args:latex+ :imagemagick t :fit yes
#+PROPERTY: header-args:latex+ :iminoptions -scale 100% -density 150 #+PROPERTY: header-args:latex+ :iminoptions -scale 100% -density 150
#+PROPERTY: header-args:latex+ :imoutoptions -quality 100 #+PROPERTY: header-args:latex+ :imoutoptions -quality 100

2
org/static-analysis.org
View File

@ -25,7 +25,7 @@
#+PROPERTY: header-args:matlab+ :mkdirp yes #+PROPERTY: header-args:matlab+ :mkdirp yes
#+PROPERTY: header-args:matlab+ :output-dir figs #+PROPERTY: header-args:matlab+ :output-dir figs
#+PROPERTY: header-args:latex :headers '("\\usepackage{tikz}" "\\usepackage{import}" "\\import{$HOME/Cloud/thesis/latex/org/}{config.tex}") #+PROPERTY: header-args:latex :headers '("\\usepackage{tikz}" "\\usepackage{import}" "\\import{$HOME/Cloud/tikz/org/}{config.tex}")
#+PROPERTY: header-args:latex+ :imagemagick t :fit yes #+PROPERTY: header-args:latex+ :imagemagick t :fit yes
#+PROPERTY: header-args:latex+ :iminoptions -scale 100% -density 150 #+PROPERTY: header-args:latex+ :iminoptions -scale 100% -density 150
#+PROPERTY: header-args:latex+ :imoutoptions -quality 100 #+PROPERTY: header-args:latex+ :imoutoptions -quality 100

130
org/stewart-architecture.org
View File

@ -25,7 +25,7 @@
#+PROPERTY: header-args:matlab+ :mkdirp yes #+PROPERTY: header-args:matlab+ :mkdirp yes
#+PROPERTY: header-args:matlab+ :output-dir figs #+PROPERTY: header-args:matlab+ :output-dir figs
#+PROPERTY: header-args:latex :headers '("\\usepackage{tikz}" "\\usepackage{import}" "\\import{$HOME/Cloud/thesis/latex/org/}{config.tex}") #+PROPERTY: header-args:latex :headers '("\\usepackage{tikz}" "\\usepackage{import}" "\\import{$HOME/Cloud/tikz/org/}{config.tex}")
#+PROPERTY: header-args:latex+ :imagemagick t :fit yes #+PROPERTY: header-args:latex+ :imagemagick t :fit yes
#+PROPERTY: header-args:latex+ :iminoptions -scale 100% -density 150 #+PROPERTY: header-args:latex+ :iminoptions -scale 100% -density 150
#+PROPERTY: header-args:latex+ :imoutoptions -quality 100 #+PROPERTY: header-args:latex+ :imoutoptions -quality 100
@ -951,6 +951,8 @@ This Matlab function is accessible [[file:../src/initializeCylindricalStruts.m][
#+begin_src matlab #+begin_src matlab
arguments arguments
stewart stewart
args.type_F char {mustBeMember(args.type_F,{'cylindrical', 'none'})} = 'cylindrical'
args.type_M char {mustBeMember(args.type_M,{'cylindrical', 'none'})} = 'cylindrical'
args.Fsm (1,1) double {mustBeNumeric, mustBePositive} = 0.1 args.Fsm (1,1) double {mustBeNumeric, mustBePositive} = 0.1
args.Fsh (1,1) double {mustBeNumeric, mustBePositive} = 50e-3 args.Fsh (1,1) double {mustBeNumeric, mustBePositive} = 50e-3
args.Fsr (1,1) double {mustBeNumeric, mustBePositive} = 5e-3 args.Fsr (1,1) double {mustBeNumeric, mustBePositive} = 5e-3
@ -995,7 +997,12 @@ This Matlab function is accessible [[file:../src/initializeCylindricalStruts.m][
:UNNUMBERED: t :UNNUMBERED: t
:END: :END:
#+begin_src matlab #+begin_src matlab
switch args.type_M
case 'cylindrical'
stewart.struts_M.type = 1; stewart.struts_M.type = 1;
case 'none'
stewart.struts_M.type = 2;
end
stewart.struts_M.I = I_M; stewart.struts_M.I = I_M;
stewart.struts_M.M = Msm; stewart.struts_M.M = Msm;
@ -1004,7 +1011,12 @@ This Matlab function is accessible [[file:../src/initializeCylindricalStruts.m][
#+end_src #+end_src
#+begin_src matlab #+begin_src matlab
switch args.type_F
case 'cylindrical'
stewart.struts_F.type = 1; stewart.struts_F.type = 1;
case 'none'
stewart.struts_F.type = 2;
end
stewart.struts_F.I = I_F; stewart.struts_F.I = I_F;
stewart.struts_F.M = Fsm; stewart.struts_F.M = Fsm;
@ -1237,10 +1249,83 @@ A simplistic model of such amplified actuator is shown in Figure [[fig:amplified
stewart.actuators.Cr = args.Cr; stewart.actuators.Cr = args.Cr;
stewart.actuators.K = K; stewart.actuators.K = K;
stewart.actuators.C = K; stewart.actuators.C = C;
#+end_src #+end_src
** =initializeJointDynamics=: Add Stiffness and Damping properties for spherical joints ** TODO =initializeFlexibleStrutDynamics=: Model each strut with a flexible element
:PROPERTIES:
:header-args:matlab+: :tangle ../src/initializeFlexibleStrutDynamics.m
:header-args:matlab+: :comments none :mkdirp yes :eval no
:END:
<<sec:initializeFlexibleStrutDynamics>>
This Matlab function is accessible [[file:../src/initializeFlexibleStrutDynamics.m][here]].
*** Function description
:PROPERTIES:
:UNNUMBERED: t
:END:
#+begin_src matlab
function [stewart] = initializeFlexibleStrutDynamics(stewart, args)
% initializeFlexibleStrutDynamics - Add Stiffness and Damping properties of each strut
%
% Syntax: [stewart] = initializeFlexibleStrutDynamics(args)
%
% Inputs:
% - args - Structure with the following fields:
% - K [nxn] - Vertical stiffness contribution of the piezoelectric stack [N/m]
% - M [nxn] - Vertical damping contribution of the piezoelectric stack [N/(m/s)]
% - xi [1x1] - Vertical (residual) stiffness when the piezoelectric stack is removed [N/m]
% - step_file [6x1] - Vertical (residual) damping when the piezoelectric stack is removed [N/(m/s)]
%
% Outputs:
% - stewart - updated Stewart structure with the added fields:
#+end_src
*** Optional Parameters
:PROPERTIES:
:UNNUMBERED: t
:END:
#+begin_src matlab
arguments
stewart
args.K double {mustBeNumeric} = zeros(6,6)
args.M double {mustBeNumeric} = zeros(6,6)
args.H double {mustBeNumeric} = 0
args.n_xyz double {mustBeNumeric} = zeros(2,3)
args.xi double {mustBeNumeric} = 0.1
args.step_file char {} = ''
end
#+end_src
*** Compute the axial offset
:PROPERTIES:
:UNNUMBERED: t
:END:
#+begin_src matlab
stewart.actuators.ax_off = (stewart.geometry.l(1) - args.H)/2; % Axial Offset at the ends of the actuator
#+end_src
*** Populate the =stewart= structure
:PROPERTIES:
:UNNUMBERED: t
:END:
#+begin_src matlab
stewart.actuators.type = 3;
stewart.actuators.Km = args.K;
stewart.actuators.Mm = args.M;
stewart.actuators.n_xyz = args.n_xyz;
stewart.actuators.xi = args.xi;
stewart.actuators.step_file = args.step_file;
stewart.actuators.K = args.K(3,3); % Axial Stiffness
#+end_src
** TODO =initializeJointDynamics=: Add Stiffness and Damping properties for spherical joints
:PROPERTIES: :PROPERTIES:
:header-args:matlab+: :tangle ../src/initializeJointDynamics.m :header-args:matlab+: :tangle ../src/initializeJointDynamics.m
:header-args:matlab+: :comments none :mkdirp yes :eval no :header-args:matlab+: :comments none :mkdirp yes :eval no
@ -1291,8 +1376,8 @@ This Matlab function is accessible [[file:../src/initializeJointDynamics.m][here
#+begin_src matlab #+begin_src matlab
arguments arguments
stewart stewart
args.type_F char {mustBeMember(args.type_F,{'universal', 'spherical', 'universal_p', 'spherical_p'})} = 'universal' args.type_F char {mustBeMember(args.type_F,{'universal', 'spherical', 'universal_p', 'spherical_p', 'flexible'})} = 'universal'
args.type_M char {mustBeMember(args.type_M,{'universal', 'spherical', 'universal_p', 'spherical_p'})} = 'spherical' args.type_M char {mustBeMember(args.type_M,{'universal', 'spherical', 'universal_p', 'spherical_p', 'flexible'})} = 'spherical'
args.Kf_M (6,1) double {mustBeNumeric, mustBeNonnegative} = 15*ones(6,1) args.Kf_M (6,1) double {mustBeNumeric, mustBeNonnegative} = 15*ones(6,1)
args.Cf_M (6,1) double {mustBeNumeric, mustBeNonnegative} = 1e-4*ones(6,1) args.Cf_M (6,1) double {mustBeNumeric, mustBeNonnegative} = 1e-4*ones(6,1)
args.Kt_M (6,1) double {mustBeNumeric, mustBeNonnegative} = 20*ones(6,1) args.Kt_M (6,1) double {mustBeNumeric, mustBeNonnegative} = 20*ones(6,1)
@ -1301,6 +1386,16 @@ This Matlab function is accessible [[file:../src/initializeJointDynamics.m][here
args.Cf_F (6,1) double {mustBeNumeric, mustBeNonnegative} = 1e-4*ones(6,1) args.Cf_F (6,1) double {mustBeNumeric, mustBeNonnegative} = 1e-4*ones(6,1)
args.Kt_F (6,1) double {mustBeNumeric, mustBeNonnegative} = 20*ones(6,1) args.Kt_F (6,1) double {mustBeNumeric, mustBeNonnegative} = 20*ones(6,1)
args.Ct_F (6,1) double {mustBeNumeric, mustBeNonnegative} = 1e-3*ones(6,1) args.Ct_F (6,1) double {mustBeNumeric, mustBeNonnegative} = 1e-3*ones(6,1)
args.K_M double {mustBeNumeric} = zeros(6,6)
args.M_M double {mustBeNumeric} = zeros(6,6)
args.n_xyz_M double {mustBeNumeric} = zeros(2,3)
args.xi_M double {mustBeNumeric} = 0.1
args.step_file_M char {} = ''
args.K_F double {mustBeNumeric} = zeros(6,6)
args.M_F double {mustBeNumeric} = zeros(6,6)
args.n_xyz_F double {mustBeNumeric} = zeros(2,3)
args.xi_F double {mustBeNumeric} = 0.1
args.step_file_F char {} = ''
end end
#+end_src #+end_src
@ -1318,6 +1413,8 @@ This Matlab function is accessible [[file:../src/initializeJointDynamics.m][here
stewart.joints_F.type = 3; stewart.joints_F.type = 3;
case 'spherical_p' case 'spherical_p'
stewart.joints_F.type = 4; stewart.joints_F.type = 4;
case 'flexible'
stewart.joints_F.type = 5;
end end
switch args.type_M switch args.type_M
@ -1329,6 +1426,8 @@ This Matlab function is accessible [[file:../src/initializeJointDynamics.m][here
stewart.joints_M.type = 3; stewart.joints_M.type = 3;
case 'spherical_p' case 'spherical_p'
stewart.joints_M.type = 4; stewart.joints_M.type = 4;
case 'flexible'
stewart.joints_M.type = 5;
end end
#+end_src #+end_src
@ -1371,7 +1470,6 @@ Rotational Stiffness
stewart.joints_F.Kt = args.Kf_F; stewart.joints_F.Kt = args.Kf_F;
#+end_src #+end_src
Rotational Damping Rotational Damping
#+begin_src matlab #+begin_src matlab
stewart.joints_M.Cf = args.Cf_M; stewart.joints_M.Cf = args.Cf_M;
@ -1381,6 +1479,26 @@ Rotational Damping
stewart.joints_F.Ct = args.Cf_F; stewart.joints_F.Ct = args.Cf_F;
#+end_src #+end_src
*** Stiffness and Mass matrices for flexible joint
:PROPERTIES:
:UNNUMBERED: t
:END:
#+begin_src matlab
stewart.joints_F.M = args.M_F;
stewart.joints_F.K = args.K_F;
stewart.joints_F.n_xyz = args.n_xyz_F;
stewart.joints_F.xi = args.xi_F;
stewart.joints_F.xi = args.xi_F;
stewart.joints_F.step_file = args.step_file_F;
stewart.joints_M.M = args.M_M;
stewart.joints_M.K = args.K_M;
stewart.joints_M.n_xyz = args.n_xyz_M;
stewart.joints_M.xi = args.xi_M;
stewart.joints_M.step_file = args.step_file_M;
#+end_src
** =initializeInertialSensor=: Initialize the inertial sensor in each strut ** =initializeInertialSensor=: Initialize the inertial sensor in each strut
:PROPERTIES: :PROPERTIES:
:header-args:matlab+: :tangle ../src/initializeInertialSensor.m :header-args:matlab+: :tangle ../src/initializeInertialSensor.m

BIN
simscape_subsystems/Stewart_Platform.slx
View File

Binary file not shown.

BIN
simscape_subsystems/stewart_strut.slx
View File

Binary file not shown.

2
src/initializeAmplifiedStrutDynamics.m
View File

@ -40,4 +40,4 @@ stewart.actuators.Kr = args.Kr;
stewart.actuators.Cr = args.Cr; stewart.actuators.Cr = args.Cr;
stewart.actuators.K = K; stewart.actuators.K = K;
stewart.actuators.C = K; stewart.actuators.C = C;

16
src/initializeCylindricalStruts.m
View File

@ -27,6 +27,8 @@ function [stewart] = initializeCylindricalStruts(stewart, args)
arguments arguments
stewart stewart
args.type_F char {mustBeMember(args.type_F,{'cylindrical', 'none'})} = 'cylindrical'
args.type_M char {mustBeMember(args.type_M,{'cylindrical', 'none'})} = 'cylindrical'
args.Fsm (1,1) double {mustBeNumeric, mustBePositive} = 0.1 args.Fsm (1,1) double {mustBeNumeric, mustBePositive} = 0.1
args.Fsh (1,1) double {mustBeNumeric, mustBePositive} = 50e-3 args.Fsh (1,1) double {mustBeNumeric, mustBePositive} = 50e-3
args.Fsr (1,1) double {mustBeNumeric, mustBePositive} = 5e-3 args.Fsr (1,1) double {mustBeNumeric, mustBePositive} = 5e-3
@ -56,14 +58,24 @@ for i = 1:6
1/2 * Msm(i) * Msr(i)^2]); 1/2 * Msm(i) * Msr(i)^2]);
end end
stewart.struts_M.type = 1; switch args.type_M
case 'cylindrical'
stewart.struts_M.type = 1;
case 'none'
stewart.struts_M.type = 2;
end
stewart.struts_M.I = I_M; stewart.struts_M.I = I_M;
stewart.struts_M.M = Msm; stewart.struts_M.M = Msm;
stewart.struts_M.R = Msr; stewart.struts_M.R = Msr;
stewart.struts_M.H = Msh; stewart.struts_M.H = Msh;
stewart.struts_F.type = 1; switch args.type_F
case 'cylindrical'
stewart.struts_F.type = 1;
case 'none'
stewart.struts_F.type = 2;
end
stewart.struts_F.I = I_F; stewart.struts_F.I = I_F;
stewart.struts_F.M = Fsm; stewart.struts_F.M = Fsm;

38
src/initializeFlexibleStrutDynamics.m Normal file
View File

@ -0,0 +1,38 @@
function [stewart] = initializeFlexibleStrutDynamics(stewart, args)
% initializeFlexibleStrutDynamics - Add Stiffness and Damping properties of each strut
%
% Syntax: [stewart] = initializeFlexibleStrutDynamics(args)
%
% Inputs:
% - args - Structure with the following fields:
% - K [nxn] - Vertical stiffness contribution of the piezoelectric stack [N/m]
% - M [nxn] - Vertical damping contribution of the piezoelectric stack [N/(m/s)]
% - xi [1x1] - Vertical (residual) stiffness when the piezoelectric stack is removed [N/m]
% - step_file [6x1] - Vertical (residual) damping when the piezoelectric stack is removed [N/(m/s)]
%
% Outputs:
% - stewart - updated Stewart structure with the added fields:
arguments
stewart
args.K double {mustBeNumeric} = zeros(6,6)
args.M double {mustBeNumeric} = zeros(6,6)
args.H double {mustBeNumeric} = 0
args.n_xyz double {mustBeNumeric} = zeros(2,3)
args.xi double {mustBeNumeric} = 0.1
args.step_file char {} = ''
end
stewart.actuators.ax_off = (stewart.geometry.l(1) - args.H)/2; % Axial Offset at the ends of the actuator
stewart.actuators.type = 3;
stewart.actuators.Km = args.K;
stewart.actuators.Mm = args.M;
stewart.actuators.n_xyz = args.n_xyz;
stewart.actuators.xi = args.xi;
stewart.actuators.step_file = args.step_file;
stewart.actuators.K = args.K(3,3); % Axial Stiffness

31
src/initializeJointDynamics.m
View File

@ -29,8 +29,8 @@ function [stewart] = initializeJointDynamics(stewart, args)
arguments arguments
stewart stewart
args.type_F char {mustBeMember(args.type_F,{'universal', 'spherical', 'universal_p', 'spherical_p'})} = 'universal' args.type_F char {mustBeMember(args.type_F,{'universal', 'spherical', 'universal_p', 'spherical_p', 'flexible'})} = 'universal'
args.type_M char {mustBeMember(args.type_M,{'universal', 'spherical', 'universal_p', 'spherical_p'})} = 'spherical' args.type_M char {mustBeMember(args.type_M,{'universal', 'spherical', 'universal_p', 'spherical_p', 'flexible'})} = 'spherical'
args.Kf_M (6,1) double {mustBeNumeric, mustBeNonnegative} = 15*ones(6,1) args.Kf_M (6,1) double {mustBeNumeric, mustBeNonnegative} = 15*ones(6,1)
args.Cf_M (6,1) double {mustBeNumeric, mustBeNonnegative} = 1e-4*ones(6,1) args.Cf_M (6,1) double {mustBeNumeric, mustBeNonnegative} = 1e-4*ones(6,1)
args.Kt_M (6,1) double {mustBeNumeric, mustBeNonnegative} = 20*ones(6,1) args.Kt_M (6,1) double {mustBeNumeric, mustBeNonnegative} = 20*ones(6,1)
@ -39,6 +39,16 @@ arguments
args.Cf_F (6,1) double {mustBeNumeric, mustBeNonnegative} = 1e-4*ones(6,1) args.Cf_F (6,1) double {mustBeNumeric, mustBeNonnegative} = 1e-4*ones(6,1)
args.Kt_F (6,1) double {mustBeNumeric, mustBeNonnegative} = 20*ones(6,1) args.Kt_F (6,1) double {mustBeNumeric, mustBeNonnegative} = 20*ones(6,1)
args.Ct_F (6,1) double {mustBeNumeric, mustBeNonnegative} = 1e-3*ones(6,1) args.Ct_F (6,1) double {mustBeNumeric, mustBeNonnegative} = 1e-3*ones(6,1)
args.K_M double {mustBeNumeric} = zeros(6,6)
args.M_M double {mustBeNumeric} = zeros(6,6)
args.n_xyz_M double {mustBeNumeric} = zeros(2,3)
args.xi_M double {mustBeNumeric} = 0.1
args.step_file_M char {} = ''
args.K_F double {mustBeNumeric} = zeros(6,6)
args.M_F double {mustBeNumeric} = zeros(6,6)
args.n_xyz_F double {mustBeNumeric} = zeros(2,3)
args.xi_F double {mustBeNumeric} = 0.1
args.step_file_F char {} = ''
end end
switch args.type_F switch args.type_F
@ -50,6 +60,8 @@ switch args.type_F
stewart.joints_F.type = 3; stewart.joints_F.type = 3;
case 'spherical_p' case 'spherical_p'
stewart.joints_F.type = 4; stewart.joints_F.type = 4;
case 'flexible'
stewart.joints_F.type = 5;
end end
switch args.type_M switch args.type_M
@ -61,6 +73,8 @@ switch args.type_M
stewart.joints_M.type = 3; stewart.joints_M.type = 3;
case 'spherical_p' case 'spherical_p'
stewart.joints_M.type = 4; stewart.joints_M.type = 4;
case 'flexible'
stewart.joints_M.type = 5;
end end
stewart.joints_M.Kx = zeros(6,1); stewart.joints_M.Kx = zeros(6,1);
@ -90,3 +104,16 @@ stewart.joints_M.Ct = args.Cf_M;
stewart.joints_F.Cf = args.Cf_F; stewart.joints_F.Cf = args.Cf_F;
stewart.joints_F.Ct = args.Cf_F; stewart.joints_F.Ct = args.Cf_F;
stewart.joints_F.M = args.M_F;
stewart.joints_F.K = args.K_F;
stewart.joints_F.n_xyz = args.n_xyz_F;
stewart.joints_F.xi = args.xi_F;
stewart.joints_F.xi = args.xi_F;
stewart.joints_F.step_file = args.step_file_F;
stewart.joints_M.M = args.M_M;
stewart.joints_M.K = args.K_M;
stewart.joints_M.n_xyz = args.n_xyz_M;
stewart.joints_M.xi = args.xi_M;
stewart.joints_M.step_file = args.step_file_M;