1382 lines
50 KiB
Org Mode
1382 lines
50 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, bibliography=totoc]
|
|
#+LaTeX_HEADER_EXTRA: \input{preamble.tex}
|
|
#+LATEX_HEADER_EXTRA: \bibliography{test-bench-flexible-joints.bib}
|
|
|
|
#+BIND: org-latex-bib-compiler "biber"
|
|
|
|
#+PROPERTY: header-args:matlab :session *MATLAB*
|
|
#+PROPERTY: header-args:matlab+ :comments org
|
|
#+PROPERTY: header-args:matlab+ :exports none
|
|
#+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:matlab+ :tangle no
|
|
|
|
#+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
|
|
|
|
#+latex: \clearpage
|
|
|
|
* Build :noexport:
|
|
#+NAME: startblock
|
|
#+BEGIN_SRC emacs-lisp :results none :tangle no
|
|
(add-to-list 'org-latex-classes
|
|
'("scrreprt"
|
|
"\\documentclass{scrreprt}"
|
|
("\\chapter{%s}" . "\\chapter*{%s}")
|
|
("\\section{%s}" . "\\section*{%s}")
|
|
("\\subsection{%s}" . "\\subsection*{%s}")
|
|
("\\paragraph{%s}" . "\\paragraph*{%s}")
|
|
))
|
|
|
|
|
|
;; Remove automatic org heading labels
|
|
(defun my-latex-filter-removeOrgAutoLabels (text backend info)
|
|
"Org-mode automatically generates labels for headings despite explicit use of `#+LABEL`. This filter forcibly removes all automatically generated org-labels in headings."
|
|
(when (org-export-derived-backend-p backend 'latex)
|
|
(replace-regexp-in-string "\\\\label{sec:org[a-f0-9]+}\n" "" text)))
|
|
(add-to-list 'org-export-filter-headline-functions
|
|
'my-latex-filter-removeOrgAutoLabels)
|
|
|
|
;; Remove all org comments in the output LaTeX file
|
|
(defun delete-org-comments (backend)
|
|
(loop for comment in (reverse (org-element-map (org-element-parse-buffer)
|
|
'comment 'identity))
|
|
do
|
|
(setf (buffer-substring (org-element-property :begin comment)
|
|
(org-element-property :end comment))
|
|
"")))
|
|
(add-hook 'org-export-before-processing-hook 'delete-org-comments)
|
|
|
|
;; Use no package by default
|
|
(setq org-latex-packages-alist nil)
|
|
(setq org-latex-default-packages-alist nil)
|
|
|
|
;; Do not include the subtitle inside the title
|
|
(setq org-latex-subtitle-separate t)
|
|
(setq org-latex-subtitle-format "\\subtitle{%s}")
|
|
|
|
(setq org-export-before-parsing-hook '(org-ref-glossary-before-parsing
|
|
org-ref-acronyms-before-parsing))
|
|
#+END_SRC
|
|
|
|
* Notes :noexport:
|
|
|
|
Prefix for figures/section/tables =test_joints=
|
|
|
|
Compilation of the following reports:
|
|
- [X] [[file:~/Cloud/work-projects/ID31-NASS/matlab/test-bench-flexible-joints-old/index.org][test-bench-flexible-joints-adv]]
|
|
Ideas of measuring shear stiffness, axial stiffness and torsion
|
|
Not done in the end
|
|
- [X] [[/home/thomas/Cloud/work-projects/ID31-NASS/matlab/test-bench-flexible-joints-old/bending.org][bending measurement]]
|
|
Some possible errors when measuring bending stiffness
|
|
- [X] [[file:~/Cloud/documents/internships/2021-martin-reichert/Bachelor thesis.pdf][Report of Martin]]
|
|
Analytical estimation of the stiffness
|
|
Estimation of possible errors in the estimation of the stiffness
|
|
May not be useful here.
|
|
- [X] [[file:~/Cloud/work-projects/ID31-NASS/matlab/test-bench-nass-flexible-joints/test-bench-flexible-joints.org][test-bench-nass-flexible-joints]]
|
|
Here only the bending stiffness is measured
|
|
- [ ] Also check start of this report: [[file:~/Cloud/work-projects/ID31-NASS/matlab/nass-simscape/org/nano_hexapod.org][nano_hexapod]]
|
|
Model of the flexible joints
|
|
Maybe add a section for the model of the flexible joints (of maybe this was done in the "detailed design" section?)
|
|
- [ ] Maybe say that some flexible joints where not machined properly (show picture with deformed machining and one with "chips" stuck inside)
|
|
- [ ] Explain why the encoder is here: in line with the measurement, no "abbe errors"
|
|
|
|
Goal:
|
|
- Characterization of flexible joints:
|
|
- Remind the specifications
|
|
- Most important: bending stiffness
|
|
- Dimensional measurement
|
|
- Presentation of test bench to measure stiffness
|
|
- Possible measurement errors and how to prevent them
|
|
- Calibration of force sensor
|
|
- Section 6 is most important: measurement results
|
|
- Conclusion
|
|
|
|
|
|
* Introduction :ignore:
|
|
|
|
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 ref:tab:test_joints_specs.
|
|
|
|
#+name: tab:test_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/\mu m$ | 94 |
|
|
| Shear Stiffness | $> 1\,N/\mu m$ | 13 |
|
|
| Bending Stiffness | $< 100\,Nm/\text{rad}$ | 5 |
|
|
| Torsion Stiffness | $< 500\,Nm/\text{rad}$ | 260 |
|
|
| Bending Stroke | $> 1\,\text{mrad}$ | 24.5 |
|
|
| Torsion Stroke | $> 5\,\mu\text{rad}$ | |
|
|
|
|
Then, the classical geometry of a flexible ball joint shown in Figure ref:fig:test_joints_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 ref:tab:test_joints_specs.
|
|
|
|
#+name: fig:test_joints_fem_geometry
|
|
#+caption: Flexible part of the Joint used for FEM - CAD view
|
|
#+attr_latex: :width 0.5\linewidth
|
|
[[file:figs/test_joints_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 ref:fig:test_joints_received.
|
|
|
|
#+name: fig:test_joints_received
|
|
#+caption: 15 of the 16 flexible joints
|
|
#+attr_latex: :width \linewidth
|
|
[[file:figs/test_joints_received.jpg]]
|
|
|
|
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 ref:sec:test_joints_flex_dim_meas: each flexible joint is measured using a profile projector
|
|
- Section ref:sec:test_joints_test_bench_desc: the stiffness measurement bench is presented
|
|
- Section ref:sec:test_joints_error_budget: an error budget is performed in order to estimate the accuracy of the measured stiffness
|
|
- Section ref:sec:test_joints_first_measurements: first measurements are performed
|
|
- Section ref:sec:test_joints_bending_stiffness_meas: the bending stiffness of the flexible joints are measured
|
|
|
|
|
|
#+name: tab:test_joints_section_matlab_code
|
|
#+caption: Report sections and corresponding Matlab files
|
|
#+attr_latex: :environment tabularx :width 0.6\linewidth :align lX
|
|
#+attr_latex: :center t :booktabs t
|
|
| *Sections* | *Matlab File* |
|
|
|-----------------------------+--------------------|
|
|
| Section ref:sec:test_joints | =test_joints_1_.m= |
|
|
| | |
|
|
| | |
|
|
|
|
* Dimensional Measurements
|
|
:PROPERTIES:
|
|
:header-args:matlab+: :tangle matlab/test_joints_1_dim_meas.m
|
|
:END:
|
|
<<sec:test_joints_flex_dim_meas>>
|
|
** Measurement Bench
|
|
|
|
The axis corresponding to the flexible joints are defined in Figure ref:fig:test_joints_axis.
|
|
|
|
#+name: fig:test_joints_axis
|
|
#+caption: Define axis for the flexible joints
|
|
#+attr_latex: :width 0.3\linewidth
|
|
[[file:figs/test_joints_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 ref:fig:test_joints_y_flex_meas_setup.
|
|
|
|
#+name: fig:test_joints_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/test_joints_y_flex_meas_setup.png]]
|
|
|
|
What we typically observe is shown in Figure ref:fig:test_joints_soft_measure_size.
|
|
It is then possible to estimate to dimension of the flexible beam with an accuracy of $\approx 5\,\mu m$,
|
|
|
|
#+name: fig:test_joints_soft_measure_size
|
|
#+attr_latex: :width 1.0\linewidth
|
|
#+caption: Image used to measure the flexible joint's dimensions
|
|
[[file:figs/test_joints_soft_measure_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 :noweb yes
|
|
<<m-init-path>>
|
|
#+end_src
|
|
|
|
#+begin_src matlab :eval no :noweb yes
|
|
<<m-init-path-tangle>>
|
|
#+end_src
|
|
|
|
#+begin_src matlab :noweb yes
|
|
<<m-init-other>>
|
|
#+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 ref:tab:test_joints_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:test_joints_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 ref:fig:test_joints_size_hist.
|
|
|
|
#+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/test_joints_size_hist.pdf', 'width', 'normal', 'height', 'normal');
|
|
#+end_src
|
|
|
|
#+name: fig:test_joints_size_hist
|
|
#+caption: Histogram for the (16x2) measured beams' thickness
|
|
#+RESULTS:
|
|
[[file:figs/test_joints_size_hist.png]]
|
|
|
|
#+begin_src matlab :exports none :tangle no
|
|
%% Save beam sizes
|
|
save('./matlab/mat/flex_meas_dim.mat', 'meas_flex');
|
|
#+end_src
|
|
|
|
#+begin_src matlab :exports none :eval no
|
|
%% Save beam sizes
|
|
save('./mat/flex_meas_dim.mat', 'meas_flex');
|
|
#+end_src
|
|
|
|
** Bad flexible joints
|
|
|
|
#+name: fig:test_joints_bad
|
|
#+caption: Example of two flexible joints that were considered unsatisfactory after visual inspection
|
|
#+begin_figure
|
|
#+attr_latex: :caption \subcaption{\label{fig:test_joints_bad_shape}Non-Symmetrical shape}
|
|
#+attr_latex: :options {0.49\textwidth}
|
|
#+begin_subfigure
|
|
#+attr_latex: :height 6cm
|
|
[[file:figs/test_joints_bad_shape.jpg]]
|
|
#+end_subfigure
|
|
#+attr_latex: :caption \subcaption{\label{fig:test_joints_bad_chips}"Chips" stuck in the air gap}
|
|
#+attr_latex: :options {0.49\textwidth}
|
|
#+begin_subfigure
|
|
#+attr_latex: :height 6cm
|
|
[[file:figs/test_joints_bad_chips.jpg]]
|
|
#+end_subfigure
|
|
#+end_figure
|
|
|
|
* Measurement Test Bench - Bending Stiffness
|
|
:PROPERTIES:
|
|
:header-args:matlab+: :tangle matlab/test_joints_2_bench_dimensioning.m
|
|
:END:
|
|
<<sec:test_joints_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 ref:fig:test_joints_bench_working_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_joints_bench_working_principle
|
|
#+caption: Test Bench - working principle
|
|
[[file:figs/test_joints_bench_working_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
|
|
|
|
#+begin_src matlab :tangle no :noweb yes
|
|
<<m-init-path>>
|
|
#+end_src
|
|
|
|
#+begin_src matlab :eval no :noweb yes
|
|
<<m-init-path-tangle>>
|
|
#+end_src
|
|
|
|
#+begin_src matlab :noweb yes
|
|
<<m-init-other>>
|
|
#+end_src
|
|
|
|
** Flexible joint Geometry
|
|
The flexible joint used for the Nano-Hexapod is shown in Figure ref:fig:test_joints_bend_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:test_joints_bend_geometry
|
|
#+caption: Geometry of the flexible joint
|
|
[[file:figs/test_joints_bend_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 ref:fig:test_joints_bench_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_joints_bench_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_joints_bench_overview.png]]
|
|
|
|
A side view of the bench with the important quantities are shown in Figure ref:fig:test_joints_bench_side.
|
|
|
|
#+name: fig:test_joints_bench_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_joints_bench_side.png]]
|
|
|
|
* Error budget
|
|
:PROPERTIES:
|
|
:header-args:matlab+: :tangle matlab/test_joints_3_error_budget.m
|
|
:END:
|
|
<<sec:test_joints_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
|
|
|
|
#+begin_src matlab :tangle no :noweb yes
|
|
<<m-init-path>>
|
|
#+end_src
|
|
|
|
#+begin_src matlab :eval no :noweb yes
|
|
<<m-init-path-tangle>>
|
|
#+end_src
|
|
|
|
#+begin_src matlab :noweb yes
|
|
<<m-init-other>>
|
|
#+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 ref:tab:test_joints_axial_shear_prop and ref:tab:test_joints_bending_torsion_prop.
|
|
|
|
#+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:test_joints_axial_shear_prop
|
|
#+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:test_joints_bending_torsion_prop
|
|
#+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 ref:fig:test_joints_bench_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
|
|
|
|
** 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
|
|
:PROPERTIES:
|
|
:header-args:matlab+: :tangle matlab/test_joints_4_first_meas.m
|
|
:END:
|
|
<<sec:test_joints_first_measurements>>
|
|
** Introduction :ignore:
|
|
|
|
- *Encoder*: [[file:doc/L-9517-9448-05-B_Data_sheet_RESOLUTE_BiSS_en.pdf][Renishaw Resolute 1nm]]
|
|
|
|
** 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 :noweb yes
|
|
<<m-init-path>>
|
|
#+end_src
|
|
|
|
#+begin_src matlab :eval no :noweb yes
|
|
<<m-init-path-tangle>>
|
|
#+end_src
|
|
|
|
#+begin_src matlab :noweb yes
|
|
<<m-init-other>>
|
|
#+end_src
|
|
|
|
** Force Sensor Calibration
|
|
|
|
#+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 ref:fig:test_joints_force_sensor_calib.
|
|
|
|
#+name: fig:test_joints_force_sensor_calib
|
|
#+caption: Zoom on the two force sensors in contact
|
|
#+attr_latex: :width 0.8\linewidth
|
|
[[file:figs/test_joints_force_sensor_calib.jpg]]
|
|
|
|
The two force sensors are therefore measuring the exact same force, and we can compare the two measurements.
|
|
|
|
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/test_joints_force_sensor_calib_time.pdf', 'width', 'wide', 'height', 'normal');
|
|
#+end_src
|
|
|
|
#+name: fig:test_joints_force_sensor_calib_time
|
|
#+caption: Measured force using both sensors as a function of time
|
|
#+RESULTS:
|
|
[[file:figs/test_joints_force_sensor_calib_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 ref:fig:test_joints_force_sensor_calib_fit.
|
|
|
|
#+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/test_joints_force_sensor_calib_fit.pdf', 'width', 'wide', 'height', 'normal');
|
|
#+end_src
|
|
|
|
#+name: fig:test_joints_force_sensor_calib_fit
|
|
#+caption: Measured two forces and linear fit
|
|
#+RESULTS:
|
|
[[file:figs/test_joints_force_sensor_calib_fit.png]]
|
|
|
|
The measurement error between the two sensors is shown in Figure ref:fig:test_joints_force_sensor_calib_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/test_joints_force_sensor_calib_error.pdf', 'width', 'wide', 'height', 'normal');
|
|
#+end_src
|
|
|
|
#+name: fig:test_joints_force_sensor_calib_error
|
|
#+caption: Error in Newtons
|
|
#+RESULTS:
|
|
[[file:figs/test_joints_force_sensor_calib_error.png]]
|
|
|
|
** Force Sensor Stiffness
|
|
|
|
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 ref:fig:test_joints_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:test_joints_meas_force_sensor_stiffness
|
|
#+caption: Bench used to measured the stiffness of the force sensor
|
|
#+attr_latex: :width 0.6\linewidth
|
|
[[file:figs/test_joints_meas_force_sensor_stiffness.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$.
|
|
|
|
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 ref:fig:test_joints_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/test_joints_force_sensor_stiffness_fit.pdf', 'width', 'wide', 'height', 'normal');
|
|
#+end_src
|
|
|
|
#+name: fig:test_joints_force_sensor_stiffness_fit
|
|
#+caption: Displacement as a function of the measured force
|
|
#+RESULTS:
|
|
[[file:figs/test_joints_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/test_joints_5_bending_stiff_meas.m
|
|
:END:
|
|
<<sec:test_joints_bending_stiffness_meas>>
|
|
** Introduction
|
|
|
|
A picture of the bench used to measure the X-bending stiffness of the flexible joints is shown in Figure ref:fig:test_joints_picture_bench_overview.
|
|
A closer view on flexible joint is shown in Figure ref:fig:test_joints_picture_bench_close and a zoom on the force sensor tip is shown in Figure ref:fig:test_joints_picture_bench_zoom.
|
|
|
|
#+name: fig:test_joints_picture_bench_overview
|
|
#+caption: Side view of the flexible joint stiffness bench. X-Bending stiffness is measured.
|
|
#+attr_latex: :width \linewidth
|
|
[[file:figs/test_joints_picture_bench_overview.jpg]]
|
|
|
|
#+name: fig:test_joints_picture_bench_close
|
|
#+caption: Zoom on the flexible joint - Side view
|
|
#+attr_latex: :width \linewidth
|
|
[[file:figs/test_joints_picture_bench_close.jpg]]
|
|
|
|
|
|
#+name: fig:test_joints_picture_bench_zoom
|
|
#+caption: Zoom on the tip of the force sensor
|
|
#+attr_latex: :width 0.4\linewidth
|
|
[[file:figs/test_joints_picture_bench_zoom.jpg]]
|
|
|
|
The same bench used to measure the Y-bending stiffness of the flexible joint by pivoting the flexible joint by 90 degrees.
|
|
|
|
** 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 :noweb yes
|
|
<<m-init-path>>
|
|
#+end_src
|
|
|
|
#+begin_src matlab :eval no :noweb yes
|
|
<<m-init-path-tangle>>
|
|
#+end_src
|
|
|
|
#+begin_src matlab :noweb yes
|
|
<<m-init-other>>
|
|
#+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 ref:fig:test_joints_meas_bend_time.
|
|
|
|
#+begin_src matlab :exports none
|
|
%% Time Domain plots
|
|
figure;
|
|
tiledlayout(2, 1, 'TileSpacing', 'Compact', '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/test_joints_meas_bend_time.pdf', 'width', 'wide', 'height', 'tall');
|
|
#+end_src
|
|
|
|
#+name: fig:test_joints_meas_bend_time
|
|
#+caption: Typical time domain measurements
|
|
#+RESULTS:
|
|
[[file:figs/test_joints_meas_bend_time.png]]
|
|
|
|
The displacement as a function of the force is then shown in Figure ref:fig:test_joints_meas_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/test_joints_meas_F_d.pdf', 'width', 'wide', 'height', 'normal');
|
|
#+end_src
|
|
|
|
#+name: fig:test_joints_meas_F_d
|
|
#+caption: Typical measurement of the diplacement as a function of the applied force
|
|
#+RESULTS:
|
|
[[file:figs/test_joints_meas_F_d.png]]
|
|
|
|
The bending stiffness can be estimated by computing the slope of the curve in Figure ref:fig:test_joints_meas_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 ref:fig:test_joints_meas_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/test_joints_meas_F_d_lin_fit.pdf', 'width', 'wide', 'height', 'normal');
|
|
#+end_src
|
|
|
|
#+name: fig:test_joints_meas_F_d_lin_fit
|
|
#+caption: Typical measurement of the diplacement as a function of the applied force with estimated linear fits
|
|
#+RESULTS:
|
|
[[file:figs/test_joints_meas_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:
|
|
- Bending Stiffness: 5.5Nm/rad
|
|
- Bending Stiffness at stop: 173.6Nm/rad
|
|
- Bending Stroke: 18.9mrad
|
|
|
|
** 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 ref:tab:test_joints_meas_results_x_dir for the X direction and in Table ref:tab:test_joints_meas_results_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:test_joints_meas_results_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:test_joints_meas_results_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 ref:fig:test_joints_bend_stiff_hist and of the bending stroke in Figure ref:fig:test_joints_bend_stroke_hist.
|
|
|
|
#+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/test_joints_bend_stiff_hist.pdf', 'width', 'wide', 'height', 'normal');
|
|
#+end_src
|
|
|
|
#+name: fig:test_joints_bend_stiff_hist
|
|
#+caption: Histogram of the measured bending stiffness
|
|
#+RESULTS:
|
|
[[file:figs/test_joints_bend_stiff_hist.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/test_joints_bend_stroke_hist.pdf', 'width', 'wide', 'height', 'normal');
|
|
#+end_src
|
|
|
|
#+name: fig:test_joints_bend_stroke_hist
|
|
#+caption: Histogram of the measured bending stroke
|
|
#+RESULTS:
|
|
[[file:figs/test_joints_bend_stroke_hist.png]]
|
|
|
|
The relation between the measured beam thickness and the measured bending stiffness is shown in Figure ref:fig:test_joints_thickness_stiffness.
|
|
|
|
#+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/test_joints_thickness_stiffness.pdf', 'width', 'wide', 'height', 'normal');
|
|
#+end_src
|
|
|
|
#+name: fig:test_joints_thickness_stiffness
|
|
#+caption: Measured bending stiffness as a function of the estimated flexible beam thickness
|
|
#+RESULTS:
|
|
[[file:figs/test_joints_thickness_stiffness.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
|
|
|
|
* Conclusion
|
|
<<sec:test_joints_conclusion>>
|
|
|
|
* Bibliography :ignore:
|
|
#+latex: \printbibliography[heading=bibintoc,title={Bibliography}]
|
|
|
|
* Helping Functions :noexport:
|
|
** Initialize Path
|
|
#+NAME: m-init-path
|
|
#+BEGIN_SRC matlab
|
|
%% Path for functions, data and scripts
|
|
addpath('./matlab/mat/'); % Path for data
|
|
addpath('./matlab/'); % Path for scripts
|
|
#+END_SRC
|
|
|
|
#+NAME: m-init-path-tangle
|
|
#+BEGIN_SRC matlab
|
|
%% Path for functions, data and scripts
|
|
addpath('./mat/'); % Path for data
|
|
#+END_SRC
|
|
|
|
** Initialize other elements
|
|
#+NAME: m-init-other
|
|
#+BEGIN_SRC matlab
|
|
%% Colors for the figures
|
|
colors = colororder;
|
|
#+END_SRC
|