1646 lines
57 KiB
Org Mode
1646 lines
57 KiB
Org Mode
#+TITLE: Flexible Joints - Test Bench
|
|
:DRAWER:
|
|
#+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="https://research.tdehaeze.xyz/css/style.css"/>
|
|
#+HTML_HEAD: <script type="text/javascript" src="https://research.tdehaeze.xyz/js/script.js"></script>
|
|
|
|
#+BIND: org-latex-image-default-option "scale=1"
|
|
#+BIND: org-latex-image-default-width ""
|
|
|
|
#+LaTeX_CLASS: scrreprt
|
|
#+LaTeX_CLASS_OPTIONS: [a4paper, 10pt, DIV=12, parskip=full]
|
|
#+LaTeX_HEADER_EXTRA: \input{preamble.tex}
|
|
|
|
#+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+ :tangle 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:
|
|
|
|
#+begin_export html
|
|
<hr>
|
|
<p>This report is also available as a <a href="./test-bench-flexible-joints.pdf">pdf</a>.</p>
|
|
<hr>
|
|
#+end_export
|
|
|
|
* Introduction :ignore:
|
|
In this document, we present a test-bench that has been developed in order to measure the bending stiffness of flexible joints.
|
|
|
|
It is structured as follow:
|
|
- Section [[sec:flexible_joints]]: the geometry of the flexible joints and the expected stiffness and stroke are presented
|
|
- Section [[sec:flex_dim_meas]]: each flexible joint is measured using a profile projector
|
|
- Section [[sec:test_bench_desc]]: the stiffness measurement bench is presented
|
|
- Section [[sec:error_budget]]: an error budget is performed in order to estimate the accuracy of the measured stiffness
|
|
- Section [[sec:first_measurements]]: first measurements are performed
|
|
- Section [[sec:bending_stiffness_meas]]: the bending stiffness of the flexible joints are measured
|
|
|
|
* Flexible Joints
|
|
<<sec:flexible_joints>>
|
|
|
|
The flexible joints that are going to be measured in this document have been design to be used with a Nano-Hexapod (Figure [[fig:nano_hexapod]]).
|
|
|
|
#+name: fig:nano_hexapod
|
|
#+caption: CAD view of the Nano-Hexapod containing the flexible joints
|
|
#+attr_latex: :width 0.7\linewidth
|
|
[[file:figs/nano_hexapod.png]]
|
|
|
|
Ideally, these flexible joints would behave as perfect ball joints, that is to say:
|
|
- no bending and torsional stiffnesses
|
|
- infinite shear and axial stiffnesses
|
|
- un-limited bending and torsional stroke
|
|
- no friction, no backlash
|
|
|
|
|
|
The real characteristics of the flexible joints will influence the dynamics of the Nano-Hexapod.
|
|
Using a multi-body dynamical model of the nano-hexapod, the specifications in term of stiffness and stroke of the flexible joints have been determined and summarized in Table [[tab:flexible_joints_specs]].
|
|
|
|
#+name: tab:flexible_joints_specs
|
|
#+caption: Specifications for the flexible joints and estimated characteristics from the Finite Element Model
|
|
#+attr_latex: :environment tabularx :width 0.5\linewidth :align Xcc
|
|
#+attr_latex: :center t :booktabs t :float t
|
|
| | *Specification* | *FEM* |
|
|
|-------------------+-----------------+-------|
|
|
| Axial Stiffness | > 100 [N/um] | 94 |
|
|
| Shear Stiffness | > 1 [N/um] | 13 |
|
|
| Bending Stiffness | < 100 [Nm/rad] | 5 |
|
|
| Torsion Stiffness | < 500 [Nm/rad] | 260 |
|
|
| Bending Stroke | > 1 [mrad] | 24.5 |
|
|
| Torsion Stroke | > 5 [urad] | |
|
|
|
|
Then, the classical geometry of a flexible ball joint shown in Figure [[fig:flexible_joint_fem_geometry]] has been optimized in order to meet the requirements.
|
|
This has been done using a Finite Element Software and the obtained joint's characteristics are summarized in Table [[tab:flexible_joints_specs]].
|
|
|
|
#+name: fig:flexible_joint_fem_geometry
|
|
#+caption: Flexible part of the Joint used for FEM - CAD view
|
|
#+attr_latex: :width 0.5\linewidth
|
|
[[file:figs/flexible_joint_fem_geometry.png]]
|
|
|
|
The obtained geometry are defined in the [[file:doc/flex_joints.pdf][drawings of the flexible joints]].
|
|
The material is a special kind of stainless steel called "F16PH".
|
|
|
|
The flexible joints can be seen on Figure [[fig:received_flex]].
|
|
|
|
#+name: fig:received_flex
|
|
#+caption: 15 of the 16 flexible joints
|
|
#+attr_latex: :width \linewidth
|
|
[[file:figs/IMG_20210302_173619.jpg]]
|
|
|
|
* Dimensional Measurements
|
|
:PROPERTIES:
|
|
:header-args:matlab+: :tangle ./matlab/dim_meas.m
|
|
:END:
|
|
<<sec:flex_dim_meas>>
|
|
** Measurement Bench
|
|
|
|
The axis corresponding to the flexible joints are defined in Figure [[fig:flexible_joint_axis]].
|
|
|
|
#+name: fig:flexible_joint_axis
|
|
#+caption: Define axis for the flexible joints
|
|
#+attr_latex: :width 0.3\linewidth
|
|
[[file:figs/flexible_joint_axis.png]]
|
|
|
|
The dimensions of the flexible part in the Y-Z plane will contribute to the X-bending stiffness.
|
|
Similarly, the dimensions of the flexible part in the X-Z plane will contribute to the Y-bending stiffness.
|
|
|
|
The setup to measure the dimension of the "X" flexible beam is shown in Figure [[fig:flexible_joint_y_flex_meas_setup]].
|
|
|
|
#+name: fig:flexible_joint_y_flex_meas_setup
|
|
#+caption: Setup to measure the dimension of the flexible beam corresponding to the X-bending stiffness
|
|
#+attr_latex: :width 1.0\linewidth
|
|
[[file:figs/flexible_joint_y_flex_meas_setup.png]]
|
|
|
|
What we typically observe is shown in Figure [[fig:soft_measure_flex_size]].
|
|
It is then possible to estimate to dimension of the flexible beam with an accuracy of $\approx 5\,\mu m$,
|
|
|
|
#+name: fig:soft_measure_flex_size
|
|
#+attr_latex: :width 1.0\linewidth
|
|
#+caption: Image used to measure the flexible joint's dimensions
|
|
[[file:figs/soft_measure_flex_size.jpg]]
|
|
|
|
|
|
** 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 :tangle no
|
|
addpath('./matlab/mat/');
|
|
addpath('./matlab/');
|
|
#+end_src
|
|
|
|
#+begin_src matlab :eval no
|
|
addpath('./mat/');
|
|
#+end_src
|
|
|
|
** Measurement Results
|
|
# - Strange shape: 5
|
|
|
|
The expected flexible beam thickness is $250\,\mu m$.
|
|
However, it is more important that the thickness of all beams are close to each other.
|
|
|
|
The dimension of the beams are been measured at each end to be able to estimate the mean of the beam thickness.
|
|
|
|
All the measured dimensions are summarized in Table [[tab:flex_dim]].
|
|
|
|
#+begin_src matlab :exports none
|
|
meas_flex = [[223, 226, 224, 214];
|
|
[229, 231, 237, 224];
|
|
[234, 230, 239, 231];
|
|
[233, 227, 229, 232];
|
|
[225, 212, 228, 228];
|
|
[220, 221, 224, 220];
|
|
[206, 207, 228, 226];
|
|
[230, 224, 224, 223];
|
|
[223, 231, 228, 233];
|
|
[228, 230, 235, 231];
|
|
[197, 207, 211, 204];
|
|
[227, 226, 225, 226];
|
|
[215, 228, 231, 220];
|
|
[216, 224, 224, 221];
|
|
[209, 214, 220, 221];
|
|
[213, 210, 230, 229]];
|
|
#+end_src
|
|
|
|
#+begin_src matlab :exports results :results value table replace :tangle no :post addhdr(*this*)
|
|
data2orgtable(meas_flex, {'1','2','3','4','5','6','7','8','9','10','11','12','13','14','15','16'}, {'Y1', 'Y2', 'X1', 'X2'}, ' %.0f ');
|
|
#+end_src
|
|
|
|
#+name: tab:flex_dim
|
|
#+caption: Measured Dimensions of the flexible beams in $\mu m$
|
|
#+attr_latex: :environment tabularx :width 0.4\linewidth :align Xcccc
|
|
#+attr_latex: :center t :booktabs t :float t
|
|
#+RESULTS:
|
|
| | Y1 | Y2 | X1 | X2 |
|
|
|----+-----+-----+-----+-----|
|
|
| 1 | 223 | 226 | 224 | 214 |
|
|
| 2 | 229 | 231 | 237 | 224 |
|
|
| 3 | 234 | 230 | 239 | 231 |
|
|
| 4 | 233 | 227 | 229 | 232 |
|
|
| 5 | 225 | 212 | 228 | 228 |
|
|
| 6 | 220 | 221 | 224 | 220 |
|
|
| 7 | 206 | 207 | 228 | 226 |
|
|
| 8 | 230 | 224 | 224 | 223 |
|
|
| 9 | 223 | 231 | 228 | 233 |
|
|
| 10 | 228 | 230 | 235 | 231 |
|
|
| 11 | 197 | 207 | 211 | 204 |
|
|
| 12 | 227 | 226 | 225 | 226 |
|
|
| 13 | 215 | 228 | 231 | 220 |
|
|
| 14 | 216 | 224 | 224 | 221 |
|
|
| 15 | 209 | 214 | 220 | 221 |
|
|
| 16 | 213 | 210 | 230 | 229 |
|
|
|
|
An histogram of these measured dimensions is shown in Figure [[fig:beam_dim_histogram]].
|
|
|
|
#+begin_src matlab :exports none
|
|
figure;
|
|
histogram([(meas_flex(:,1)+meas_flex(:,2))/2,(meas_flex(:,3)+meas_flex(:,4))/2], 7)
|
|
xlabel("Beam's Thickness [$\mu m$]");
|
|
#+end_src
|
|
|
|
#+begin_src matlab :tangle no :exports results :results file replace
|
|
exportFig('figs/beam_dim_histogram.pdf', 'width', 'normal', 'height', 'normal');
|
|
#+end_src
|
|
|
|
#+name: fig:beam_dim_histogram
|
|
#+caption: Histogram for the (16x2) measured beams' thickness
|
|
#+RESULTS:
|
|
[[file:figs/beam_dim_histogram.png]]
|
|
|
|
#+begin_src matlab :tangle no :exports none
|
|
save('matlab/mat/flex_meas_dim.mat', 'meas_flex');
|
|
#+end_src
|
|
|
|
* Measurement Test Bench - Bending Stiffness
|
|
:PROPERTIES:
|
|
:header-args:matlab+: :tangle ./matlab/bench_dimensioning.m
|
|
:END:
|
|
<<sec:test_bench_desc>>
|
|
** Introduction :ignore:
|
|
The most important characteristic of the flexible joint that we want to measure is its bending stiffness $k_{R_x} \approx k_{R_y}$.
|
|
|
|
To do so, we have to apply a torque $T_x$ on the flexible joint and measure its angular deflection $\theta_x$.
|
|
The stiffness is then
|
|
\begin{equation}
|
|
k_{R_x} = \frac{T_x}{\theta_x}
|
|
\end{equation}
|
|
|
|
As it is quite difficult to apply a pure torque, a force will be applied instead.
|
|
The application point of the force should far enough from the flexible part such that the obtained bending is much larger than the displacement in shear.
|
|
|
|
The working principle of the bench is schematically shown in Figure [[fig:test_bench_principle]].
|
|
One part of the flexible joint is fixed. On the mobile part, a force $F_x$ is applied which is equivalent to a torque applied on the flexible joint center.
|
|
The induced rotation is measured with a displacement sensor $d_x$.
|
|
|
|
#+name: fig:test_bench_principle
|
|
#+caption: Test Bench - working principle
|
|
[[file:figs/test_bench_principle.png]]
|
|
|
|
|
|
This test-bench will be used to have a first approximation of the bending stiffnesss and stroke of the flexible joints.
|
|
Another test-bench, better engineered will be used to measure the flexible joint's characteristics with better accuracy.
|
|
|
|
** 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
|
|
|
|
** Flexible joint Geometry
|
|
The flexible joint used for the Nano-Hexapod is shown in Figure [[fig:flexible_joint_geometry]].
|
|
Its bending stiffness is foreseen to be $k_{R_y}\approx 5\,\frac{Nm}{rad}$ and its stroke $\theta_{y,\text{max}}\approx 25\,mrad$.
|
|
|
|
#+name: fig:flexible_joint_geometry
|
|
#+caption: Geometry of the flexible joint
|
|
[[file:figs/flexible_joint_geometry.png]]
|
|
|
|
The height between the flexible point (center of the joint) and the point where external forces are applied is $h = 20\,mm$.
|
|
|
|
Let's define the parameters on Matlab.
|
|
#+begin_src matlab
|
|
kRx = 5; % Bending Stiffness [Nm/rad]
|
|
Rxmax = 25e-3; % Bending Stroke [rad]
|
|
h = 20e-3; % Height [m]
|
|
#+end_src
|
|
|
|
** Required external applied force
|
|
|
|
The bending $\theta_y$ of the flexible joint due to the force $F_x$ is:
|
|
\begin{equation}
|
|
\theta_y = \frac{M_y}{k_{R_y}} = \frac{F_x h}{k_{R_y}}
|
|
\end{equation}
|
|
|
|
Therefore, the applied force to test the full range of the flexible joint is:
|
|
\begin{equation}
|
|
F_{x,\text{max}} = \frac{k_{R_y} \theta_{y,\text{max}}}{h}
|
|
\end{equation}
|
|
|
|
#+begin_src matlab
|
|
Fxmax = kRx*Rxmax/h; % Force to induce maximum stroke [N]
|
|
#+end_src
|
|
|
|
And we obtain:
|
|
#+begin_src matlab :results value raw replace :exports results
|
|
sprintf('\\begin{equation} F_{x,max} = %.1f\\, [N] \\end{equation}', Fxmax)
|
|
#+end_src
|
|
|
|
#+RESULTS:
|
|
\begin{equation} F_{x,max} = 6.2\, [N] \end{equation}
|
|
|
|
The measurement range of the force sensor should then be higher than $6.2\,N$.
|
|
|
|
** Required actuator stroke and sensors range
|
|
|
|
The flexible joint is designed to allow a bending motion of $\pm 25\,mrad$.
|
|
The corresponding stroke at the location of the force sensor is:
|
|
\[ d_{x,\text{max}} = h \tan(R_{x,\text{max}}) \]
|
|
|
|
#+begin_src matlab
|
|
dxmax = h*tan(Rxmax);
|
|
#+end_src
|
|
|
|
#+begin_src matlab :results value raw replace :exports results
|
|
sprintf('\\begin{equation} d_{max} = %.1f\\, [mm] \\end{equation}', 1e3*dxmax)
|
|
#+end_src
|
|
|
|
#+RESULTS:
|
|
\begin{equation} d_{max} = 0.5\, [mm] \end{equation}
|
|
|
|
In order to test the full range of the flexible joint, the stroke of the translation stage used to move the force sensor should be higher than $0.5\,mm$.
|
|
Similarly, the measurement range of the displacement sensor should also be higher than $0.5\,mm$.
|
|
|
|
** Test Bench
|
|
|
|
A CAD view of the measurement bench is shown in Figure [[fig:test_bench_flex_overview]].
|
|
|
|
#+begin_note
|
|
Here are the different elements used in this bench:
|
|
- *Translation Stage*: [[file:doc/V-408-Datasheet.pdf][V-408]]
|
|
- *Load Cells*: [[file:doc/A700000007147087.pdf][FC2231-0000-0010-L]]
|
|
- *Encoder*: [[file:doc/L-9517-9448-05-B_Data_sheet_RESOLUTE_BiSS_en.pdf][Renishaw Resolute 1nm]]
|
|
#+end_note
|
|
|
|
Both the measured force and displacement are acquired at the same time using a Speedgoat machine.
|
|
|
|
#+name: fig:test_bench_flex_overview
|
|
#+caption: Schematic of the test bench to measure the bending stiffness of the flexible joints
|
|
#+attr_latex: :width 0.8\linewidth
|
|
[[file:figs/test_bench_flex_overview.png]]
|
|
|
|
A side view of the bench with the important quantities are shown in Figure [[fig:test_bench_flex_side]].
|
|
|
|
#+name: fig:test_bench_flex_side
|
|
#+caption: Schematic of the test bench to measure the bending stiffness of the flexible joints
|
|
#+attr_latex: :width 0.25\linewidth
|
|
#+attr_html: :width 300px
|
|
[[file:figs/test_bench_flex_side.png]]
|
|
|
|
* Error budget
|
|
:PROPERTIES:
|
|
:header-args:matlab+: :tangle ./matlab/error_budget.m
|
|
:END:
|
|
<<sec:error_budget>>
|
|
** Introduction :ignore:
|
|
|
|
Many things can impact the accuracy of the measured bending stiffness such as:
|
|
- Errors in the force and displacement measurement
|
|
- Shear effects
|
|
- Deflection of the Force sensor
|
|
- Errors in the geometry of the bench
|
|
|
|
In this section, we wish to estimate the attainable accuracy with the current bench, and identified the limiting factors.
|
|
|
|
|
|
** 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
|
|
|
|
** Finite Element Model
|
|
From the Finite Element Model, the stiffness and stroke of the flexible joint have been computed and summarized in Tables [[tab:axial_shear_characteristics]] and [[tab:bending_torsion_characteristics]].
|
|
|
|
#+begin_src matlab :exports none
|
|
%% Stiffness
|
|
ka = 94e6; % Axial Stiffness [N/m]
|
|
ks = 13e6; % Shear Stiffness [N/m]
|
|
kb = 5; % Bending Stiffness [Nm/rad]
|
|
kt = 260; % Torsional Stiffness [Nm/rad]
|
|
|
|
%% Maximum force
|
|
Fa = 469; % Axial Force before yield [N]
|
|
Fs = 242; % Shear Force before yield [N]
|
|
Fb = 0.118; % Bending Force before yield [Nm]
|
|
Ft = 1.508; % Torsional Force before yield [Nm]
|
|
|
|
%% Compute the corresponding stroke
|
|
Xa = Fa/ka; % Axial Stroke before yield [m]
|
|
Xs = Fs/ks; % Shear Stroke before yield [m]
|
|
Xb = Fb/kb; % Bending Stroke before yield [rad]
|
|
Xt = Ft/kt; % Torsional Stroke before yield [rad]
|
|
#+end_src
|
|
|
|
#+begin_src matlab :exports results :results value table replace :tangle no :post addhdr(*this*)
|
|
data2orgtable([1e-6*ka, Fa, 1e6*Xa; 1e-6*ks, Fs, 1e6*Xs], {'Axial', 'Shear'}, {'Stiffness [N/um]', 'Max Force [N]', 'Stroke [um]'}, ' %.0f ');
|
|
#+end_src
|
|
|
|
#+name: tab:axial_shear_characteristics
|
|
#+caption: Axial/Shear characteristics
|
|
#+attr_latex: :environment tabularx :width 0.6\linewidth :align Xccc
|
|
#+attr_latex: :center t :booktabs t :float t
|
|
#+RESULTS:
|
|
| | Stiffness [N/um] | Max Force [N] | Stroke [um] |
|
|
|-------+------------------+---------------+-------------|
|
|
| Axial | 94 | 469 | 5 |
|
|
| Shear | 13 | 242 | 19 |
|
|
|
|
#+begin_src matlab :exports results :results value table replace :tangle no :post addhdr(*this*)
|
|
data2orgtable([kb, 1e3*Fb, 1e3*Xb; kt, 1e3*Ft, 1e3*Xt], {'Bending', 'Torsional'}, {'Stiffness [Nm/rad]', 'Max Torque [Nmm]', 'Stroke [mrad]'}, ' %.0f ');
|
|
#+end_src
|
|
|
|
#+name: tab:bending_torsion_characteristics
|
|
#+caption: Bending/Torsion characteristics
|
|
#+attr_latex: :environment tabularx :width 0.7\linewidth :align Xccc
|
|
#+attr_latex: :center t :booktabs t :float t
|
|
#+RESULTS:
|
|
| | Stiffness [Nm/rad] | Max Torque [Nmm] | Stroke [mrad] |
|
|
|-----------+--------------------+------------------+---------------|
|
|
| Bending | 5 | 118 | 24 |
|
|
| Torsional | 260 | 1508 | 6 |
|
|
|
|
** Setup
|
|
|
|
The setup is schematically represented in Figure [[fig:test_bench_flex_side_bis]].
|
|
|
|
The force is applied on top of the flexible joint with a distance $h$ with the joint's center.
|
|
The displacement of the flexible joint is also measured at the same height.
|
|
|
|
The height between the joint's center and the force application point is:
|
|
#+begin_src matlab
|
|
h = 25e-3; % Height [m]
|
|
#+end_src
|
|
|
|
#+name: fig:test_bench_flex_side_bis
|
|
#+caption: Schematic of the test bench to measure the bending stiffness of the flexible joints
|
|
#+attr_latex: :width 0.25\linewidth
|
|
#+attr_html: :width 300px
|
|
[[file:figs/test_bench_flex_side.png]]
|
|
|
|
** Effect of Bending
|
|
The torque applied is:
|
|
\begin{equation}
|
|
M_y = F_x \cdot h
|
|
\end{equation}
|
|
|
|
The flexible joint is experiencing a rotation $\theta_y$ due to the torque $M_y$:
|
|
\begin{equation}
|
|
\theta_y = \frac{M_y}{k_{R_y}} = \frac{F_x \cdot h}{k_{R_y}}
|
|
\end{equation}
|
|
|
|
This rotation is then measured by the displacement sensor.
|
|
The measured displacement is:
|
|
\begin{equation}
|
|
D_b = h \tan(\theta_y) = h \tan\left( \frac{F_x \cdot h}{k_{R_y}} \right) \label{eq:bending_stiffness_formula}
|
|
\end{equation}
|
|
|
|
** Computation of the bending stiffness
|
|
From equation eqref:eq:bending_stiffness_formula, we can compute the bending stiffness:
|
|
\begin{equation}
|
|
k_{R_y} = \frac{F_x \cdot h}{\tan^{-1}\left( \frac{D_b}{h} \right)}
|
|
\end{equation}
|
|
|
|
For small displacement, we have
|
|
\begin{equation}
|
|
\boxed{k_{R_y} \approx h^2 \frac{F_x}{d_x}}
|
|
\end{equation}
|
|
|
|
And therefore, to precisely measure $k_{R_y}$, we need to:
|
|
- precisely measure the motion $d_x$
|
|
- precisely measure the applied force $F_x$
|
|
- precisely now the height of the force application point $h$
|
|
|
|
** Estimation error due to force and displacement sensors accuracy
|
|
The maximum error on the measured displacement with the encoder is 40 nm.
|
|
This quite negligible compared to the measurement range of 0.5 mm.
|
|
|
|
The accuracy of the force sensor is around 1% and therefore, we should expect to have an accuracy on the measured stiffness of at most 1%.
|
|
|
|
** Estimation error due to Shear
|
|
The effect of Shear on the measured displacement is simply:
|
|
\begin{equation}
|
|
D_s = \frac{F_x}{k_s}
|
|
\end{equation}
|
|
|
|
The measured displacement will be the effect of shear + effect of bending
|
|
\begin{equation}
|
|
d_x = D_b + D_s = h \tan\left( \frac{F_x \cdot h}{k_{R_y}} \right) + \frac{F_x}{k_s} \approx F_x \left( \frac{h^2}{k_{R_y}} + \frac{1}{k_s} \right)
|
|
\end{equation}
|
|
|
|
The estimated bending stiffness $k_{\text{est}}$ will then be:
|
|
\begin{equation}
|
|
k_{\text{est}} = h^2 \frac{F_x}{d_x} \approx k_{R_y} \frac{1}{1 + \frac{k_{R_y}}{k_s h^2}}
|
|
\end{equation}
|
|
|
|
#+begin_src matlab :results value replace :exports results :tangle no
|
|
sprintf('The measurement error due to Shear is %.1f %%', 100*abs(1-1/(1 + kb/(ks*h^2))))
|
|
#+end_src
|
|
|
|
#+RESULTS:
|
|
: The measurement error due to Shear is 0.1 %
|
|
|
|
** Estimation error due to force sensor compression
|
|
The measured displacement is not done directly at the joint's location.
|
|
The force sensor compression will then induce an error on the joint's stiffness.
|
|
|
|
The force sensor stiffness $k_F$ is estimated to be around:
|
|
#+begin_src matlab
|
|
kF = 50/0.05e-3; % [N/m]
|
|
#+end_src
|
|
|
|
#+begin_src matlab :results value replace :exports results
|
|
sprintf('k_F = %.1e [N/m]', kF)
|
|
#+end_src
|
|
|
|
#+RESULTS:
|
|
: k_F = 1.0e+06 [N/m]
|
|
|
|
The measured displacement will be the sum of the displacement induced by the bending and by the compression of the force sensor:
|
|
\begin{equation}
|
|
d_x = D_b + \frac{F_x}{k_F} = h \tan\left( \frac{F_x \cdot h}{k_{R_y}} \right) + \frac{F_x}{k_F} \approx F_x \left( \frac{h^2}{k_{R_y}} + \frac{1}{k_F} \right)
|
|
\end{equation}
|
|
|
|
The estimated bending stiffness $k_{\text{est}}$ will then be:
|
|
\begin{equation}
|
|
k_{\text{est}} = h^2 \frac{F_x}{d_x} \approx k_{R_y} \frac{1}{1 + \frac{k_{R_y}}{k_F h^2}}
|
|
\end{equation}
|
|
|
|
#+begin_src matlab :results value replace :exports results :tangle no
|
|
sprintf('The measurement error due to height estimation errors is %.1f %%', 100*abs(1-1/(1 + kb/(kF*h^2))))
|
|
#+end_src
|
|
|
|
#+RESULTS:
|
|
: The measurement error due to height estimation errors is 0.8 %
|
|
|
|
** Estimation error due to height estimation error
|
|
Let's consider an error in the estimation of the height from the application of the force to the joint's center:
|
|
\begin{equation}
|
|
h_{\text{est}} = h (1 + \epsilon)
|
|
\end{equation}
|
|
|
|
The computed bending stiffness will be:
|
|
\begin{equation}
|
|
k_\text{est} \approx h_{\text{est}}^2 \frac{F_x}{d_x}
|
|
\end{equation}
|
|
|
|
And the stiffness estimation error is:
|
|
\begin{equation}
|
|
\frac{k_{\text{est}}}{k_{R_y}} = (1 + \epsilon)^2
|
|
\end{equation}
|
|
|
|
#+begin_src matlab
|
|
h_err = 0.2e-3; % Height estimation error [m]
|
|
#+end_src
|
|
|
|
#+begin_src matlab :results value replace :exports results :tangle no
|
|
sprintf('The measurement error due to height estimation errors of %.1f [mm] is %.1f %%', 1e3*h_err, 100*abs(1-(1 + h_err/h)^2))
|
|
#+end_src
|
|
|
|
#+RESULTS:
|
|
: The measurement error due to height estimation errors of 0.2 [mm] is 1.6 %
|
|
|
|
** Conclusion
|
|
Based on the above analysis, we should expect no better than few percent of accuracy using the current test-bench.
|
|
This is well enough for a first estimation of the bending stiffness of the flexible joints.
|
|
|
|
Another measurement bench allowing better accuracy will be developed.
|
|
|
|
* First Measurements
|
|
<<sec:first_measurements>>
|
|
** Introduction :ignore:
|
|
|
|
|
|
- Section [[sec:test_meas_probe]]:
|
|
- Section [[sec:meas_probe_stiffness]]:
|
|
|
|
** Agreement between the probe and the encoder
|
|
:PROPERTIES:
|
|
:header-args:matlab+: :tangle ./matlab/probe_vs_encoder.m
|
|
:END:
|
|
<<sec:test_meas_probe>>
|
|
*** Introduction :ignore:
|
|
|
|
#+begin_note
|
|
- *Encoder*: [[file:doc/L-9517-9448-05-B_Data_sheet_RESOLUTE_BiSS_en.pdf][Renishaw Resolute 1nm]]
|
|
- *Displacement Probe*: [[file:doc/Millimar--3723046--BA--C1208-C1216-C1240--FR--2016-11-08.pdf][Millimar C1216 electronics]] and [[file:doc/tmp3m0cvmue_7888038c-cdc8-48d8-a837-35de02760685.pdf][Millimar 1318 probe]]
|
|
#+end_note
|
|
|
|
*** Setup :ignore:
|
|
The measurement setup is made such that the probe measured the translation table displacement.
|
|
It should then measure the same displacement as the encoder.
|
|
Using this setup, we should be able to compare the probe and the encoder.
|
|
|
|
*** 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 :tangle no
|
|
addpath('./matlab/mat/');
|
|
addpath('./matlab/');
|
|
#+end_src
|
|
|
|
#+begin_src matlab :eval no
|
|
addpath('./mat/');
|
|
#+end_src
|
|
|
|
*** Results :ignore:
|
|
Let's load the measurements.
|
|
#+begin_src matlab
|
|
load('meas_probe_against_encoder.mat', 't', 'd', 'dp', 'F')
|
|
#+end_src
|
|
|
|
#+begin_src matlab :exports none
|
|
%% Sampling time [s]
|
|
Ts = (t(end) - t(1))/(length(t)-1);
|
|
|
|
%% Remove first second
|
|
t = t(ceil(1/Ts):end);
|
|
d = -d(ceil(1/Ts):end);
|
|
dp = -dp(ceil(1/Ts):end);
|
|
F = F(ceil(1/Ts):end);
|
|
#+end_src
|
|
|
|
The time domain measured displacement by the probe and by the encoder is shown in Figure [[fig:comp_encoder_probe_time]].
|
|
|
|
#+begin_src matlab :exports none
|
|
%% Time Domain plots
|
|
figure;
|
|
hold on;
|
|
plot(t, d, 'DisplayName', 'Encoder');
|
|
plot(t, dp, 'DisplayName', 'Probe');
|
|
hold off;
|
|
xlabel('Time [s]'); ylabel('Displacement [m]');
|
|
#+end_src
|
|
|
|
#+begin_src matlab :tangle no :exports results :results file replace
|
|
exportFig('figs/comp_encoder_probe_time.pdf', 'width', 'wide', 'height', 'normal');
|
|
#+end_src
|
|
|
|
#+name: fig:comp_encoder_probe_time
|
|
#+caption: Time domain measurement
|
|
#+RESULTS:
|
|
[[file:figs/comp_encoder_probe_time.png]]
|
|
|
|
If we zoom, we see that there is some delay between the encoder and the probe (Figure [[fig:comp_encoder_probe_time_zoom]]).
|
|
|
|
#+begin_src matlab :exports none
|
|
%% Zoom
|
|
figure;
|
|
hold on;
|
|
plot(t, d, 'DisplayName', 'Encoder');
|
|
plot(t, dp, 'DisplayName', 'Probe');
|
|
hold off;
|
|
xlabel('Time [s]'); ylabel('Displacement [m]');
|
|
xlim([7.7, 7.9])
|
|
#+end_src
|
|
|
|
#+begin_src matlab :tangle no :exports results :results file replace
|
|
exportFig('figs/comp_encoder_probe_time_zoom.pdf', 'width', 'wide', 'height', 'normal');
|
|
#+end_src
|
|
|
|
#+name: fig:comp_encoder_probe_time_zoom
|
|
#+caption: Time domain measurement (Zoom)
|
|
#+RESULTS:
|
|
[[file:figs/comp_encoder_probe_time_zoom.png]]
|
|
|
|
This delay is estimated using the =finddelay= command.
|
|
|
|
#+begin_src matlab :results value replace :exports results :tangle no
|
|
sprintf('The time delay is approximately %.1f [ms]', 1e3*Ts*finddelay(d, dp))
|
|
#+end_src
|
|
|
|
#+RESULTS:
|
|
: The time delay is approximately 15.8 [ms]
|
|
|
|
The measured mismatch between the encoder and the probe with and without compensating for the time delay are shown in Figure [[fig:comp_encoder_probe_mismatch]].
|
|
|
|
#+begin_src matlab :exports none
|
|
figure;
|
|
hold on;
|
|
plot(t, d-dp, 'DisplayName', 'Raw Mismatch');
|
|
plot(t(1:end-finddelay(d, dp)), d(1:end-finddelay(d, dp))-dp(finddelay(d, dp)+1:end), 'DisplayName', 'Removed Delay');
|
|
hold off;
|
|
xlabel('Time [s]'); ylabel('Measurement Missmatch [m]');
|
|
#+end_src
|
|
|
|
#+begin_src matlab :tangle no :exports results :results file replace
|
|
exportFig('figs/comp_encoder_probe_mismatch.pdf', 'width', 'wide', 'height', 'normal');
|
|
#+end_src
|
|
|
|
#+name: fig:comp_encoder_probe_mismatch
|
|
#+caption: Measurement mismatch, with and without delay compensation
|
|
#+RESULTS:
|
|
[[file:figs/comp_encoder_probe_mismatch.png]]
|
|
|
|
Finally, the displacement of the probe is shown as a function of the displacement of the encoder and a linear fit is made (Figure [[fig:comp_encoder_probe_linear_fit]]).
|
|
|
|
#+begin_src matlab :exports none
|
|
figure;
|
|
hold on;
|
|
plot(1e3*d, 1e3*dp, 'DisplayName', 'Raw data');
|
|
plot(1e3*d, 1e3*d*(d\dp), 'DisplayName', sprintf('Linear fit: $\\alpha = %.5f$', (d\dp)));
|
|
hold on;
|
|
xlabel('Encoder [mm]'); ylabel('Probe [mm]');
|
|
legend('location', 'southeast')
|
|
#+end_src
|
|
|
|
#+begin_src matlab :tangle no :exports results :results file replace
|
|
exportFig('figs/comp_encoder_probe_linear_fit.pdf', 'width', 'normal', 'height', 'normal');
|
|
#+end_src
|
|
|
|
#+name: fig:comp_encoder_probe_linear_fit
|
|
#+caption: Measured displacement by the probe as a function of the measured displacement by the encoder
|
|
#+RESULTS:
|
|
[[file:figs/comp_encoder_probe_linear_fit.png]]
|
|
|
|
#+begin_important
|
|
From the measurement, it is shown that the probe is well calibrated.
|
|
However, there is some time delay of tens of milliseconds that could induce some measurement errors.
|
|
#+end_important
|
|
|
|
** Measurement of the Millimar 1318 probe stiffness
|
|
:PROPERTIES:
|
|
:header-args:matlab+: :tangle ./matlab/probe_stiffness.m
|
|
:END:
|
|
<<sec:meas_probe_stiffness>>
|
|
|
|
*** Introduction :ignore:
|
|
|
|
#+begin_note
|
|
- *Translation Stage*: [[file:doc/V-408-Datasheet.pdf][V-408]]
|
|
- *Load Cell*: [[file:doc/A700000007147087.pdf][FC2231-0000-0010-L]]
|
|
- *Encoder*: [[file:doc/L-9517-9448-05-B_Data_sheet_RESOLUTE_BiSS_en.pdf][Renishaw Resolute 1nm]]
|
|
- *Displacement Probe*: [[file:doc/Millimar--3723046--BA--C1208-C1216-C1240--FR--2016-11-08.pdf][Millimar C1216 electronics]] and [[file:doc/tmp3m0cvmue_7888038c-cdc8-48d8-a837-35de02760685.pdf][Millimar 1318 probe]]
|
|
#+end_note
|
|
|
|
#+name: fig:setup_mahr_stiff_meas_side
|
|
#+caption: Setup - Side View
|
|
#+attr_latex: :width \linewidth
|
|
[[file:figs/setup_mahr_stiff_meas_side.jpg]]
|
|
|
|
#+name: fig:setup_mahr_stiff_meas_top
|
|
#+caption: Setup - Top View
|
|
#+attr_latex: :width \linewidth
|
|
[[file:figs/setup_mahr_stiff_meas_top.jpg]]
|
|
|
|
*** 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 :tangle no
|
|
addpath('./matlab/mat/');
|
|
addpath('./matlab/');
|
|
#+end_src
|
|
|
|
#+begin_src matlab :eval no
|
|
addpath('./mat/');
|
|
#+end_src
|
|
|
|
*** Results :ignore:
|
|
Let's load the measurement results.
|
|
#+begin_src matlab
|
|
load('meas_stiff_probe.mat', 't', 'd', 'dp', 'F')
|
|
#+end_src
|
|
|
|
#+begin_src matlab :exports none
|
|
%% Sampling time [s]
|
|
Ts = (t(end) - t(1))/(length(t)-1);
|
|
|
|
%% Remove first second
|
|
t = t(ceil(1/Ts):end);
|
|
d = d(ceil(1/Ts):end);
|
|
dp = dp(ceil(1/Ts):end);
|
|
F = F(ceil(1/Ts):end);
|
|
|
|
|
|
%% Remove Offset
|
|
t = t - t(1);
|
|
F = F - mean(F(1:ceil(1/Ts)));
|
|
#+end_src
|
|
|
|
The time domain measured force and displacement are shown in Figure [[fig:mahr_time_domain]].
|
|
|
|
#+begin_src matlab :exports none
|
|
%% Time Domain plots
|
|
figure;
|
|
tiledlayout(2, 1, 'TileSpacing', 'None', 'Padding', 'None');
|
|
|
|
ax1 = nexttile;
|
|
plot(t, F);
|
|
ylabel('Force [N]'); set(gca, 'XTickLabel',[]);
|
|
|
|
ax2 = nexttile;
|
|
plot(t, d);
|
|
xlabel('Time [s]'); ylabel('Displacement [m]');
|
|
#+end_src
|
|
|
|
#+begin_src matlab :tangle no :exports results :results file replace
|
|
exportFig('figs/mahr_time_domain.pdf', 'width', 'wide', 'height', 'tall');
|
|
#+end_src
|
|
|
|
#+name: fig:mahr_time_domain
|
|
#+caption: Time domain measurements
|
|
#+RESULTS:
|
|
[[file:figs/mahr_time_domain.png]]
|
|
|
|
|
|
Now we can estimate the stiffness with a linear fit.
|
|
|
|
#+begin_src matlab :results value replace :exports results :tangle no
|
|
sprintf('Stiffness is %.3f [N/mm]', abs(1e-3*(d\F)))
|
|
#+end_src
|
|
|
|
This is very close to the 0.04 [N/mm] written in the [[file:doc/tmp3m0cvmue_7888038c-cdc8-48d8-a837-35de02760685.pdf][Millimar 1318 probe datasheet]].
|
|
|
|
And compare the linear fit with the raw measurement data (Figure [[fig:mahr_stiffness_f_d_plot]]).
|
|
|
|
#+begin_src matlab :exports none
|
|
figure;
|
|
hold on;
|
|
plot(F, d, 'DisplayName', 'Raw data');
|
|
plot(F, F/(d\F), 'DisplayName', 'Linear fit');
|
|
hold off;
|
|
xlabel('Measured Force [N]');
|
|
ylabel('Measured Displacement [m]');
|
|
legend('location', 'southeast');
|
|
#+end_src
|
|
|
|
#+begin_src matlab :tangle no :exports results :results file replace
|
|
exportFig('figs/mahr_stiffness_f_d_plot.pdf', 'width', 'wide', 'height', 'normal');
|
|
#+end_src
|
|
|
|
#+name: fig:mahr_stiffness_f_d_plot
|
|
#+caption: Measured displacement as a function of the measured force. Raw data and linear fit
|
|
#+RESULTS:
|
|
[[file:figs/mahr_stiffness_f_d_plot.png]]
|
|
|
|
#+begin_summary
|
|
The Millimar 1318 probe has a stiffness of $\approx 0.04\,[N/mm]$.
|
|
#+end_summary
|
|
|
|
** Force Sensor Calibration
|
|
*** Introduction :ignore:
|
|
|
|
#+begin_note
|
|
*Load Cells*:
|
|
- [[file:doc/A700000007147087.pdf][FC2231-0000-0010-L]]
|
|
- [[file:doc/FRE_DS_XFL212R_FR_A3.pdf][XFL212R]]
|
|
#+end_note
|
|
|
|
There are both specified to have $\pm 1 \%$ of non-linearity over the full range.
|
|
|
|
The XFL212R has a spherical interface while the FC2231 has a flat surface.
|
|
Therefore, we should have a nice point contact when using the two force sensors as shown in Figure [[fig:force_sensor_calibration_setup]].
|
|
|
|
#+name: fig:force_sensor_calibration_setup
|
|
#+caption: Zoom on the two force sensors in contact
|
|
#+attr_latex: :width 0.8\linewidth
|
|
[[file:figs/IMG_20210309_145333.jpg]]
|
|
|
|
The two force sensors are therefore measuring the exact same force, and we can compare the two measurements.
|
|
|
|
*** 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 :tangle no
|
|
addpath('./matlab/mat/');
|
|
addpath('./matlab/');
|
|
#+end_src
|
|
|
|
#+begin_src matlab :eval no
|
|
addpath('./mat/');
|
|
#+end_src
|
|
|
|
*** Analysis :ignore:
|
|
Let's load the measured force of both sensors.
|
|
#+begin_src matlab
|
|
%% Load measurement data
|
|
load('calibration_force_sensor.mat', 't', 'F', 'Fc')
|
|
#+end_src
|
|
|
|
We remove any offset such that they are both measuring no force when not in contact.
|
|
#+begin_src matlab
|
|
%% Remove offset
|
|
F = F - mean(F( t > 0.5 & t < 1.0));
|
|
Fc = Fc - mean(Fc(t > 0.5 & t < 1.0));
|
|
#+end_src
|
|
|
|
#+begin_src matlab :exports none
|
|
figure;
|
|
hold on;
|
|
plot(t, F, 'DisplayName', 'FC2231');
|
|
plot(t, Fc, 'DisplayName', 'XFL212R');
|
|
hold off;
|
|
xlabel('Time [s]'); ylabel('Measured Force [N]');
|
|
xlim([0,15]); ylim([0,55]);
|
|
legend('location', 'southeast');
|
|
#+end_src
|
|
|
|
#+begin_src matlab :tangle no :exports results :results file replace
|
|
exportFig('figs/force_calibration_time.pdf', 'width', 'wide', 'height', 'normal');
|
|
#+end_src
|
|
|
|
#+name: fig:force_calibration_time
|
|
#+caption: Measured force using both sensors as a function of time
|
|
#+RESULTS:
|
|
[[file:figs/force_calibration_time.png]]
|
|
|
|
Let's select only the first part from the moment they are in contact until the maximum force is reached.
|
|
|
|
#+begin_src matlab
|
|
%% Only get the first part until maximum force
|
|
F = F( t > 1.55 & t < 4.65);
|
|
Fc = Fc(t > 1.55 & t < 4.65);
|
|
#+end_src
|
|
|
|
Then, let's make a linear fit between the two measured forces.
|
|
|
|
#+begin_src matlab
|
|
%% Make a line fit
|
|
fit_F = polyfit(Fc, F, 1);
|
|
#+end_src
|
|
|
|
The two forces are plotted against each other as well as the linear fit in Figure [[fig:calibrated_force_dit]].
|
|
|
|
#+begin_src matlab :exports none
|
|
figure;
|
|
hold on;
|
|
plot(Fc, F, '-', 'DisplayName', 'Raw Data');
|
|
plot(Fc([1,end]), Fc([1,end])*fit_F(1) + fit_F(2), '--', 'DisplayName', 'Line Fit');
|
|
hold off;
|
|
xlabel('XFL212R [N]'); ylabel('FC2231 [N]');
|
|
xlim([0,50]); ylim([0,50]);
|
|
legend('location', 'southeast');
|
|
#+end_src
|
|
|
|
#+begin_src matlab :tangle no :exports results :results file replace
|
|
exportFig('figs/calibrated_force_dit.pdf', 'width', 'wide', 'height', 'normal');
|
|
#+end_src
|
|
|
|
#+name: fig:calibrated_force_dit
|
|
#+caption: Measured two forces and linear fit
|
|
#+RESULTS:
|
|
[[file:figs/calibrated_force_dit.png]]
|
|
|
|
The measurement error between the two sensors is shown in Figure [[fig:force_meas_error]].
|
|
It is below 0.1N for the full measurement range.
|
|
|
|
#+begin_src matlab :exports none
|
|
figure;
|
|
hold on;
|
|
plot(Fc, F - (Fc*fit_F(1) + fit_F(2)), 'k-');
|
|
hold off;
|
|
xlim([0,50]); ylim([-0.12, 0.12]);
|
|
xlabel('Measured Force [N]');
|
|
ylabel('Error [N]')
|
|
#+end_src
|
|
|
|
#+begin_src matlab :tangle no :exports results :results file replace
|
|
exportFig('figs/force_meas_error.pdf', 'width', 'wide', 'height', 'normal');
|
|
#+end_src
|
|
|
|
#+name: fig:force_meas_error
|
|
#+caption: Error in Newtons
|
|
#+RESULTS:
|
|
[[file:figs/force_meas_error.png]]
|
|
|
|
The same error is shown in percentage in Figure [[fig:force_meas_error_percentage]].
|
|
The error is less than 1% when the measured force is above 5N.
|
|
|
|
#+begin_src matlab :exports none
|
|
figure;
|
|
plot(Fc, 100*(F - (Fc*fit_F(1) + fit_F(2)))./Fc, 'k-');
|
|
xlim([0,50]); ylim([-4, 1]);
|
|
xlabel('Measured Force [N]');
|
|
ylabel('Error [\%]')
|
|
#+end_src
|
|
|
|
#+begin_src matlab :tangle no :exports results :results file replace
|
|
exportFig('figs/force_meas_error_percentage.pdf', 'width', 'wide', 'height', 'normal');
|
|
#+end_src
|
|
|
|
#+name: fig:force_meas_error_percentage
|
|
#+caption: Error in percentage
|
|
#+RESULTS:
|
|
[[file:figs/force_meas_error_percentage.png]]
|
|
|
|
** Force Sensor Noise
|
|
*** Introduction :ignore:
|
|
The objective of this measurement is to estimate the noise of the force sensor [[file:doc/A700000007147087.pdf][FC2231-0000-0010-L]].
|
|
To do so, we don't apply any force to the sensor, and we measure its output for 100s.
|
|
|
|
*** 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 :tangle no
|
|
addpath('./matlab/mat/');
|
|
addpath('./matlab/');
|
|
#+end_src
|
|
|
|
#+begin_src matlab :eval no
|
|
addpath('./mat/');
|
|
#+end_src
|
|
|
|
*** Analysis :ignore:
|
|
Let's load the measurement data.
|
|
|
|
#+begin_src matlab
|
|
%% Load measurement data
|
|
load('force_sensor_noise_meas.mat', 't', 'F');
|
|
Ts = t(2) - t(1);
|
|
#+end_src
|
|
|
|
The measured force is shown in Figure [[fig:force_noise_time]].
|
|
|
|
#+begin_src matlab :exports none
|
|
%% Take last 100s
|
|
F = F(t > t(end)-100);
|
|
t = t(t > t(end)-100);
|
|
|
|
%% Remove force offset and reset time
|
|
F = F - mean(F);
|
|
t = t - t(1);
|
|
#+end_src
|
|
|
|
#+begin_src matlab :exports none
|
|
figure;
|
|
plot(t, F)
|
|
xlabel('Time [s]');
|
|
ylabel('Force [N]');
|
|
#+end_src
|
|
|
|
#+begin_src matlab :tangle no :exports results :results file replace
|
|
exportFig('figs/force_noise_time.pdf', 'width', 'wide', 'height', 'normal');
|
|
#+end_src
|
|
|
|
#+name: fig:force_noise_time
|
|
#+caption: Measured force
|
|
#+RESULTS:
|
|
[[file:figs/force_noise_time.png]]
|
|
|
|
Let's now compute the Amplitude Spectral Density of the measured force.
|
|
|
|
#+begin_src matlab
|
|
%% Compute Spectral Density of Measured Force
|
|
% Hanning window
|
|
win = hanning(ceil(1/Ts));
|
|
|
|
% Power Spectral Density
|
|
[pxx, f] = pwelch(F, win, [], [], 1/Ts);
|
|
#+end_src
|
|
|
|
The results is shown in Figure [[fig:force_noise_asd]].
|
|
|
|
#+begin_src matlab :exports none
|
|
figure;
|
|
hold on;
|
|
plot(f, sqrt(pxx));
|
|
hold off;
|
|
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
|
|
xlabel('Frequency [Hz]'); ylabel('ASD [$N/\sqrt{Hz}$]');
|
|
xlim([1, 1/Ts/2]); ylim([4e-5, 1e-3]);
|
|
#+end_src
|
|
|
|
#+begin_src matlab :tangle no :exports results :results file replace
|
|
exportFig('figs/force_noise_asd.pdf', 'width', 'wide', 'height', 'normal');
|
|
#+end_src
|
|
|
|
#+name: fig:force_noise_asd
|
|
#+caption: Amplitude Spectral Density of the meaured force
|
|
#+RESULTS:
|
|
[[file:figs/force_noise_asd.png]]
|
|
|
|
|
|
** Force Sensor Stiffness
|
|
*** Introduction :ignore:
|
|
|
|
The objective of this measurement is to estimate the stiffness of the force sensor [[file:doc/A700000007147087.pdf][FC2231-0000-0010-L]].
|
|
|
|
To do so, a very stiff element is fixed in front of the force sensor as shown in Figure [[fig:setup_meas_force_sensor_stiffness]].
|
|
|
|
Then, we apply a force on the stiff element through the force sensor.
|
|
We measure the deflection of the force sensor using an encoder.
|
|
|
|
Then, having the force and the deflection, we should be able to estimate the stiffness of the force sensor supposing the stiffness of the other elements are much larger.
|
|
|
|
#+name: fig:setup_meas_force_sensor_stiffness
|
|
#+caption: Bench used to measured the stiffness of the force sensor
|
|
#+attr_latex: :width 0.6\linewidth
|
|
[[file:figs/IMG_20210309_145242.jpg]]
|
|
|
|
From the documentation, the deflection of the sensor at the maximum load (50N) is 0.05mm, the stiffness is therefore foreseen to be around $1\,N/\mu m$.
|
|
|
|
*** 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 :tangle no
|
|
addpath('./matlab/mat/');
|
|
addpath('./matlab/');
|
|
#+end_src
|
|
|
|
#+begin_src matlab :eval no
|
|
addpath('./mat/');
|
|
#+end_src
|
|
|
|
*** Analysis :ignore:
|
|
|
|
Let's load the measured force as well as the measured displacement.
|
|
#+begin_src matlab
|
|
%% Load measurement data
|
|
load('force_sensor_stiffness_meas.mat', 't', 'F', 'd')
|
|
#+end_src
|
|
|
|
Some pre-processing is applied on the data.
|
|
#+begin_src matlab
|
|
%% Remove offset
|
|
F = F - mean(F(t > 0.5 & t < 1.0));
|
|
|
|
%% Select important part of data
|
|
F = F( t > 4.55 & t < 7.24);
|
|
d = d( t > 4.55 & t < 7.24); d = d - d(1);
|
|
t = t( t > 4.55 & t < 7.24);
|
|
#+end_src
|
|
|
|
The linear fit is performed.
|
|
#+begin_src matlab
|
|
%% Linear fit
|
|
fit_k = polyfit(F, d, 1);
|
|
#+end_src
|
|
|
|
The displacement as a function of the force as well as the linear fit are shown in Figure [[fig:force_sensor_stiffness_fit]].
|
|
#+begin_src matlab :exports none
|
|
figure;
|
|
hold on;
|
|
plot(F, 1e6*d, '-', 'DisplayName', 'Raw Data');
|
|
plot(F([1,end]), 1e6*(F([1,end])*fit_k(1) + fit_k(2)), '--', 'DisplayName', 'Line Fit');
|
|
hold off;
|
|
xlabel('Force [$N$]'); ylabel('Displacement [$\mu m$]');
|
|
xlim([0,45]); ylim([0,60]);
|
|
legend('location', 'southeast');
|
|
#+end_src
|
|
|
|
#+begin_src matlab :tangle no :exports results :results file replace
|
|
exportFig('figs/force_sensor_stiffness_fit.pdf', 'width', 'wide', 'height', 'normal');
|
|
#+end_src
|
|
|
|
#+name: fig:force_sensor_stiffness_fit
|
|
#+caption: Displacement as a function of the measured force
|
|
#+RESULTS:
|
|
[[file:figs/force_sensor_stiffness_fit.png]]
|
|
|
|
And we obtain the following stiffness:
|
|
#+begin_src matlab :results value replace :exports results
|
|
%% Force Sensor Stiffness
|
|
sprintf('k = %.2f [N/um]', 1e-6*1/fit_k(1));
|
|
#+end_src
|
|
|
|
#+RESULTS:
|
|
: k = 0.76 [N/um]
|
|
|
|
* Bending Stiffness Measurement
|
|
:PROPERTIES:
|
|
:header-args:matlab+: :tangle ./matlab/bending_stiff_meas.m
|
|
:END:
|
|
<<sec:bending_stiffness_meas>>
|
|
** Introduction
|
|
|
|
A picture of the bench used to measure the X-bending stiffness of the flexible joints is shown in Figure [[fig:picture_bending_x_meas_side_overview]].
|
|
A closer view on flexible joint is shown in Figure [[fig:picture_bending_x_meas_side_close]] and a zoom on the force sensor tip is shown in Figure [[fig:picture_bending_x_meas_side_zoom]].
|
|
|
|
#+name: fig:picture_bending_x_meas_side_overview
|
|
#+caption: Side view of the flexible joint stiffness bench. X-Bending stiffness is measured.
|
|
#+attr_latex: :width \linewidth
|
|
[[file:figs/picture_bending_x_meas_side_overview.jpg]]
|
|
|
|
#+name: fig:picture_bending_x_meas_side_close
|
|
#+caption: Zoom on the flexible joint - Side view
|
|
#+attr_latex: :width \linewidth
|
|
[[file:figs/picture_bending_x_meas_side_close.jpg]]
|
|
|
|
|
|
#+name: fig:picture_bending_x_meas_side_zoom
|
|
#+caption: Zoom on the tip of the force sensor
|
|
#+attr_latex: :width 0.4\linewidth
|
|
[[file:figs/picture_bending_x_meas_side_zoom.jpg]]
|
|
|
|
The same bench used to measure the Y-bending stiffness of the flexible joint is shown in Figure [[fig:picture_bending_y_meas_side_close]].
|
|
|
|
#+name: fig:picture_bending_y_meas_side_close
|
|
#+caption: Stiffness measurement bench - Y-d bending measurement
|
|
#+attr_latex: :width \linewidth
|
|
[[file:figs/picture_bending_y_meas_side_close.jpg]]
|
|
|
|
** 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 :tangle no
|
|
addpath('./matlab/mat/');
|
|
addpath('./matlab/');
|
|
#+end_src
|
|
|
|
#+begin_src matlab :eval no
|
|
addpath('./mat/');
|
|
#+end_src
|
|
|
|
** Analysis of one measurement
|
|
|
|
In this section is shown how the data are analysis in order to measured:
|
|
- the bending stiffness
|
|
- the bending stroke
|
|
- the stiffness once the mechanical stops are in contact
|
|
|
|
|
|
The height from the flexible joint's center and the point of application force $h$ is defined below:
|
|
#+begin_src matlab
|
|
h = 25e-3; % [m]
|
|
#+end_src
|
|
|
|
#+begin_src matlab
|
|
%% Load Data
|
|
load('meas_stiff_flex_1_x.mat', 't', 'F', 'd');
|
|
|
|
%% Zero the force
|
|
F = F - mean(F(t > 0.1 & t < 0.3));
|
|
|
|
%% Start measurement at t = 0.2 s
|
|
d = d(t > 0.2);
|
|
F = F(t > 0.2);
|
|
t = t(t > 0.2); t = t - t(1);
|
|
#+end_src
|
|
|
|
The obtained time domain measurements are shown in Figure [[fig:flex_joint_meas_example_time_domain]].
|
|
|
|
#+begin_src matlab :exports none
|
|
%% Time Domain plots
|
|
figure;
|
|
tiledlayout(2, 1, 'TileSpacing', 'None', 'Padding', 'None');
|
|
|
|
ax1 = nexttile;
|
|
plot(t, F);
|
|
ylabel('Force [N]'); set(gca, 'XTickLabel',[]);
|
|
|
|
ax2 = nexttile;
|
|
plot(t, 1e3*d);
|
|
hold off;
|
|
xlabel('Time [s]'); ylabel('Displacement [mm]');
|
|
|
|
linkaxes([ax1,ax2],'x');
|
|
xlim([0,5]);
|
|
#+end_src
|
|
|
|
#+begin_src matlab :tangle no :exports results :results file replace
|
|
exportFig('figs/flex_joint_meas_example_time_domain.pdf', 'width', 'wide', 'height', 'tall');
|
|
#+end_src
|
|
|
|
#+name: fig:flex_joint_meas_example_time_domain
|
|
#+caption: Typical time domain measurements
|
|
#+RESULTS:
|
|
[[file:figs/flex_joint_meas_example_time_domain.png]]
|
|
|
|
The displacement as a function of the force is then shown in Figure [[fig:flex_joint_meas_example_F_d]].
|
|
|
|
#+begin_src matlab :exports none
|
|
figure;
|
|
plot(F, 1e3*d);
|
|
xlabel('Force [N]'); ylabel('Displacement [mm]');
|
|
xlim([0,6]); ylim([0,1]);
|
|
#+end_src
|
|
|
|
#+begin_src matlab :tangle no :exports results :results file replace
|
|
exportFig('figs/flex_joint_meas_example_F_d.pdf', 'width', 'wide', 'height', 'normal');
|
|
#+end_src
|
|
|
|
#+name: fig:flex_joint_meas_example_F_d
|
|
#+caption: Typical measurement of the diplacement as a function of the applied force
|
|
#+RESULTS:
|
|
[[file:figs/flex_joint_meas_example_F_d.png]]
|
|
|
|
The bending stiffness can be estimated by computing the slope of the curve in Figure [[fig:flex_joint_meas_example_F_d]].
|
|
The bending stroke and the stiffness when touching the mechanical stop can also be estimated from the same figure.
|
|
|
|
#+begin_src matlab
|
|
%% Determine the linear region and region when touching the mechanical stop
|
|
% Find when the force sensor touches the flexible joint
|
|
i_l_start = find(F > 0.3, 1, 'first');
|
|
% Reset the measured diplacement at that point
|
|
d = d - d(i_l_start);
|
|
% Find then the maximum force is applied
|
|
[~, i_s_stop] = max(F);
|
|
% Linear region stops ~ when 90% of the stroke is reached
|
|
i_l_stop = find(d > 0.9*d(i_s_stop), 1, 'first');
|
|
% "Stop" region start ~1N before maximum force is applied
|
|
i_s_start = find(F > max(F)-1, 1, 'first');
|
|
|
|
%% Define variables for the two regions
|
|
F_l = F(i_l_start:i_l_stop);
|
|
d_l = d(i_l_start:i_l_stop);
|
|
|
|
F_s = F(i_s_start:i_s_stop);
|
|
d_s = d(i_s_start:i_s_stop);
|
|
#+end_src
|
|
|
|
#+begin_src matlab
|
|
%% Fit the best straight line for the two regions
|
|
fit_l = polyfit(F_l, d_l, 1);
|
|
fit_s = polyfit(F_s, d_s, 1);
|
|
|
|
%% Reset displacement based on fit
|
|
d = d - fit_l(2);
|
|
fit_s(2) = fit_s(2) - fit_l(2);
|
|
fit_l(2) = 0;
|
|
#+end_src
|
|
|
|
The raw data as well as the fit corresponding to the two stiffnesses are shown in Figure [[fig:flex_joint_meas_example_F_d_lin_fit]].
|
|
|
|
#+begin_src matlab :exports none
|
|
figure;
|
|
hold on;
|
|
plot(F(1:i_s_stop), 1e3*d(1:i_s_stop), '.k')
|
|
plot(F_l, 1e3*(F_l*fit_l(1) + fit_l(2)))
|
|
plot(F_s, 1e3*(F_s*fit_s(1) + fit_s(2)))
|
|
hold off;
|
|
xlabel('Force [N]'); ylabel('Displacement [mm]');
|
|
xlim([0,6]);
|
|
#+end_src
|
|
|
|
#+begin_src matlab :tangle no :exports results :results file replace
|
|
exportFig('figs/flex_joint_meas_example_F_d_lin_fit.pdf', 'width', 'wide', 'height', 'normal');
|
|
#+end_src
|
|
|
|
#+name: fig:flex_joint_meas_example_F_d_lin_fit
|
|
#+caption: Typical measurement of the diplacement as a function of the applied force with estimated linear fits
|
|
#+RESULTS:
|
|
[[file:figs/flex_joint_meas_example_F_d_lin_fit.png]]
|
|
|
|
Then, the bending stroke is estimated as crossing point between the two fitted lines:
|
|
#+begin_src matlab
|
|
d_max = fit_l(1)*fit_s(2)/(fit_l(1) - fit_s(1));
|
|
#+end_src
|
|
|
|
The obtained characteristics are summarized in Table [[tab:obtained_caracteristics_flex_1_x]].
|
|
|
|
#+begin_src matlab :exports results :results value table replace :tangle no
|
|
data2orgtable([(h)^2/fit_l(1); (h)^2/fit_s(1); 1e3*atan2(d_max,h)], {'Bending Stiffness [Nm/rad]', 'Bending Stiffness @ stop [Nm/rad]', 'Bending Stroke [mrad]'}, {}, ' %.1f ');
|
|
#+end_src
|
|
|
|
#+name: tab:obtained_caracteristics_flex_1_x
|
|
#+caption: Estimated characteristics of the flexible joint number 1 for the X-direction
|
|
#+attr_latex: :environment tabularx :width 0.5\linewidth :align lc
|
|
#+attr_latex: :center t :booktabs t :float t
|
|
#+RESULTS:
|
|
| Bending Stiffness [Nm/rad] | 5.5 |
|
|
| Bending Stiffness @ stop [Nm/rad] | 173.6 |
|
|
| Bending Stroke [mrad] | 18.9 |
|
|
|
|
** Bending stiffness and bending stroke of all the flexible joints
|
|
|
|
Now, let's estimate the bending stiffness and stroke for all the flexible joints.
|
|
|
|
#+begin_src matlab :exports none
|
|
%% Initialize variables
|
|
kRx = zeros(1,16);
|
|
kSx = zeros(1,16);
|
|
Rmx = zeros(1,16);
|
|
|
|
for i = 1:16
|
|
%% Load the data
|
|
load(['meas_stiff_flex_' num2str(i) '_x.mat'], 't', 'F', 'd');
|
|
|
|
%% Automatic Zero of the force
|
|
F = F - mean(F(t > 0.1 & t < 0.3));
|
|
|
|
%% Start measurement at t = 0.2 s
|
|
d = d(t > 0.2);
|
|
F = F(t > 0.2);
|
|
t = t(t > 0.2); t = t - t(1);
|
|
|
|
%% Estimate linear region and "stop" region
|
|
i_l_start = find(F > 0.3, 1, 'first');
|
|
d = d - d(i_l_start);
|
|
[~, i_s_stop] = max(F);
|
|
i_l_stop = find(d > 0.9*d(i_s_stop), 1, 'first');
|
|
i_s_start = find(F > max(F)-1, 1, 'first');
|
|
|
|
F_l = F(i_l_start:i_l_stop);
|
|
d_l = d(i_l_start:i_l_stop);
|
|
|
|
F_s = F(i_s_start:i_s_stop);
|
|
d_s = d(i_s_start:i_s_stop);
|
|
|
|
%% Straight line fit
|
|
fit_l = polyfit(F_l, d_l, 1);
|
|
fit_s = polyfit(F_s, d_s, 1);
|
|
|
|
%% Reset displacement based on fit
|
|
d = d - fit_l(2);
|
|
fit_s(2) = fit_s(2) - fit_l(2);
|
|
fit_l(2) = 0;
|
|
|
|
%% Estimated Stroke
|
|
d_max = fit_l(1)*fit_s(2)/(fit_l(1) - fit_s(1));
|
|
|
|
%% Save stiffnesses and stroke
|
|
kRx(i) = (h)^2/fit_l(1);
|
|
kSx(i) = (h)^2/fit_s(1);
|
|
Rmx(i) = atan2(d_max,h);
|
|
|
|
end
|
|
#+end_src
|
|
|
|
#+begin_src matlab :exports none
|
|
%% Initialize variables
|
|
kRy = zeros(1,16);
|
|
kSy = zeros(1,16);
|
|
Rmy = zeros(1,16);
|
|
|
|
for i = 1:16
|
|
%% Load the data
|
|
load(['meas_stiff_flex_' num2str(i) '_y.mat'], 't', 'F', 'd');
|
|
|
|
%% Automatic Zero of the force
|
|
F = F - mean(F(t > 0.1 & t < 0.3));
|
|
|
|
%% Start measurement at t = 0.2 s
|
|
d = d(t > 0.2);
|
|
F = F(t > 0.2);
|
|
t = t(t > 0.2); t = t - t(1);
|
|
|
|
%% Estimate linear region and "stop" region
|
|
i_l_start = find(F > 0.3, 1, 'first');
|
|
d = d - d(i_l_start);
|
|
[~, i_s_stop] = max(F);
|
|
i_l_stop = find(d > 0.9*d(i_s_stop), 1, 'first');
|
|
i_s_start = find(F > max(F)-1, 1, 'first');
|
|
|
|
F_l = F(i_l_start:i_l_stop);
|
|
d_l = d(i_l_start:i_l_stop);
|
|
|
|
F_s = F(i_s_start:i_s_stop);
|
|
d_s = d(i_s_start:i_s_stop);
|
|
|
|
%% Straight line fit
|
|
fit_l = polyfit(F_l, d_l, 1);
|
|
fit_s = polyfit(F_s, d_s, 1);
|
|
|
|
%% Reset displacement based on fit
|
|
d = d - fit_l(2);
|
|
fit_s(2) = fit_s(2) - fit_l(2);
|
|
fit_l(2) = 0;
|
|
|
|
%% Estimated Stroke
|
|
d_max = fit_l(1)*fit_s(2)/(fit_l(1) - fit_s(1));
|
|
|
|
%% Save stiffnesses and stroke
|
|
kRy(i) = (h)^2/fit_l(1);
|
|
kSy(i) = (h)^2/fit_s(1);
|
|
Rmy(i) = atan2(d_max,h);
|
|
|
|
end
|
|
#+end_src
|
|
|
|
The results are summarized in Table [[tab:meas_flexible_joints_x_dir]] for the X direction and in Table [[tab:meas_flexible_joints_y_dir]] for the Y direction.
|
|
|
|
#+begin_src matlab :exports results :results value table replace :tangle no :post addhdr(*this*)
|
|
data2orgtable([kRx; kSx; 1e3*Rmx]', {'1','2','3','4','5','6','7','8','9','10','11','12','13','14','15','16'}, {'$R_{R_x}$ [Nm/rad]', '$k_{R_x,s}$ [Nm/rad]', '$R_{x,\text{max}}$ [mrad]'}, ' %.1f ');
|
|
#+end_src
|
|
|
|
#+name: tab:meas_flexible_joints_x_dir
|
|
#+caption: Measured characteristics of the flexible joints in the X direction
|
|
#+attr_latex: :environment tabularx :width 0.6\linewidth :align cccc
|
|
#+attr_latex: :center t :booktabs t :float t
|
|
#+RESULTS:
|
|
| | $R_{R_x}$ [Nm/rad] | $k_{R_x,s}$ [Nm/rad] | $R_{x,\text{max}}$ [mrad] |
|
|
|----+--------------------+----------------------+---------------------------|
|
|
| 1 | 5.5 | 173.6 | 18.9 |
|
|
| 2 | 6.1 | 195.0 | 17.6 |
|
|
| 3 | 6.1 | 191.3 | 17.7 |
|
|
| 4 | 5.8 | 136.7 | 18.3 |
|
|
| 5 | 5.7 | 88.9 | 22.0 |
|
|
| 6 | 5.7 | 183.9 | 18.7 |
|
|
| 7 | 5.7 | 157.9 | 17.9 |
|
|
| 8 | 5.8 | 166.1 | 17.9 |
|
|
| 9 | 5.8 | 159.5 | 18.2 |
|
|
| 10 | 6.0 | 143.6 | 18.1 |
|
|
| 11 | 5.0 | 163.8 | 17.7 |
|
|
| 12 | 6.1 | 111.9 | 17.0 |
|
|
| 13 | 6.0 | 142.0 | 17.4 |
|
|
| 14 | 5.8 | 130.1 | 17.9 |
|
|
| 15 | 5.7 | 170.7 | 18.6 |
|
|
| 16 | 6.0 | 148.7 | 17.5 |
|
|
|
|
#+begin_src matlab :exports results :results value table replace :tangle no :post addhdr(*this*)
|
|
data2orgtable([kRy; kSy; 1e3*Rmy]', {'1','2','3','4','5','6','7','8','9','10','11','12','13','14','15','16'}, {'$R_{R_y}$ [Nm/rad]', '$k_{R_y,s}$ [Nm/rad]', '$R_{y,\text{may}}$ [mrad]'}, ' %.1f ');
|
|
#+end_src
|
|
|
|
#+name: tab:meas_flexible_joints_y_dir
|
|
#+caption: Measured characteristics of the flexible joints in the Y direction
|
|
#+attr_latex: :environment tabularx :width 0.6\linewidth :align cccc
|
|
#+attr_latex: :center t :booktabs t :float t
|
|
#+RESULTS:
|
|
| | $R_{R_y}$ [Nm/rad] | $k_{R_y,s}$ [Nm/rad] | $R_{y,\text{may}}$ [mrad] |
|
|
|----+--------------------+----------------------+---------------------------|
|
|
| 1 | 5.7 | 323.5 | 17.9 |
|
|
| 2 | 5.9 | 306.0 | 17.2 |
|
|
| 3 | 6.0 | 224.4 | 16.8 |
|
|
| 4 | 5.7 | 247.3 | 17.8 |
|
|
| 5 | 5.8 | 250.9 | 13.0 |
|
|
| 6 | 5.8 | 244.5 | 17.8 |
|
|
| 7 | 5.3 | 214.8 | 18.1 |
|
|
| 8 | 5.8 | 217.2 | 17.6 |
|
|
| 9 | 5.7 | 225.0 | 17.6 |
|
|
| 10 | 6.0 | 254.7 | 17.3 |
|
|
| 11 | 4.9 | 261.1 | 18.4 |
|
|
| 12 | 5.9 | 161.5 | 16.7 |
|
|
| 13 | 6.1 | 227.6 | 16.8 |
|
|
| 14 | 5.9 | 221.3 | 17.8 |
|
|
| 15 | 5.4 | 241.5 | 17.8 |
|
|
| 16 | 5.3 | 291.1 | 17.7 |
|
|
|
|
** Analysis
|
|
The dispersion of the measured bending stiffness is shown in Figure [[fig:bending_stiffness_histogram]] and of the bending stroke in Figure [[fig:bending_stroke_histogram]].
|
|
|
|
#+begin_src matlab :exports none
|
|
figure;
|
|
hold on;
|
|
histogram(kRx, 'DisplayName', '$k_{R_x}$')
|
|
histogram(kRy, 'DisplayName', '$k_{R_y}$')
|
|
hold off;
|
|
xlabel('Bending Stiffness [Nm/rad]')
|
|
legend();
|
|
#+end_src
|
|
|
|
#+begin_src matlab :tangle no :exports results :results file replace
|
|
exportFig('figs/bending_stiffness_histogram.pdf', 'width', 'wide', 'height', 'normal');
|
|
#+end_src
|
|
|
|
#+name: fig:bending_stiffness_histogram
|
|
#+caption: Histogram of the measured bending stiffness
|
|
#+RESULTS:
|
|
[[file:figs/bending_stiffness_histogram.png]]
|
|
|
|
#+begin_src matlab :exports none
|
|
figure;
|
|
hold on;
|
|
histogram(1e3*Rmx, 'DisplayName', '$k_{R_x}$')
|
|
histogram(1e3*Rmy, 'DisplayName', '$k_{R_y}$')
|
|
hold off;
|
|
xlabel('Bending Stroke [mrad]')
|
|
legend();
|
|
#+end_src
|
|
|
|
#+begin_src matlab :tangle no :exports results :results file replace
|
|
exportFig('figs/bending_stroke_histogram.pdf', 'width', 'wide', 'height', 'normal');
|
|
#+end_src
|
|
|
|
#+name: fig:bending_stroke_histogram
|
|
#+caption: Histogram of the measured bending stroke
|
|
#+RESULTS:
|
|
[[file:figs/bending_stroke_histogram.png]]
|
|
|
|
The relation between the measured beam thickness and the measured bending stiffness is shown in Figure [[fig:flex_thickness_vs_bending_stiff]].
|
|
|
|
#+begin_src matlab :exports none
|
|
load('flex_meas_dim.mat', 'meas_flex');
|
|
figure;
|
|
hold on;
|
|
plot((meas_flex(:,1)+meas_flex(:,2))/2, kRx, 'o', 'DisplayName', '$x$')
|
|
plot((meas_flex(:,3)+meas_flex(:,4))/2, kRy, 'o', 'DisplayName', '$y$')
|
|
hold off;
|
|
xlabel('Flexible Beam Thickness [$\mu m$]');
|
|
ylabel('Bending Stiffness [Nm/rad]');
|
|
legend('location', 'southeast');
|
|
#+end_src
|
|
|
|
#+begin_src matlab :tangle no :exports results :results file replace
|
|
exportFig('figs/flex_thickness_vs_bending_stiff.pdf', 'width', 'wide', 'height', 'normal');
|
|
#+end_src
|
|
|
|
#+name: fig:flex_thickness_vs_bending_stiff
|
|
#+caption: Measured bending stiffness as a function of the estimated flexible beam thickness
|
|
#+RESULTS:
|
|
[[file:figs/flex_thickness_vs_bending_stiff.png]]
|
|
|
|
** Conclusion
|
|
#+begin_important
|
|
The measured bending stiffness and bending stroke of the flexible joints are very close to the estimated one using a Finite Element Model.
|
|
|
|
The characteristics of all the flexible joints are also quite close to each other.
|
|
This should allow us to model them with unique parameters.
|
|
#+end_important
|
|
|