diff --git a/figs/CaptureScreen_1.jpg b/figs/CaptureScreen_1.jpg new file mode 100644 index 0000000..e1a6a71 Binary files /dev/null and b/figs/CaptureScreen_1.jpg differ diff --git a/figs/CaptureScreen_2.jpg b/figs/CaptureScreen_2.jpg new file mode 100644 index 0000000..1375e17 Binary files /dev/null and b/figs/CaptureScreen_2.jpg differ diff --git a/figs/IMG_20210302_144000.jpg b/figs/IMG_20210302_144000.jpg new file mode 100644 index 0000000..286db7e Binary files /dev/null and b/figs/IMG_20210302_144000.jpg differ diff --git a/figs/IMG_20210302_173619.jpg b/figs/IMG_20210302_173619.jpg new file mode 100644 index 0000000..cfb00b2 Binary files /dev/null and b/figs/IMG_20210302_173619.jpg differ diff --git a/figs/IMG_20210309_145242.jpg b/figs/IMG_20210309_145242.jpg new file mode 100644 index 0000000..d8ed1f0 Binary files /dev/null and b/figs/IMG_20210309_145242.jpg differ diff --git a/figs/IMG_20210309_145333.jpg b/figs/IMG_20210309_145333.jpg new file mode 100644 index 0000000..b5b7e3b Binary files /dev/null and b/figs/IMG_20210309_145333.jpg differ diff --git a/figs/beam_dim_histogram.pdf b/figs/beam_dim_histogram.pdf new file mode 100644 index 0000000..8cd08ee Binary files /dev/null and b/figs/beam_dim_histogram.pdf differ diff --git a/figs/beam_dim_histogram.png b/figs/beam_dim_histogram.png new file mode 100644 index 0000000..f273d67 Binary files /dev/null and b/figs/beam_dim_histogram.png differ diff --git a/figs/bending_stiffness_histogram.pdf b/figs/bending_stiffness_histogram.pdf new file mode 100644 index 0000000..ebe8c76 Binary files /dev/null and b/figs/bending_stiffness_histogram.pdf differ diff --git a/figs/bending_stiffness_histogram.png b/figs/bending_stiffness_histogram.png new file mode 100644 index 0000000..163d65b Binary files /dev/null and b/figs/bending_stiffness_histogram.png differ diff --git a/figs/bending_stroke_histogram.pdf b/figs/bending_stroke_histogram.pdf new file mode 100644 index 0000000..b06d561 Binary files /dev/null and b/figs/bending_stroke_histogram.pdf differ diff --git a/figs/bending_stroke_histogram.png b/figs/bending_stroke_histogram.png new file mode 100644 index 0000000..9935c98 Binary files /dev/null and b/figs/bending_stroke_histogram.png differ diff --git a/figs/calibrated_force_dit.pdf b/figs/calibrated_force_dit.pdf new file mode 100644 index 0000000..146a5fc Binary files /dev/null and b/figs/calibrated_force_dit.pdf differ diff --git a/figs/calibrated_force_dit.png b/figs/calibrated_force_dit.png new file mode 100644 index 0000000..ed52fda Binary files /dev/null and b/figs/calibrated_force_dit.png differ diff --git a/figs/comp_encoder_probe_linear_fit.pdf b/figs/comp_encoder_probe_linear_fit.pdf new file mode 100644 index 0000000..fd05db8 Binary files /dev/null and b/figs/comp_encoder_probe_linear_fit.pdf differ diff --git a/figs/comp_encoder_probe_linear_fit.png b/figs/comp_encoder_probe_linear_fit.png new file mode 100644 index 0000000..1a1e7b2 Binary files /dev/null and b/figs/comp_encoder_probe_linear_fit.png differ diff --git a/figs/comp_encoder_probe_mismatch.pdf b/figs/comp_encoder_probe_mismatch.pdf new file mode 100644 index 0000000..054e0d8 Binary files /dev/null and b/figs/comp_encoder_probe_mismatch.pdf differ diff --git a/figs/comp_encoder_probe_mismatch.png b/figs/comp_encoder_probe_mismatch.png new file mode 100644 index 0000000..9bd1677 Binary files /dev/null and b/figs/comp_encoder_probe_mismatch.png differ diff --git a/figs/comp_encoder_probe_time.pdf b/figs/comp_encoder_probe_time.pdf new file mode 100644 index 0000000..912c600 Binary files /dev/null and b/figs/comp_encoder_probe_time.pdf differ diff --git a/figs/comp_encoder_probe_time.png b/figs/comp_encoder_probe_time.png new file mode 100644 index 0000000..ebd7842 Binary files /dev/null and b/figs/comp_encoder_probe_time.png differ diff --git a/figs/comp_encoder_probe_time_zoom.pdf b/figs/comp_encoder_probe_time_zoom.pdf new file mode 100644 index 0000000..fd51d59 Binary files /dev/null and b/figs/comp_encoder_probe_time_zoom.pdf differ diff --git a/figs/comp_encoder_probe_time_zoom.png b/figs/comp_encoder_probe_time_zoom.png new file mode 100644 index 0000000..d98b1ef Binary files /dev/null and b/figs/comp_encoder_probe_time_zoom.png differ diff --git a/figs/flex_joint_meas_example_F_d.pdf b/figs/flex_joint_meas_example_F_d.pdf new file mode 100644 index 0000000..e524dc6 Binary files /dev/null and b/figs/flex_joint_meas_example_F_d.pdf differ diff --git a/figs/flex_joint_meas_example_F_d.png b/figs/flex_joint_meas_example_F_d.png new file mode 100644 index 0000000..d23bd41 Binary files /dev/null and b/figs/flex_joint_meas_example_F_d.png differ diff --git a/figs/flex_joint_meas_example_F_d_lin_fit.pdf b/figs/flex_joint_meas_example_F_d_lin_fit.pdf new file mode 100644 index 0000000..023cac0 Binary files /dev/null and b/figs/flex_joint_meas_example_F_d_lin_fit.pdf differ diff --git a/figs/flex_joint_meas_example_F_d_lin_fit.png b/figs/flex_joint_meas_example_F_d_lin_fit.png new file mode 100644 index 0000000..41af04c Binary files /dev/null and b/figs/flex_joint_meas_example_F_d_lin_fit.png differ diff --git a/figs/flex_joint_meas_example_time_domain.pdf b/figs/flex_joint_meas_example_time_domain.pdf new file mode 100644 index 0000000..12bd933 Binary files /dev/null and b/figs/flex_joint_meas_example_time_domain.pdf differ diff --git a/figs/flex_joint_meas_example_time_domain.png b/figs/flex_joint_meas_example_time_domain.png new file mode 100644 index 0000000..f27ab3b Binary files /dev/null and b/figs/flex_joint_meas_example_time_domain.png differ diff --git a/figs/flex_thickness_vs_bending_stiff.pdf b/figs/flex_thickness_vs_bending_stiff.pdf new file mode 100644 index 0000000..cbd119e Binary files /dev/null and b/figs/flex_thickness_vs_bending_stiff.pdf differ diff --git a/figs/flex_thickness_vs_bending_stiff.png b/figs/flex_thickness_vs_bending_stiff.png new file mode 100644 index 0000000..96e17e5 Binary files /dev/null and b/figs/flex_thickness_vs_bending_stiff.png differ diff --git a/figs/flexible_joint_axis.pdf b/figs/flexible_joint_axis.pdf new file mode 100644 index 0000000..1c5e631 Binary files /dev/null and b/figs/flexible_joint_axis.pdf differ diff --git a/figs/flexible_joint_axis.png b/figs/flexible_joint_axis.png new file mode 100644 index 0000000..837c41e Binary files /dev/null and b/figs/flexible_joint_axis.png differ diff --git a/figs/flexible_joint_axis.svg b/figs/flexible_joint_axis.svg new file mode 100644 index 0000000..9d66c2b Binary files /dev/null and b/figs/flexible_joint_axis.svg differ diff --git a/figs/flexible_joint_fem_geometry.pdf b/figs/flexible_joint_fem_geometry.pdf new file mode 100644 index 0000000..473ef9d Binary files /dev/null and b/figs/flexible_joint_fem_geometry.pdf differ diff --git a/figs/flexible_joint_fem_geometry.png b/figs/flexible_joint_fem_geometry.png new file mode 100644 index 0000000..3f83419 Binary files /dev/null and b/figs/flexible_joint_fem_geometry.png differ diff --git a/figs/flexible_joint_geometry.pdf b/figs/flexible_joint_geometry.pdf new file mode 100644 index 0000000..5ea68ff Binary files /dev/null and b/figs/flexible_joint_geometry.pdf differ diff --git a/figs/flexible_joint_geometry.png b/figs/flexible_joint_geometry.png new file mode 100644 index 0000000..94f62e0 Binary files /dev/null and b/figs/flexible_joint_geometry.png differ diff --git a/figs/flexible_joint_geometry.svg b/figs/flexible_joint_geometry.svg new file mode 100644 index 0000000..1a603fc Binary files /dev/null and b/figs/flexible_joint_geometry.svg differ diff --git a/figs/flexible_joint_y_flex_meas_setup.jpg b/figs/flexible_joint_y_flex_meas_setup.jpg new file mode 100644 index 0000000..6694082 Binary files /dev/null and b/figs/flexible_joint_y_flex_meas_setup.jpg differ diff --git a/figs/flexible_joint_y_flex_meas_setup.pdf b/figs/flexible_joint_y_flex_meas_setup.pdf new file mode 100644 index 0000000..2232fee Binary files /dev/null and b/figs/flexible_joint_y_flex_meas_setup.pdf differ diff --git a/figs/flexible_joint_y_flex_meas_setup.png b/figs/flexible_joint_y_flex_meas_setup.png new file mode 100644 index 0000000..5c8554e Binary files /dev/null and b/figs/flexible_joint_y_flex_meas_setup.png differ diff --git a/figs/force_calibration_time.pdf b/figs/force_calibration_time.pdf new file mode 100644 index 0000000..db7df4b Binary files /dev/null and b/figs/force_calibration_time.pdf differ diff --git a/figs/force_calibration_time.png b/figs/force_calibration_time.png new file mode 100644 index 0000000..1a36b54 Binary files /dev/null and b/figs/force_calibration_time.png differ diff --git a/figs/force_meas_error.pdf b/figs/force_meas_error.pdf new file mode 100644 index 0000000..7483b5c Binary files /dev/null and b/figs/force_meas_error.pdf differ diff --git a/figs/force_meas_error.png b/figs/force_meas_error.png new file mode 100644 index 0000000..76fe216 Binary files /dev/null and b/figs/force_meas_error.png differ diff --git a/figs/force_meas_error_percentage.pdf b/figs/force_meas_error_percentage.pdf new file mode 100644 index 0000000..db32239 Binary files /dev/null and b/figs/force_meas_error_percentage.pdf differ diff --git a/figs/force_meas_error_percentage.png b/figs/force_meas_error_percentage.png new file mode 100644 index 0000000..d4b7a43 Binary files /dev/null and b/figs/force_meas_error_percentage.png differ diff --git a/figs/force_noise_asd.pdf b/figs/force_noise_asd.pdf new file mode 100644 index 0000000..2ef0c71 Binary files /dev/null and b/figs/force_noise_asd.pdf differ diff --git a/figs/force_noise_asd.png b/figs/force_noise_asd.png new file mode 100644 index 0000000..c97ca78 Binary files /dev/null and b/figs/force_noise_asd.png differ diff --git a/figs/force_noise_time.pdf b/figs/force_noise_time.pdf new file mode 100644 index 0000000..c21b68c Binary files /dev/null and b/figs/force_noise_time.pdf differ diff --git a/figs/force_noise_time.png b/figs/force_noise_time.png new file mode 100644 index 0000000..9dade79 Binary files /dev/null and b/figs/force_noise_time.png differ diff --git a/figs/force_sensor_stiffness_fit.pdf b/figs/force_sensor_stiffness_fit.pdf new file mode 100644 index 0000000..c5fc348 Binary files /dev/null and b/figs/force_sensor_stiffness_fit.pdf differ diff --git a/figs/force_sensor_stiffness_fit.png b/figs/force_sensor_stiffness_fit.png new file mode 100644 index 0000000..5edcf8e Binary files /dev/null and b/figs/force_sensor_stiffness_fit.png differ diff --git a/figs/mahr_stiffness_f_d_plot.pdf b/figs/mahr_stiffness_f_d_plot.pdf new file mode 100644 index 0000000..6014127 Binary files /dev/null and b/figs/mahr_stiffness_f_d_plot.pdf differ diff --git a/figs/mahr_stiffness_f_d_plot.png b/figs/mahr_stiffness_f_d_plot.png new file mode 100644 index 0000000..d9e2a23 Binary files /dev/null and b/figs/mahr_stiffness_f_d_plot.png differ diff --git a/figs/mahr_time_domain.pdf b/figs/mahr_time_domain.pdf new file mode 100644 index 0000000..2f15a87 Binary files /dev/null and b/figs/mahr_time_domain.pdf differ diff --git a/figs/mahr_time_domain.png b/figs/mahr_time_domain.png new file mode 100644 index 0000000..388950d Binary files /dev/null and b/figs/mahr_time_domain.png differ diff --git a/figs/nano_hexapod.pdf b/figs/nano_hexapod.pdf new file mode 100644 index 0000000..6fa0749 Binary files /dev/null and b/figs/nano_hexapod.pdf differ diff --git a/figs/nano_hexapod.png b/figs/nano_hexapod.png new file mode 100644 index 0000000..ea040c3 Binary files /dev/null and b/figs/nano_hexapod.png differ diff --git a/figs/picture_bending_x_meas_side_close.jpg b/figs/picture_bending_x_meas_side_close.jpg new file mode 100644 index 0000000..cd98709 Binary files /dev/null and b/figs/picture_bending_x_meas_side_close.jpg differ diff --git a/figs/picture_bending_x_meas_side_overview.jpg b/figs/picture_bending_x_meas_side_overview.jpg new file mode 100644 index 0000000..f479dbc Binary files /dev/null and b/figs/picture_bending_x_meas_side_overview.jpg differ diff --git a/figs/picture_bending_x_meas_side_zoom.jpg b/figs/picture_bending_x_meas_side_zoom.jpg new file mode 100644 index 0000000..9b98498 Binary files /dev/null and b/figs/picture_bending_x_meas_side_zoom.jpg differ diff --git a/figs/picture_bending_y_meas_side_close.jpg b/figs/picture_bending_y_meas_side_close.jpg new file mode 100644 index 0000000..dd9bf1f Binary files /dev/null and b/figs/picture_bending_y_meas_side_close.jpg differ diff --git a/figs/setup_mahr_stiff_meas_side.jpg b/figs/setup_mahr_stiff_meas_side.jpg new file mode 100644 index 0000000..b6371cd Binary files /dev/null and b/figs/setup_mahr_stiff_meas_side.jpg differ diff --git a/figs/setup_mahr_stiff_meas_top.jpg b/figs/setup_mahr_stiff_meas_top.jpg new file mode 100644 index 0000000..8f2f084 Binary files /dev/null and b/figs/setup_mahr_stiff_meas_top.jpg differ diff --git a/figs/setup_meas_flex_dim_y.png b/figs/setup_meas_flex_dim_y.png new file mode 100644 index 0000000..1e2dfc4 Binary files /dev/null and b/figs/setup_meas_flex_dim_y.png differ diff --git a/figs/soft_measure_flex_size.jpg b/figs/soft_measure_flex_size.jpg new file mode 100644 index 0000000..c1063b7 Binary files /dev/null and b/figs/soft_measure_flex_size.jpg differ diff --git a/figs/test-bench-schematic.pdf b/figs/test-bench-schematic.pdf new file mode 100644 index 0000000..3c9214f Binary files /dev/null and b/figs/test-bench-schematic.pdf differ diff --git a/figs/test-bench-schematic.png b/figs/test-bench-schematic.png new file mode 100644 index 0000000..f767b73 Binary files /dev/null and b/figs/test-bench-schematic.png differ diff --git a/figs/test-bench-schematic.svg b/figs/test-bench-schematic.svg new file mode 100644 index 0000000..428f001 Binary files /dev/null and b/figs/test-bench-schematic.svg differ diff --git a/figs/test_bench_flex_overview.pdf b/figs/test_bench_flex_overview.pdf new file mode 100644 index 0000000..4ce6108 Binary files /dev/null and b/figs/test_bench_flex_overview.pdf differ diff --git a/figs/test_bench_flex_overview.png b/figs/test_bench_flex_overview.png new file mode 100644 index 0000000..d9ce984 Binary files /dev/null and b/figs/test_bench_flex_overview.png differ diff --git a/figs/test_bench_flex_overview.svg b/figs/test_bench_flex_overview.svg new file mode 100644 index 0000000..d59017b Binary files /dev/null and b/figs/test_bench_flex_overview.svg differ diff --git a/figs/test_bench_flex_side.pdf b/figs/test_bench_flex_side.pdf new file mode 100644 index 0000000..ea4c50e Binary files /dev/null and b/figs/test_bench_flex_side.pdf differ diff --git a/figs/test_bench_flex_side.png b/figs/test_bench_flex_side.png new file mode 100644 index 0000000..4bd30e5 Binary files /dev/null and b/figs/test_bench_flex_side.png differ diff --git a/figs/test_bench_flex_side.svg b/figs/test_bench_flex_side.svg new file mode 100644 index 0000000..76209a0 Binary files /dev/null and b/figs/test_bench_flex_side.svg differ diff --git a/figs/test_bench_principle.pdf b/figs/test_bench_principle.pdf new file mode 100644 index 0000000..7f074e6 Binary files /dev/null and b/figs/test_bench_principle.pdf differ diff --git a/figs/test_bench_principle.png b/figs/test_bench_principle.png new file mode 100644 index 0000000..5919694 Binary files /dev/null and b/figs/test_bench_principle.png differ diff --git a/figs/test_bench_principle.svg b/figs/test_bench_principle.svg new file mode 100644 index 0000000..2ec4c99 Binary files /dev/null and b/figs/test_bench_principle.svg differ diff --git a/test-bench-flexible-joints.org b/test-bench-flexible-joints.org index 46f78b4..8d2cb64 100644 --- a/test-bench-flexible-joints.org +++ b/test-bench-flexible-joints.org @@ -97,15 +97,27 @@ * Notes :noexport: -Compilation of the following reports: -- [ ] test-bench-flexible-joints-adv [[file:~/Cloud/work-projects/ID31-NASS/matlab/test-bench-flexible-joints-old/index.org][index]] and [[/home/thomas/Cloud/work-projects/ID31-NASS/matlab/test-bench-flexible-joints-old/bending.org][bending]] -- [ ] [[file:~/Cloud/documents/internships/2021-martin-reichert/Bachelor thesis.pdf][Report of Martin]] -- [ ] [[file:~/Cloud/work-projects/ID31-NASS/matlab/test-bench-nass-flexible-joints/test-bench-flexible-joints.org][test-bench-nass-flexible-joints]] +- Prefix for figures/section/tables =test_bench_joints= -Also check start of this report: [[file:~/Cloud/work-projects/ID31-NASS/matlab/nass-simscape/org/nano_hexapod.org][nano_hexapod]] +Compilation of the following reports: +- [ ] [[file:~/Cloud/work-projects/ID31-NASS/matlab/test-bench-flexible-joints-old/index.org][test-bench-flexible-joints-adv]] +- [ ] [[/home/thomas/Cloud/work-projects/ID31-NASS/matlab/test-bench-flexible-joints-old/bending.org][bending measurement]] +- [ ] [[file:~/Cloud/documents/internships/2021-martin-reichert/Bachelor thesis.pdf][Report of Martin]] +- [X] [[file:~/Cloud/work-projects/ID31-NASS/matlab/test-bench-nass-flexible-joints/test-bench-flexible-joints.org][test-bench-nass-flexible-joints]] +- [ ] Also check start of this report: [[file:~/Cloud/work-projects/ID31-NASS/matlab/nass-simscape/org/nano_hexapod.org][nano_hexapod]] * 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 ref:sec:flexible_joints: the geometry of the flexible joints and the expected stiffness and stroke are presented +- Section ref:sec:flex_dim_meas: each flexible joint is measured using a profile projector +- Section ref:sec:test_bench_desc: the stiffness measurement bench is presented +- Section ref:sec:error_budget: an error budget is performed in order to estimate the accuracy of the measured stiffness +- Section ref:sec:first_measurements: first measurements are performed +- Section ref:sec:bending_stiffness_meas: the bending stiffness of the flexible joints are measured + #+name: tab:flexible_joints_section_matlab_code #+caption: Report sections and corresponding Matlab files #+attr_latex: :environment tabularx :width 0.6\linewidth :align lX @@ -115,14 +127,91 @@ Also check start of this report: [[file:~/Cloud/work-projects/ID31-NASS/matlab/n | Section ref:sec:flexible_joints_ | =flexible_joints_1_.m= | -* Mechanical Inspection -:PROPERTIES: -:HEADER-ARGS:matlab+: :tangle matlab/flexible_joints_1_.m -:END: -<> -** Introduction :ignore: +* Flexible Joints +<> -** Matlab Init :noexport:ignore: +The flexible joints that are going to be measured in this document have been design to be used with a Nano-Hexapod (Figure ref: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 ref: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 ref: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 ref: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 ref: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: +<> +** Measurement Bench + +The axis corresponding to the flexible joints are defined in Figure ref: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 ref: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 ref: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) <> #+end_src @@ -131,18 +220,1499 @@ Also check start of this report: [[file:~/Cloud/work-projects/ID31-NASS/matlab/n <> #+end_src -#+begin_src matlab :tangle no :noweb yes -<> +#+begin_src matlab :tangle no +addpath('./matlab/mat/'); +addpath('./matlab/'); #+end_src -#+begin_src matlab :eval no :noweb yes -<> +#+begin_src matlab :eval no +addpath('./mat/'); #+end_src -#+begin_src matlab :noweb yes -<> +** 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: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 ref: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: +<> +** 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_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) +<> +#+end_src + +#+begin_src matlab :exports none :results silent :noweb yes +<> +#+end_src + +** Flexible joint Geometry +The flexible joint used for the Nano-Hexapod is shown in Figure ref: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 ref: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 ref: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: +<> +** 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) +<> +#+end_src + +#+begin_src matlab :exports none :results silent :noweb yes +<> +#+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:axial_shear_characteristics and ref: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 ref: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 +<> +** Introduction :ignore: + + +- Section ref:sec:test_meas_probe: +- Section ref:sec:meas_probe_stiffness: + +** Agreement between the probe and the encoder +:PROPERTIES: +:header-args:matlab+: :tangle ./matlab/probe_vs_encoder.m +:END: +<> +*** 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) +<> +#+end_src + +#+begin_src matlab :exports none :results silent :noweb yes +<> +#+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 ref: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 ref: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 ref: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 ref: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: +<> + +*** 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) +<> +#+end_src + +#+begin_src matlab :exports none :results silent :noweb yes +<> +#+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 ref: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 ref: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 ref: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) +<> +#+end_src + +#+begin_src matlab :exports none :results silent :noweb yes +<> +#+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 ref: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 ref: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 ref: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) +<> +#+end_src + +#+begin_src matlab :exports none :results silent :noweb yes +<> +#+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 ref: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 ref: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 ref: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) +<> +#+end_src + +#+begin_src matlab :exports none :results silent :noweb yes +<> +#+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 ref: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: +<> +** Introduction + +A picture of the bench used to measure the X-bending stiffness of the flexible joints is shown in Figure ref:fig:picture_bending_x_meas_side_overview. +A closer view on flexible joint is shown in Figure ref:fig:picture_bending_x_meas_side_close and a zoom on the force sensor tip is shown in Figure ref: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 ref: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) +<> +#+end_src + +#+begin_src matlab :exports none :results silent :noweb yes +<> +#+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 ref: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 ref: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 ref:tab:meas_flexible_joints_x_dir for the X direction and in Table ref: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 ref:fig:bending_stiffness_histogram and of the bending stroke in Figure ref: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 ref: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 + * Conclusion <> diff --git a/test-bench-flexible-joints.pdf b/test-bench-flexible-joints.pdf index 34a4f5b..4e5804d 100644 Binary files a/test-bench-flexible-joints.pdf and b/test-bench-flexible-joints.pdf differ diff --git a/test-bench-flexible-joints.tex b/test-bench-flexible-joints.tex index 2e18b5d..522dad3 100644 --- a/test-bench-flexible-joints.tex +++ b/test-bench-flexible-joints.tex @@ -1,4 +1,4 @@ -% Created 2024-03-19 Tue 11:14 +% Created 2024-03-19 Tue 17:35 % Intended LaTeX compiler: pdflatex \documentclass[a4paper, 10pt, DIV=12, parskip=full, bibliography=totoc]{scrreprt} @@ -22,6 +22,18 @@ \tableofcontents \clearpage +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: +\begin{itemize} +\item Section \ref{sec:flexible_joints}: the geometry of the flexible joints and the expected stiffness and stroke are presented +\item Section \ref{sec:flex_dim_meas}: each flexible joint is measured using a profile projector +\item Section \ref{sec:test_bench_desc}: the stiffness measurement bench is presented +\item Section \ref{sec:error_budget}: an error budget is performed in order to estimate the accuracy of the measured stiffness +\item Section \ref{sec:first_measurements}: first measurements are performed +\item Section \ref{sec:bending_stiffness_meas}: the bending stiffness of the flexible joints are measured +\end{itemize} + \begin{table}[htbp] \caption{\label{tab:flexible_joints_section_matlab_code}Report sections and corresponding Matlab files} \centering @@ -33,8 +45,786 @@ Section \ref{sec:flexible_joints}\_ & \texttt{flexible\_joints\_1\_.m}\\ \bottomrule \end{tabularx} \end{table} -\chapter{Mechanical Inspection} -\label{sec:flexible_joints_mechanics} +\chapter{Flexible Joints} +\label{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 \ref{fig:nano_hexapod}). + +\begin{figure}[htbp] +\centering +\includegraphics[scale=1,width=0.7\linewidth]{figs/nano_hexapod.png} +\caption{\label{fig:nano_hexapod}CAD view of the Nano-Hexapod containing the flexible joints} +\end{figure} + +Ideally, these flexible joints would behave as perfect ball joints, that is to say: +\begin{itemize} +\item no bending and torsional stiffnesses +\item infinite shear and axial stiffnesses +\item un-limited bending and torsional stroke +\item no friction, no backlash +\end{itemize} + + +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:flexible_joints_specs}. + +\begin{table}[htbp] +\caption{\label{tab:flexible_joints_specs}Specifications for the flexible joints and estimated characteristics from the Finite Element Model} +\centering +\begin{tabularx}{0.5\linewidth}{Xcc} +\toprule + & \textbf{Specification} & \textbf{FEM}\\ +\midrule +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] & \\ +\bottomrule +\end{tabularx} +\end{table} + +Then, the classical geometry of a flexible ball joint shown in Figure \ref{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 \ref{tab:flexible_joints_specs}. + +\begin{figure}[htbp] +\centering +\includegraphics[scale=1,width=0.5\linewidth]{figs/flexible_joint_fem_geometry.png} +\caption{\label{fig:flexible_joint_fem_geometry}Flexible part of the Joint used for FEM - CAD view} +\end{figure} + +The obtained geometry are defined in the \href{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:received_flex}. + +\begin{figure}[htbp] +\centering +\includegraphics[scale=1,width=\linewidth]{figs/IMG_20210302_173619.jpg} +\caption{\label{fig:received_flex}15 of the 16 flexible joints} +\end{figure} +\chapter{Dimensional Measurements} +\label{sec:flex_dim_meas} +\section{Measurement Bench} + +The axis corresponding to the flexible joints are defined in Figure \ref{fig:flexible_joint_axis}. + +\begin{figure}[htbp] +\centering +\includegraphics[scale=1,width=0.3\linewidth]{figs/flexible_joint_axis.png} +\caption{\label{fig:flexible_joint_axis}Define axis for the flexible joints} +\end{figure} + +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:flexible_joint_y_flex_meas_setup}. + +\begin{figure}[htbp] +\centering +\includegraphics[scale=1,width=1.0\linewidth]{figs/flexible_joint_y_flex_meas_setup.png} +\caption{\label{fig:flexible_joint_y_flex_meas_setup}Setup to measure the dimension of the flexible beam corresponding to the X-bending stiffness} +\end{figure} + +What we typically observe is shown in Figure \ref{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\), + +\begin{figure}[htbp] +\centering +\includegraphics[scale=1,width=1.0\linewidth]{figs/soft_measure_flex_size.jpg} +\caption{\label{fig:soft_measure_flex_size}Image used to measure the flexible joint's dimensions} +\end{figure} +\section{Measurement Results} +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:flex_dim}. + +\begin{table}[htbp] +\caption{\label{tab:flex_dim}Measured Dimensions of the flexible beams in \(\mu m\)} +\centering +\begin{tabularx}{0.4\linewidth}{Xcccc} +\toprule + & Y1 & Y2 & X1 & X2\\ +\midrule +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\\ +\bottomrule +\end{tabularx} +\end{table} + +An histogram of these measured dimensions is shown in Figure \ref{fig:beam_dim_histogram}. + +\begin{figure}[htbp] +\centering +\includegraphics[scale=1]{figs/beam_dim_histogram.png} +\caption{\label{fig:beam_dim_histogram}Histogram for the (16x2) measured beams' thickness} +\end{figure} +\chapter{Measurement Test Bench - Bending Stiffness} +\label{sec:test_bench_desc} +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_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\). + +\begin{figure}[htbp] +\centering +\includegraphics[scale=1]{figs/test_bench_principle.png} +\caption{\label{fig:test_bench_principle}Test Bench - working principle} +\end{figure} + + +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. +\section{Flexible joint Geometry} +The flexible joint used for the Nano-Hexapod is shown in Figure \ref{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\). + +\begin{figure}[htbp] +\centering +\includegraphics[scale=1]{figs/flexible_joint_geometry.png} +\caption{\label{fig:flexible_joint_geometry}Geometry of the flexible joint} +\end{figure} + +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. +\section{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} + +And we obtain: +\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\). +\section{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{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\). +\section{Test Bench} + +A CAD view of the measurement bench is shown in Figure \ref{fig:test_bench_flex_overview}. + +\begin{note} +Here are the different elements used in this bench: +\begin{itemize} +\item \textbf{Translation Stage}: \href{doc/V-408-Datasheet.pdf}{V-408} +\item \textbf{Load Cells}: \href{doc/A700000007147087.pdf}{FC2231-0000-0010-L} +\item \textbf{Encoder}: \href{doc/L-9517-9448-05-B\_Data\_sheet\_RESOLUTE\_BiSS\_en.pdf}{Renishaw Resolute 1nm} +\end{itemize} +\end{note} + +Both the measured force and displacement are acquired at the same time using a Speedgoat machine. + +\begin{figure}[htbp] +\centering +\includegraphics[scale=1,width=0.8\linewidth]{figs/test_bench_flex_overview.png} +\caption{\label{fig:test_bench_flex_overview}Schematic of the test bench to measure the bending stiffness of the flexible joints} +\end{figure} + +A side view of the bench with the important quantities are shown in Figure \ref{fig:test_bench_flex_side}. + +\begin{figure}[htbp] +\centering +\includegraphics[scale=1,width=0.25\linewidth]{figs/test_bench_flex_side.png} +\caption{\label{fig:test_bench_flex_side}Schematic of the test bench to measure the bending stiffness of the flexible joints} +\end{figure} +\chapter{Error budget} +\label{sec:error_budget} +Many things can impact the accuracy of the measured bending stiffness such as: +\begin{itemize} +\item Errors in the force and displacement measurement +\item Shear effects +\item Deflection of the Force sensor +\item Errors in the geometry of the bench +\end{itemize} + +In this section, we wish to estimate the attainable accuracy with the current bench, and identified the limiting factors. +\section{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:axial_shear_characteristics} and \ref{tab:bending_torsion_characteristics}. + +\begin{table}[htbp] +\caption{\label{tab:axial_shear_characteristics}Axial/Shear characteristics} +\centering +\begin{tabularx}{0.6\linewidth}{Xccc} +\toprule + & Stiffness [N/um] & Max Force [N] & Stroke [um]\\ +\midrule +Axial & 94 & 469 & 5\\ +Shear & 13 & 242 & 19\\ +\bottomrule +\end{tabularx} +\end{table} + +\begin{table}[htbp] +\caption{\label{tab:bending_torsion_characteristics}Bending/Torsion characteristics} +\centering +\begin{tabularx}{0.7\linewidth}{Xccc} +\toprule + & Stiffness [Nm/rad] & Max Torque [Nmm] & Stroke [mrad]\\ +\midrule +Bending & 5 & 118 & 24\\ +Torsional & 260 & 1508 & 6\\ +\bottomrule +\end{tabularx} +\end{table} +\section{Setup} + +The setup is schematically represented in Figure \ref{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{figure}[htbp] +\centering +\includegraphics[scale=1,width=0.25\linewidth]{figs/test_bench_flex_side.png} +\caption{\label{fig:test_bench_flex_side_bis}Schematic of the test bench to measure the bending stiffness of the flexible joints} +\end{figure} +\section{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} +\section{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: +\begin{itemize} +\item precisely measure the motion \(d_x\) +\item precisely measure the applied force \(F_x\) +\item precisely now the height of the force application point \(h\) +\end{itemize} +\section{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\%. +\section{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{verbatim} +The measurement error due to Shear is 0.1 % +\end{verbatim} +\section{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{verbatim} +k_F = 1.0e+06 [N/m] +\end{verbatim} + + +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{verbatim} +The measurement error due to height estimation errors is 0.8 % +\end{verbatim} +\section{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{verbatim} +The measurement error due to height estimation errors of 0.2 [mm] is 1.6 % +\end{verbatim} +\section{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. +\chapter{First Measurements} +\label{sec:first_measurements} +\begin{itemize} +\item Section \ref{sec:test_meas_probe}: +\item Section \ref{sec:meas_probe_stiffness}: +\end{itemize} +\section{Agreement between the probe and the encoder} +\label{sec:test_meas_probe} +\begin{note} +\begin{itemize} +\item \textbf{Encoder}: \href{doc/L-9517-9448-05-B\_Data\_sheet\_RESOLUTE\_BiSS\_en.pdf}{Renishaw Resolute 1nm} +\item \textbf{Displacement Probe}: \href{doc/Millimar--3723046--BA--C1208-C1216-C1240--FR--2016-11-08.pdf}{Millimar C1216 electronics} and \href{doc/tmp3m0cvmue\_7888038c-cdc8-48d8-a837-35de02760685.pdf}{Millimar 1318 probe} +\end{itemize} +\end{note} + +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. + +Let's load the measurements. +The time domain measured displacement by the probe and by the encoder is shown in Figure \ref{fig:comp_encoder_probe_time}. + +\begin{figure}[htbp] +\centering +\includegraphics[scale=1]{figs/comp_encoder_probe_time.png} +\caption{\label{fig:comp_encoder_probe_time}Time domain measurement} +\end{figure} + +If we zoom, we see that there is some delay between the encoder and the probe (Figure \ref{fig:comp_encoder_probe_time_zoom}). + +\begin{figure}[htbp] +\centering +\includegraphics[scale=1]{figs/comp_encoder_probe_time_zoom.png} +\caption{\label{fig:comp_encoder_probe_time_zoom}Time domain measurement (Zoom)} +\end{figure} + +This delay is estimated using the \texttt{finddelay} command. + +\begin{verbatim} +The time delay is approximately 15.8 [ms] +\end{verbatim} + + +The measured mismatch between the encoder and the probe with and without compensating for the time delay are shown in Figure \ref{fig:comp_encoder_probe_mismatch}. + +\begin{figure}[htbp] +\centering +\includegraphics[scale=1]{figs/comp_encoder_probe_mismatch.png} +\caption{\label{fig:comp_encoder_probe_mismatch}Measurement mismatch, with and without delay compensation} +\end{figure} + +Finally, the displacement of the probe is shown as a function of the displacement of the encoder and a linear fit is made (Figure \ref{fig:comp_encoder_probe_linear_fit}). + +\begin{figure}[htbp] +\centering +\includegraphics[scale=1]{figs/comp_encoder_probe_linear_fit.png} +\caption{\label{fig:comp_encoder_probe_linear_fit}Measured displacement by the probe as a function of the measured displacement by the encoder} +\end{figure} + +\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} +\section{Measurement of the Millimar 1318 probe stiffness} +\label{sec:meas_probe_stiffness} + +\begin{note} +\begin{itemize} +\item \textbf{Translation Stage}: \href{doc/V-408-Datasheet.pdf}{V-408} +\item \textbf{Load Cell}: \href{doc/A700000007147087.pdf}{FC2231-0000-0010-L} +\item \textbf{Encoder}: \href{doc/L-9517-9448-05-B\_Data\_sheet\_RESOLUTE\_BiSS\_en.pdf}{Renishaw Resolute 1nm} +\item \textbf{Displacement Probe}: \href{doc/Millimar--3723046--BA--C1208-C1216-C1240--FR--2016-11-08.pdf}{Millimar C1216 electronics} and \href{doc/tmp3m0cvmue\_7888038c-cdc8-48d8-a837-35de02760685.pdf}{Millimar 1318 probe} +\end{itemize} +\end{note} + +\begin{figure}[htbp] +\centering +\includegraphics[scale=1,width=\linewidth]{figs/setup_mahr_stiff_meas_side.jpg} +\caption{\label{fig:setup_mahr_stiff_meas_side}Setup - Side View} +\end{figure} + +\begin{figure}[htbp] +\centering +\includegraphics[scale=1,width=\linewidth]{figs/setup_mahr_stiff_meas_top.jpg} +\caption{\label{fig:setup_mahr_stiff_meas_top}Setup - Top View} +\end{figure} + +Let's load the measurement results. +The time domain measured force and displacement are shown in Figure \ref{fig:mahr_time_domain}. + +\begin{figure}[htbp] +\centering +\includegraphics[scale=1]{figs/mahr_time_domain.png} +\caption{\label{fig:mahr_time_domain}Time domain measurements} +\end{figure} + + +Now we can estimate the stiffness with a linear fit. + +This is very close to the 0.04 [N/mm] written in the \href{doc/tmp3m0cvmue\_7888038c-cdc8-48d8-a837-35de02760685.pdf}{Millimar 1318 probe datasheet}. + +And compare the linear fit with the raw measurement data (Figure \ref{fig:mahr_stiffness_f_d_plot}). + +\begin{figure}[htbp] +\centering +\includegraphics[scale=1]{figs/mahr_stiffness_f_d_plot.png} +\caption{\label{fig:mahr_stiffness_f_d_plot}Measured displacement as a function of the measured force. Raw data and linear fit} +\end{figure} + +\begin{summary} +The Millimar 1318 probe has a stiffness of \(\approx 0.04\,[N/mm]\). +\end{summary} +\section{Force Sensor Calibration} +\begin{note} +\textbf{Load Cells}: +\begin{itemize} +\item \href{doc/A700000007147087.pdf}{FC2231-0000-0010-L} +\item \href{doc/FRE\_DS\_XFL212R\_FR\_A3.pdf}{XFL212R} +\end{itemize} +\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:force_sensor_calibration_setup}. + +\begin{figure}[htbp] +\centering +\includegraphics[scale=1,width=0.8\linewidth]{figs/IMG_20210309_145333.jpg} +\caption{\label{fig:force_sensor_calibration_setup}Zoom on the two force sensors in contact} +\end{figure} + +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. +We remove any offset such that they are both measuring no force when not in contact. +\begin{figure}[htbp] +\centering +\includegraphics[scale=1]{figs/force_calibration_time.png} +\caption{\label{fig:force_calibration_time}Measured force using both sensors as a function of time} +\end{figure} + +Let's select only the first part from the moment they are in contact until the maximum force is reached. + +Then, let's make a linear fit between the two measured forces. + +The two forces are plotted against each other as well as the linear fit in Figure \ref{fig:calibrated_force_dit}. + +\begin{figure}[htbp] +\centering +\includegraphics[scale=1]{figs/calibrated_force_dit.png} +\caption{\label{fig:calibrated_force_dit}Measured two forces and linear fit} +\end{figure} + +The measurement error between the two sensors is shown in Figure \ref{fig:force_meas_error}. +It is below 0.1N for the full measurement range. + +\begin{figure}[htbp] +\centering +\includegraphics[scale=1]{figs/force_meas_error.png} +\caption{\label{fig:force_meas_error}Error in Newtons} +\end{figure} + +The same error is shown in percentage in Figure \ref{fig:force_meas_error_percentage}. +The error is less than 1\% when the measured force is above 5N. + +\begin{figure}[htbp] +\centering +\includegraphics[scale=1]{figs/force_meas_error_percentage.png} +\caption{\label{fig:force_meas_error_percentage}Error in percentage} +\end{figure} +\section{Force Sensor Noise} +The objective of this measurement is to estimate the noise of the force sensor \href{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. + +Let's load the measurement data. + +The measured force is shown in Figure \ref{fig:force_noise_time}. + +\begin{figure}[htbp] +\centering +\includegraphics[scale=1]{figs/force_noise_time.png} +\caption{\label{fig:force_noise_time}Measured force} +\end{figure} + +Let's now compute the Amplitude Spectral Density of the measured force. + +The results is shown in Figure \ref{fig:force_noise_asd}. + +\begin{figure}[htbp] +\centering +\includegraphics[scale=1]{figs/force_noise_asd.png} +\caption{\label{fig:force_noise_asd}Amplitude Spectral Density of the meaured force} +\end{figure} +\section{Force Sensor Stiffness} +The objective of this measurement is to estimate the stiffness of the force sensor \href{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: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. + +\begin{figure}[htbp] +\centering +\includegraphics[scale=1,width=0.6\linewidth]{figs/IMG_20210309_145242.jpg} +\caption{\label{fig:setup_meas_force_sensor_stiffness}Bench used to measured the stiffness of the force sensor} +\end{figure} + +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. +Some pre-processing is applied on the data. +The linear fit is performed. +The displacement as a function of the force as well as the linear fit are shown in Figure \ref{fig:force_sensor_stiffness_fit}. +\begin{figure}[htbp] +\centering +\includegraphics[scale=1]{figs/force_sensor_stiffness_fit.png} +\caption{\label{fig:force_sensor_stiffness_fit}Displacement as a function of the measured force} +\end{figure} + +And we obtain the following stiffness: +\begin{verbatim} +k = 0.76 [N/um] +\end{verbatim} +\chapter{Bending Stiffness Measurement} +\label{sec:bending_stiffness_meas} +\section{Introduction} + +A picture of the bench used to measure the X-bending stiffness of the flexible joints is shown in Figure \ref{fig:picture_bending_x_meas_side_overview}. +A closer view on flexible joint is shown in Figure \ref{fig:picture_bending_x_meas_side_close} and a zoom on the force sensor tip is shown in Figure \ref{fig:picture_bending_x_meas_side_zoom}. + +\begin{figure}[htbp] +\centering +\includegraphics[scale=1,width=\linewidth]{figs/picture_bending_x_meas_side_overview.jpg} +\caption{\label{fig:picture_bending_x_meas_side_overview}Side view of the flexible joint stiffness bench. X-Bending stiffness is measured.} +\end{figure} + +\begin{figure}[htbp] +\centering +\includegraphics[scale=1,width=\linewidth]{figs/picture_bending_x_meas_side_close.jpg} +\caption{\label{fig:picture_bending_x_meas_side_close}Zoom on the flexible joint - Side view} +\end{figure} + + +\begin{figure}[htbp] +\centering +\includegraphics[scale=1,width=0.4\linewidth]{figs/picture_bending_x_meas_side_zoom.jpg} +\caption{\label{fig:picture_bending_x_meas_side_zoom}Zoom on the tip of the force sensor} +\end{figure} + +The same bench used to measure the Y-bending stiffness of the flexible joint is shown in Figure \ref{fig:picture_bending_y_meas_side_close}. + +\begin{figure}[htbp] +\centering +\includegraphics[scale=1,width=\linewidth]{figs/picture_bending_y_meas_side_close.jpg} +\caption{\label{fig:picture_bending_y_meas_side_close}Stiffness measurement bench - Y-d bending measurement} +\end{figure} +\section{Analysis of one measurement} + +In this section is shown how the data are analysis in order to measured: +\begin{itemize} +\item the bending stiffness +\item the bending stroke +\item the stiffness once the mechanical stops are in contact +\end{itemize} + + +The height from the flexible joint's center and the point of application force \(h\) is defined below: +The obtained time domain measurements are shown in Figure \ref{fig:flex_joint_meas_example_time_domain}. + +\begin{figure}[htbp] +\centering +\includegraphics[scale=1]{figs/flex_joint_meas_example_time_domain.png} +\caption{\label{fig:flex_joint_meas_example_time_domain}Typical time domain measurements} +\end{figure} + +The displacement as a function of the force is then shown in Figure \ref{fig:flex_joint_meas_example_F_d}. + +\begin{figure}[htbp] +\centering +\includegraphics[scale=1]{figs/flex_joint_meas_example_F_d.png} +\caption{\label{fig:flex_joint_meas_example_F_d}Typical measurement of the diplacement as a function of the applied force} +\end{figure} + +The bending stiffness can be estimated by computing the slope of the curve in Figure \ref{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. + +The raw data as well as the fit corresponding to the two stiffnesses are shown in Figure \ref{fig:flex_joint_meas_example_F_d_lin_fit}. + +\begin{figure}[htbp] +\centering +\includegraphics[scale=1]{figs/flex_joint_meas_example_F_d_lin_fit.png} +\caption{\label{fig:flex_joint_meas_example_F_d_lin_fit}Typical measurement of the diplacement as a function of the applied force with estimated linear fits} +\end{figure} + +Then, the bending stroke is estimated as crossing point between the two fitted lines: +The obtained characteristics are summarized in Table \ref{tab:obtained_caracteristics_flex_1_x}. + +\begin{table}[htbp] +\caption{\label{tab:obtained_caracteristics_flex_1_x}Estimated characteristics of the flexible joint number 1 for the X-direction} +\centering +\begin{tabularx}{0.5\linewidth}{lc} +\toprule +Bending Stiffness [Nm/rad] & 5.5\\ +Bending Stiffness @ stop [Nm/rad] & 173.6\\ +Bending Stroke [mrad] & 18.9\\ +\bottomrule +\end{tabularx} +\end{table} +\section{Bending stiffness and bending stroke of all the flexible joints} + +Now, let's estimate the bending stiffness and stroke for all the flexible joints. + +The results are summarized in Table \ref{tab:meas_flexible_joints_x_dir} for the X direction and in Table \ref{tab:meas_flexible_joints_y_dir} for the Y direction. + +\begin{table}[htbp] +\caption{\label{tab:meas_flexible_joints_x_dir}Measured characteristics of the flexible joints in the X direction} +\centering +\begin{tabularx}{0.6\linewidth}{cccc} +\toprule + & \(R_{R_x}\) {[}Nm/rad] & \(k_{R_x,s}\) {[}Nm/rad] & \(R_{x,\text{max}}\) {[}mrad]\\ +\midrule +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\\ +\bottomrule +\end{tabularx} +\end{table} + +\begin{table}[htbp] +\caption{\label{tab:meas_flexible_joints_y_dir}Measured characteristics of the flexible joints in the Y direction} +\centering +\begin{tabularx}{0.6\linewidth}{cccc} +\toprule + & \(R_{R_y}\) {[}Nm/rad] & \(k_{R_y,s}\) {[}Nm/rad] & \(R_{y,\text{may}}\) {[}mrad]\\ +\midrule +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\\ +\bottomrule +\end{tabularx} +\end{table} +\section{Analysis} +The dispersion of the measured bending stiffness is shown in Figure \ref{fig:bending_stiffness_histogram} and of the bending stroke in Figure \ref{fig:bending_stroke_histogram}. + +\begin{figure}[htbp] +\centering +\includegraphics[scale=1]{figs/bending_stiffness_histogram.png} +\caption{\label{fig:bending_stiffness_histogram}Histogram of the measured bending stiffness} +\end{figure} + +\begin{figure}[htbp] +\centering +\includegraphics[scale=1]{figs/bending_stroke_histogram.png} +\caption{\label{fig:bending_stroke_histogram}Histogram of the measured bending stroke} +\end{figure} + +The relation between the measured beam thickness and the measured bending stiffness is shown in Figure \ref{fig:flex_thickness_vs_bending_stiff}. + +\begin{figure}[htbp] +\centering +\includegraphics[scale=1]{figs/flex_thickness_vs_bending_stiff.png} +\caption{\label{fig:flex_thickness_vs_bending_stiff}Measured bending stiffness as a function of the estimated flexible beam thickness} +\end{figure} +\section{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} \chapter{Conclusion} \label{sec:flexible_joints_conclusion} \printbibliography[heading=bibintoc,title={Bibliography}]