diff --git a/figs/detail_kinematics_centralized_control.pdf b/figs/detail_kinematics_centralized_control.pdf new file mode 100644 index 0000000..1a2c9f5 Binary files /dev/null and b/figs/detail_kinematics_centralized_control.pdf differ diff --git a/figs/detail_kinematics_centralized_control.png b/figs/detail_kinematics_centralized_control.png new file mode 100644 index 0000000..8fc133e Binary files /dev/null and b/figs/detail_kinematics_centralized_control.png differ diff --git a/figs/detail_kinematics_centralized_control.svg b/figs/detail_kinematics_centralized_control.svg new file mode 100644 index 0000000..b301bba --- /dev/null +++ b/figs/detail_kinematics_centralized_control.svg @@ -0,0 +1,167 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/figs/detail_kinematics_cubic_above_large.pdf b/figs/detail_kinematics_cubic_above_large.pdf new file mode 100644 index 0000000..e4f1ea7 Binary files /dev/null and b/figs/detail_kinematics_cubic_above_large.pdf differ diff --git a/figs/detail_kinematics_cubic_above_large.png b/figs/detail_kinematics_cubic_above_large.png new file mode 100644 index 0000000..5e3a222 Binary files /dev/null and b/figs/detail_kinematics_cubic_above_large.png differ diff --git a/figs/detail_kinematics_cubic_above_large_iso.pdf b/figs/detail_kinematics_cubic_above_large_iso.pdf new file mode 100644 index 0000000..50bfeb2 Binary files /dev/null and b/figs/detail_kinematics_cubic_above_large_iso.pdf differ diff --git a/figs/detail_kinematics_cubic_above_large_iso.png b/figs/detail_kinematics_cubic_above_large_iso.png new file mode 100644 index 0000000..3a4359e Binary files /dev/null and b/figs/detail_kinematics_cubic_above_large_iso.png differ diff --git a/figs/detail_kinematics_cubic_above_large_side.pdf b/figs/detail_kinematics_cubic_above_large_side.pdf new file mode 100644 index 0000000..eb7271d Binary files /dev/null and b/figs/detail_kinematics_cubic_above_large_side.pdf differ diff --git a/figs/detail_kinematics_cubic_above_large_side.png b/figs/detail_kinematics_cubic_above_large_side.png new file mode 100644 index 0000000..ec5d7d1 Binary files /dev/null and b/figs/detail_kinematics_cubic_above_large_side.png differ diff --git a/figs/detail_kinematics_cubic_above_large_top.pdf b/figs/detail_kinematics_cubic_above_large_top.pdf new file mode 100644 index 0000000..b548239 Binary files /dev/null and b/figs/detail_kinematics_cubic_above_large_top.pdf differ diff --git a/figs/detail_kinematics_cubic_above_large_top.png b/figs/detail_kinematics_cubic_above_large_top.png new file mode 100644 index 0000000..5a7e322 Binary files /dev/null and b/figs/detail_kinematics_cubic_above_large_top.png differ diff --git a/figs/detail_kinematics_cubic_above_medium.pdf b/figs/detail_kinematics_cubic_above_medium.pdf new file mode 100644 index 0000000..ca87b8e Binary files /dev/null and b/figs/detail_kinematics_cubic_above_medium.pdf differ diff --git a/figs/detail_kinematics_cubic_above_medium.png b/figs/detail_kinematics_cubic_above_medium.png new file mode 100644 index 0000000..659b8fc Binary files /dev/null and b/figs/detail_kinematics_cubic_above_medium.png differ diff --git a/figs/detail_kinematics_cubic_above_medium_iso.pdf b/figs/detail_kinematics_cubic_above_medium_iso.pdf new file mode 100644 index 0000000..4198116 Binary files /dev/null and b/figs/detail_kinematics_cubic_above_medium_iso.pdf differ diff --git a/figs/detail_kinematics_cubic_above_medium_iso.png b/figs/detail_kinematics_cubic_above_medium_iso.png new file mode 100644 index 0000000..1ef7810 Binary files /dev/null and b/figs/detail_kinematics_cubic_above_medium_iso.png differ diff --git a/figs/detail_kinematics_cubic_above_medium_side.pdf b/figs/detail_kinematics_cubic_above_medium_side.pdf new file mode 100644 index 0000000..db07b40 Binary files /dev/null and b/figs/detail_kinematics_cubic_above_medium_side.pdf differ diff --git a/figs/detail_kinematics_cubic_above_medium_side.png b/figs/detail_kinematics_cubic_above_medium_side.png new file mode 100644 index 0000000..f2bda0b Binary files /dev/null and b/figs/detail_kinematics_cubic_above_medium_side.png differ diff --git a/figs/detail_kinematics_cubic_above_medium_top.pdf b/figs/detail_kinematics_cubic_above_medium_top.pdf new file mode 100644 index 0000000..de4a32e Binary files /dev/null and b/figs/detail_kinematics_cubic_above_medium_top.pdf differ diff --git a/figs/detail_kinematics_cubic_above_medium_top.png b/figs/detail_kinematics_cubic_above_medium_top.png new file mode 100644 index 0000000..2e9887c Binary files /dev/null and b/figs/detail_kinematics_cubic_above_medium_top.png differ diff --git a/figs/detail_kinematics_cubic_above_small.pdf b/figs/detail_kinematics_cubic_above_small.pdf new file mode 100644 index 0000000..7880306 Binary files /dev/null and b/figs/detail_kinematics_cubic_above_small.pdf differ diff --git a/figs/detail_kinematics_cubic_above_small.png b/figs/detail_kinematics_cubic_above_small.png new file mode 100644 index 0000000..aed58ab Binary files /dev/null and b/figs/detail_kinematics_cubic_above_small.png differ diff --git a/figs/detail_kinematics_cubic_above_small_iso.pdf b/figs/detail_kinematics_cubic_above_small_iso.pdf new file mode 100644 index 0000000..6881fb8 Binary files /dev/null and b/figs/detail_kinematics_cubic_above_small_iso.pdf differ diff --git a/figs/detail_kinematics_cubic_above_small_iso.png b/figs/detail_kinematics_cubic_above_small_iso.png new file mode 100644 index 0000000..e8db783 Binary files /dev/null and b/figs/detail_kinematics_cubic_above_small_iso.png differ diff --git a/figs/detail_kinematics_cubic_above_small_side.pdf b/figs/detail_kinematics_cubic_above_small_side.pdf new file mode 100644 index 0000000..fbb9c73 Binary files /dev/null and b/figs/detail_kinematics_cubic_above_small_side.pdf differ diff --git a/figs/detail_kinematics_cubic_above_small_side.png b/figs/detail_kinematics_cubic_above_small_side.png new file mode 100644 index 0000000..f82b719 Binary files /dev/null and b/figs/detail_kinematics_cubic_above_small_side.png differ diff --git a/figs/detail_kinematics_cubic_above_small_top.pdf b/figs/detail_kinematics_cubic_above_small_top.pdf new file mode 100644 index 0000000..3c11cee Binary files /dev/null and b/figs/detail_kinematics_cubic_above_small_top.pdf differ diff --git a/figs/detail_kinematics_cubic_above_small_top.png b/figs/detail_kinematics_cubic_above_small_top.png new file mode 100644 index 0000000..0fcd528 Binary files /dev/null and b/figs/detail_kinematics_cubic_above_small_top.png differ diff --git a/figs/detail_kinematics_cubic_architecture_example.pdf b/figs/detail_kinematics_cubic_architecture_example.pdf new file mode 100644 index 0000000..bf1a4f9 Binary files /dev/null and b/figs/detail_kinematics_cubic_architecture_example.pdf differ diff --git a/figs/detail_kinematics_cubic_architecture_example.png b/figs/detail_kinematics_cubic_architecture_example.png new file mode 100644 index 0000000..7a5183c Binary files /dev/null and b/figs/detail_kinematics_cubic_architecture_example.png differ diff --git a/figs/detail_kinematics_cubic_architecture_example_small.pdf b/figs/detail_kinematics_cubic_architecture_example_small.pdf new file mode 100644 index 0000000..4ceb86a Binary files /dev/null and b/figs/detail_kinematics_cubic_architecture_example_small.pdf differ diff --git a/figs/detail_kinematics_cubic_architecture_example_small.png b/figs/detail_kinematics_cubic_architecture_example_small.png new file mode 100644 index 0000000..211b4d0 Binary files /dev/null and b/figs/detail_kinematics_cubic_architecture_example_small.png differ diff --git a/figs/detail_kinematics_cubic_cart_coupling_cok.pdf b/figs/detail_kinematics_cubic_cart_coupling_cok.pdf new file mode 100644 index 0000000..186e2c6 Binary files /dev/null and b/figs/detail_kinematics_cubic_cart_coupling_cok.pdf differ diff --git a/figs/detail_kinematics_cubic_cart_coupling_cok.png b/figs/detail_kinematics_cubic_cart_coupling_cok.png new file mode 100644 index 0000000..7afb5b6 Binary files /dev/null and b/figs/detail_kinematics_cubic_cart_coupling_cok.png differ diff --git a/figs/detail_kinematics_cubic_cart_coupling_com.pdf b/figs/detail_kinematics_cubic_cart_coupling_com.pdf new file mode 100644 index 0000000..383fc9c Binary files /dev/null and b/figs/detail_kinematics_cubic_cart_coupling_com.pdf differ diff --git a/figs/detail_kinematics_cubic_cart_coupling_com.png b/figs/detail_kinematics_cubic_cart_coupling_com.png new file mode 100644 index 0000000..4a3f93c Binary files /dev/null and b/figs/detail_kinematics_cubic_cart_coupling_com.png differ diff --git a/figs/detail_kinematics_cubic_cart_coupling_com_cok.pdf b/figs/detail_kinematics_cubic_cart_coupling_com_cok.pdf new file mode 100644 index 0000000..9c1c9e1 Binary files /dev/null and b/figs/detail_kinematics_cubic_cart_coupling_com_cok.pdf differ diff --git a/figs/detail_kinematics_cubic_cart_coupling_com_cok.png b/figs/detail_kinematics_cubic_cart_coupling_com_cok.png new file mode 100644 index 0000000..de990e1 Binary files /dev/null and b/figs/detail_kinematics_cubic_cart_coupling_com_cok.png differ diff --git a/figs/detail_kinematics_cubic_centered_payload.pdf b/figs/detail_kinematics_cubic_centered_payload.pdf new file mode 100644 index 0000000..494dd87 Binary files /dev/null and b/figs/detail_kinematics_cubic_centered_payload.pdf differ diff --git a/figs/detail_kinematics_cubic_centered_payload.png b/figs/detail_kinematics_cubic_centered_payload.png new file mode 100644 index 0000000..0409158 Binary files /dev/null and b/figs/detail_kinematics_cubic_centered_payload.png differ diff --git a/figs/detail_kinematics_cubic_decentralized_dL.pdf b/figs/detail_kinematics_cubic_decentralized_dL.pdf new file mode 100644 index 0000000..6040163 Binary files /dev/null and b/figs/detail_kinematics_cubic_decentralized_dL.pdf differ diff --git a/figs/detail_kinematics_cubic_decentralized_dL.png b/figs/detail_kinematics_cubic_decentralized_dL.png new file mode 100644 index 0000000..b6c14e5 Binary files /dev/null and b/figs/detail_kinematics_cubic_decentralized_dL.png differ diff --git a/figs/detail_kinematics_cubic_decentralized_fn.pdf b/figs/detail_kinematics_cubic_decentralized_fn.pdf new file mode 100644 index 0000000..5b545a8 Binary files /dev/null and b/figs/detail_kinematics_cubic_decentralized_fn.pdf differ diff --git a/figs/detail_kinematics_cubic_decentralized_fn.png b/figs/detail_kinematics_cubic_decentralized_fn.png new file mode 100644 index 0000000..211fb9c Binary files /dev/null and b/figs/detail_kinematics_cubic_decentralized_fn.png differ diff --git a/figs/detail_kinematics_cubic_mobility_rotations.pdf b/figs/detail_kinematics_cubic_mobility_rotations.pdf new file mode 100644 index 0000000..3fc1bd0 Binary files /dev/null and b/figs/detail_kinematics_cubic_mobility_rotations.pdf differ diff --git a/figs/detail_kinematics_cubic_mobility_rotations.png b/figs/detail_kinematics_cubic_mobility_rotations.png new file mode 100644 index 0000000..e22d8c3 Binary files /dev/null and b/figs/detail_kinematics_cubic_mobility_rotations.png differ diff --git a/figs/detail_kinematics_cubic_mobility_translations.pdf b/figs/detail_kinematics_cubic_mobility_translations.pdf new file mode 100644 index 0000000..138e254 Binary files /dev/null and b/figs/detail_kinematics_cubic_mobility_translations.pdf differ diff --git a/figs/detail_kinematics_cubic_mobility_translations.png b/figs/detail_kinematics_cubic_mobility_translations.png new file mode 100644 index 0000000..c0cfb5f Binary files /dev/null and b/figs/detail_kinematics_cubic_mobility_translations.png differ diff --git a/figs/detail_kinematics_cubic_payload.pdf b/figs/detail_kinematics_cubic_payload.pdf new file mode 100644 index 0000000..c797311 Binary files /dev/null and b/figs/detail_kinematics_cubic_payload.pdf differ diff --git a/figs/detail_kinematics_cubic_payload.png b/figs/detail_kinematics_cubic_payload.png new file mode 100644 index 0000000..975fa3c Binary files /dev/null and b/figs/detail_kinematics_cubic_payload.png differ diff --git a/figs/detail_kinematics_cubic_schematic.pdf b/figs/detail_kinematics_cubic_schematic.pdf new file mode 100644 index 0000000..4fa0570 Binary files /dev/null and b/figs/detail_kinematics_cubic_schematic.pdf differ diff --git a/figs/detail_kinematics_cubic_schematic.png b/figs/detail_kinematics_cubic_schematic.png new file mode 100644 index 0000000..8381eaf Binary files /dev/null and b/figs/detail_kinematics_cubic_schematic.png differ diff --git a/figs/detail_kinematics_cubic_schematic.svg b/figs/detail_kinematics_cubic_schematic.svg new file mode 100644 index 0000000..6143885 --- /dev/null +++ b/figs/detail_kinematics_cubic_schematic.svg @@ -0,0 +1,233 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/figs/detail_kinematics_cubic_schematic_full.pdf b/figs/detail_kinematics_cubic_schematic_full.pdf new file mode 100644 index 0000000..6f427ea Binary files /dev/null and b/figs/detail_kinematics_cubic_schematic_full.pdf differ diff --git a/figs/detail_kinematics_cubic_schematic_full.png b/figs/detail_kinematics_cubic_schematic_full.png new file mode 100644 index 0000000..1980e43 Binary files /dev/null and b/figs/detail_kinematics_cubic_schematic_full.png differ diff --git a/figs/detail_kinematics_cubic_schematic_full.svg b/figs/detail_kinematics_cubic_schematic_full.svg new file mode 100644 index 0000000..6f0108d --- /dev/null +++ b/figs/detail_kinematics_cubic_schematic_full.svg @@ -0,0 +1,327 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/figs/detail_kinematics_cubic_schematic_off_centered.pdf b/figs/detail_kinematics_cubic_schematic_off_centered.pdf new file mode 100644 index 0000000..1d1a60a Binary files /dev/null and b/figs/detail_kinematics_cubic_schematic_off_centered.pdf differ diff --git a/figs/detail_kinematics_cubic_schematic_off_centered.png b/figs/detail_kinematics_cubic_schematic_off_centered.png new file mode 100644 index 0000000..2e8008e Binary files /dev/null and b/figs/detail_kinematics_cubic_schematic_off_centered.png differ diff --git a/figs/detail_kinematics_cubic_schematic_off_centered.svg b/figs/detail_kinematics_cubic_schematic_off_centered.svg new file mode 100644 index 0000000..ebdaf97 --- /dev/null +++ b/figs/detail_kinematics_cubic_schematic_off_centered.svg @@ -0,0 +1,146 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/figs/detail_kinematics_decentralized_control.pdf b/figs/detail_kinematics_decentralized_control.pdf new file mode 100644 index 0000000..646edea Binary files /dev/null and b/figs/detail_kinematics_decentralized_control.pdf differ diff --git a/figs/detail_kinematics_decentralized_control.png b/figs/detail_kinematics_decentralized_control.png new file mode 100644 index 0000000..999d34e Binary files /dev/null and b/figs/detail_kinematics_decentralized_control.png differ diff --git a/figs/detail_kinematics_decentralized_control.svg b/figs/detail_kinematics_decentralized_control.svg new file mode 100644 index 0000000..a6e84d1 --- /dev/null +++ b/figs/detail_kinematics_decentralized_control.svg @@ -0,0 +1,109 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/figs/detail_kinematics_mobility_angle_strut_distance.pdf b/figs/detail_kinematics_mobility_angle_strut_distance.pdf index 22d4ff8..1ff9ff8 100644 Binary files a/figs/detail_kinematics_mobility_angle_strut_distance.pdf and b/figs/detail_kinematics_mobility_angle_strut_distance.pdf differ diff --git a/figs/detail_kinematics_mobility_trans_result.pdf b/figs/detail_kinematics_mobility_trans_result.pdf index b09d064..77339b2 100644 Binary files a/figs/detail_kinematics_mobility_trans_result.pdf and b/figs/detail_kinematics_mobility_trans_result.pdf differ diff --git a/figs/detail_kinematics_mobility_translation_strut_orientation.pdf b/figs/detail_kinematics_mobility_translation_strut_orientation.pdf index ce8ead6..9e3c7da 100644 Binary files a/figs/detail_kinematics_mobility_translation_strut_orientation.pdf and b/figs/detail_kinematics_mobility_translation_strut_orientation.pdf differ diff --git a/figs/detail_kinematics_mobility_translation_strut_orientation.png b/figs/detail_kinematics_mobility_translation_strut_orientation.png index 0f9d761..7ae788e 100644 Binary files a/figs/detail_kinematics_mobility_translation_strut_orientation.png and b/figs/detail_kinematics_mobility_translation_strut_orientation.png differ diff --git a/figs/detail_kinematics_non_cubic_decentralized_dL.pdf b/figs/detail_kinematics_non_cubic_decentralized_dL.pdf new file mode 100644 index 0000000..e7a21a0 Binary files /dev/null and b/figs/detail_kinematics_non_cubic_decentralized_dL.pdf differ diff --git a/figs/detail_kinematics_non_cubic_decentralized_dL.png b/figs/detail_kinematics_non_cubic_decentralized_dL.png new file mode 100644 index 0000000..bbf077a Binary files /dev/null and b/figs/detail_kinematics_non_cubic_decentralized_dL.png differ diff --git a/figs/detail_kinematics_non_cubic_decentralized_fn.pdf b/figs/detail_kinematics_non_cubic_decentralized_fn.pdf new file mode 100644 index 0000000..45e8e3a Binary files /dev/null and b/figs/detail_kinematics_non_cubic_decentralized_fn.pdf differ diff --git a/figs/detail_kinematics_non_cubic_decentralized_fn.png b/figs/detail_kinematics_non_cubic_decentralized_fn.png new file mode 100644 index 0000000..b204328 Binary files /dev/null and b/figs/detail_kinematics_non_cubic_decentralized_fn.png differ diff --git a/figs/detail_kinematics_non_cubic_payload.pdf b/figs/detail_kinematics_non_cubic_payload.pdf new file mode 100644 index 0000000..0b1d98a Binary files /dev/null and b/figs/detail_kinematics_non_cubic_payload.pdf differ diff --git a/figs/detail_kinematics_non_cubic_payload.png b/figs/detail_kinematics_non_cubic_payload.png new file mode 100644 index 0000000..d6f6c63 Binary files /dev/null and b/figs/detail_kinematics_non_cubic_payload.png differ diff --git a/figs/examples/detail_kinematics_beijen.jpg b/figs/examples/detail_kinematics_beijen.jpg new file mode 100644 index 0000000..151052d Binary files /dev/null and b/figs/examples/detail_kinematics_beijen.jpg differ diff --git a/figs/examples/detail_kinematics_cleary.jpg b/figs/examples/detail_kinematics_cleary.jpg new file mode 100644 index 0000000..2748571 Binary files /dev/null and b/figs/examples/detail_kinematics_cleary.jpg differ diff --git a/figs/examples/detail_kinematics_czech.jpg b/figs/examples/detail_kinematics_czech.jpg new file mode 100644 index 0000000..350732d Binary files /dev/null and b/figs/examples/detail_kinematics_czech.jpg differ diff --git a/figs/examples/detail_kinematics_dong07.jpg b/figs/examples/detail_kinematics_dong07.jpg new file mode 100644 index 0000000..6297139 Binary files /dev/null and b/figs/examples/detail_kinematics_dong07.jpg differ diff --git a/figs/examples/detail_kinematics_du14.jpg b/figs/examples/detail_kinematics_du14.jpg new file mode 100644 index 0000000..9f452df Binary files /dev/null and b/figs/examples/detail_kinematics_du14.jpg differ diff --git a/figs/examples/detail_kinematics_geng.jpg b/figs/examples/detail_kinematics_geng.jpg new file mode 100644 index 0000000..55f82c0 Binary files /dev/null and b/figs/examples/detail_kinematics_geng.jpg differ diff --git a/figs/examples/detail_kinematics_ht_uw.jpg b/figs/examples/detail_kinematics_ht_uw.jpg new file mode 100644 index 0000000..a4fa4f8 Binary files /dev/null and b/figs/examples/detail_kinematics_ht_uw.jpg differ diff --git a/figs/examples/detail_kinematics_iran.jpg b/figs/examples/detail_kinematics_iran.jpg new file mode 100644 index 0000000..22992bf Binary files /dev/null and b/figs/examples/detail_kinematics_iran.jpg differ diff --git a/figs/examples/detail_kinematics_jpl.jpg b/figs/examples/detail_kinematics_jpl.jpg new file mode 100644 index 0000000..7bedf4a Binary files /dev/null and b/figs/examples/detail_kinematics_jpl.jpg differ diff --git a/figs/examples/detail_kinematics_kim00.jpg b/figs/examples/detail_kinematics_kim00.jpg new file mode 100644 index 0000000..15ac6b4 Binary files /dev/null and b/figs/examples/detail_kinematics_kim00.jpg differ diff --git a/figs/examples/detail_kinematics_mais.jpg b/figs/examples/detail_kinematics_mais.jpg new file mode 100644 index 0000000..60ece3d Binary files /dev/null and b/figs/examples/detail_kinematics_mais.jpg differ diff --git a/figs/examples/detail_kinematics_nanoscale.jpg b/figs/examples/detail_kinematics_nanoscale.jpg new file mode 100644 index 0000000..8f1fb02 Binary files /dev/null and b/figs/examples/detail_kinematics_nanoscale.jpg differ diff --git a/figs/examples/detail_kinematics_naval.jpg b/figs/examples/detail_kinematics_naval.jpg new file mode 100644 index 0000000..f06bb35 Binary files /dev/null and b/figs/examples/detail_kinematics_naval.jpg differ diff --git a/figs/examples/detail_kinematics_naves.jpg b/figs/examples/detail_kinematics_naves.jpg new file mode 100644 index 0000000..4bb0a9d Binary files /dev/null and b/figs/examples/detail_kinematics_naves.jpg differ diff --git a/figs/examples/detail_kinematics_pph.jpg b/figs/examples/detail_kinematics_pph.jpg new file mode 100644 index 0000000..423f1d4 Binary files /dev/null and b/figs/examples/detail_kinematics_pph.jpg differ diff --git a/figs/examples/detail_kinematics_satra.jpg b/figs/examples/detail_kinematics_satra.jpg new file mode 100644 index 0000000..74f12f5 Binary files /dev/null and b/figs/examples/detail_kinematics_satra.jpg differ diff --git a/figs/examples/detail_kinematics_su04.jpg b/figs/examples/detail_kinematics_su04.jpg new file mode 100644 index 0000000..fe23588 Binary files /dev/null and b/figs/examples/detail_kinematics_su04.jpg differ diff --git a/figs/examples/detail_kinematics_tang18.jpg b/figs/examples/detail_kinematics_tang18.jpg new file mode 100644 index 0000000..5c96ec5 Binary files /dev/null and b/figs/examples/detail_kinematics_tang18.jpg differ diff --git a/figs/examples/detail_kinematics_ting07.jpg b/figs/examples/detail_kinematics_ting07.jpg new file mode 100644 index 0000000..80306f0 Binary files /dev/null and b/figs/examples/detail_kinematics_ting07.jpg differ diff --git a/figs/examples/detail_kinematics_torii.jpg b/figs/examples/detail_kinematics_torii.jpg new file mode 100644 index 0000000..33d2c73 Binary files /dev/null and b/figs/examples/detail_kinematics_torii.jpg differ diff --git a/figs/examples/detail_kinematics_ulb_pz.jpg b/figs/examples/detail_kinematics_ulb_pz.jpg new file mode 100644 index 0000000..1ff5b0d Binary files /dev/null and b/figs/examples/detail_kinematics_ulb_pz.jpg differ diff --git a/figs/examples/detail_kinematics_uqp.jpg b/figs/examples/detail_kinematics_uqp.jpg new file mode 100644 index 0000000..94b04e4 Binary files /dev/null and b/figs/examples/detail_kinematics_uqp.jpg differ diff --git a/figs/examples/detail_kinematics_uw_gsp.jpg b/figs/examples/detail_kinematics_uw_gsp.jpg new file mode 100644 index 0000000..dfde30d Binary files /dev/null and b/figs/examples/detail_kinematics_uw_gsp.jpg differ diff --git a/figs/examples/detail_kinematics_wang16.jpg b/figs/examples/detail_kinematics_wang16.jpg new file mode 100644 index 0000000..d995996 Binary files /dev/null and b/figs/examples/detail_kinematics_wang16.jpg differ diff --git a/figs/examples/detail_kinematics_yang19.jpg b/figs/examples/detail_kinematics_yang19.jpg new file mode 100644 index 0000000..221f0f8 Binary files /dev/null and b/figs/examples/detail_kinematics_yang19.jpg differ diff --git a/figs/examples/detail_kinematics_zhang11.jpg b/figs/examples/detail_kinematics_zhang11.jpg new file mode 100644 index 0000000..4ed939a Binary files /dev/null and b/figs/examples/detail_kinematics_zhang11.jpg differ diff --git a/nass-geometry.org b/nass-geometry.org index 47c329e..00c0335 100644 --- a/nass-geometry.org +++ b/nass-geometry.org @@ -117,6 +117,89 @@ Optimal geometry? - [ ] [[file:~/Cloud/work-projects/ID31-NASS/matlab/stewart-simscape/org/kinematic-study.org::*Estimated required actuator stroke from specified platform mobility][Estimated required actuator stroke from specified platform mobility]] - [ ] [[file:~/Cloud/work-projects/ID31-NASS/matlab/stewart-simscape/org/kinematic-study.org::*Estimation of the Joint required Stroke][Estimation of the Joint required Stroke]] +** Not used +#+begin_src latex :file detail_kinematics_cubic_schematic.pdf + \begin{tikzpicture} + \begin{scope}[rotate={45}, shift={(0, 0, -4)}] + % We first define the coordinate of the points of the Cube + \coordinate[] (bot) at (0,0,4); + \coordinate[] (top) at (4,4,0); + \coordinate[] (A1) at (0,0,0); + \coordinate[] (A2) at (4,0,4); + \coordinate[] (A3) at (0,4,4); + \coordinate[] (B1) at (4,0,0); + \coordinate[] (B2) at (4,4,4); + \coordinate[] (B3) at (0,4,0); + + % Center of the Cube + \node[] (cubecenter) at ($0.5*(bot) + 0.5*(top)$){$\bullet$}; + % \node[above right] at (cubecenter){$C$}; + + % We draw parts of the cube that corresponds to the Stewart platform + \draw[] (A1)node[]{$\bullet$} -- (B1)node[]{$\bullet$} -- (A2)node[]{$\bullet$} -- (B2)node[]{$\bullet$} -- (A3)node[]{$\bullet$} -- (B3)node[]{$\bullet$} -- (A1); + \draw[opacity=0.5] (bot) -- (A1); + \draw[opacity=0.5] (bot) -- (A2); + \draw[opacity=0.5] (bot) -- (A3); + \draw[opacity=0.5] (top) -- (B1); + \draw[opacity=0.5] (top) -- (B2); + \draw[opacity=0.5] (top) -- (B3); + + % ai and bi are computed + \def\lfrom{0.1} + \def\lto{0.9} + + \coordinate(a1) at ($(A1) - \lfrom*(A1) + \lfrom*(B1)$); + \coordinate(b1) at ($(A1) - \lto*(A1) + \lto*(B1)$); + \coordinate(a2) at ($(A2) - \lfrom*(A2) + \lfrom*(B1)$); + \coordinate(b2) at ($(A2) - \lto*(A2) + \lto*(B1)$); + \coordinate(a3) at ($(A2) - \lfrom*(A2) + \lfrom*(B2)$); + \coordinate(b3) at ($(A2) - \lto*(A2) + \lto*(B2)$); + \coordinate(a4) at ($(A3) - \lfrom*(A3) + \lfrom*(B2)$); + \coordinate(b4) at ($(A3) - \lto*(A3) + \lto*(B2)$); + \coordinate(a5) at ($(A3) - \lfrom*(A3) + \lfrom*(B3)$); + \coordinate(b5) at ($(A3) - \lto*(A3) + \lto*(B3)$); + \coordinate(a6) at ($(A1) - \lfrom*(A1) + \lfrom*(B3)$); + \coordinate(b6) at ($(A1) - \lto*(A1) + \lto*(B3)$); + + % Center of the Stewart Platform + % \node[color=colorblue] at ($0.25*(a1) + 0.25*(a6) + 0.25*(b3) + 0.25*(b4)$){$\bullet$}; + + % We draw the fixed and mobiles platforms + \path[fill=colorblue, opacity=0.2] (a1) -- (a2) -- (a3) -- (a4) -- (a5) -- (a6) -- cycle; + \path[fill=colorblue, opacity=0.2] (b1) -- (b2) -- (b3) -- (b4) -- (b5) -- (b6) -- cycle; + \draw[color=colorblue, dashed] (a1) -- (a2) -- (a3) -- (a4) -- (a5) -- (a6) -- cycle; + \draw[color=colorblue, dashed] (b1) -- (b2) -- (b3) -- (b4) -- (b5) -- (b6) -- cycle; + + % The legs of the hexapod are drawn + \draw[color=colorblue] (a1)node{$\bullet$} -- (b1)node{$\bullet$}; + \draw[color=colorblue] (a2)node{$\bullet$} -- (b2)node{$\bullet$}; + \draw[color=colorblue] (a3)node{$\bullet$} -- (b3)node{$\bullet$}; + \draw[color=colorblue] (a4)node{$\bullet$} -- (b4)node{$\bullet$}; + \draw[color=colorblue] (a5)node{$\bullet$} -- (b5)node{$\bullet$}; + \draw[color=colorblue] (a6)node{$\bullet$} -- (b6)node{$\bullet$}; + \end{scope} + + % Height of the Hexapod + \coordinate[] (sizepos) at ($(a2)+(0.2, 0)$); + \coordinate[] (origin) at (0,0,0); + % \draw[<->, dashed] (a2-|sizepos) -- node[midway, right]{$H$} (b2-|sizepos); + % Height offset + % \draw[<->, dashed] (a2-|sizepos) -- node[midway, right]{$H_0$} (origin-|sizepos); + + % \draw[<->, dashed] (0.5,2,0) --node[near end, right]{${}^{F}O_{C}$} ++(0,2,0); + % \draw[<->, dashed] (-2,2,0) --node[midway, right]{${}^{F}H_{A}$} ++(0,1,0); + % \draw[<->, dashed] (-2,6,0) --node[midway, right]{${}^{M}H_{B}$} ++(0,-1.5,0); + + % Useful part of the cube + % \draw[<->, dashed] ($(A2)+(0.5,0)$) -- node[midway, right]{$H_{C}$} ($(B1)+(0.5,0)$); + \end{tikzpicture} +#+end_src + +#+name: fig:detail_kinematics_cubic_schematic +#+caption: Stewart platform Cubic architecture. The struts are aligned with the sides of a cube. +#+RESULTS: +[[file:figs/detail_kinematics_cubic_schematic.png]] + ** TODO [#A] Copy relevant parts of reports ** DONE [#A] Structure the review of Stewart platforms @@ -138,13 +221,172 @@ CLOSED: [2025-03-30 Sun 11:54] - [ ] Only keep integrated sensor and not external metrology - [ ] Check for missing information -** TODO [#A] Maybe need to have the Simscape model for the stewart platform? +** DONE [#A] Maybe need to have the Simscape model for the stewart platform? +CLOSED: [2025-03-30 Sun 19:38] For what use? Study of coupling between strut sensor +** DONE [#A] Verify Mobility of Stewart platform +CLOSED: [2025-04-01 Tue 09:36] + +*Mobility is not a sphere but a cube!* + +From [[cite:&mcinroy00_desig_contr_flexur_joint_hexap]]: +#+begin_quote +This implies that, if all struts can move equal +amounts, then the translational part of the hexapod’s Cartesian +workspace forms a *sphere*. Thus, this is a useful geometry when +the ability to move equal amounts in all translational directions +is required. +#+end_quote +*This is wrong* + +Maybe easy check by taking few example points. +#+begin_src matlab :exports none :results none +%% Example of one Stewart platform and associated translational mobility +L_max = 50e-6; % Maximum actuator stroke (+/-) [m] + +stewart = initializeStewartPlatform(); +stewart = initializeFramesPositions(stewart, 'H', 100e-3, 'MO_B', -50e-3); +stewart = generateGeneralConfiguration(stewart, 'FH', 0, 'FR', 100e-3, 'MH', 0, 'MR', 100e-3, ... + 'FTh', [-5, 5, 120-5, 120+5, 240-5, 240+5]*(pi/180), ... + 'MTh', [-60+5, 60-5, 60+5, 180-5, 180+5, -60-5]*(pi/180)); +stewart = computeJointsPose(stewart); +stewart = initializeStrutDynamics(stewart, 'k', 1); +stewart = computeJacobian(stewart); +stewart = initializeCylindricalPlatforms(stewart, 'Fpr', 110e-3, 'Mpr', 110e-3); + +displayArchitecture(stewart, 'labels', false, 'frames', false, 'F_color', [0,0,0], 'M_color', [0,0,0], 'L_color', [0,0,0]); +#+end_src + +#+begin_src matlab +thetas = linspace(0, pi, 100); +phis = linspace(0, 2*pi, 100); +rs = zeros(length(thetas), length(phis)); + +for i = 1:length(thetas) + for j = 1:length(phis) + % Unit vector pointing to "spherical direction" + Tx = sin(thetas(i))*cos(phis(j)); + Ty = sin(thetas(i))*sin(phis(j)); + Tz = cos(thetas(i)); + + % Compute Strut motion required for unit displacement in theta/phi direction + dL = stewart.kinematics.J*[Tx; Ty; Tz; 0; 0; 0;]; + + % Due to maximum strut stroke, maximum displacement in the considered direction is limited + rs(i, j) = L_max/max(abs(dL)); + end +end + +% Sphere with radius equal to actuator stroke +[Xs,Ys,Zs] = sphere; +Xs = 1e6*L_max*Xs; +Ys = 1e6*L_max*Ys; +Zs = 1e6*L_max*Zs; + +[phi_grid, theta_grid] = meshgrid(phis, thetas); +X = 1e6 * rs .* sin(theta_grid) .* cos(phi_grid); +Y = 1e6 * rs .* sin(theta_grid) .* sin(phi_grid); +Z = 1e6 * rs .* cos(theta_grid); + +figure('Renderer', 'painters'); +hold on; +surf(X, Y, Z, 'FaceColor', 'none', 'LineWidth', 0.1, 'EdgeColor', [0, 0, 0]); +surf(Xs, Ys, Zs, 'FaceColor', colors(2,:), 'EdgeColor', 'none'); +quiver3(0, 0, 0, 100, 0, 0, 'k', 'LineWidth', 2, 'MaxHeadSize', 0.9); +quiver3(0, 0, 0, 0, 100, 0, 'k', 'LineWidth', 2, 'MaxHeadSize', 0.9); +quiver3(0, 0, 0, 0, 0, 100, 'k', 'LineWidth', 2, 'MaxHeadSize', 0.9); +hold off; +axis equal; +grid off; +axis off; +view(55, 25); +#+end_src + +#+begin_src matlab +for i = 1:length(thetas) + for j = 1:length(phis) + max(abs(stewart.kinematics.J*[X(i,j); Y(i,j); Z(i,j); 0; 0; 0])) + end +end +#+end_src + +#+begin_src matlab +inv(stewart.kinematics.J)*[42.8; 40.8; 29.3; 0; 0; 0] +stewart.kinematics.J*[-6.4; -0.89; 24.6; 136.3; -348.7; -89.2] +#+end_src + +** TODO [#A] Compute all the figures +SCHEDULED: <2025-04-01 Tue> + +** DONE [#B] Verify cubic architecture in literature +CLOSED: [2025-04-01 Tue 11:31] + +[[cite:&yang19_dynam_model_decoup_contr_flexib]]: *It is not cubic* +#+begin_src matlab +a1 = [0.1829; 0.06039; -0.03515]; +a2 = [-0.03916; 0.1886; -0.03515]; +a3 = [-0.1438; 0.1282 ;-0.03515]; +b1 = [0.02771; 0.1906; 0.03515]; +b2 = [0.1512; 0.1193; 0.03515]; +b3 = [-0.1789; -0.07131; 0.03515]; + +v1 = b1-a1; +v2 = b2-a2; +v3 = b3-a3; +angle_rad = acos(dot(v1,v3)/(norm(v1)*norm(v3))); +angle_deg = rad2deg(angle_rad) +#+end_src + + +[[cite:&furutani04_nanom_cuttin_machin_using_stewar]] +It says 35 degrees from the horizontal plane for the struts. +Check if this is the case for a cubic architecture. +#+begin_src matlab +H = 200e-3; % height of the Stewart platform [m] +MO_B = 50e-3; % Position {B} with respect to {M} [m] + +stewart = initializeStewartPlatform(); +stewart = initializeFramesPositions(stewart, 'H', H, 'MO_B', MO_B); +stewart = generateCubicConfiguration(stewart, 'Hc', H, 'FOc', H/2, 'FHa', 25e-3, 'MHb', 25e-3); +stewart = computeJointsPose(stewart); +stewart = initializeStrutDynamics(stewart, 'k', 1e6, 'c', 1e1); +stewart = initializeJointDynamics(stewart, 'type_F', '2dof', 'type_M', '3dof'); +stewart = computeJacobian(stewart); +stewart = initializeStewartPose(stewart); +stewart = initializeCylindricalPlatforms(stewart, ... + 'Mpm', 1e-6, ... % Massless platform + 'Fpm', 1e-6, ... % Massless platform + 'Mph', 20e-3, ... % Thin platform + 'Fph', 20e-3, ... % Thin platform + 'Mpr', 1.2*max(vecnorm(stewart.platform_M.Mb)), ... + 'Fpr', 1.2*max(vecnorm(stewart.platform_F.Fa))); +stewart = initializeCylindricalStruts(stewart, ... + 'Fsm', 1e-6, ... % Massless strut + 'Msm', 1e-6, ... % Massless strut + 'Fsh', stewart.geometry.l(1)/2, ... + 'Msh', stewart.geometry.l(1)/2 ... +); + +% Verify 90 degrees between the struts +v1 = stewart.geometry.As(:,1); +v2 = stewart.geometry.As(:,2); +angle_rad = acos(dot(v1,v2)/(norm(v1)*norm(v2))); +angle_deg = rad2deg(angle_rad) + +% Check angle with horizontal plane +v1 = stewart.geometry.As(:,1) +v2 = [1;0;0] +angle_rad = acos(dot(v1,v2)/(norm(v1)*norm(v2))); +angle_deg = rad2deg(angle_rad) +#+end_src + ** DONE [#A] Get analytical formula of stiffness matrix for cubic architecture? -CLOSED: [2025-03-29 Sat 16:31] +CLOSED: [2025-03-31 Mon 21:40] +*** Introduction +- [ ] Copy this analysis to relevant section - Make some simplifying assumption: - Cube at the center of the Stewart platform @@ -239,7 +481,7 @@ CLOSED: [2025-03-29 Sat 16:31] Compute: - [X] si : easy (always the same) -- [ ] bi : should also be easy +- [X] bi : should also be easy - Have to find intersection between struts and top platform (height of the joints) - Need the equation of the cube's sides? @@ -355,6 +597,153 @@ if norm(K - stewart_center.kinematics.K) > 1e-9 end #+end_src +*** Analytical equations + +A and B at cube's center. +Position of bi can be anywhere along the cube's edges + +#+begin_src matlab +% Define symbolic variables +syms k Hc alpha + +% Define si matrix (support vectors) +si = 1/sqrt(3)*[ + [ sqrt(2), 0, 1]; ... + [-sqrt(2)/2, -sqrt(3/2), 1]; ... + [-sqrt(2)/2, sqrt(3/2), 1]; ... + [ sqrt(2), 0, 1]; ... + [-sqrt(2)/2, -sqrt(3/2), 1]; ... + [-sqrt(2)/2, sqrt(3/2), 1] ... +]; + +% Define ci matrix (connection vectors) +ci = Hc * [ + [1/sqrt(2), -sqrt(3)/sqrt(2), 0.5]; ... + [1/sqrt(2), -sqrt(3)/sqrt(2), 0.5]; ... + [1/sqrt(2), sqrt(3)/sqrt(2), 0.5]; ... + [1/sqrt(2), sqrt(3)/sqrt(2), 0.5]; ... + [-sqrt(2), 0, 0.5]; ... + [-sqrt(2), 0, 0.5] ... +]; + +% Calculate bi vectors +bi = ci + alpha * si; + +% Initialize stiffness matrix +K = sym(zeros(6,6)); + +% Calculate elements of the stiffness matrix +for i = 1:6 + % Extract vectors for each leg + s_i = si(i,:)'; + b_i = bi(i,:)'; + + % Calculate cross product vector + cross_bs = cross(b_i, s_i); + + % Build matrix blocks + K(1:3, 4:6) = K(1:3, 4:6) + s_i * cross_bs'; + K(4:6, 1:3) = K(4:6, 1:3) + cross_bs * s_i'; + K(1:3, 1:3) = K(1:3, 1:3) + s_i * s_i'; + K(4:6, 4:6) = K(4:6, 4:6) + cross_bs * cross_bs'; +end + +% Scale by stiffness coefficient +K = k * K; + +% Simplify the expressions +K = simplify(K); + +% Display the analytical stiffness matrix +disp('Analytical Stiffness Matrix:'); +pretty(K); + +% If you want to analyze specific components +disp('Top-left block (K₁₁):'); +pretty(K(1:3, 1:3)); + +disp('Top-right block (K₁₂):'); +pretty(K(1:3, 4:6)); + +disp('Bottom-left block (K₂₁):'); +pretty(K(4:6, 1:3)); + +disp('Bottom-right block (K₂₂):'); +pretty(K(4:6, 4:6)); + +% Eigenvalue analysis (optional) +disp('Eigenvalues:'); +eig_vals = simplify(eig(K)); +pretty(eig_vals); +#+end_src + +*** Effect of un-centered frame with cube's center +#+begin_src matlab +% Define symbolic variables +syms k Hc alpha H + +assume(k > 0); % k is positive real +assume(Hc, 'real'); % Hc is real +assume(H, 'real'); % H is real +assume(alpha, 'real'); % alpha is real + + +% Define si matrix (support vectors) +si = 1/sqrt(3)*[ + [ sqrt(2), 0, 1]; ... + [-sqrt(2)/2, -sqrt(3/2), 1]; ... + [-sqrt(2)/2, sqrt(3/2), 1]; ... + [ sqrt(2), 0, 1]; ... + [-sqrt(2)/2, -sqrt(3/2), 1]; ... + [-sqrt(2)/2, sqrt(3/2), 1] ... +]; + +% Define ci matrix (connection vectors) +ci = Hc * [ + [1/sqrt(2), -sqrt(3)/sqrt(2), 0.5]; ... + [1/sqrt(2), -sqrt(3)/sqrt(2), 0.5]; ... + [1/sqrt(2), sqrt(3)/sqrt(2), 0.5]; ... + [1/sqrt(2), sqrt(3)/sqrt(2), 0.5]; ... + [-sqrt(2), 0, 0.5]; ... + [-sqrt(2), 0, 0.5] ... +]; + +% Apply vertical shift to ci +ci = ci + H * [0, 0, 1]; + +% Calculate bi vectors +bi = ci + alpha * si; + +% Initialize stiffness matrix +K = sym(zeros(6,6)); + +% Calculate elements of the stiffness matrix +for i = 1:6 + % Extract vectors for each leg + s_i = si(i,:)'; + b_i = bi(i,:)'; + + % Calculate cross product vector + cross_bs = cross(b_i, s_i); + + % Build matrix blocks + K(1:3, 4:6) = K(1:3, 4:6) + s_i * cross_bs'; + K(4:6, 1:3) = K(4:6, 1:3) + cross_bs * s_i'; + K(1:3, 1:3) = K(1:3, 1:3) + s_i * s_i'; + K(4:6, 4:6) = K(4:6, 4:6) + cross_bs * cross_bs'; +end + +% Scale by stiffness coefficient +K = k * K; + +% Simplify the expressions +K = simplify(K); + +% Display the analytical stiffness matrix +disp('Analytical Stiffness Matrix:'); +pretty(K); +#+end_src + *** Centered cube - joints at cube's vertices => diagonal stiffness matrix #+begin_src matlab @@ -390,6 +779,22 @@ K = k*K K_formula = diag([2*k, 2*k, 2*k, 1.5*k*Hc^2, 1.5*k*Hc^2, 6*k*Hc^2]) #+end_src +*** Verify general structure of the Stewart platform + +#+begin_src matlab +stewart = initializeStewartPlatform(); +stewart = initializeFramesPositions(stewart, 'H', 100e-3, 'MO_B', -50e-3); +stewart = generateGeneralConfiguration(stewart, 'FH', 0, 'FR', 100e-3, 'MH', 0, 'MR', 100e-3, ... + 'FTh', [-5, 5, 120-5, 120+5, 240-5, 240+5]*(pi/180), ... + 'MTh', [-60+5, 60-5, 60+5, 180-5, 180+5, -60-5]*(pi/180)); +stewart = computeJointsPose(stewart); +stewart = initializeStrutDynamics(stewart, 'k', 1); +stewart = computeJacobian(stewart); +stewart = initializeCylindricalPlatforms(stewart, 'Fpr', 110e-3, 'Mpr', 110e-3); + +displayArchitecture(stewart, 'labels', false, 'frames', false, 'F_color', [0,0,0], 'M_color', [0,0,0], 'L_color', [0,0,0]); +#+end_src + ** DONE [#A] Make table for review of Stewart platforms CLOSED: [2025-03-19 Wed 18:25] @@ -591,7 +996,7 @@ The choice of frames ($\{A\}$ and $\{B\}$), independently of the physical Stewar <> #+end_src -** Platform Mobility +** Platform Mobility / Workspace **** Introduction :ignore: The mobility of the Stewart platform (or any manipulator) is here defined as the range of motion that it can perform. @@ -625,6 +1030,12 @@ As will be shown in Section ref:sec:detail_kinematics_cubic, there are some geom As the mobility is of dimension six, it is difficult to represent. Depending on the applications, only the translation mobility or the rotation mobility may be represented. +#+begin_quote +Although there is no human readable way to represent the complete workspace, some projections of the full workspace can be drawn. +#+end_quote + +Difficulty of studying workspace of parallel manipulators. + **** Mobility in translation Here, for simplicity, only translations are first considered: @@ -640,6 +1051,7 @@ Here, for simplicity, only translations are first considered: Note that no platform angular motion is here considered. When combining angular motion, the linear stroke decreases. - When considering some symmetry in the system (as typically the case), the shape becomes a Trigonal trapezohedron whose height and width depends on the orientation of the struts. We only get 6 faces as usually the Stewart platform consists of 3 sets of 2 parallels struts. +- In reality, portion of spheres, but well approximated by flat surfaces for short stroke hexapods. #+begin_src matlab :exports none :results none %% Example of one Stewart platform and associated translational mobility @@ -705,7 +1117,7 @@ view(55, 25); #+end_src #+begin_src matlab :tangle no :exports results :results file none -exportFig('figs/detail_kinematics_mobility_trans_result.pdf', 'width', 'normal', 'height', 'tall'); +exportFig('figs/detail_kinematics_mobility_trans_result.pdf', 'width', 'normal', 'height', 'tall', 'simplify', true); #+end_src #+name: fig:detail_kinematics_mobility_trans @@ -773,8 +1185,8 @@ exportFig('figs/detail_kinematics_stewart_mobility_hori_struts.pdf', 'width', 'h #+begin_src matlab :exports none :results none %% Translation mobility for two Stewart platform geometry -thetas = linspace(0, pi, 50); -phis = linspace(0, 2*pi, 50); +thetas = linspace(0, pi, 100); +phis = linspace(0, 2*pi, 100); rs_vert = zeros(length(thetas), length(phis)); rs_hori = zeros(length(thetas), length(phis)); @@ -809,8 +1221,8 @@ Zs = 1e6*L_max*Zs; figure; hold on; -surf(X_vert, Y_vert, Z_vert, 'FaceColor', 'white', 'LineWidth', 0.2, 'EdgeColor', colors(1,:)); -surf(X_hori, Y_hori+400, Z_hori, 'FaceColor', 'white', 'LineWidth', 0.2, 'EdgeColor', colors(2,:)); +surf(X_vert, Y_vert, Z_vert, 'FaceColor', 'white', 'LineWidth', 0.1, 'EdgeColor', colors(1,:)); +surf(X_hori, Y_hori+400, Z_hori, 'FaceColor', 'white', 'LineWidth', 0.1, 'EdgeColor', colors(2,:)); quiver3(0, 0, 0, 200, 0, 0, 'k', 'LineWidth', 2, 'MaxHeadSize', 0.7); quiver3(0, 0, 0, 0, 200, 0, 'k', 'LineWidth', 2, 'MaxHeadSize', 0.7); quiver3(0, 0, 0, 0, 0, 200, 'k', 'LineWidth', 2, 'MaxHeadSize', 0.7); @@ -831,7 +1243,7 @@ view(105, 15); #+end_src #+begin_src matlab :tangle no :exports results :results file none -exportFig('figs/detail_kinematics_mobility_translation_strut_orientation.pdf', 'width', 'full', 'height', 'tall'); +exportFig('figs/detail_kinematics_mobility_translation_strut_orientation.pdf', 'width', 'full', 'height', 'tall', 'simplify', true); #+end_src #+name: fig:detail_kinematics_stewart_mobility_examples @@ -952,8 +1364,8 @@ Z_space = 1e6 * rs_space .* cos(theta_grid); figure; hold on; -surf(X_close, Y_close, Z_close, 'FaceColor', 'white', 'LineWidth', 0.2, 'EdgeColor', colors(1,:)); -surf(X_space, Y_space+6000, Z_space, 'FaceColor', 'white', 'LineWidth', 0.2, 'EdgeColor', colors(2,:)); +surf(X_close, Y_close, Z_close, 'FaceColor', 'white', 'LineWidth', 0.1, 'EdgeColor', colors(1,:)); +surf(X_space, Y_space+6000, Z_space, 'FaceColor', 'white', 'LineWidth', 0.1, 'EdgeColor', colors(2,:)); quiver3(0, 0, 0, 4000, 0, 0, 'k', 'LineWidth', 2, 'MaxHeadSize', 0.7); quiver3(0, 0, 0, 0, 4000, 0, 'k', 'LineWidth', 2, 'MaxHeadSize', 0.7); quiver3(0, 0, 0, 0, 0, 4000, 'k', 'LineWidth', 2, 'MaxHeadSize', 0.7); @@ -974,7 +1386,7 @@ view(105, 15); #+end_src #+begin_src matlab :tangle no :exports results :results file none -exportFig('figs/detail_kinematics_mobility_angle_strut_distance.pdf', 'width', 'full', 'height', 'full'); +exportFig('figs/detail_kinematics_mobility_angle_strut_distance.pdf', 'width', 'full', 'height', 'full', 'simplify', true); #+end_src #+name: fig:detail_kinematics_stewart_mobility_examples @@ -1074,6 +1486,8 @@ This depends on the geometry and on the chosen {A} frame. For specific configurations, it is possible to have a diagonal K matrix. +This will be discussed in Section ref:ssec:detail_kinematics_cubic_static. + ** Dynamical properties **** In the Cartesian Frame @@ -1107,7 +1521,6 @@ This will be studied with the cubic architecture. [[cite:&afzali-far16_vibrat_dynam_isotr_hexap_analy_studies]]: "*Dynamic isotropy*, leading to equal eigenfrequencies, is a powerful optimization measure." - ** Conclusion :PROPERTIES: :UNNUMBERED: t @@ -1150,153 +1563,18 @@ These trade-offs give some guidelines when choosing the Stewart platform geometr The Cubic configuration for the Stewart platform was first proposed in [[cite:&geng94_six_degree_of_freed_activ]]. -This configuration is quite specific in the sense that the active struts are arranged in a mutually orthogonal configuration connecting the corners of a cube Figure ref:fig:detail_kinematics_cubic_schematic. +This configuration is quite specific in the sense that the active struts are arranged in a mutually orthogonal configuration connecting the corners of a cube Figure ref:fig:detail_kinematics_cubic_architecture_examples. Cubic configuration: - The struts are corresponding to 6 of the 8 edges of a cube. - This way, all struts are perpendicular to each other (except sets of two that are parallel). -#+begin_src latex :file detail_kinematics_cubic_schematic.pdf - \begin{tikzpicture} - \begin{scope}[rotate={45}, shift={(0, 0, -4)}] - % We first define the coordinate of the points of the Cube - \coordinate[] (bot) at (0,0,4); - \coordinate[] (top) at (4,4,0); - \coordinate[] (A1) at (0,0,0); - \coordinate[] (A2) at (4,0,4); - \coordinate[] (A3) at (0,4,4); - \coordinate[] (B1) at (4,0,0); - \coordinate[] (B2) at (4,4,4); - \coordinate[] (B3) at (0,4,0); - - % Center of the Cube - \node[] (cubecenter) at ($0.5*(bot) + 0.5*(top)$){$\bullet$}; - % \node[above right] at (cubecenter){$C$}; - - % We draw parts of the cube that corresponds to the Stewart platform - \draw[] (A1)node[]{$\bullet$} -- (B1)node[]{$\bullet$} -- (A2)node[]{$\bullet$} -- (B2)node[]{$\bullet$} -- (A3)node[]{$\bullet$} -- (B3)node[]{$\bullet$} -- (A1); - \draw[opacity=0.5] (bot) -- (A1); - \draw[opacity=0.5] (bot) -- (A2); - \draw[opacity=0.5] (bot) -- (A3); - \draw[opacity=0.5] (top) -- (B1); - \draw[opacity=0.5] (top) -- (B2); - \draw[opacity=0.5] (top) -- (B3); - - % ai and bi are computed - \def\lfrom{0.1} - \def\lto{0.9} - - \coordinate(a1) at ($(A1) - \lfrom*(A1) + \lfrom*(B1)$); - \coordinate(b1) at ($(A1) - \lto*(A1) + \lto*(B1)$); - \coordinate(a2) at ($(A2) - \lfrom*(A2) + \lfrom*(B1)$); - \coordinate(b2) at ($(A2) - \lto*(A2) + \lto*(B1)$); - \coordinate(a3) at ($(A2) - \lfrom*(A2) + \lfrom*(B2)$); - \coordinate(b3) at ($(A2) - \lto*(A2) + \lto*(B2)$); - \coordinate(a4) at ($(A3) - \lfrom*(A3) + \lfrom*(B2)$); - \coordinate(b4) at ($(A3) - \lto*(A3) + \lto*(B2)$); - \coordinate(a5) at ($(A3) - \lfrom*(A3) + \lfrom*(B3)$); - \coordinate(b5) at ($(A3) - \lto*(A3) + \lto*(B3)$); - \coordinate(a6) at ($(A1) - \lfrom*(A1) + \lfrom*(B3)$); - \coordinate(b6) at ($(A1) - \lto*(A1) + \lto*(B3)$); - - % Center of the Stewart Platform - % \node[color=colorblue] at ($0.25*(a1) + 0.25*(a6) + 0.25*(b3) + 0.25*(b4)$){$\bullet$}; - - % We draw the fixed and mobiles platforms - \path[fill=colorblue, opacity=0.2] (a1) -- (a2) -- (a3) -- (a4) -- (a5) -- (a6) -- cycle; - \path[fill=colorblue, opacity=0.2] (b1) -- (b2) -- (b3) -- (b4) -- (b5) -- (b6) -- cycle; - \draw[color=colorblue, dashed] (a1) -- (a2) -- (a3) -- (a4) -- (a5) -- (a6) -- cycle; - \draw[color=colorblue, dashed] (b1) -- (b2) -- (b3) -- (b4) -- (b5) -- (b6) -- cycle; - - % The legs of the hexapod are drawn - \draw[color=colorblue] (a1)node{$\bullet$} -- (b1)node{$\bullet$}; - \draw[color=colorblue] (a2)node{$\bullet$} -- (b2)node{$\bullet$}; - \draw[color=colorblue] (a3)node{$\bullet$} -- (b3)node{$\bullet$}; - \draw[color=colorblue] (a4)node{$\bullet$} -- (b4)node{$\bullet$}; - \draw[color=colorblue] (a5)node{$\bullet$} -- (b5)node{$\bullet$}; - \draw[color=colorblue] (a6)node{$\bullet$} -- (b6)node{$\bullet$}; - \end{scope} - - % Height of the Hexapod - \coordinate[] (sizepos) at ($(a2)+(0.2, 0)$); - \coordinate[] (origin) at (0,0,0); - % \draw[<->, dashed] (a2-|sizepos) -- node[midway, right]{$H$} (b2-|sizepos); - % Height offset - % \draw[<->, dashed] (a2-|sizepos) -- node[midway, right]{$H_0$} (origin-|sizepos); - - % \draw[<->, dashed] (0.5,2,0) --node[near end, right]{${}^{F}O_{C}$} ++(0,2,0); - % \draw[<->, dashed] (-2,2,0) --node[midway, right]{${}^{F}H_{A}$} ++(0,1,0); - % \draw[<->, dashed] (-2,6,0) --node[midway, right]{${}^{M}H_{B}$} ++(0,-1.5,0); - - % Useful part of the cube - % \draw[<->, dashed] ($(A2)+(0.5,0)$) -- node[midway, right]{$H_{C}$} ($(B1)+(0.5,0)$); - \end{tikzpicture} -#+end_src - -#+name: fig:detail_kinematics_cubic_schematic -#+caption: Stewart platform Cubic architecture. The struts are aligned with the sides of a cube. -#+RESULTS: -[[file:figs/detail_kinematics_cubic_schematic.png]] - - -The cubic configuration is attributed a number of properties that made this configuration widely used ([[cite:&preumont07_six_axis_singl_stage_activ;&jafari03_orthog_gough_stewar_platf_microm]]). -From [[cite:&geng94_six_degree_of_freed_activ]]: -1) Uniformity in control capability in all directions -2) Uniformity in stiffness in all directions -3) Minimum cross coupling force effect among actuators -4) Facilitate collocated sensor-actuator control system design -5) Simple kinematics relationships -6) Simple dynamic analysis -7) Simple mechanical design - -According to [[cite:&preumont07_six_axis_singl_stage_activ]], it "minimizes the cross-coupling amongst actuators and sensors of different legs" (being orthogonal to each other). - -Specific points of interest are: -- uniform mobility, uniform stiffness, and coupling properties - -In this section: -- Such properties are studied -- Additional properties interesting for control? -- It is determined if the cubic architecture is interested for the nano-hexapod - -** 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 :noweb yes -<> -#+end_src - -#+begin_src matlab :eval no :noweb yes -<> -#+end_src - -#+begin_src matlab :noweb yes -<> -#+end_src - -#+begin_src matlab :noweb yes -<> -#+end_src - -** The Cubic Architecture -<> - -Typical cubic architecture (Figure ref:fig:detail_kinematics_cubic_architecture_examples). - Struts with similar size than the cube's edge (Figure ref:fig:detail_kinematics_cubic_architecture_example). Similar to Figures ref:fig:detail_kinematics_jpl, ref:fig:detail_kinematics_uw_gsp and ref:fig:detail_kinematics_uqp. Struts smaller than the cube's edge (Figure ref:fig:detail_kinematics_cubic_architecture_example_small). Similar to the Stewart platform of Figure ref:fig:detail_kinematics_ulb_pz. -The two stewart platform are having the same properties (stiffness matrix, when evaluated at the cube's center). - #+begin_src matlab :exports none :results none %% Example of a typical "cubic" architecture MO_B = -50e-3; % Position {B} with respect to {M} [m] @@ -1361,22 +1639,955 @@ exportFig('figs/detail_kinematics_cubic_architecture_example_small.pdf', 'width' #+attr_latex: :caption \subcaption{\label{fig:detail_kinematics_cubic_architecture_example}sub caption a} #+attr_latex: :options {0.49\textwidth} #+begin_subfigure -#+attr_latex: :width 0.95\linewidth +#+attr_latex: :scale 1 [[file:figs/detail_kinematics_cubic_architecture_example.png]] #+end_subfigure #+attr_latex: :caption \subcaption{\label{fig:detail_kinematics_cubic_architecture_example_small}sub caption b} #+attr_latex: :options {0.49\textwidth} #+begin_subfigure -#+attr_latex: :width 0.95\linewidth +#+attr_latex: :scale 1 [[file:figs/detail_kinematics_cubic_architecture_example_small.png]] #+end_subfigure #+end_figure +The cubic configuration is attributed a number of properties that made this configuration widely used ([[cite:&preumont07_six_axis_singl_stage_activ;&jafari03_orthog_gough_stewar_platf_microm]]). +From [[cite:&geng94_six_degree_of_freed_activ]]: +1) Uniformity in control capability in all directions +2) Uniformity in stiffness in all directions +3) Minimum cross coupling force effect among actuators +4) Facilitate collocated sensor-actuator control system design +5) Simple kinematics relationships +6) Simple dynamic analysis +7) Simple mechanical design + +According to [[cite:&preumont07_six_axis_singl_stage_activ]], it "minimizes the cross-coupling amongst actuators and sensors of different legs" (being orthogonal to each other). + +Specific points of interest are: +- uniform mobility, uniform stiffness, and coupling properties + +In this section: +- Such properties are studied +- Additional properties interesting for control? +- It is determined if the cubic architecture is interested for the nano-hexapod + +** 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 :noweb yes +<> +#+end_src + +#+begin_src matlab :eval no :noweb yes +<> +#+end_src + +#+begin_src matlab :noweb yes +<> +#+end_src + +#+begin_src matlab :noweb yes +<> +#+end_src + ** Static Properties <> +**** Stiffness matrix for the Cubic architecture +Consider the cubic architecture shown in Figure ref:fig:detail_kinematics_cubic_schematic_full. -**** Uniform stiffness +The unit vectors corresponding to the edges of the cube are described by eqref:eq:detail_kinematics_cubic_s. + +\begin{equation}\label{eq:detail_kinematics_cubic_s} + \hat{\bm{s}}_1 = \begin{bmatrix} \sqrt{2}/\sqrt{3} \\ 0 \\ 1/\sqrt{3} \end{bmatrix} \quad + \hat{\bm{s}}_2 = \begin{bmatrix} -1/\sqrt{6} \\ -1/\sqrt{2} \\ 1/\sqrt{3} \end{bmatrix} \quad + \hat{\bm{s}}_3 = \begin{bmatrix} -1/\sqrt{6} \\ 1/\sqrt{2} \\ 1/\sqrt{3} \end{bmatrix} \quad + \hat{\bm{s}}_4 = \begin{bmatrix} \sqrt{2}/\sqrt{3} \\ 0 \\ 1/\sqrt{3} \end{bmatrix} \quad + \hat{\bm{s}}_5 = \begin{bmatrix} -1/\sqrt{6} \\ -1/\sqrt{2} \\ 1/\sqrt{3} \end{bmatrix} \quad + \hat{\bm{s}}_6 = \begin{bmatrix} -1/\sqrt{6} \\ 1/\sqrt{2} \\ 1/\sqrt{3} \end{bmatrix} +\end{equation} + +Coordinates of the cube's vertices relevant for the top joints, expressed with respect to the cube's center eqref:eq:detail_kinematics_cubic_vertices. + +\begin{equation}\label{eq:detail_kinematics_cubic_vertices} + \tilde{\bm{b}}_1 = \tilde{\bm{b}}_2 = H_c \begin{bmatrix} \frac{1}{\sqrt{2}} \\ \frac{-\sqrt{3}}{\sqrt{2}} \\ \frac{1}{2} \end{bmatrix}, \quad + \tilde{\bm{b}}_3 = \tilde{\bm{b}}_4 = H_c \begin{bmatrix} \frac{1}{\sqrt{2}} \\ \frac{ \sqrt{3}}{\sqrt{2}} \\ \frac{1}{2} \end{bmatrix}, \quad + \tilde{\bm{b}}_5 = \tilde{\bm{b}}_6 = H_c \begin{bmatrix} \frac{-2}{\sqrt{2}} \\ 0 \\ \frac{1}{2} \end{bmatrix} +\end{equation} + +#+begin_src latex :file detail_kinematics_cubic_schematic_full.pdf :results file none + \begin{tikzpicture} + \begin{scope}[rotate={45}, shift={(0, 0, -4)}] + % We first define the coordinate of the points of the Cube + \coordinate[] (bot) at (0,0,4); + \coordinate[] (top) at (4,4,0); + \coordinate[] (A1) at (0,0,0); + \coordinate[] (A2) at (4,0,4); + \coordinate[] (A3) at (0,4,4); + \coordinate[] (B1) at (4,0,0); + \coordinate[] (B2) at (4,4,4); + \coordinate[] (B3) at (0,4,0); + + % Center of the Cube + \node[] (cubecenter) at ($0.5*(bot) + 0.5*(top)$){$\bullet$}; + + % We draw parts of the cube that corresponds to the Stewart platform + \draw[] (A1)node[]{$\bullet$} -- (B1)node[]{$\bullet$} -- (A2)node[]{$\bullet$} -- (B2)node[]{$\bullet$} -- (A3)node[]{$\bullet$} -- (B3)node[]{$\bullet$} -- (A1); + + % ai and bi are computed + \def\lfrom{0.0} + \def\lto{1.0} + + \coordinate(a1) at ($(A1) - \lfrom*(A1) + \lfrom*(B1)$); + \coordinate(b1) at ($(A1) - \lto*(A1) + \lto*(B1)$); + \coordinate(a2) at ($(A2) - \lfrom*(A2) + \lfrom*(B1)$); + \coordinate(b2) at ($(A2) - \lto*(A2) + \lto*(B1)$); + \coordinate(a3) at ($(A2) - \lfrom*(A2) + \lfrom*(B2)$); + \coordinate(b3) at ($(A2) - \lto*(A2) + \lto*(B2)$); + \coordinate(a4) at ($(A3) - \lfrom*(A3) + \lfrom*(B2)$); + \coordinate(b4) at ($(A3) - \lto*(A3) + \lto*(B2)$); + \coordinate(a5) at ($(A3) - \lfrom*(A3) + \lfrom*(B3)$); + \coordinate(b5) at ($(A3) - \lto*(A3) + \lto*(B3)$); + \coordinate(a6) at ($(A1) - \lfrom*(A1) + \lfrom*(B3)$); + \coordinate(b6) at ($(A1) - \lto*(A1) + \lto*(B3)$); + + % We draw the fixed and mobiles platforms + \path[fill=colorblue, opacity=0.2] (a1) -- (a2) -- (a3) -- (a4) -- (a5) -- (a6) -- cycle; + \path[fill=colorblue, opacity=0.2] (b1) -- (b2) -- (b3) -- (b4) -- (b5) -- (b6) -- cycle; + \draw[color=colorblue, dashed] (a1) -- (a2) -- (a3) -- (a4) -- (a5) -- (a6) -- cycle; + \draw[color=colorblue, dashed] (b1) -- (b2) -- (b3) -- (b4) -- (b5) -- (b6) -- cycle; + + % The legs of the hexapod are drawn + \draw[color=colorblue] (a1)node{$\bullet$} -- (b1)node{$\bullet$}; + \draw[color=colorblue] (a2)node{$\bullet$} -- (b2)node{$\bullet$}; + \draw[color=colorblue] (a3)node{$\bullet$} -- (b3)node{$\bullet$}; + \draw[color=colorblue] (a4)node{$\bullet$} -- (b4)node{$\bullet$}; + \draw[color=colorblue] (a5)node{$\bullet$} -- (b5)node{$\bullet$}; + \draw[color=colorblue] (a6)node{$\bullet$} -- (b6)node{$\bullet$}; + + % Unit vector + \draw[color=colorred, ->] ($0.9*(a1)+0.1*(b1)$)node{$\bullet$} -- ($0.65*(a1)+0.35*(b1)$)node[right]{$\hat{\bm{s}}_3$}; + \draw[color=colorred, ->] ($0.9*(a2)+0.1*(b2)$)node{$\bullet$} -- ($0.65*(a2)+0.35*(b2)$)node[left]{$\hat{\bm{s}}_4$}; + \draw[color=colorred, ->] ($0.9*(a3)+0.1*(b3)$)node{$\bullet$} -- ($0.65*(a3)+0.35*(b3)$)node[below]{$\hat{\bm{s}}_5$}; + \draw[color=colorred, ->] ($0.9*(a4)+0.1*(b4)$)node{$\bullet$} -- ($0.65*(a4)+0.35*(b4)$)node[below]{$\hat{\bm{s}}_6$}; + \draw[color=colorred, ->] ($0.9*(a5)+0.1*(b5)$)node{$\bullet$} -- ($0.65*(a5)+0.35*(b5)$)node[left]{$\hat{\bm{s}}_1$}; + \draw[color=colorred, ->] ($0.9*(a6)+0.1*(b6)$)node{$\bullet$} -- ($0.65*(a6)+0.35*(b6)$)node[right]{$\hat{\bm{s}}_2$}; + + % Labels + \node[above=0.1 of B1] {$\tilde{\bm{b}}_3 = \tilde{\bm{b}}_4$}; + \node[above=0.1 of B2] {$\tilde{\bm{b}}_5 = \tilde{\bm{b}}_6$}; + \node[above=0.1 of B3] {$\tilde{\bm{b}}_1 = \tilde{\bm{b}}_2$}; + \end{scope} + + % Height of the Hexapod + \coordinate[] (sizepos) at ($(a2)+(0.2, 0)$); + \coordinate[] (origin) at (0,0,0); + + \draw[->] (cubecenter.center) node[above right]{$\{B\}$} -- ++(0,0,1); + \draw[->] (cubecenter.center) -- ++(1,0,0); + \draw[->] (cubecenter.center) -- ++(0,1,0); + + % Useful part of the cube + \draw[<->, dashed] ($(A2)+(0.5,0)$) -- node[midway, right]{$H_{C}$} ($(B1)+(0.5,0)$); + \end{tikzpicture} +#+end_src + +#+begin_src latex :file detail_kinematics_cubic_schematic.pdf :results file none + \begin{tikzpicture} + \begin{scope}[rotate={45}, shift={(0, 0, -4)}] + % We first define the coordinate of the points of the Cube + \coordinate[] (bot) at (0,0,4); + \coordinate[] (top) at (4,4,0); + \coordinate[] (A1) at (0,0,0); + \coordinate[] (A2) at (4,0,4); + \coordinate[] (A3) at (0,4,4); + \coordinate[] (B1) at (4,0,0); + \coordinate[] (B2) at (4,4,4); + \coordinate[] (B3) at (0,4,0); + + % Center of the Cube + \node[] (cubecenter) at ($0.5*(bot) + 0.5*(top)$){$\bullet$}; + + % We draw parts of the cube that corresponds to the Stewart platform + \draw[] (A1)node[]{$\bullet$} -- (B1)node[]{$\bullet$} -- (A2)node[]{$\bullet$} -- (B2)node[]{$\bullet$} -- (A3)node[]{$\bullet$} -- (B3)node[]{$\bullet$} -- (A1); + + % ai and bi are computed + \def\lfrom{0.2} + \def\lto{0.8} + + \coordinate(a1) at ($(A1) - \lfrom*(A1) + \lfrom*(B1)$); + \coordinate(b1) at ($(A1) - \lto*(A1) + \lto*(B1)$); + \coordinate(a2) at ($(A2) - \lfrom*(A2) + \lfrom*(B1)$); + \coordinate(b2) at ($(A2) - \lto*(A2) + \lto*(B1)$); + \coordinate(a3) at ($(A2) - \lfrom*(A2) + \lfrom*(B2)$); + \coordinate(b3) at ($(A2) - \lto*(A2) + \lto*(B2)$); + \coordinate(a4) at ($(A3) - \lfrom*(A3) + \lfrom*(B2)$); + \coordinate(b4) at ($(A3) - \lto*(A3) + \lto*(B2)$); + \coordinate(a5) at ($(A3) - \lfrom*(A3) + \lfrom*(B3)$); + \coordinate(b5) at ($(A3) - \lto*(A3) + \lto*(B3)$); + \coordinate(a6) at ($(A1) - \lfrom*(A1) + \lfrom*(B3)$); + \coordinate(b6) at ($(A1) - \lto*(A1) + \lto*(B3)$); + + % We draw the fixed and mobiles platforms + \path[fill=colorblue, opacity=0.2] (a1) -- (a2) -- (a3) -- (a4) -- (a5) -- (a6) -- cycle; + \path[fill=colorblue, opacity=0.2] (b1) -- (b2) -- (b3) -- (b4) -- (b5) -- (b6) -- cycle; + \draw[color=colorblue, dashed] (a1) -- (a2) -- (a3) -- (a4) -- (a5) -- (a6) -- cycle; + \draw[color=colorblue, dashed] (b1) -- (b2) -- (b3) -- (b4) -- (b5) -- (b6) -- cycle; + + % The legs of the hexapod are drawn + \draw[color=colorblue] (a1)node{$\bullet$} -- (b1)node{$\bullet$}node[below right]{$\bm{b}_3$}; + \draw[color=colorblue] (a2)node{$\bullet$} -- (b2)node{$\bullet$}node[right]{$\bm{b}_4$}; + \draw[color=colorblue] (a3)node{$\bullet$} -- (b3)node{$\bullet$}node[above right]{$\bm{b}_5$}; + \draw[color=colorblue] (a4)node{$\bullet$} -- (b4)node{$\bullet$}node[above left]{$\bm{b}_6$}; + \draw[color=colorblue] (a5)node{$\bullet$} -- (b5)node{$\bullet$}node[left]{$\bm{b}_1$}; + \draw[color=colorblue] (a6)node{$\bullet$} -- (b6)node{$\bullet$}node[below left]{$\bm{b}_2$}; + + % Labels + \node[above=0.1 of B1] {$\tilde{\bm{b}}_3 = \tilde{\bm{b}}_4$}; + \node[above=0.1 of B2] {$\tilde{\bm{b}}_5 = \tilde{\bm{b}}_6$}; + \node[above=0.1 of B3] {$\tilde{\bm{b}}_1 = \tilde{\bm{b}}_2$}; + \end{scope} + + % Height of the Hexapod + \coordinate[] (sizepos) at ($(a2)+(0.2, 0)$); + \coordinate[] (origin) at (0,0,0); + + \draw[->] (cubecenter.center) node[above right]{$\{B\}$} -- ++(0,0,1); + \draw[->] (cubecenter.center) -- ++(1,0,0); + \draw[->] (cubecenter.center) -- ++(0,1,0); + \end{tikzpicture} +#+end_src + +#+begin_src latex :file detail_kinematics_cubic_schematic_off_centered.pdf :results file none + \begin{tikzpicture} + \begin{scope}[rotate={45}, shift={(0, 0, -4)}] + % We first define the coordinate of the points of the Cube + \coordinate[] (bot) at (0,0,4); + \coordinate[] (top) at (4,4,0); + \coordinate[] (A1) at (0,0,0); + \coordinate[] (A2) at (4,0,4); + \coordinate[] (A3) at (0,4,4); + \coordinate[] (B1) at (4,0,0); + \coordinate[] (B2) at (4,4,4); + \coordinate[] (B3) at (0,4,0); + + % Center of the Cube + \node[] (cubecenter) at ($0.5*(bot) + 0.5*(top)$){$\bullet$}; + + % We draw parts of the cube that corresponds to the Stewart platform + \draw[] (A1)node[]{$\bullet$} -- (B1)node[]{$\bullet$} -- (A2)node[]{$\bullet$} -- (B2)node[]{$\bullet$} -- (A3)node[]{$\bullet$} -- (B3)node[]{$\bullet$} -- (A1); + + % ai and bi are computed + \def\lfrom{0.1} + \def\lto{0.9} + + \coordinate(a1) at ($(A1) - \lfrom*(A1) + \lfrom*(B1)$); + \coordinate(b1) at ($(A1) - \lto*(A1) + \lto*(B1)$); + \coordinate(a2) at ($(A2) - \lfrom*(A2) + \lfrom*(B1)$); + \coordinate(b2) at ($(A2) - \lto*(A2) + \lto*(B1)$); + \coordinate(a3) at ($(A2) - \lfrom*(A2) + \lfrom*(B2)$); + \coordinate(b3) at ($(A2) - \lto*(A2) + \lto*(B2)$); + \coordinate(a4) at ($(A3) - \lfrom*(A3) + \lfrom*(B2)$); + \coordinate(b4) at ($(A3) - \lto*(A3) + \lto*(B2)$); + \coordinate(a5) at ($(A3) - \lfrom*(A3) + \lfrom*(B3)$); + \coordinate(b5) at ($(A3) - \lto*(A3) + \lto*(B3)$); + \coordinate(a6) at ($(A1) - \lfrom*(A1) + \lfrom*(B3)$); + \coordinate(b6) at ($(A1) - \lto*(A1) + \lto*(B3)$); + + % We draw the fixed and mobiles platforms + \path[fill=colorblue, opacity=0.2] (a1) -- (a2) -- (a3) -- (a4) -- (a5) -- (a6) -- cycle; + \path[fill=colorblue, opacity=0.2] (b1) -- (b2) -- (b3) -- (b4) -- (b5) -- (b6) -- cycle; + \draw[color=colorblue, dashed] (a1) -- (a2) -- (a3) -- (a4) -- (a5) -- (a6) -- cycle; + \draw[color=colorblue, dashed] (b1) -- (b2) -- (b3) -- (b4) -- (b5) -- (b6) -- cycle; + + % The legs of the hexapod are drawn + \draw[color=colorblue] (a1)node{$\bullet$} -- (b1)node{$\bullet$}; + \draw[color=colorblue] (a2)node{$\bullet$} -- (b2)node{$\bullet$}; + \draw[color=colorblue] (a3)node{$\bullet$} -- (b3)node{$\bullet$}; + \draw[color=colorblue] (a4)node{$\bullet$} -- (b4)node{$\bullet$}; + \draw[color=colorblue] (a5)node{$\bullet$} -- (b5)node{$\bullet$}; + \draw[color=colorblue] (a6)node{$\bullet$} -- (b6)node{$\bullet$}; + \end{scope} + + % Height of the Hexapod + \coordinate[] (sizepos) at ($(a2)+(0.2, 0)$); + \coordinate[] (origin) at (0,0,0); + + \draw[->] ($(cubecenter.center)+(0,2.0,0)$) node[above right]{$\{B\}$} -- ++(0,0,1); + \draw[->] ($(cubecenter.center)+(0,2.0,0)$) -- ++(1,0,0); + \draw[->] ($(cubecenter.center)+(0,2.0,0)$) -- ++(0,1,0); + + \draw[<->, dashed] (cubecenter.center) -- node[midway, right]{$H$} ($(cubecenter.center)+(0,2.0,0)$); + \end{tikzpicture} +#+end_src + +#+name: fig:detail_kinematics_cubic_schematic_cases +#+caption: Struts are represented un blue. The cube's center by a dot. +#+attr_latex: :options [htbp] +#+begin_figure +#+attr_latex: :caption \subcaption{\label{fig:detail_kinematics_cubic_schematic_full}Full cube} +#+attr_latex: :options {0.33\textwidth} +#+begin_subfigure +#+attr_latex: :width 0.9\linewidth +[[file:figs/detail_kinematics_cubic_schematic_full.png]] +#+end_subfigure +#+attr_latex: :caption \subcaption{\label{fig:detail_kinematics_cubic_schematic}Cube's portion} +#+attr_latex: :options {0.33\textwidth} +#+begin_subfigure +#+attr_latex: :width 0.9\linewidth +[[file:figs/detail_kinematics_cubic_schematic.png]] +#+end_subfigure +#+attr_latex: :caption \subcaption{\label{fig:detail_kinematics_cubic_schematic_off_centered}Off Centered} +#+attr_latex: :options {0.33\textwidth} +#+begin_subfigure +#+attr_latex: :width 0.9\linewidth +[[file:figs/detail_kinematics_cubic_schematic_off_centered.png]] +#+end_subfigure +#+end_figure + +#+begin_src matlab +%% Analytical formula for Stiffness matrix of the Cubic Stewart platform +% Define symbolic variables +syms k Hc alpha H + +assume(k > 0); % k is positive real +assume(Hc, 'real'); % Hc is real +assume(H, 'real'); % H is real +assume(alpha, 'real'); % alpha is real + +% Define si matrix (edges of the cubes) +si = 1/sqrt(3)*[ + [ sqrt(2), 0, 1]; ... + [-sqrt(2)/2, -sqrt(3/2), 1]; ... + [-sqrt(2)/2, sqrt(3/2), 1]; ... + [ sqrt(2), 0, 1]; ... + [-sqrt(2)/2, -sqrt(3/2), 1]; ... + [-sqrt(2)/2, sqrt(3/2), 1] ... +]; + +% Define ci matrix (vertices of the cubes) +ci = Hc * [ + [1/sqrt(2), -sqrt(3)/sqrt(2), 0.5]; ... + [1/sqrt(2), -sqrt(3)/sqrt(2), 0.5]; ... + [1/sqrt(2), sqrt(3)/sqrt(2), 0.5]; ... + [1/sqrt(2), sqrt(3)/sqrt(2), 0.5]; ... + [-sqrt(2), 0, 0.5]; ... + [-sqrt(2), 0, 0.5] ... +]; + +% Apply vertical shift to ci +ci = ci + H * [0, 0, 1]; + +% Calculate bi vectors (Stewart platform top joints) +bi = ci + alpha * si; + +% Initialize stiffness matrix +K = sym(zeros(6,6)); + +% Calculate elements of the stiffness matrix +for i = 1:6 + % Extract vectors for each leg + s_i = si(i,:)'; + b_i = bi(i,:)'; + + % Calculate cross product vector + cross_bs = cross(b_i, s_i); + + % Build matrix blocks + K(1:3, 4:6) = K(1:3, 4:6) + s_i * cross_bs'; + K(4:6, 1:3) = K(4:6, 1:3) + cross_bs * s_i'; + K(1:3, 1:3) = K(1:3, 1:3) + s_i * s_i'; + K(4:6, 4:6) = K(4:6, 4:6) + cross_bs * cross_bs'; +end + +% Scale by stiffness coefficient +K = k * K; + +% Simplify the expressions +K = simplify(K); + +% Display the analytical stiffness matrix +disp('Analytical Stiffness Matrix:'); +pretty(K); +#+end_src + +In that case (top joints at the cube's vertices), a diagonal stiffness matrix is obtained eqref:eq:detail_kinematics_cubic_stiffness. +Translation stiffness is twice the stiffness of the struts, and rotational stiffness is proportional to the square of the cube's size Hc. + +\begin{equation}\label{eq:detail_kinematics_cubic_stiffness} + \bm{K}_{\{B\} = \{C\}} = k \begin{bmatrix} + 2 & 0 & 0 & 0 & 0 & 0 \\ + 0 & 2 & 0 & 0 & 0 & 0 \\ + 0 & 0 & 2 & 0 & 0 & 0 \\ + 0 & 0 & 0 & \frac{3}{2} H_c^2 & 0 & 0 \\ + 0 & 0 & 0 & 0 & \frac{3}{2} H_c^2 & 0 \\ + 0 & 0 & 0 & 0 & 0 & 6 H_c^2 \\ + \end{bmatrix} +\end{equation} + +But typically, the top joints are not placed at the cube's vertices but on the cube's edges (Figure ref:fig:detail_kinematics_cubic_schematic). +In that case, the location of the top joints can be expressed by eqref:eq:detail_kinematics_cubic_edges. + +\begin{equation}\label{eq:detail_kinematics_cubic_edges} +\bm{b}_i = \tilde{\bm{b}}_i + \alpha \hat{\bm{s}}_i +\end{equation} + +But the computed stiffness matrix is the same eqref:eq:detail_kinematics_cubic_stiffness. + +The Stiffness matrix is diagonal for forces and torques applied on the top platform, but expressed at the center of the cube, and for translations and rotations of the top platform expressed with respect to the cube's center. + +- [ ] Should I introduce the term "center of stiffness" here? + +**** Effect of having frame $\{B\}$ off-centered + +However, as soon as the location of the A and B frames are shifted from the cube's center, off diagonal elements in the stiffness matrix appear. + +Let's consider here a vertical shift as shown in Figure ref:fig:detail_kinematics_cubic_schematic_off_centered. +In that case, the stiffness matrix is eqref:eq:detail_kinematics_cubic_stiffness_off_centered. +Off diagonal elements are increasing with the height difference between the cube's center and the considered B frame. + +\begin{equation}\label{eq:detail_kinematics_cubic_stiffness_off_centered} + \bm{K}_{\{B\} \neq \{C\}} = k \begin{bmatrix} + 2 & 0 & 0 & 0 & -2 H & 0 \\ + 0 & 2 & 0 & 2 H & 0 & 0 \\ + 0 & 0 & 2 & 0 & 0 & 0 \\ + 0 & 2 H & 0 & \frac{3}{2} H_c^2 + 2 H^2 & 0 & 0 \\ + -2 H & 0 & 0 & 0 & \frac{3}{2} H_c^2 + 2 H^2 & 0 \\ + 0 & 0 & 0 & 0 & 0 & 6 H_c^2 \\ + \end{bmatrix} +\end{equation} + + +Such structure of the stiffness matrix is very typical with Stewart platform that have some symmetry, but not necessary only for cubic architectures. + +Therefore, the stiffness of the cubic architecture is special only when considering a frame located at the center of the cube. +This is not very convenient, as in the vast majority of cases, the interesting frame is located about the top platform. + +Note that the cube's center needs not to be at the "center" of the Stewart platform. +This can lead to interesting architectures shown in Section ref:ssec:detail_kinematics_cubic_design. + +**** Uniform Mobility + +Uniform mobility in X,Y,Z directions (Figure ref:fig:detail_kinematics_cubic_mobility_translations) +- This is somehow more uniform than other architecture +- A cube is obtained +- The length of the cube's edge is equal to the strut axial stroke +- Mobility in translation does not depend on the cube's size + +Some have argue that the translational mobility of the Cubic Stewart platform is a sphere [[cite:&mcinroy00_desig_contr_flexur_joint_hexap]], and this is useful to be able to move equal amount in all directions. +As shown here, this is wrong. +It is possible the consider that the mobility is uniform along the directions of the struts, but usually these are not interesting directions. + + +Also show mobility in Rx,Ry,Rz (Figure ref:fig:detail_kinematics_cubic_mobility_rotations): +- more mobility in Rx and Ry than in Rz +- Mobility decreases with the size of the cube + +#+begin_src matlab +%% Cubic configuration +H = 100e-3; % Height of the Stewart platform [m] +Hc = 100e-3; % Size of the useful part of the cube [m] +FOc = 50e-3; % Center of the cube at the Stewart platform center +MO_B = -50e-3; % Position {B} with respect to {M} [m] +MHb = 0; + +stewart_cubic = initializeStewartPlatform(); +stewart_cubic = initializeFramesPositions(stewart_cubic, 'H', H, 'MO_B', MO_B); +stewart_cubic = generateCubicConfiguration(stewart_cubic, 'Hc', Hc, 'FOc', FOc, 'FHa', 5e-3, 'MHb', MHb); +stewart_cubic = computeJointsPose(stewart_cubic); +stewart_cubic = initializeStrutDynamics(stewart_cubic, 'k', 1); +stewart_cubic = computeJacobian(stewart_cubic); +stewart_cubic = initializeCylindricalPlatforms(stewart_cubic, 'Fpr', 150e-3, 'Mpr', 150e-3); + +% Let's now define the actuator stroke. +L_max = 50e-6; % [m] +#+end_src + +#+begin_src matlab :exports none :results none +%% Mobility of a Stewart platform with Cubic architecture - Translations +thetas = linspace(0, pi, 100); +phis = linspace(0, 2*pi, 200); +rs = zeros(length(thetas), length(phis)); + +for i = 1:length(thetas) + for j = 1:length(phis) + Tx = sin(thetas(i))*cos(phis(j)); + Ty = sin(thetas(i))*sin(phis(j)); + Tz = cos(thetas(i)); + + dL = stewart_cubic.kinematics.J*[Tx; Ty; Tz; 0; 0; 0;]; % dL required for 1m displacement in theta/phi direction + + rs(i, j) = L_max/max(abs(dL)); + % rs(i, j) = max(abs([dL(dL<0)*L_min; dL(dL>=0)*L_max])); + end +end + +[phi_grid, theta_grid] = meshgrid(phis, thetas); +X = 1e6 * rs .* sin(theta_grid) .* cos(phi_grid); +Y = 1e6 * rs .* sin(theta_grid) .* sin(phi_grid); +Z = 1e6 * rs .* cos(theta_grid); + +figure; +hold on; +surf(X, Y, Z, 'FaceColor', 'white', 'EdgeColor', colors(1,:)); +quiver3(0, 0, 0, 150, 0, 0, 'k', 'LineWidth', 2, 'MaxHeadSize', 0.7); +quiver3(0, 0, 0, 0, 150, 0, 'k', 'LineWidth', 2, 'MaxHeadSize', 0.7); +quiver3(0, 0, 0, 0, 0, 150, 'k', 'LineWidth', 2, 'MaxHeadSize', 0.7); +text(150, 0, 0, '$D_x$', 'FontSize', 10, 'HorizontalAlignment', 'center', 'VerticalAlignment', 'top' ); +text(0, 150, 0, '$D_y$', 'FontSize', 10, 'HorizontalAlignment', 'right', 'VerticalAlignment', 'bottom'); +text(0, 0, 150, '$D_z$', 'FontSize', 10, 'HorizontalAlignment', 'left', 'VerticalAlignment', 'top' ); +hold off; +axis equal; +grid off; +axis off; +view(105, 15); +#+end_src + +#+begin_src matlab :tangle no :exports results :results file none +exportFig('figs/detail_kinematics_cubic_mobility_translations.pdf', 'width', 'normal', 'height', 'full', 'simplify', true); +#+end_src + +#+begin_src matlab :exports none :results none +%% Mobility of a Stewart platform with Cubic architecture - Rotations +thetas = linspace(0, pi, 100); +phis = linspace(0, 2*pi, 200); +rs_cubic = zeros(length(thetas), length(phis)); + +for i = 1:length(thetas) + for j = 1:length(phis) + Rx = sin(thetas(i))*cos(phis(j)); + Ry = sin(thetas(i))*sin(phis(j)); + Rz = cos(thetas(i)); + + dL = stewart_cubic.kinematics.J*[0; 0; 0; Rx; Ry; Rz;]; + rs_cubic(i, j) = L_max/max(abs(dL)); + end +end + +[phi_grid, theta_grid] = meshgrid(phis, thetas); + +X_cubic = 1e6 * rs_cubic .* sin(theta_grid) .* cos(phi_grid); +Y_cubic = 1e6 * rs_cubic .* sin(theta_grid) .* sin(phi_grid); +Z_cubic = 1e6 * rs_cubic .* cos(theta_grid); + +figure; +hold on; +surf(X_cubic, Y_cubic, Z_cubic, 'FaceColor', 'white', 'LineWidth', 0.2, 'EdgeColor', colors(1,:)); +quiver3(0, 0, 0, 1500, 0, 0, 'k', 'LineWidth', 2, 'MaxHeadSize', 0.7); +quiver3(0, 0, 0, 0, 1500, 0, 'k', 'LineWidth', 2, 'MaxHeadSize', 0.7); +quiver3(0, 0, 0, 0, 0, 1500, 'k', 'LineWidth', 2, 'MaxHeadSize', 0.7); +text(1500, 0, 0, '$R_x$', 'FontSize', 10, 'HorizontalAlignment', 'center', 'VerticalAlignment', 'top' ); +text(0, 1500, 0, '$R_y$', 'FontSize', 10, 'HorizontalAlignment', 'right', 'VerticalAlignment', 'bottom'); +text(0, 0, 1500, '$R_z$', 'FontSize', 10, 'HorizontalAlignment', 'left', 'VerticalAlignment', 'top' ); +hold off; +axis equal; +grid off; +axis off; +view(105, 15); +#+end_src + +#+begin_src matlab :tangle no :exports results :results file none +exportFig('figs/detail_kinematics_cubic_mobility_rotations.pdf', 'width', 'normal', 'height', 'full', 'simplify', true); +#+end_src + +#+name: fig:detail_kinematics_cubic_mobility +#+caption: Mobility of a Stewart platform with Cubic architecture. Both for translations (\subref{fig:detail_kinematics_cubic_mobility_translations}) and rotations (\subref{fig:detail_kinematics_cubic_mobility_rotations}) +#+attr_latex: :options [htbp] +#+begin_figure +#+attr_latex: :caption \subcaption{\label{fig:detail_kinematics_cubic_mobility_translations}Mobility in translation} +#+attr_latex: :options {0.48\textwidth} +#+begin_subfigure +#+attr_latex: :scale 1 +[[file:figs/detail_kinematics_cubic_mobility_translations.png]] +#+end_subfigure +#+attr_latex: :caption \subcaption{\label{fig:detail_kinematics_cubic_mobility_rotations}Mobility in rotation} +#+attr_latex: :options {0.48\textwidth} +#+begin_subfigure +#+attr_latex: :scale 1 +[[file:figs/detail_kinematics_cubic_mobility_rotations.png]] +#+end_subfigure +#+end_figure + +** Dynamical Decoupling +<> +**** Introduction :ignore: + +- [ ] [[cite:&mcinroy00_desig_contr_flexur_joint_hexap]] + Why is this here? + +In this section, the dynamics of the platform in the cartesian frame is studied. +This corresponds to the transfer function from forces and torques $\bm{\mathcal{F}}$ to translations and rotations $\bm{\mathcal{X}}$ of the top platform. +If relative motion sensor are located in each strut ($\bm{\mathcal{L}}$ is measured), the pose $\bm{\mathcal{X}}$ is computed using the Jacobian matrix as shown in Figure ref:fig:detail_kinematics_centralized_control. + +#+begin_src latex :file detail_kinematics_centralized_control.pdf +\begin{tikzpicture} + \node[block] (Jt) at (0, 0) {$\bm{J}^{-T}$}; + \node[block, right= of Jt] (G) {$\bm{G}$}; + \node[block, right= of G] (J) {$\bm{J}^{-1}$}; + \node[block, left= of Jt] (Kx) {$\bm{K}_{\mathcal{X}}$}; + + \draw[->] (Kx.east) -- node[midway, above]{$\bm{\mathcal{F}}$} (Jt.west); + \draw[->] (Jt.east) -- (G.west) node[above left]{$\bm{\tau}$}; + \draw[->] (G.east) -- (J.west) node[above left]{$\bm{\mathcal{L}}$}; + \draw[->] (J.east) -- ++(1.0, 0); + \draw[->] ($(J.east) + (0.5, 0)$)node[]{$\bullet$} node[above]{$\bm{\mathcal{X}}$} -- ++(0, -1) -| ($(Kx.west) + (-0.5, 0)$) -- (Kx.west); + + \begin{scope}[on background layer] + \node[fit={(Jt.south west) (J.north east)}, fill=black!20!white, draw, dashed, inner sep=4pt] (Px) {}; + \node[anchor={south}] at (Px.north){\small{Cartesian Plant}}; + \end{scope} +\end{tikzpicture} +#+end_src + +#+name: fig:detail_kinematics_centralized_control +#+caption: From Strut coordinate to Cartesian coordinate using the Jacobian matrix +#+RESULTS: +[[file:figs/detail_kinematics_centralized_control.png]] + +We want to see if the Stewart platform has some special properties for control in the cartesian frame. + +**** Low frequency and High frequency coupling + +As was derived during the conceptual design phase, the dynamics from $\bm{\mathcal{F}}$ to $\bm{\mathcal{X}}$ is described by eqref:eq:detail_kinematics_transfer_function_cart + +\begin{equation}\label{eq:detail_kinematics_transfer_function_cart} + \frac{{\mathcal{X}}}{\bm{\mathcal{F}}}(s) = ( \bm{M} s^2 + \bm{J}^{T} \bm{\mathcal{C}} \bm{J} s + \bm{J}^{T} \bm{\mathcal{K}} \bm{J} )^{-1} +\end{equation} + + +At low frequency: the static behavior of the platform depends on the stiffness matrix eqref:eq:detail_kinematics_transfer_function_cart_low_freq. + +\begin{equation}\label{eq:detail_kinematics_transfer_function_cart_low_freq} + \frac{{\mathcal{X}}}{\bm{\mathcal{F}}}(j \omega) \xrightarrow[\omega \to 0]{} \bm{K}^{-1} +\end{equation} + +In section ref:ssec:detail_kinematics_cubic_static, it was shown that for the cubic configuration, the stiffness matrix is diagonal if frame $\{B\}$ is taken at the cube's center. +In that case, the "cartesian" plant is decoupled at low frequency. + +At high frequency, the behavior depends on the mass matrix (evaluated at frame B) eqref:eq:detail_kinematics_transfer_function_high_freq. + +\begin{equation}\label{eq:detail_kinematics_transfer_function_high_freq} + \frac{{\mathcal{X}}}{\bm{\mathcal{F}}}(j \omega) \xrightarrow[\omega \to \infty]{} - \omega^2 \bm{M}^{-1} +\end{equation} + +To have the mass matrix diagonal, the center of mass of the mobile parts needs to coincide with the B frame and the principal axes of inertia of the body also needs to coincide with the axis of the B frame. + +To verify that, +- CoM above the top platform (Figure ref:fig:detail_kinematics_cubic_payload) +- The transfer functions from F to X are computed for two specific locations of the B frames: + - center of mass: coupled at low frequency due to non diagonal stiffness matrix (Figure ref:fig:detail_kinematics_cubic_cart_coupling_com) + - center of stiffness: coupled at high frequency due to non diagonal mass matrix (Figure ref:fig:detail_kinematics_cubic_cart_coupling_cok) +- In both cases, we would get similar dynamics for a non-cubic stewart platform. + +#+name: fig:detail_kinematics_cubic_payload +#+caption: Cubic stewart platform with top cylindrical payload +#+attr_latex: :width 0.6\linewidth +[[file:figs/detail_kinematics_cubic_payload.png]] + +#+begin_src matlab +%% Input/Output definition of the Simscape model +clear io; io_i = 1; +io(io_i) = linio([mdl, '/Controller'], 1, 'openinput'); io_i = io_i + 1; % Actuator Force Inputs [N] +io(io_i) = linio([mdl, '/plant'], 1, 'openoutput'); io_i = io_i + 1; % External metrology [m,rad] + +% Prepare simulation +controller = initializeController('type', 'open-loop'); +sample = initializeSample('type', 'cylindrical', 'm', 10, 'H', 100e-3, 'R', 100e-3); + +%% Cubic Stewart platform with payload above the top platform - B frame at the CoM +H = 200e-3; % height of the Stewart platform [m] +MO_B = 50e-3; % Position {B} with respect to {M} [m] + +stewart = initializeStewartPlatform(); +stewart = initializeFramesPositions(stewart, 'H', H, 'MO_B', MO_B); +stewart = generateCubicConfiguration(stewart, 'Hc', H, 'FOc', H/2, 'FHa', 25e-3, 'MHb', 25e-3); +stewart = computeJointsPose(stewart); +stewart = initializeStrutDynamics(stewart, 'k', 1e6, 'c', 1e1); +stewart = initializeJointDynamics(stewart, 'type_F', '2dof', 'type_M', '3dof'); +stewart = computeJacobian(stewart); +stewart = initializeStewartPose(stewart); +stewart = initializeCylindricalPlatforms(stewart, ... + 'Mpm', 1e-6, ... % Massless platform + 'Fpm', 1e-6, ... % Massless platform + 'Mph', 20e-3, ... % Thin platform + 'Fph', 20e-3, ... % Thin platform + 'Mpr', 1.2*max(vecnorm(stewart.platform_M.Mb)), ... + 'Fpr', 1.2*max(vecnorm(stewart.platform_F.Fa))); +stewart = initializeCylindricalStruts(stewart, ... + 'Fsm', 1e-6, ... % Massless strut + 'Msm', 1e-6, ... % Massless strut + 'Fsh', stewart.geometry.l(1)/2, ... + 'Msh', stewart.geometry.l(1)/2 ... +); + +% Run the linearization +G_CoM = linearize(mdl, io)*inv(stewart.kinematics.J).'; +G_CoM.InputName = {'Fx', 'Fy', 'Fz', 'Mx', 'My', 'Mz'}; +G_CoM.OutputName = {'Dx', 'Dy', 'Dz', 'Rx', 'Ry', 'Rz'}; + +%% Same geometry but B Frame at cube's center (CoK) +MO_B = -100e-3; % Position {B} with respect to {M} [m] +stewart = initializeStewartPlatform(); +stewart = initializeFramesPositions(stewart, 'H', H, 'MO_B', MO_B); +stewart = generateCubicConfiguration(stewart, 'Hc', H, 'FOc', H/2, 'FHa', 25e-3, 'MHb', 25e-3); +stewart = computeJointsPose(stewart); +stewart = initializeStrutDynamics(stewart, 'k', 1e6, 'c', 1e1); +stewart = initializeJointDynamics(stewart, 'type_F', '2dof', 'type_M', '3dof'); +stewart = computeJacobian(stewart); +stewart = initializeStewartPose(stewart); +stewart = initializeCylindricalPlatforms(stewart, ... + 'Mpm', 1e-6, ... % Massless platform + 'Fpm', 1e-6, ... % Massless platform + 'Mph', 20e-3, ... % Thin platform + 'Fph', 20e-3, ... % Thin platform + 'Mpr', 1.2*max(vecnorm(stewart.platform_M.Mb)), ... + 'Fpr', 1.2*max(vecnorm(stewart.platform_F.Fa))); +stewart = initializeCylindricalStruts(stewart, ... + 'Fsm', 1e-6, ... % Massless strut + 'Msm', 1e-6, ... % Massless strut + 'Fsh', stewart.geometry.l(1)/2, ... + 'Msh', stewart.geometry.l(1)/2 ... +); + +% Run the linearization +G_CoK = linearize(mdl, io)*inv(stewart.kinematics.J.'); +G_CoK.InputName = {'Fx', 'Fy', 'Fz', 'Mx', 'My', 'Mz'}; +G_CoK.OutputName = {'Dx', 'Dy', 'Dz', 'Rx', 'Ry', 'Rz'}; +#+end_src + +#+begin_src matlab :exports none :results none +%% Coupling in the cartesian frame for a Cubic Stewart platform - Frame {B} is at the center of mass of the payload +freqs = logspace(0, 4, 1000); +figure; +tiledlayout(1, 1, 'TileSpacing', 'Compact', 'Padding', 'None'); +ax1 = nexttile(); +hold on; +% for i = 1:5 +% for j = i+1:6 +% plot(freqs, abs(squeeze(freqresp(G_CoM(i, j), freqs, 'Hz'))), 'color', [0, 0, 0, 0.2], ... +% 'HandleVisibility', 'off'); +% end +% end +plot(freqs, abs(squeeze(freqresp(G_CoM(1, 1), freqs, 'Hz'))), 'color', colors(1,:), ... + 'DisplayName', '$D_x/F_x$'); +plot(freqs, abs(squeeze(freqresp(G_CoM(2, 2), freqs, 'Hz'))), 'color', colors(2,:), ... + 'DisplayName', '$D_y/F_y$'); +plot(freqs, abs(squeeze(freqresp(G_CoM(3, 3), freqs, 'Hz'))), 'color', colors(3,:), ... + 'DisplayName', '$D_z/F_z$'); +plot(freqs, abs(squeeze(freqresp(G_CoM(4, 4), freqs, 'Hz'))), 'color', colors(4,:), ... + 'DisplayName', '$R_x/M_x$'); +plot(freqs, abs(squeeze(freqresp(G_CoM(5, 5), freqs, 'Hz'))), 'color', colors(5,:), ... + 'DisplayName', '$R_y/M_y$'); +plot(freqs, abs(squeeze(freqresp(G_CoM(6, 6), freqs, 'Hz'))), 'color', colors(6,:), ... + 'DisplayName', '$R_z/M_z$'); +plot(freqs, abs(squeeze(freqresp(G_CoM(4, 2), freqs, 'Hz'))), 'color', [0, 0, 0, 0.2], ... + 'DisplayName', '$R_x/F_y$'); +plot(freqs, abs(squeeze(freqresp(G_CoM(5, 1), freqs, 'Hz'))), 'color', [0, 0, 0, 0.2], ... + 'DisplayName', '$R_y/F_x$'); +plot(freqs, abs(squeeze(freqresp(G_CoM(1, 5), freqs, 'Hz'))), 'color', [0, 0, 0, 0.2], ... + 'DisplayName', '$D_x/M_y$'); +plot(freqs, abs(squeeze(freqresp(G_CoM(2, 4), freqs, 'Hz'))), 'color', [0, 0, 0, 0.2], ... + 'DisplayName', '$D_y/M_x$'); +hold off; +set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log'); +xlabel('Frequency [Hz]'); ylabel('Amplitude'); +leg = legend('location', 'southwest', 'FontSize', 8, 'NumColumns', 2); +leg.ItemTokenSize(1) = 15; +xlim([1, 1e4]); +ylim([1e-10, 2e-3]) +#+end_src + +#+begin_src matlab :tangle no :exports results :results file none +exportFig('figs/detail_kinematics_cubic_cart_coupling_com.pdf', 'width', 'half', 'height', 600); +#+end_src + +#+begin_src matlab :exports none :results none +%% Coupling in the cartesian frame for a Cubic Stewart platform - Frame {B} is at the center of the cube +freqs = logspace(0, 4, 1000); +figure; +tiledlayout(1, 1, 'TileSpacing', 'Compact', 'Padding', 'None'); +ax1 = nexttile(); +hold on; +% for i = 1:5 +% for j = i+1:6 +% plot(freqs, abs(squeeze(freqresp(G_CoK(i, j), freqs, 'Hz'))), 'color', [0, 0, 0, 0.2], ... +% 'HandleVisibility', 'off'); +% end +% end +plot(freqs, abs(squeeze(freqresp(G_CoK(1, 1), freqs, 'Hz'))), 'color', colors(1,:), ... + 'DisplayName', '$D_x/F_x$'); +plot(freqs, abs(squeeze(freqresp(G_CoK(2, 2), freqs, 'Hz'))), 'color', colors(2,:), ... + 'DisplayName', '$D_y/F_y$'); +plot(freqs, abs(squeeze(freqresp(G_CoK(3, 3), freqs, 'Hz'))), 'color', colors(3,:), ... + 'DisplayName', '$D_z/F_z$'); +plot(freqs, abs(squeeze(freqresp(G_CoK(4, 4), freqs, 'Hz'))), 'color', colors(4,:), ... + 'DisplayName', '$R_x/M_x$'); +plot(freqs, abs(squeeze(freqresp(G_CoK(5, 5), freqs, 'Hz'))), 'color', colors(5,:), ... + 'DisplayName', '$R_y/M_y$'); +plot(freqs, abs(squeeze(freqresp(G_CoK(6, 6), freqs, 'Hz'))), 'color', colors(6,:), ... + 'DisplayName', '$R_z/M_z$'); +plot(freqs, abs(squeeze(freqresp(G_CoK(4, 2), freqs, 'Hz'))), 'color', [0, 0, 0, 0.2], ... + 'DisplayName', '$R_x/F_y$'); +plot(freqs, abs(squeeze(freqresp(G_CoK(5, 1), freqs, 'Hz'))), 'color', [0, 0, 0, 0.2], ... + 'DisplayName', '$R_y/F_x$'); +plot(freqs, abs(squeeze(freqresp(G_CoK(1, 5), freqs, 'Hz'))), 'color', [0, 0, 0, 0.2], ... + 'DisplayName', '$D_x/M_y$'); +plot(freqs, abs(squeeze(freqresp(G_CoK(2, 4), freqs, 'Hz'))), 'color', [0, 0, 0, 0.2], ... + 'DisplayName', '$D_y/M_x$'); +hold off; +set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log'); +xlabel('Frequency [Hz]'); ylabel('Amplitude'); +leg = legend('location', 'southeast', 'FontSize', 8, 'NumColumns', 2); +leg.ItemTokenSize(1) = 15; +xlim([1, 1e4]); +ylim([1e-10, 2e-3]) +#+end_src + +#+begin_src matlab :tangle no :exports results :results file none +exportFig('figs/detail_kinematics_cubic_cart_coupling_cok.pdf', 'width', 'half', 'height', 600); +#+end_src + +#+name: fig:detail_kinematics_cubic_cart_coupling +#+caption: Transfer functions for a Cubic Stewart platform expressed in the Cartesian frame. Two locations of the $\{B\}$ frame are considered: at the cube's center (\subref{fig:detail_kinematics_cubic_cart_coupling_cok}) and at the center of mass of the moving body (\subref{fig:detail_kinematics_cubic_cart_coupling_com}). +#+attr_latex: :options [htbp] +#+begin_figure +#+attr_latex: :caption \subcaption{\label{fig:detail_kinematics_cubic_cart_coupling_com}$\{B\}$ at the center of mass} +#+attr_latex: :options {0.48\textwidth} +#+begin_subfigure +#+attr_latex: :width 0.95\linewidth +[[file:figs/detail_kinematics_cubic_cart_coupling_com.png]] +#+end_subfigure +#+attr_latex: :caption \subcaption{\label{fig:detail_kinematics_cubic_cart_coupling_cok}$\{B\}$ at the cube's center} +#+attr_latex: :options {0.48\textwidth} +#+begin_subfigure +#+attr_latex: :width 0.95\linewidth +[[file:figs/detail_kinematics_cubic_cart_coupling_cok.png]] +#+end_subfigure +#+end_figure + +**** Payload's CoM at the cube's center + +It is therefore natural to try to have the cube's center and the center of mass of the moving part coincide at the same location. + +- CoM at the center of the cube: Figure ref:fig:detail_kinematics_cubic_centered_payload + +This is what is physically done in [[cite:&mcinroy99_dynam;&mcinroy99_precis_fault_toler_point_using_stewar_platf;&mcinroy00_desig_contr_flexur_joint_hexap;&li01_simul_vibrat_isolat_point_contr;&jafari03_orthog_gough_stewar_platf_microm]] +Shown in Figure ref:fig:detail_kinematics_uw_gsp + +The obtained dynamics is indeed well decoupled, thanks to the diagonal stiffness matrix and mass matrix as the same time. + +The main issue with this is that usually we want the payload to be located above the top platform, as it is the case for the nano-hexapod. +Indeed, if a similar design than the one shown in Figure ref:fig:detail_kinematics_cubic_centered_payload was used, the x-ray beam will hit the different struts during the rotation of the spindle. + +#+begin_src matlab +%% Cubic Stewart platform with payload above the top platform +H = 200e-3; +MO_B = -100e-3; % Position {B} with respect to {M} [m] + +stewart = initializeStewartPlatform(); +stewart = initializeFramesPositions(stewart, 'H', H, 'MO_B', MO_B); +stewart = generateCubicConfiguration(stewart, 'Hc', H, 'FOc', H/2, 'FHa', 25e-3, 'MHb', 25e-3); +stewart = computeJointsPose(stewart); +stewart = initializeStrutDynamics(stewart, 'k', 1e6, 'c', 1e1); +stewart = initializeJointDynamics(stewart, 'type_F', '2dof', 'type_M', '3dof'); +stewart = computeJacobian(stewart); +stewart = initializeStewartPose(stewart); +stewart = initializeCylindricalPlatforms(stewart, ... + 'Mpm', 1e-6, ... % Massless platform + 'Fpm', 1e-6, ... % Massless platform + 'Mph', 20e-3, ... % Thin platform + 'Fph', 20e-3, ... % Thin platform + 'Mpr', 1.2*max(vecnorm(stewart.platform_M.Mb)), ... + 'Fpr', 1.2*max(vecnorm(stewart.platform_F.Fa))); +stewart = initializeCylindricalStruts(stewart, ... + 'Fsm', 1e-6, ... % Massless strut + 'Msm', 1e-6, ... % Massless strut + 'Fsh', stewart.geometry.l(1)/2, ... + 'Msh', stewart.geometry.l(1)/2 ... +); + +% Sample at the Center of the cube +sample = initializeSample('type', 'cylindrical', 'm', 10, 'H', 100e-3, 'H_offset', -H/2-50e-3); + +% Run the linearization +G_CoM_CoK = linearize(mdl, io)*inv(stewart.kinematics.J.'); +G_CoM_CoK.InputName = {'Fx', 'Fy', 'Fz', 'Mx', 'My', 'Mz'}; +G_CoM_CoK.OutputName = {'Dx', 'Dy', 'Dz', 'Rx', 'Ry', 'Rz'}; +#+end_src + +#+begin_src matlab :exports none +freqs = logspace(0, 4, 1000); +figure; +tiledlayout(1, 1, 'TileSpacing', 'Compact', 'Padding', 'None'); +ax1 = nexttile(); +hold on; +plot(freqs, abs(squeeze(freqresp(G_CoM_CoK(1, 1), freqs, 'Hz'))), 'color', colors(1,:), ... + 'DisplayName', '$D_x/F_x$'); +plot(freqs, abs(squeeze(freqresp(G_CoM_CoK(2, 2), freqs, 'Hz'))), 'color', colors(2,:), ... + 'DisplayName', '$D_y/F_y$'); +plot(freqs, abs(squeeze(freqresp(G_CoM_CoK(3, 3), freqs, 'Hz'))), 'color', colors(3,:), ... + 'DisplayName', '$D_z/F_z$'); +plot(freqs, abs(squeeze(freqresp(G_CoM_CoK(4, 4), freqs, 'Hz'))), 'color', colors(4,:), ... + 'DisplayName', '$R_x/M_x$'); +plot(freqs, abs(squeeze(freqresp(G_CoM_CoK(5, 5), freqs, 'Hz'))), 'color', colors(5,:), ... + 'DisplayName', '$R_y/M_y$'); +plot(freqs, abs(squeeze(freqresp(G_CoM_CoK(6, 6), freqs, 'Hz'))), 'color', colors(6,:), ... + 'DisplayName', '$R_z/M_z$'); +plot(freqs, abs(squeeze(freqresp(G_CoM_CoK(4, 2), freqs, 'Hz'))), 'color', [0, 0, 0, 0.2], ... + 'DisplayName', '$R_x/F_y$'); +plot(freqs, abs(squeeze(freqresp(G_CoM_CoK(5, 1), freqs, 'Hz'))), 'color', [0, 0, 0, 0.2], ... + 'DisplayName', '$R_y/F_x$'); +plot(freqs, abs(squeeze(freqresp(G_CoM_CoK(1, 5), freqs, 'Hz'))), 'color', [0, 0, 0, 0.2], ... + 'DisplayName', '$D_x/M_y$'); +plot(freqs, abs(squeeze(freqresp(G_CoM_CoK(2, 4), freqs, 'Hz'))), 'color', [0, 0, 0, 0.2], ... + 'DisplayName', '$D_y/M_x$'); +hold off; +set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log'); +xlabel('Frequency [Hz]'); ylabel('Amplitude [m/V]'); +leg = legend('location', 'southwest', 'FontSize', 8, 'NumColumns', 2); +leg.ItemTokenSize(1) = 15; +xlim([1, 1e4]); +ylim([1e-10, 2e-3]) +#+end_src + +#+begin_src matlab :tangle no :exports results :results file none +exportFig('figs/detail_kinematics_cubic_cart_coupling_com_cok.pdf', 'width', 'half', 'height', 600); +#+end_src + +#+name: fig:detail_kinematics_cubic_com_cok +#+caption: Cubic Stewart platform with payload at the cube's center (\subref{fig:detail_kinematics_cubic_centered_payload}). Obtained cartesian plant is fully decoupled (\subref{fig:detail_kinematics_cubic_cart_coupling_com_cok}) +#+attr_latex: :options [htbp] +#+begin_figure +#+attr_latex: :caption \subcaption{\label{fig:detail_kinematics_cubic_centered_payload}Payload at the cube's center} +#+attr_latex: :options {0.49\textwidth} +#+begin_subfigure +#+attr_latex: :width 0.95\linewidth +[[file:figs/detail_kinematics_cubic_centered_payload.png]] +#+end_subfigure +#+attr_latex: :caption \subcaption{\label{fig:detail_kinematics_cubic_cart_coupling_com_cok}Fully decoupled cartesian plant} +#+attr_latex: :options {0.49\textwidth} +#+begin_subfigure +#+attr_latex: :width 0.95\linewidth +[[file:figs/detail_kinematics_cubic_cart_coupling_com_cok.png]] +#+end_subfigure +#+end_figure + +**** TODO Uniform stiffness :noexport: + +One may argue that the compliance matrix is more important that the stiffness matrix, as it describes how the platform with deforms to forces and torques. +As soon at the forces and torques are not longer applied to the center of the cube (which is typically not the case, except for specific case, as will be discussed), the Cubic architecture no longer provides same compliance in horizontal and vertical directions. + +Conclusion: +- Cubic architecture: + Very specific in the sense that it can give both: + - Same XYZ stiffness + - Diagonal K matrix + But only when evaluated at the cube's center First, we have to understand what is the physical meaning of the Stiffness matrix $\bm{K}$. @@ -1392,19 +2603,6 @@ If the stiffness matrix is inversible, its inverse is the compliance matrix: $\b Thus, if the stiffness matrix is diagonal, the compliance matrix is also diagonal and a force (resp. torque) $\bm{\mathcal{F}}_i$ applied on the mobile platform at $\{B\}$ will induce a pure translation (resp. rotation) of the mobile platform represented by $\{B\}$ with respect to $\{A\}$. - -- [ ] Frames at the center of the cube => diagonal K matrix => static decoupling in the cartesian frame (show the control architecture?) -- [ ] Frames above the top platform => non-diagonal K matrix => coupled at low frequency -- [ ] Uniform stiffness in X,Y,Z, equal to two times the actuator stiffness - Krx = Kry, but not equal to Krz -- [ ] Jacobian matrix? Any special? - - -The cubic architecture has indeed identical translational stiffnesses. - -Therefore, the cubic architecture is special only when considering a frame located at the center of the cube. -This is not very convenient, as in the vast majority of cases, the interesting frame is located about the top platform. - #+begin_src matlab :exports none :results none %% Cubic Architecture - Effect of the position of frame {A} and {B} H = 100e-3; % Height of the Stewart platform [m] @@ -1442,542 +2640,11 @@ displayArchitecture(stewart_offset, 'labels', false, 'frames', true); plotCube(stewart_offset, 'Hc', Hc, 'FOc', FOc, 'color', [0,0,0,0.5], 'link_to_struts', true); #+end_src -- [ ] Get the analytical formula for the Stiffness matrix? - -#+begin_src matlab :exports results :results value table replace :tangle no :post addhdr(*this*) -data2orgtable(stewart_center.kinematics.K, {}, {}, ' %.4f '); -#+end_src - -#+RESULTS: -| 2.0 | 0.0 | -0.0 | -0.0 | 0.0 | -0.0 | -|------+------+------+-------+-------+------| -| 0.0 | 2.0 | -0.0 | -0.0 | -0.0 | -0.0 | -| -0.0 | -0.0 | 2.0 | -0.0 | 0.0 | 0.0 | -| -0.0 | -0.0 | -0.0 | 0.015 | -0.0 | 0.0 | -| 0.0 | -0.0 | 0.0 | -0.0 | 0.015 | -0.0 | -| -0.0 | -0.0 | 0.0 | 0.0 | -0.0 | 0.06 | - -#+begin_src matlab :exports results :results value table replace :tangle no :post addhdr(*this*) -data2orgtable(stewart_offset.kinematics.K, {}, {}, ' %.4f '); -#+end_src - -#+RESULTS: -| 2.0 | -0.0 | -0.0 | 0.0 | -0.2 | 0.0 | -|------+------+------+-------+-------+------| -| -0.0 | 2.0 | 0.0 | 0.2 | -0.0 | 0.0 | -| -0.0 | 0.0 | 2.0 | -0.0 | 0.0 | 0.0 | -| 0.0 | 0.2 | -0.0 | 0.035 | -0.0 | 0.0 | -| -0.2 | -0.0 | 0.0 | -0.0 | 0.035 | 0.0 | -| 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.06 | - -Note that the cube's center needs not to be at the "center" of the Stewart platform. -This can lead to interesting architectures shown in Section ref:ssec:detail_kinematics_cubic_design. - Here are the conclusion about the Stiffness matrix for the Cubic configuration: - The cubic configuration permits to have $k_x = k_y = k_z$ and $k_{\theta_x} = k_{\theta_y}$ - The stiffness matrix $K$ is diagonal for the cubic configuration if the Jacobian is estimated at the cube center -**** Uniform Mobility - -Uniform mobility in X,Y,Z directions - -Show that be obtain a cube. - -Cubic configuration: "Vertical cube" with -#+begin_src matlab -%% With cubic configuration -H = 100e-3; % Height of the Stewart platform [m] -Hc = 100e-3; % Size of the useful part of the cube [m] -FOc = 50e-3; % Center of the cube at the Stewart platform center -MO_B = -50e-3; % Position {B} with respect to {M} [m] -MHb = 0; - -stewart_cubic = initializeStewartPlatform(); -stewart_cubic = initializeFramesPositions(stewart_cubic, 'H', H, 'MO_B', MO_B); -stewart_cubic = generateCubicConfiguration(stewart_cubic, 'Hc', Hc, 'FOc', FOc, 'FHa', 5e-3, 'MHb', MHb); -stewart_cubic = computeJointsPose(stewart_cubic); -stewart_cubic = initializeStrutDynamics(stewart_cubic, 'k', 1); -stewart_cubic = computeJacobian(stewart_cubic); -stewart_cubic = initializeCylindricalPlatforms(stewart_cubic, 'Fpr', 150e-3, 'Mpr', 150e-3); - -% Let's now define the actuator stroke. -L_max = 50e-6; % [m] -#+end_src - -#+begin_src matlab -thetas = linspace(0, pi, 100); -phis = linspace(0, 2*pi, 200); -rs = zeros(length(thetas), length(phis)); - -for i = 1:length(thetas) - for j = 1:length(phis) - Tx = sin(thetas(i))*cos(phis(j)); - Ty = sin(thetas(i))*sin(phis(j)); - Tz = cos(thetas(i)); - - dL = stewart_cubic.kinematics.J*[Tx; Ty; Tz; 0; 0; 0;]; % dL required for 1m displacement in theta/phi direction - - rs(i, j) = L_max/max(abs(dL)); - % rs(i, j) = max(abs([dL(dL<0)*L_min; dL(dL>=0)*L_max])); - end -end - -% Get circle that fits inside the accessible space -min(min(rs)) -max(max(rs)) -#+end_src - -#+begin_src matlab -[phi_grid, theta_grid] = meshgrid(phis, thetas); -X = 1e6 * rs .* sin(theta_grid) .* cos(phi_grid); -Y = 1e6 * rs .* sin(theta_grid) .* sin(phi_grid); -Z = 1e6 * rs .* cos(theta_grid); - -figure; -s = surf(X, Y, Z, 'FaceColor', 'white'); -s.EdgeColor = colors(1,:); -axis equal; -grid on; -xlabel('X Translation [$\mu$m]'); ylabel('Y Translation [$\mu$m]'); zlabel('Z Translation [$\mu$m]'); -xlim(5e6*[-L_max, L_max]); ylim(5e6*[-L_max, L_max]); zlim(5e6*[-L_max, L_max]); -#+end_src - -** Dynamical Decoupling -<> -**** Introduction :ignore: - -[[cite:&mcinroy00_desig_contr_flexur_joint_hexap]] - -In this section, we study the dynamics of the platform in the cartesian frame. - -We here suppose that there is one relative motion sensor in each strut ($\delta\bm{\mathcal{L}}$ is measured) and we would like to control the position of the top platform pose $\delta \bm{\mathcal{X}}$. - -Thanks to the Jacobian matrix, we can use the "architecture" shown in Figure ref:fig:detail_kinematics_local_to_cartesian_coordinates to obtain the dynamics of the system from forces/torques applied by the actuators on the top platform to translations/rotations of the top platform. - -#+begin_src latex :file detail_kinematics_local_to_cartesian_coordinates.pdf -\begin{tikzpicture} - \node[block] (Jt) at (0, 0) {$\bm{J}^{-T}$}; - \node[block, right= of Jt] (G) {$\bm{G}$}; - \node[block, right= of G] (J) {$\bm{J}^{-1}$}; - - \draw[->] ($(Jt.west)+(-0.8, 0)$) -- (Jt.west) node[above left]{$\bm{\mathcal{F}}$}; - \draw[->] (Jt.east) -- (G.west) node[above left]{$\bm{\tau}$}; - \draw[->] (G.east) -- (J.west) node[above left]{$\delta\bm{\mathcal{L}}$}; - \draw[->] (J.east) -- ++(0.8, 0) node[above left]{$\delta\bm{\mathcal{X}}$}; -\end{tikzpicture} -#+end_src - -#+name: fig:detail_kinematics_local_to_cartesian_coordinates -#+caption: From Strut coordinate to Cartesian coordinate using the Jacobian matrix -#+RESULTS: -[[file:figs/detail_kinematics_local_to_cartesian_coordinates.png]] - -We here study the dynamics from $\bm{\mathcal{F}}$ to $\delta\bm{\mathcal{X}}$. - -One has to note that when considering the static behavior: -\[ \bm{G}(s = 0) = \begin{bmatrix} - 1/k_1 & & 0 \\ - & \ddots & 0 \\ - 0 & & 1/k_6 - \end{bmatrix}\] - -And thus: -\[ \frac{\delta\bm{\mathcal{X}}}{\bm{\mathcal{F}}}(s = 0) = \bm{J}^{-1} \bm{G}(s = 0) \bm{J}^{-T} = \bm{K}^{-1} = \bm{C} \] - -We conclude that the *static* behavior of the platform depends on the stiffness matrix. -For the cubic configuration, we have a diagonal stiffness matrix is the frames $\{A\}$ and $\{B\}$ are coincident with the cube's center. - -**** Cube's center at the Center of Mass of the mobile platform -Let's create a Cubic Stewart Platform where the *Center of Mass of the mobile platform is located at the center of the cube*. - -We define the size of the Stewart platform and the position of frames $\{A\}$ and $\{B\}$. -#+begin_src matlab -H = 200e-3; % height of the Stewart platform [m] -MO_B = -10e-3; % Position {B} with respect to {M} [m] -#+end_src - -Now, we set the cube's parameters such that the center of the cube is coincident with $\{A\}$ and $\{B\}$. -#+begin_src matlab -Hc = 2.5*H; % Size of the useful part of the cube [m] -FOc = H + MO_B; % Center of the cube with respect to {F} -#+end_src - -#+begin_src matlab -stewart = initializeStewartPlatform(); -stewart = initializeFramesPositions(stewart, 'H', H, 'MO_B', MO_B); -stewart = generateCubicConfiguration(stewart, 'Hc', Hc, 'FOc', FOc, 'FHa', 25e-3, 'MHb', 25e-3); -stewart = computeJointsPose(stewart); -stewart = initializeStrutDynamics(stewart, 'k', 1e6, 'c', 1e1); -stewart = initializeJointDynamics(stewart, 'type_F', 'universal', 'type_M', 'spherical'); -stewart = computeJacobian(stewart); -stewart = initializeStewartPose(stewart); -#+end_src - -Now we set the geometry and mass of the mobile platform such that its center of mass is coincident with $\{A\}$ and $\{B\}$. -#+begin_src matlab -stewart = initializeCylindricalPlatforms(stewart, 'Fpr', 1.2*max(vecnorm(stewart.platform_F.Fa)), ... - 'Mpm', 10, ... - 'Mph', 20e-3, ... - 'Mpr', 1.2*max(vecnorm(stewart.platform_M.Mb))); -#+end_src - -And we set small mass for the struts. -#+begin_src matlab -stewart = initializeCylindricalStruts(stewart, 'Fsm', 1e-3, 'Msm', 1e-3); -stewart = initializeInertialSensor(stewart); -#+end_src - -No flexibility below the Stewart platform and no payload. -#+begin_src matlab -ground = initializeGround('type', 'none'); -payload = initializePayload('type', 'none'); -controller = initializeController('type', 'open-loop'); -#+end_src - -The obtain geometry is shown in figure [[fig:stewart_cubic_conf_decouple_dynamics]]. - -#+begin_src matlab :exports none -displayArchitecture(stewart, 'labels', false, 'view', 'all'); -#+end_src - -#+header: :tangle no :exports results :results none :noweb yes -#+begin_src matlab :var filepath="figs/stewart_cubic_conf_decouple_dynamics.pdf" :var figsize="full-tall" :post pdf2svg(file=*this*, ext="png") -<> -#+end_src - -#+name: fig:stewart_cubic_conf_decouple_dynamics -#+caption: Geometry used for the simulations - The cube's center, the frames $\{A\}$ and $\{B\}$ and the Center of mass of the mobile platform are coincident ([[./figs/stewart_cubic_conf_decouple_dynamics.png][png]], [[./figs/stewart_cubic_conf_decouple_dynamics.pdf][pdf]]) -[[file:figs/stewart_cubic_conf_decouple_dynamics.png]] - -We now identify the dynamics from forces applied in each strut $\bm{\tau}$ to the displacement of each strut $d \bm{\mathcal{L}}$. -#+begin_src matlab -open('stewart_platform_model.slx') - -%% Options for Linearized -options = linearizeOptions; -options.SampleTime = 0; - -%% Name of the Simulink File -mdl = 'stewart_platform_model'; - -%% Input/Output definition -clear io; io_i = 1; -io(io_i) = linio([mdl, '/Controller'], 1, 'openinput'); io_i = io_i + 1; % Actuator Force Inputs [N] -io(io_i) = linio([mdl, '/Stewart Platform'], 1, 'openoutput', [], 'dLm'); io_i = io_i + 1; % Relative Displacement Outputs [m] - -%% Run the linearization -G = linearize(mdl, io, options); -G.InputName = {'F1', 'F2', 'F3', 'F4', 'F5', 'F6'}; -G.OutputName = {'Dm1', 'Dm2', 'Dm3', 'Dm4', 'Dm5', 'Dm6'}; -#+end_src - -Now, thanks to the Jacobian (Figure [[fig:local_to_cartesian_coordinates]]), we compute the transfer function from $\bm{\mathcal{F}}$ to $\bm{\mathcal{X}}$. -#+begin_src matlab -Gc = inv(stewart.kinematics.J)*G*inv(stewart.kinematics.J'); -Gc = inv(stewart.kinematics.J)*G*stewart.kinematics.J; -Gc.InputName = {'Fx', 'Fy', 'Fz', 'Mx', 'My', 'Mz'}; -Gc.OutputName = {'Dx', 'Dy', 'Dz', 'Rx', 'Ry', 'Rz'}; -#+end_src - -The obtain dynamics $\bm{G}_{c}(s) = \bm{J}^{-T} \bm{G}(s) \bm{J}^{-1}$ is shown in Figure [[fig:stewart_cubic_decoupled_dynamics_cartesian]]. - -#+begin_src matlab :exports none -freqs = logspace(1, 3, 500); - -figure; - -ax1 = subplot(2, 2, 1); -hold on; -for i = 1:6 - for j = i+1:6 - plot(freqs, abs(squeeze(freqresp(Gc(i, j), freqs, 'Hz'))), 'k-'); - end -end -set(gca,'ColorOrderIndex',1); -plot(freqs, abs(squeeze(freqresp(Gc(1, 1), freqs, 'Hz')))); -plot(freqs, abs(squeeze(freqresp(Gc(2, 2), freqs, 'Hz')))); -plot(freqs, abs(squeeze(freqresp(Gc(3, 3), freqs, 'Hz')))); -hold off; -set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log'); -ylabel('Amplitude [m/N]'); set(gca, 'XTickLabel',[]); - -ax3 = subplot(2, 2, 3); -hold on; -for i = 1:6 - for j = i+1:6 - p4 = plot(freqs, 180/pi*angle(squeeze(freqresp(Gc(i, j), freqs, 'Hz'))), 'k-'); - end -end -set(gca,'ColorOrderIndex',1); -p1 = plot(freqs, 180/pi*angle(squeeze(freqresp(Gc(1, 1), freqs, 'Hz')))); -p2 = plot(freqs, 180/pi*angle(squeeze(freqresp(Gc(2, 2), freqs, 'Hz')))); -p3 = plot(freqs, 180/pi*angle(squeeze(freqresp(Gc(3, 3), freqs, 'Hz')))); -hold off; -set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin'); -ylabel('Phase [deg]'); xlabel('Frequency [Hz]'); -ylim([-180, 180]); -yticks([-180, -90, 0, 90, 180]); -legend([p1, p2, p3, p4], {'$D_x/F_x$','$D_y/F_y$', '$D_z/F_z$', '$D_i/F_j$'}) - -ax2 = subplot(2, 2, 2); -hold on; -for i = 1:6 - for j = i+1:6 - plot(freqs, abs(squeeze(freqresp(Gc(i, j), freqs, 'Hz'))), 'k-'); - end -end -set(gca,'ColorOrderIndex',1); -plot(freqs, abs(squeeze(freqresp(Gc(4, 4), freqs, 'Hz')))); -plot(freqs, abs(squeeze(freqresp(Gc(5, 5), freqs, 'Hz')))); -plot(freqs, abs(squeeze(freqresp(Gc(6, 6), freqs, 'Hz')))); -hold off; -set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log'); -ylabel('Amplitude [m/N]'); set(gca, 'XTickLabel',[]); - -ax4 = subplot(2, 2, 4); -hold on; -for i = 1:6 - for j = i+1:6 - p4 = plot(freqs, 180/pi*angle(squeeze(freqresp(Gc(i, j), freqs, 'Hz'))), 'k-'); - end -end -set(gca,'ColorOrderIndex',1); -p1 = plot(freqs, 180/pi*angle(squeeze(freqresp(Gc(4, 4), freqs, 'Hz')))); -p2 = plot(freqs, 180/pi*angle(squeeze(freqresp(Gc(5, 5), freqs, 'Hz')))); -p3 = plot(freqs, 180/pi*angle(squeeze(freqresp(Gc(6, 6), freqs, 'Hz')))); -hold off; -set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin'); -ylabel('Phase [deg]'); xlabel('Frequency [Hz]'); -ylim([-180, 180]); -yticks([-180, -90, 0, 90, 180]); -legend([p1, p2, p3, p4], {'$R_x/M_x$','$R_y/M_y$', '$R_z/M_z$', '$R_i/M_j$'}) - -linkaxes([ax1,ax2,ax3,ax4],'x'); -#+end_src - -#+header: :tangle no :exports results :results none :noweb yes -#+begin_src matlab :var filepath="figs/stewart_cubic_decoupled_dynamics_cartesian.pdf" :var figsize="full-tall" :post pdf2svg(file=*this*, ext="png") -<> -#+end_src - -#+name: fig:stewart_cubic_decoupled_dynamics_cartesian -#+caption: Dynamics from $\bm{\mathcal{F}}$ to $\bm{\mathcal{X}}$ ([[./figs/stewart_cubic_decoupled_dynamics_cartesian.png][png]], [[./figs/stewart_cubic_decoupled_dynamics_cartesian.pdf][pdf]]) -[[file:figs/stewart_cubic_decoupled_dynamics_cartesian.png]] - -It is interesting to note here that the system shown in Figure [[fig:local_to_cartesian_coordinates_bis]] also yield a decoupled system (explained in section 1.3.3 in cite:li01_simul_fault_vibrat_isolat_point). - -#+begin_src latex :file local_to_cartesian_coordinates_bis.pdf -\begin{tikzpicture} - \node[block] (Jt) at (0, 0) {$\bm{J}$}; - \node[block, right= of Jt] (G) {$\bm{G}$}; - \node[block, right= of G] (J) {$\bm{J}^{-1}$}; - - \draw[->] ($(Jt.west)+(-0.8, 0)$) -- (Jt.west); - \draw[->] (Jt.east) -- (G.west) node[above left]{$\bm{\tau}$}; - \draw[->] (G.east) -- (J.west) node[above left]{$\delta\bm{\mathcal{L}}$}; - \draw[->] (J.east) -- ++(0.8, 0) node[above left]{$\delta\bm{\mathcal{X}}$}; -\end{tikzpicture} -#+end_src - -#+name: fig:local_to_cartesian_coordinates_bis -#+caption: Alternative way to decouple the system -#+RESULTS: -[[file:figs/local_to_cartesian_coordinates_bis.png]] - -#+begin_important -The dynamics is well decoupled at all frequencies. - -We have the same dynamics for: -- $D_x/F_x$, $D_y/F_y$ and $D_z/F_z$ -- $R_x/M_x$ and $D_y/F_y$ - -The Dynamics from $F_i$ to $D_i$ is just a 1-dof mass-spring-damper system. - -This is because the Mass, Damping and Stiffness matrices are all diagonal. -#+end_important - - - -**** Cube's center not coincident with the Mass of the Mobile platform -Let's create a Stewart platform with a cubic architecture where the cube's center is at the center of the Stewart platform. -#+begin_src matlab -H = 200e-3; % height of the Stewart platform [m] -MO_B = -100e-3; % Position {B} with respect to {M} [m] -#+end_src - -Now, we set the cube's parameters such that the center of the cube is coincident with $\{A\}$ and $\{B\}$. -#+begin_src matlab -Hc = 2.5*H; % Size of the useful part of the cube [m] -FOc = H + MO_B; % Center of the cube with respect to {F} -#+end_src - -#+begin_src matlab -stewart = initializeStewartPlatform(); -stewart = initializeFramesPositions(stewart, 'H', H, 'MO_B', MO_B); -stewart = generateCubicConfiguration(stewart, 'Hc', Hc, 'FOc', FOc, 'FHa', 25e-3, 'MHb', 25e-3); -stewart = computeJointsPose(stewart); -stewart = initializeStrutDynamics(stewart, 'K', 1e6*ones(6,1), 'C', 1e1*ones(6,1)); -stewart = initializeJointDynamics(stewart, 'type_F', 'universal', 'type_M', 'spherical'); -stewart = computeJacobian(stewart); -stewart = initializeStewartPose(stewart); -#+end_src - -However, the Center of Mass of the mobile platform is *not* located at the cube's center. -#+begin_src matlab -stewart = initializeCylindricalPlatforms(stewart, 'Fpr', 1.2*max(vecnorm(stewart.platform_F.Fa)), ... - 'Mpm', 10, ... - 'Mph', 20e-3, ... - 'Mpr', 1.2*max(vecnorm(stewart.platform_M.Mb))); -#+end_src - -And we set small mass for the struts. -#+begin_src matlab -stewart = initializeCylindricalStruts(stewart, 'Fsm', 1e-3, 'Msm', 1e-3); -stewart = initializeInertialSensor(stewart); -#+end_src - -No flexibility below the Stewart platform and no payload. -#+begin_src matlab -ground = initializeGround('type', 'none'); -payload = initializePayload('type', 'none'); -controller = initializeController('type', 'open-loop'); -#+end_src - -The obtain geometry is shown in figure [[fig:stewart_cubic_conf_mass_above]]. -#+begin_src matlab :exports none -displayArchitecture(stewart, 'labels', false, 'view', 'all'); -#+end_src - -#+header: :tangle no :exports results :results none :noweb yes -#+begin_src matlab :var filepath="figs/stewart_cubic_conf_mass_above.pdf" :var figsize="full-tall" :post pdf2svg(file=*this*, ext="png") -<> -#+end_src - -#+name: fig:stewart_cubic_conf_mass_above -#+caption: Geometry used for the simulations - The cube's center is coincident with the frames $\{A\}$ and $\{B\}$ but not with the Center of mass of the mobile platform ([[./figs/stewart_cubic_conf_mass_above.png][png]], [[./figs/stewart_cubic_conf_mass_above.pdf][pdf]]) -[[file:figs/stewart_cubic_conf_mass_above.png]] - -We now identify the dynamics from forces applied in each strut $\bm{\tau}$ to the displacement of each strut $d \bm{\mathcal{L}}$. -#+begin_src matlab -open('stewart_platform_model.slx') - -%% Options for Linearized -options = linearizeOptions; -options.SampleTime = 0; - -%% Name of the Simulink File -mdl = 'stewart_platform_model'; - -%% Input/Output definition -clear io; io_i = 1; -io(io_i) = linio([mdl, '/Controller'], 1, 'openinput'); io_i = io_i + 1; % Actuator Force Inputs [N] -io(io_i) = linio([mdl, '/Stewart Platform'], 1, 'openoutput', [], 'dLm'); io_i = io_i + 1; % Relative Displacement Outputs [m] - -%% Run the linearization -G = linearize(mdl, io, options); -G.InputName = {'F1', 'F2', 'F3', 'F4', 'F5', 'F6'}; -G.OutputName = {'Dm1', 'Dm2', 'Dm3', 'Dm4', 'Dm5', 'Dm6'}; -#+end_src - -And we use the Jacobian to compute the transfer function from $\bm{\mathcal{F}}$ to $\bm{\mathcal{X}}$. -#+begin_src matlab -Gc = inv(stewart.kinematics.J)*G*inv(stewart.kinematics.J'); -Gc.InputName = {'Fx', 'Fy', 'Fz', 'Mx', 'My', 'Mz'}; -Gc.OutputName = {'Dx', 'Dy', 'Dz', 'Rx', 'Ry', 'Rz'}; -#+end_src - -The obtain dynamics $\bm{G}_{c}(s) = \bm{J}^{-T} \bm{G}(s) \bm{J}^{-1}$ is shown in Figure [[fig:stewart_conf_coupling_mass_matrix]]. - -#+begin_src matlab :exports none -freqs = logspace(1, 3, 500); - -figure; - -ax1 = subplot(2, 2, 1); -hold on; -for i = 1:6 - for j = i+1:6 - plot(freqs, abs(squeeze(freqresp(Gc(i, j), freqs, 'Hz'))), 'k-'); - end -end -set(gca,'ColorOrderIndex',1); -plot(freqs, abs(squeeze(freqresp(Gc(1, 1), freqs, 'Hz')))); -plot(freqs, abs(squeeze(freqresp(Gc(2, 2), freqs, 'Hz')))); -plot(freqs, abs(squeeze(freqresp(Gc(3, 3), freqs, 'Hz')))); -hold off; -set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log'); -ylabel('Amplitude [m/N]'); set(gca, 'XTickLabel',[]); - -ax3 = subplot(2, 2, 3); -hold on; -for i = 1:6 - for j = i+1:6 - p4 = plot(freqs, 180/pi*angle(squeeze(freqresp(Gc(i, j), freqs, 'Hz'))), 'k-'); - end -end -set(gca,'ColorOrderIndex',1); -p1 = plot(freqs, 180/pi*angle(squeeze(freqresp(Gc(1, 1), freqs, 'Hz')))); -p2 = plot(freqs, 180/pi*angle(squeeze(freqresp(Gc(2, 2), freqs, 'Hz')))); -p3 = plot(freqs, 180/pi*angle(squeeze(freqresp(Gc(3, 3), freqs, 'Hz')))); -hold off; -set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin'); -ylabel('Phase [deg]'); xlabel('Frequency [Hz]'); -ylim([-180, 180]); -yticks([-180, -90, 0, 90, 180]); -legend([p1, p2, p3, p4], {'$D_x/F_x$','$D_y/F_y$', '$D_z/F_z$', '$D_i/F_j$'}) - -ax2 = subplot(2, 2, 2); -hold on; -for i = 1:6 - for j = i+1:6 - plot(freqs, abs(squeeze(freqresp(Gc(i, j), freqs, 'Hz'))), 'k-'); - end -end -set(gca,'ColorOrderIndex',1); -plot(freqs, abs(squeeze(freqresp(Gc(4, 4), freqs, 'Hz')))); -plot(freqs, abs(squeeze(freqresp(Gc(5, 5), freqs, 'Hz')))); -plot(freqs, abs(squeeze(freqresp(Gc(6, 6), freqs, 'Hz')))); -hold off; -set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log'); -ylabel('Amplitude [m/N]'); set(gca, 'XTickLabel',[]); - -ax4 = subplot(2, 2, 4); -hold on; -for i = 1:6 - for j = i+1:6 - p4 = plot(freqs, 180/pi*angle(squeeze(freqresp(Gc(i, j), freqs, 'Hz'))), 'k-'); - end -end -set(gca,'ColorOrderIndex',1); -p1 = plot(freqs, 180/pi*angle(squeeze(freqresp(Gc(4, 4), freqs, 'Hz')))); -p2 = plot(freqs, 180/pi*angle(squeeze(freqresp(Gc(5, 5), freqs, 'Hz')))); -p3 = plot(freqs, 180/pi*angle(squeeze(freqresp(Gc(6, 6), freqs, 'Hz')))); -hold off; -set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin'); -ylabel('Phase [deg]'); xlabel('Frequency [Hz]'); -ylim([-180, 180]); -yticks([-180, -90, 0, 90, 180]); -legend([p1, p2, p3, p4], {'$R_x/M_x$','$R_y/M_y$', '$R_z/M_z$', '$R_i/M_j$'}) - -linkaxes([ax1,ax2,ax3,ax4],'x'); -#+end_src - -#+header: :tangle no :exports results :results none :noweb yes -#+begin_src matlab :var filepath="figs/stewart_conf_coupling_mass_matrix.pdf" :var figsize="full-tall" :post pdf2svg(file=*this*, ext="png") -<> -#+end_src - -#+name: fig:stewart_conf_coupling_mass_matrix -#+caption: Obtained Dynamics from $\bm{\mathcal{F}}$ to $\bm{\mathcal{X}}$ ([[./figs/stewart_conf_coupling_mass_matrix.png][png]], [[./figs/stewart_conf_coupling_mass_matrix.pdf][pdf]]) -[[file:figs/stewart_conf_coupling_mass_matrix.png]] - -#+begin_important -The system is decoupled at low frequency (the Stiffness matrix being diagonal), but it is *not* decoupled at all frequencies. - -This was expected as the mass matrix is not diagonal (the Center of Mass of the mobile platform not being coincident with the frame $\{B\}$). -#+end_important - -**** Dynamic isotropy +**** TODO Dynamic isotropy :noexport: [[cite:&afzali-far16_vibrat_dynam_isotr_hexap_analy_studies]]: - proposes an architecture where the CoM can be above the top platform @@ -1994,340 +2661,548 @@ This was expected as the mass matrix is not diagonal (the Center of Mass of the - Show examples where the dynamics can indeed be decoupled in the cartesian frame (i.e. decoupled K and M matrices) + +- [ ] Try to find a stewart platform an a payload for witch all resonances are equal. + It is not possible for a cubic architecture and a cylinder. + But maybe we can propose to not use a cubic architecture and still have dynamic isotropy? + For instance, let's consider a specific payload => give some rules to obtain dynamic isotropy: + + + Inertia of a cylinder: + Iz = 1/2mr^2 + Ix = Iy = 1/12 m (3r^2 + h^2) + +We want M = alpha K + +2k = alpha m + +alpha = 2k/m + +Krx = 3/2 k H^2 = Ix = 1/12 m + +#+begin_src matlab +%% Cubic Stewart platform with payload above the top platform +H = 200e-3; +MO_B = -100e-3; % Position {B} with respect to {M} [m] + +stewart = initializeStewartPlatform(); +stewart = initializeFramesPositions(stewart, 'H', H, 'MO_B', MO_B); +stewart = generateCubicConfiguration(stewart, 'Hc', H, 'FOc', H/2, 'FHa', 25e-3, 'MHb', 25e-3); +stewart = computeJointsPose(stewart); +stewart = initializeStrutDynamics(stewart, 'k', 1e6, 'c', 1e1); +stewart = initializeJointDynamics(stewart, 'type_F', '2dof', 'type_M', '3dof'); +stewart = computeJacobian(stewart); +stewart = initializeStewartPose(stewart); +stewart = initializeCylindricalPlatforms(stewart, ... + 'Mpm', 1e-6, ... % Massless platform + 'Fpm', 1e-6, ... % Massless platform + 'Mph', 20e-3, ... % Thin platform + 'Fph', 20e-3, ... % Thin platform + 'Mpr', 1.2*max(vecnorm(stewart.platform_M.Mb)), ... + 'Fpr', 1.2*max(vecnorm(stewart.platform_F.Fa))); +stewart = initializeCylindricalStruts(stewart, ... + 'Fsm', 1e-6, ... % Massless strut + 'Msm', 1e-6, ... % Massless strut + 'Fsh', stewart.geometry.l(1)/2, ... + 'Msh', stewart.geometry.l(1)/2 ... +); + +% Sample at the Center of the cube +sample = initializeSample('type', 'cylindrical', 'm', 10, 'H', 1/9*H, 'H_offset', -H/2-1/9*H/2, 'R', sqrt(6)*H); + +% Run the linearization +G_CoM_CoK = linearize(mdl, io)*inv(stewart.kinematics.J.'); +G_CoM_CoK.InputName = {'Fx', 'Fy', 'Fz', 'Mx', 'My', 'Mz'}; +G_CoM_CoK.OutputName = {'Dx', 'Dy', 'Dz', 'Rx', 'Ry', 'Rz'}; +#+end_src + +#+begin_src matlab :exports none +freqs = logspace(0, 4, 1000); +figure; +tiledlayout(1, 1, 'TileSpacing', 'Compact', 'Padding', 'None'); +ax1 = nexttile(); +hold on; +plot(freqs, abs(squeeze(freqresp(G_CoM_CoK(1, 1), freqs, 'Hz'))), 'color', colors(1,:), ... + 'DisplayName', '$D_x/F_x$'); +plot(freqs, abs(squeeze(freqresp(G_CoM_CoK(2, 2), freqs, 'Hz'))), 'color', colors(2,:), ... + 'DisplayName', '$D_y/F_y$'); +plot(freqs, abs(squeeze(freqresp(G_CoM_CoK(3, 3), freqs, 'Hz'))), 'color', colors(3,:), ... + 'DisplayName', '$D_z/F_z$'); +plot(freqs, abs(squeeze(freqresp(G_CoM_CoK(4, 4), freqs, 'Hz'))), 'color', colors(4,:), ... + 'DisplayName', '$R_x/M_x$'); +plot(freqs, abs(squeeze(freqresp(G_CoM_CoK(5, 5), freqs, 'Hz'))), 'color', colors(5,:), ... + 'DisplayName', '$R_y/M_y$'); +plot(freqs, abs(squeeze(freqresp(G_CoM_CoK(6, 6), freqs, 'Hz'))), 'color', colors(6,:), ... + 'DisplayName', '$R_z/M_z$'); +plot(freqs, abs(squeeze(freqresp(G_CoM_CoK(4, 2), freqs, 'Hz'))), 'color', [0, 0, 0, 0.2], ... + 'DisplayName', '$R_x/F_y$'); +plot(freqs, abs(squeeze(freqresp(G_CoM_CoK(5, 1), freqs, 'Hz'))), 'color', [0, 0, 0, 0.2], ... + 'DisplayName', '$R_y/F_x$'); +plot(freqs, abs(squeeze(freqresp(G_CoM_CoK(1, 5), freqs, 'Hz'))), 'color', [0, 0, 0, 0.2], ... + 'DisplayName', '$D_x/M_y$'); +plot(freqs, abs(squeeze(freqresp(G_CoM_CoK(2, 4), freqs, 'Hz'))), 'color', [0, 0, 0, 0.2], ... + 'DisplayName', '$D_y/M_x$'); +hold off; +set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log'); +xlabel('Frequency [Hz]'); ylabel('Amplitude [m/V]'); +leg = legend('location', 'southwest', 'FontSize', 8, 'NumColumns', 2); +leg.ItemTokenSize(1) = 15; +xlim([1, 1e4]); +ylim([1e-10, 2e-3]) +#+end_src + + + + + + + + + **** Conclusion +- Some work to still be decoupled when considering flexible joint stiffness + - [ ] Find the reference + - Better decoupling between the struts? Next section Some conclusions can be drawn from the above analysis: - Static Decoupling <=> Diagonal Stiffness matrix <=> {A} and {B} at the cube's center - Dynamic Decoupling <=> Static Decoupling + CoM of mobile platform coincident with {A} and {B}. +- Not specific to the cubic architecture +- Same stiffness in XYZ => Possible to have dynamic isotropy -** TODO Decentralized Control +** Decentralized Control +<> **** Introduction :ignore: From [[cite:preumont07_six_axis_singl_stage_activ]], the cubic configuration "/minimizes the cross-coupling amongst actuators and sensors of different legs (being orthogonal to each other)/". - This would facilitate the use of decentralized control. +#+begin_src latex :file detail_kinematics_decentralized_control.pdf +\begin{tikzpicture} + \node[block] (G) at (0,0) {$\bm{G}$}; + + \node[block, left= of G] (Kl) {$\bm{K}_{\mathcal{L}}$}; + + \draw[->] (Kl.east) -- node[midway, above]{$\bm{\tau}$} (G.west); + \draw[->] (G.east) -- ++(1.0, 0); + \draw[->] ($(G.east) + (0.5, 0)$)node[]{$\bullet$} node[above]{$\bm{\mathcal{L}}$} -- ++(0, -1) -| ($(Kl.west) + (-0.5, 0)$) -- (Kl.west); + + \begin{scope}[on background layer] + \node[fit={(G.south west) (G.north east)}, fill=black!20!white, draw, dashed, inner sep=4pt] (Pl) {}; + \node[anchor={south}] at (Pl.north){\small{Strut Plant}}; + \end{scope} +\end{tikzpicture} +#+end_src + +#+name: fig:detail_kinematics_decentralized_control +#+caption: From Strut coordinate to Cartesian coordinate using the Jacobian matrix +#+RESULTS: +[[file:figs/detail_kinematics_decentralized_control.png]] + In this section, we wish to study such properties of the cubic architecture. +Here, the plant output are sensors integrated in the Stewart platform struts. +Two sensors are considered: a displacement sensor and a force sensor. + We will compare the transfer function from sensors to actuators in each strut for a cubic architecture and for a non-cubic architecture (where the struts are not orthogonal with each other). -**** Cubic Architecture -Let's generate a Cubic architecture where the cube's center and the frames $\{A\}$ and $\{B\}$ are coincident. +The "strut plant" are compared for two Stewart platforms: +- with cubic architecture shown in Figure ref:fig:detail_kinematics_cubic_payload (page pageref:fig:detail_kinematics_cubic_payload) +- with a Stewart platform shown in Figure ref:fig:detail_kinematics_non_cubic_payload. It has the same payload and strut dynamics than for the cubic architecture. + The struts are oriented more vertically to be far away from the cubic architecture + +#+name: fig:detail_kinematics_non_cubic_payload +#+caption: Stewart platform with non-cubic architecture +#+attr_latex: :width 0.6\linewidth +[[file:figs/detail_kinematics_non_cubic_payload.png]] #+begin_src matlab +%% Input/Output definition of the Simscape model +clear io; io_i = 1; +io(io_i) = linio([mdl, '/Controller'], 1, 'openinput'); io_i = io_i + 1; % Actuator Force Inputs [N] +io(io_i) = linio([mdl, '/plant'], 2, 'openoutput', [], 'dL'); io_i = io_i + 1; % Displacement sensors [m] +io(io_i) = linio([mdl, '/plant'], 2, 'openoutput', [], 'fn'); io_i = io_i + 1; % Force Sensor [N] + +% Prepare simulation : Payload above the top platform +controller = initializeController('type', 'open-loop'); +sample = initializeSample('type', 'cylindrical', 'm', 10, 'H', 100e-3, 'R', 100e-3); + +%% Cubic Stewart platform H = 200e-3; % height of the Stewart platform [m] -MO_B = -10e-3; % Position {B} with respect to {M} [m] -Hc = 2.5*H; % Size of the useful part of the cube [m] -FOc = H + MO_B; % Center of the cube with respect to {F} -#+end_src +MO_B = 50e-3; % Position {B} with respect to {M} [m] -#+begin_src matlab stewart = initializeStewartPlatform(); stewart = initializeFramesPositions(stewart, 'H', H, 'MO_B', MO_B); -stewart = generateCubicConfiguration(stewart, 'Hc', Hc, 'FOc', FOc, 'FHa', 25e-3, 'MHb', 25e-3); +stewart = generateCubicConfiguration(stewart, 'Hc', H, 'FOc', H/2, 'FHa', 25e-3, 'MHb', 25e-3); stewart = computeJointsPose(stewart); stewart = initializeStrutDynamics(stewart, 'k', 1e6, 'c', 1e1); -stewart = initializeJointDynamics(stewart, 'type_F', 'universal', 'type_M', 'spherical'); +stewart = initializeJointDynamics(stewart, 'type_F', '2dof', 'type_M', '3dof'); stewart = computeJacobian(stewart); stewart = initializeStewartPose(stewart); -stewart = initializeCylindricalPlatforms(stewart, 'Fpr', 1.2*max(vecnorm(stewart.platform_F.Fa)), ... - 'Mpm', 10, ... - 'Mph', 20e-3, ... - 'Mpr', 1.2*max(vecnorm(stewart.platform_M.Mb))); -stewart = initializeCylindricalStruts(stewart, 'Fsm', 1e-3, 'Msm', 1e-3); -stewart = initializeInertialSensor(stewart); -#+end_src +stewart = initializeCylindricalPlatforms(stewart, ... + 'Mpm', 1e-6, ... % Massless platform + 'Fpm', 1e-6, ... % Massless platform + 'Mph', 20e-3, ... % Thin platform + 'Fph', 20e-3, ... % Thin platform + 'Mpr', 1.2*max(vecnorm(stewart.platform_M.Mb)), ... + 'Fpr', 1.2*max(vecnorm(stewart.platform_F.Fa))); +stewart = initializeCylindricalStruts(stewart, ... + 'Fsm', 1e-6, ... % Massless strut + 'Msm', 1e-6, ... % Massless strut + 'Fsh', stewart.geometry.l(1)/2, ... + 'Msh', stewart.geometry.l(1)/2 ... +); -No flexibility below the Stewart platform and no payload. -#+begin_src matlab -ground = initializeGround('type', 'none'); -payload = initializePayload('type', 'none'); -controller = initializeController('type', 'open-loop'); -#+end_src +% Run the linearization +G_cubic = linearize(mdl, io); +G_cubic.InputName = {'f1', 'f2', 'f3', 'f4', 'f5', 'f6'}; +G_cubic.OutputName = {'dL1', 'dL2', 'dL3', 'dL4', 'dL5', 'dL6', ... + 'fn1', 'fn2', 'fn3', 'fn4', 'fn5', 'fn6'}; -#+begin_src matlab -disturbances = initializeDisturbances(); -references = initializeReferences(stewart); -#+end_src - -#+begin_src matlab :exports none -displayArchitecture(stewart, 'labels', false, 'view', 'all'); -#+end_src - -And we identify the dynamics from the actuator forces $\tau_{i}$ to the relative motion sensors $\delta \mathcal{L}_{i}$ (Figure [[fig:coupling_struts_relative_sensor_cubic]]) and to the force sensors $\tau_{m,i}$ (Figure [[fig:coupling_struts_force_sensor_cubic]]). - -#+begin_src matlab :exports none -open('stewart_platform_model.slx') - -%% Options for Linearized -options = linearizeOptions; -options.SampleTime = 0; - -%% Name of the Simulink File -mdl = 'stewart_platform_model'; - -%% Input/Output definition -clear io; io_i = 1; -io(io_i) = linio([mdl, '/Controller'], 1, 'openinput'); io_i = io_i + 1; % Actuator Force Inputs [N] -io(io_i) = linio([mdl, '/Stewart Platform'], 1, 'openoutput', [], 'dLm'); io_i = io_i + 1; % Relative Displacement Outputs [m] - -%% Run the linearization -G = linearize(mdl, io, options); -G.InputName = {'F1', 'F2', 'F3', 'F4', 'F5', 'F6'}; -G.OutputName = {'Dm1', 'Dm2', 'Dm3', 'Dm4', 'Dm5', 'Dm6'}; -#+end_src - -#+begin_src matlab :exports none -freqs = logspace(1, 3, 1000); - -figure; - -ax1 = subplot(2, 1, 1); -hold on; -for i = 1:6 - for j = i+1:6 - plot(freqs, abs(squeeze(freqresp(G(i, j), freqs, 'Hz'))), 'k-'); - end -end -set(gca,'ColorOrderIndex',1); -plot(freqs, abs(squeeze(freqresp(G(1, 1), freqs, 'Hz')))); -hold off; -set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log'); -ylabel('Amplitude [m/N]'); set(gca, 'XTickLabel',[]); - -ax3 = subplot(2, 1, 2); -hold on; -for i = 1:6 - for j = i+1:6 - p2 = plot(freqs, 180/pi*angle(squeeze(freqresp(G(i, j), freqs, 'Hz'))), 'k-'); - end -end -set(gca,'ColorOrderIndex',1); -p1 = plot(freqs, 180/pi*angle(squeeze(freqresp(G(1, 1), freqs, 'Hz')))); -hold off; -set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin'); -ylabel('Phase [deg]'); xlabel('Frequency [Hz]'); -ylim([-180, 180]); -yticks([-180, -90, 0, 90, 180]); -legend([p1, p2], {'$L_i/\tau_i$', '$L_i/\tau_j$'}) - -linkaxes([ax1,ax2],'x'); -#+end_src - - -#+begin_src matlab :exports none -%% Input/Output definition -clear io; io_i = 1; -io(io_i) = linio([mdl, '/Controller'], 1, 'openinput'); io_i = io_i + 1; % Actuator Force Inputs [N] -io(io_i) = linio([mdl, '/Stewart Platform'], 1, 'openoutput', [], 'Taum'); io_i = io_i + 1; % Force Sensor Outputs [N] - -%% Run the linearization -G = linearize(mdl, io, options); -G.InputName = {'F1', 'F2', 'F3', 'F4', 'F5', 'F6'}; -G.OutputName = {'Fm1', 'Fm2', 'Fm3', 'Fm4', 'Fm5', 'Fm6'}; -#+end_src - -#+begin_src matlab :exports none -freqs = logspace(1, 3, 500); - -figure; - -ax1 = subplot(2, 1, 1); -hold on; -for i = 1:6 - for j = i+1:6 - plot(freqs, abs(squeeze(freqresp(G(i, j), freqs, 'Hz'))), 'k-'); - end -end -set(gca,'ColorOrderIndex',1); -plot(freqs, abs(squeeze(freqresp(G(1, 1), freqs, 'Hz')))); -hold off; -set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log'); -ylabel('Amplitude [N/N]'); set(gca, 'XTickLabel',[]); - -ax3 = subplot(2, 1, 2); -hold on; -for i = 1:6 - for j = i+1:6 - p2 = plot(freqs, 180/pi*angle(squeeze(freqresp(G(i, j), freqs, 'Hz'))), 'k-'); - end -end -set(gca,'ColorOrderIndex',1); -p1 = plot(freqs, 180/pi*angle(squeeze(freqresp(G(1, 1), freqs, 'Hz')))); -hold off; -set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin'); -ylabel('Phase [deg]'); xlabel('Frequency [Hz]'); -ylim([-180, 180]); -yticks([-180, -90, 0, 90, 180]); -legend([p1, p2], {'$F_{m,i}/\tau_i$', '$F_{m,i}/\tau_j$'}) - -linkaxes([ax1,ax2],'x'); -#+end_src - -**** Non-Cubic Architecture -Now we generate a Stewart platform which is not cubic but with approximately the same size as the previous cubic architecture. - -#+begin_src matlab -H = 200e-3; % height of the Stewart platform [m] -MO_B = -10e-3; % Position {B} with respect to {M} [m] -#+end_src - -#+begin_src matlab +%% Non-Cubic Stewart platform stewart = initializeStewartPlatform(); stewart = initializeFramesPositions(stewart, 'H', H, 'MO_B', MO_B); -stewart = generateGeneralConfiguration(stewart, 'FR', 250e-3, 'MR', 150e-3); +stewart = generateCubicConfiguration(stewart, 'Hc', H, 'FOc', H/2, 'FHa', 25e-3, 'MHb', 25e-3); +stewart = generateGeneralConfiguration(stewart, 'FH', 25e-3, 'FR', 250e-3, 'MH', 25e-3, 'MR', 250e-3, ... + 'FTh', [-22, 22, 120-22, 120+22, 240-22, 240+22]*(pi/180), ... + 'MTh', [-60+22, 60-22, 60+22, 180-22, 180+22, -60-22]*(pi/180)); stewart = computeJointsPose(stewart); stewart = initializeStrutDynamics(stewart, 'k', 1e6, 'c', 1e1); -stewart = initializeJointDynamics(stewart, 'type_F', 'universal', 'type_M', 'spherical'); +stewart = initializeJointDynamics(stewart, 'type_F', '2dof', 'type_M', '3dof'); stewart = computeJacobian(stewart); stewart = initializeStewartPose(stewart); -stewart = initializeCylindricalPlatforms(stewart, 'Fpr', 1.2*max(vecnorm(stewart.platform_F.Fa)), ... - 'Mpm', 10, ... - 'Mph', 20e-3, ... - 'Mpr', 1.2*max(vecnorm(stewart.platform_M.Mb))); -stewart = initializeCylindricalStruts(stewart, 'Fsm', 1e-3, 'Msm', 1e-3); -stewart = initializeInertialSensor(stewart); +stewart = initializeCylindricalPlatforms(stewart, ... + 'Mpm', 1e-6, ... % Massless platform + 'Fpm', 1e-6, ... % Massless platform + 'Mph', 20e-3, ... % Thin platform + 'Fph', 20e-3, ... % Thin platform + 'Mpr', 1.2*max(vecnorm(stewart.platform_M.Mb)), ... + 'Fpr', 1.2*max(vecnorm(stewart.platform_F.Fa))); +stewart = initializeCylindricalStruts(stewart, ... + 'Fsm', 1e-6, ... % Massless strut + 'Msm', 1e-6, ... % Massless strut + 'Fsh', stewart.geometry.l(1)/2, ... + 'Msh', stewart.geometry.l(1)/2 ... +); + +% Run the linearization +G_non_cubic = linearize(mdl, io); +G_non_cubic.InputName = {'f1', 'f2', 'f3', 'f4', 'f5', 'f6'}; +G_non_cubic.OutputName = {'dL1', 'dL2', 'dL3', 'dL4', 'dL5', 'dL6', ... + 'fn1', 'fn2', 'fn3', 'fn4', 'fn5', 'fn6'}; #+end_src -No flexibility below the Stewart platform and no payload. +**** Relative Displacement Sensors + +The transfer functions from actuator force included in each strut to the relative motion of the struts are shown in Figure ref:fig:detail_kinematics_decentralized_dL. +As expected from the equations of motion from $\bm{f}$ to $\bm{\mathcal{L}}$ eqref:eq:nhexa_transfer_function_struts, the $6 \times 6$ plants are decoupled at low frequency. + +At high frequency, the plant is coupled as the mass matrix projected in the frame of the struts is not diagonal. + +No clear advantage can be seen for the cubic architecture (figure ref:fig:detail_kinematics_cubic_decentralized_dL) as compared to the non-cubic architecture (Figure ref:fig:detail_kinematics_non_cubic_decentralized_dL). + +Note that the resonance frequencies are not the same in both cases as having the struts oriented more vertically changed the stiffness properties of the Stewart platform and hence the frequency of different modes. + +#+begin_src matlab :exports none :results none +%% Decentralized plant - Actuator force to Strut displacement - Cubic Architecture +freqs = logspace(0, 4, 1000); +figure; +tiledlayout(1, 1, 'TileSpacing', 'Compact', 'Padding', 'None'); +ax1 = nexttile(); +hold on; +for i = 1:5 + for j = i+1:6 + plot(freqs, abs(squeeze(freqresp(G_non_cubic(sprintf('dL%i',i), sprintf('f%i',j)), freqs, 'Hz'))), 'color', [colors(1,:), 0.1], ... + 'HandleVisibility', 'off'); + end +end +plot(freqs, abs(squeeze(freqresp(G_non_cubic('dL1', 'f1'), freqs, 'Hz'))), 'color', [colors(1,:)], 'linewidth', 2.5, ... + 'DisplayName', '$l_i/f_i$'); +plot(freqs, abs(squeeze(freqresp(G_non_cubic('dL2', 'f1'), freqs, 'Hz'))), 'color', [colors(1,:), 0.1], ... + 'DisplayName', '$l_i/f_j$'); +hold off; +set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log'); +xlabel('Frequency [Hz]'); ylabel('Amplitude [m/N]'); +leg = legend('location', 'northeast', 'FontSize', 8, 'NumColumns', 1); +leg.ItemTokenSize(1) = 15; +xlim([1, 1e4]); +ylim([1e-10, 1e-4]) +#+end_src + +#+begin_src matlab :tangle no :exports results :results file none +exportFig('figs/detail_kinematics_non_cubic_decentralized_dL.pdf', 'width', 'half', 'height', 'normal'); +#+end_src + +#+begin_src matlab :exports none :results none +%% Decentralized plant - Actuator force to Strut displacement - Cubic Architecture +freqs = logspace(0, 4, 1000); +figure; +tiledlayout(1, 1, 'TileSpacing', 'Compact', 'Padding', 'None'); +ax1 = nexttile(); +hold on; +for i = 1:5 + for j = i+1:6 + plot(freqs, abs(squeeze(freqresp(G_cubic(sprintf('dL%i',i), sprintf('f%i',j)), freqs, 'Hz'))), 'color', [colors(2,:), 0.1], ... + 'HandleVisibility', 'off'); + end +end +plot(freqs, abs(squeeze(freqresp(G_cubic('dL1', 'f1'), freqs, 'Hz'))), 'color', [colors(2,:)], 'linewidth', 2.5, ... + 'DisplayName', '$l_i/f_i$'); +plot(freqs, abs(squeeze(freqresp(G_cubic('dL2', 'f1'), freqs, 'Hz'))), 'color', [colors(2,:), 0.1], ... + 'DisplayName', '$l_i/f_j$'); +hold off; +set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log'); +xlabel('Frequency [Hz]'); ylabel('Amplitude [m/N]'); +leg = legend('location', 'northeast', 'FontSize', 8, 'NumColumns', 1); +leg.ItemTokenSize(1) = 15; +xlim([1, 1e4]); +ylim([1e-10, 1e-4]) +#+end_src + +#+begin_src matlab :tangle no :exports results :results file none +exportFig('figs/detail_kinematics_cubic_decentralized_dL.pdf', 'width', 'half', 'height', 'normal'); +#+end_src + +#+name: fig:detail_kinematics_decentralized_dL +#+caption: Bode plot of the transfer functions from actuator force to relative displacement sensor in each strut. Both for a non-cubic architecture (\subref{fig:detail_kinematics_non_cubic_decentralized_dL}) and for a cubic architecture (\subref{fig:detail_kinematics_cubic_decentralized_dL}) +#+attr_latex: :options [htbp] +#+begin_figure +#+attr_latex: :caption \subcaption{\label{fig:detail_kinematics_non_cubic_decentralized_dL}Non cubic architecture} +#+attr_latex: :options {0.48\textwidth} +#+begin_subfigure +#+attr_latex: :width 0.95\linewidth +[[file:figs/detail_kinematics_non_cubic_decentralized_dL.png]] +#+end_subfigure +#+attr_latex: :caption \subcaption{\label{fig:detail_kinematics_cubic_decentralized_dL}Cubic architecture} +#+attr_latex: :options {0.48\textwidth} +#+begin_subfigure +#+attr_latex: :width 0.95\linewidth +[[file:figs/detail_kinematics_cubic_decentralized_dL.png]] +#+end_subfigure +#+end_figure + +**** Force Sensors + +Similarly, the transfer functions from actuator force to force sensors included in each strut are extracted both for the cubic and non-cubic Stewart platforms. + +The results are shown in Figure ref:fig:detail_kinematics_decentralized_fn. + +#+begin_src matlab :exports none :results none +%% Decentralized plant - Actuator force to strut force sensor - Cubic Architecture +freqs = logspace(0, 4, 1000); +figure; +tiledlayout(1, 1, 'TileSpacing', 'Compact', 'Padding', 'None'); +ax1 = nexttile(); +hold on; +for i = 1:5 + for j = i+1:6 + plot(freqs, abs(squeeze(freqresp(G_non_cubic(sprintf('fn%i',i), sprintf('f%i',j)), freqs, 'Hz'))), 'color', [colors(1,:), 0.1], ... + 'HandleVisibility', 'off'); + end +end +plot(freqs, abs(squeeze(freqresp(G_non_cubic('fn1', 'f1'), freqs, 'Hz'))), 'color', [colors(1,:)], 'linewidth', 2.5, ... + 'DisplayName', '$f_{m,i}/f_i$'); +plot(freqs, abs(squeeze(freqresp(G_non_cubic('fn2', 'f1'), freqs, 'Hz'))), 'color', [colors(1,:), 0.1], ... + 'DisplayName', '$f_{m,i}/f_j$'); +hold off; +set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log'); +xlabel('Frequency [Hz]'); ylabel('Amplitude [N/N]'); +leg = legend('location', 'northeast', 'FontSize', 8, 'NumColumns', 1); +leg.ItemTokenSize(1) = 15; +xlim([1, 1e4]); ylim([1e-4, 1e2]); +#+end_src + +#+begin_src matlab :tangle no :exports results :results file none +exportFig('figs/detail_kinematics_non_cubic_decentralized_fn.pdf', 'width', 'half', 'height', 'normal'); +#+end_src + +#+begin_src matlab :exports none :results none +%% Decentralized plant - Actuator force to strut force sensor - Cubic Architecture +freqs = logspace(0, 4, 1000); +figure; +tiledlayout(1, 1, 'TileSpacing', 'Compact', 'Padding', 'None'); +ax1 = nexttile(); +hold on; +for i = 1:5 + for j = i+1:6 + plot(freqs, abs(squeeze(freqresp(G_cubic(sprintf('fn%i',i), sprintf('f%i',j)), freqs, 'Hz'))), 'color', [colors(2,:), 0.1], ... + 'HandleVisibility', 'off'); + end +end +plot(freqs, abs(squeeze(freqresp(G_cubic('fn1', 'f1'), freqs, 'Hz'))), 'color', [colors(2,:)], 'linewidth', 2.5, ... + 'DisplayName', '$f_{m,i}/f_i$'); +plot(freqs, abs(squeeze(freqresp(G_cubic('fn2', 'f1'), freqs, 'Hz'))), 'color', [colors(2,:), 0.1], ... + 'DisplayName', '$f_{m,i}/f_j$'); +hold off; +set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log'); +xlabel('Frequency [Hz]'); ylabel('Amplitude [N/N]'); +leg = legend('location', 'northeast', 'FontSize', 8, 'NumColumns', 1); +leg.ItemTokenSize(1) = 15; +xlim([1, 1e4]); ylim([1e-4, 1e2]); +#+end_src + +#+begin_src matlab :tangle no :exports results :results file none +exportFig('figs/detail_kinematics_cubic_decentralized_fn.pdf', 'width', 'half', 'height', 'normal'); +#+end_src + +#+name: fig:detail_kinematics_decentralized_fn +#+caption: Bode plot of the transfer functions from actuator force to force sensor in each strut. Both for a non-cubic architecture (\subref{fig:detail_kinematics_non_cubic_decentralized_fn}) and for a cubic architecture (\subref{fig:detail_kinematics_cubic_decentralized_fn}) +#+attr_latex: :options [htbp] +#+begin_figure +#+attr_latex: :caption \subcaption{\label{fig:detail_kinematics_non_cubic_decentralized_fn}Non cubic architecture} +#+attr_latex: :options {0.48\textwidth} +#+begin_subfigure +#+attr_latex: :width 0.95\linewidth +[[file:figs/detail_kinematics_non_cubic_decentralized_fn.png]] +#+end_subfigure +#+attr_latex: :caption \subcaption{\label{fig:detail_kinematics_cubic_decentralized_fn}Cubic architecture} +#+attr_latex: :options {0.48\textwidth} +#+begin_subfigure +#+attr_latex: :width 0.95\linewidth +[[file:figs/detail_kinematics_cubic_decentralized_fn.png]] +#+end_subfigure +#+end_figure + +**** Cubic with centered payload :noexport: + +It seems having the payload at the center of the cube makes things worst for decentralized control. + #+begin_src matlab -ground = initializeGround('type', 'none'); -payload = initializePayload('type', 'none'); -controller = initializeController('type', 'open-loop'); +%% Cubic Stewart platform with payload above the top platform +H = 200e-3; +MO_B = -100e-3; % Position {B} with respect to {M} [m] + +stewart = initializeStewartPlatform(); +stewart = initializeFramesPositions(stewart, 'H', H, 'MO_B', MO_B); +stewart = generateCubicConfiguration(stewart, 'Hc', H, 'FOc', H/2, 'FHa', 25e-3, 'MHb', 25e-3); +stewart = computeJointsPose(stewart); +stewart = initializeStrutDynamics(stewart, 'k', 1e6, 'c', 1e1); +stewart = initializeJointDynamics(stewart, 'type_F', '2dof', 'type_M', '3dof'); +stewart = computeJacobian(stewart); +stewart = initializeStewartPose(stewart); +stewart = initializeCylindricalPlatforms(stewart, ... + 'Mpm', 1e-6, ... % Massless platform + 'Fpm', 1e-6, ... % Massless platform + 'Mph', 20e-3, ... % Thin platform + 'Fph', 20e-3, ... % Thin platform + 'Mpr', 1.2*max(vecnorm(stewart.platform_M.Mb)), ... + 'Fpr', 1.2*max(vecnorm(stewart.platform_F.Fa))); +stewart = initializeCylindricalStruts(stewart, ... + 'Fsm', 1e-6, ... % Massless strut + 'Msm', 1e-6, ... % Massless strut + 'Fsh', stewart.geometry.l(1)/2, ... + 'Msh', stewart.geometry.l(1)/2 ... +); + +% Sample at the Center of the cube +sample = initializeSample('type', 'cylindrical', 'm', 10, 'H', 100e-3, 'H_offset', -H/2-50e-3); + +% Run the linearization +G_CoM_CoK = linearize(mdl, io)*inv(stewart.kinematics.J.'); +G_CoM_CoK.InputName = {'f1', 'f2', 'f3', 'f4', 'f5', 'f6'}; +G_CoM_CoK.OutputName = {'dL1', 'dL2', 'dL3', 'dL4', 'dL5', 'dL6', ... + 'fn1', 'fn2', 'fn3', 'fn4', 'fn5', 'fn6'}; #+end_src -#+begin_src matlab :exports none -displayArchitecture(stewart, 'labels', false, 'view', 'all'); -#+end_src - -And we identify the dynamics from the actuator forces $\tau_{i}$ to the relative motion sensors $\delta \mathcal{L}_{i}$ (Figure [[fig:coupling_struts_relative_sensor_non_cubic]]) and to the force sensors $\tau_{m,i}$ (Figure [[fig:coupling_struts_force_sensor_non_cubic]]). - -#+begin_src matlab :exports none -open('stewart_platform_model.slx') - -%% Options for Linearized -options = linearizeOptions; -options.SampleTime = 0; - -%% Name of the Simulink File -mdl = 'stewart_platform_model'; - -%% Input/Output definition -clear io; io_i = 1; -io(io_i) = linio([mdl, '/Controller'], 1, 'openinput'); io_i = io_i + 1; % Actuator Force Inputs [N] -io(io_i) = linio([mdl, '/Stewart Platform'], 1, 'openoutput', [], 'dLm'); io_i = io_i + 1; % Relative Displacement Outputs [m] - -%% Run the linearization -G = linearize(mdl, io, options); -G.InputName = {'F1', 'F2', 'F3', 'F4', 'F5', 'F6'}; -G.OutputName = {'Dm1', 'Dm2', 'Dm3', 'Dm4', 'Dm5', 'Dm6'}; -#+end_src - -#+begin_src matlab :exports none -freqs = logspace(1, 3, 1000); - +#+begin_src matlab :exports none :results none +%% Coupling in the cartesian frame for a Non_cubic Stewart platform - Frame {B} is at the center of mass of the payload +freqs = logspace(0, 4, 1000); figure; - -ax1 = subplot(2, 1, 1); +tiledlayout(1, 1, 'TileSpacing', 'Compact', 'Padding', 'None'); +ax1 = nexttile(); hold on; -for i = 1:6 +for i = 1:5 for j = i+1:6 - plot(freqs, abs(squeeze(freqresp(G(i, j), freqs, 'Hz'))), 'k-'); + plot(freqs, abs(squeeze(freqresp(G_non_cubic(sprintf('fn%i',i), sprintf('f%i',j)), freqs, 'Hz'))), 'color', [colors(2,:), 0.1], ... + 'HandleVisibility', 'off'); + plot(freqs, abs(squeeze(freqresp(G_CoM_CoK(sprintf('fn%i',i), sprintf('f%i',j)), freqs, 'Hz'))), 'color', [colors(3,:), 0.1], ... + 'HandleVisibility', 'off'); end end -set(gca,'ColorOrderIndex',1); -plot(freqs, abs(squeeze(freqresp(G(1, 1), freqs, 'Hz')))); +plot(freqs, abs(squeeze(freqresp(G_non_cubic('fn1', 'f1'), freqs, 'Hz'))), 'color', [colors(2,:)], 'linewidth', 2.5, ... + 'DisplayName', '$L_i/F_i$'); +plot(freqs, abs(squeeze(freqresp(G_non_cubic('fn2', 'f1'), freqs, 'Hz'))), 'color', [colors(2,:), 0.1], ... + 'DisplayName', '$L_i/F_j$'); +plot(freqs, abs(squeeze(freqresp(G_CoM_CoK('fn1', 'f1'), freqs, 'Hz'))), 'color', [colors(3,:)], 'linewidth', 2.5, ... + 'DisplayName', '$L_i/F_i$'); +plot(freqs, abs(squeeze(freqresp(G_CoM_CoK('fn2', 'f1'), freqs, 'Hz'))), 'color', [colors(3,:), 0.1], ... + 'DisplayName', '$L_i/F_j$'); hold off; set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log'); -ylabel('Amplitude [m/N]'); set(gca, 'XTickLabel',[]); - -ax3 = subplot(2, 1, 2); -hold on; -for i = 1:6 - for j = i+1:6 - p2 = plot(freqs, 180/pi*angle(squeeze(freqresp(G(i, j), freqs, 'Hz'))), 'k-'); - end -end -set(gca,'ColorOrderIndex',1); -p1 = plot(freqs, 180/pi*angle(squeeze(freqresp(G(1, 1), freqs, 'Hz')))); -hold off; -set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin'); -ylabel('Phase [deg]'); xlabel('Frequency [Hz]'); -ylim([-180, 180]); -yticks([-180, -90, 0, 90, 180]); -legend([p1, p2], {'$L_i/\tau_i$', '$L_i/\tau_j$'}) - -linkaxes([ax1,ax2],'x'); +xlabel('Frequency [Hz]'); ylabel('Amplitude [N/N]'); +leg = legend('location', 'southwest', 'FontSize', 8, 'NumColumns', 2); +leg.ItemTokenSize(1) = 15; +xlim([1, 1e4]); +ylim([1e-3, 1e2]) #+end_src -#+begin_src matlab :exports none -%% Input/Output definition -clear io; io_i = 1; -io(io_i) = linio([mdl, '/Controller'], 1, 'openinput'); io_i = io_i + 1; % Actuator Force Inputs [N] -io(io_i) = linio([mdl, '/Stewart Platform'], 1, 'openoutput', [], 'Taum'); io_i = io_i + 1; % Force Sensor Outputs [N] - -%% Run the linearization -G = linearize(mdl, io, options); -G.InputName = {'F1', 'F2', 'F3', 'F4', 'F5', 'F6'}; -G.OutputName = {'Fm1', 'Fm2', 'Fm3', 'Fm4', 'Fm5', 'Fm6'}; -#+end_src - -#+begin_src matlab :exports none -freqs = logspace(1, 3, 500); - +#+begin_src matlab :exports none :results none +%% Coupling in the cartesian frame for a Non_cubic Stewart platform - Frame {B} is at the center of mass of the payload +freqs = logspace(0, 4, 1000); figure; - -ax1 = subplot(2, 1, 1); +tiledlayout(1, 1, 'TileSpacing', 'Compact', 'Padding', 'None'); +ax1 = nexttile(); hold on; -for i = 1:6 +for i = 1:5 for j = i+1:6 - plot(freqs, abs(squeeze(freqresp(G(i, j), freqs, 'Hz'))), 'k-'); + plot(freqs, abs(squeeze(freqresp(G_non_cubic(sprintf('dL%i',i), sprintf('f%i',j)), freqs, 'Hz'))), 'color', [colors(1,:), 0.1], ... + 'HandleVisibility', 'off'); + plot(freqs, abs(squeeze(freqresp(G_cubic(sprintf('dL%i',i), sprintf('f%i',j)), freqs, 'Hz'))), 'color', [colors(2,:), 0.1], ... + 'HandleVisibility', 'off'); + plot(freqs, abs(squeeze(freqresp(G_CoM_CoK(sprintf('dL%i',i), sprintf('f%i',j)), freqs, 'Hz'))), 'color', [colors(3,:), 0.1], ... + 'HandleVisibility', 'off'); end end -set(gca,'ColorOrderIndex',1); -plot(freqs, abs(squeeze(freqresp(G(1, 1), freqs, 'Hz')))); +plot(freqs, abs(squeeze(freqresp(G_non_cubic('dL1', 'f1'), freqs, 'Hz'))), 'color', [colors(1,:)], 'linewidth', 2.5, ... + 'DisplayName', '$L_i/F_i$'); +plot(freqs, abs(squeeze(freqresp(G_non_cubic('dL2', 'f1'), freqs, 'Hz'))), 'color', [colors(1,:), 0.1], ... + 'DisplayName', '$L_i/F_j$'); +plot(freqs, abs(squeeze(freqresp(G_cubic('dL1', 'f1'), freqs, 'Hz'))), 'color', [colors(2,:)], 'linewidth', 2.5, ... + 'DisplayName', '$L_i/F_i$'); +plot(freqs, abs(squeeze(freqresp(G_cubic('dL2', 'f1'), freqs, 'Hz'))), 'color', [colors(2,:), 0.1], ... + 'DisplayName', '$L_i/F_j$'); +plot(freqs, abs(squeeze(freqresp(G_CoM_CoK('dL1', 'f1'), freqs, 'Hz'))), 'color', [colors(3,:)], 'linewidth', 2.5, ... + 'DisplayName', '$L_i/F_i$'); +plot(freqs, abs(squeeze(freqresp(G_CoM_CoK('dL2', 'f1'), freqs, 'Hz'))), 'color', [colors(3,:), 0.1], ... + 'DisplayName', '$L_i/F_j$'); hold off; set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log'); -ylabel('Amplitude [N/N]'); set(gca, 'XTickLabel',[]); - -ax3 = subplot(2, 1, 2); -hold on; -for i = 1:6 - for j = i+1:6 - p2 = plot(freqs, 180/pi*angle(squeeze(freqresp(G(i, j), freqs, 'Hz'))), 'k-'); - end -end -set(gca,'ColorOrderIndex',1); -p1 = plot(freqs, 180/pi*angle(squeeze(freqresp(G(1, 1), freqs, 'Hz')))); -hold off; -set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin'); -ylabel('Phase [deg]'); xlabel('Frequency [Hz]'); -ylim([-180, 180]); -yticks([-180, -90, 0, 90, 180]); -legend([p1, p2], {'$F_{m,i}/\tau_i$', '$F_{m,i}/\tau_j$'}) - -linkaxes([ax1,ax2],'x'); +xlabel('Frequency [Hz]'); ylabel('Amplitude [m/N]'); +leg = legend('location', 'southwest', 'FontSize', 8, 'NumColumns', 2); +leg.ItemTokenSize(1) = 15; +xlim([1, 1e4]); +ylim([1e-10, 2e-3]) #+end_src + **** Conclusion The Cubic architecture seems to not have any significant effect on the coupling between actuator and sensors of each strut and thus provides no advantages for decentralized control. - ** Cubic architecture with Cube's center above the top platform <> **** Introduction :ignore: -We saw in section ref:ssec:detail_kinematics_cubic_static that in order to have a diagonal stiffness matrix, the cube's center needs to be located at frames $\{A\}$ and $\{B\}$. -Or, typically $\{A\}$ and $\{B\}$ are located above the top platform where forces are applied and where displacements are expressed. +As was shown in Section ref:ssec:detail_kinematics_cubic_dynamic, the cubic architecture can have very interesting dynamical properties when the center of mass of the moving body is at the cube's center. +This is because, both the mass and stiffness matrices are diagonal. +As shown in in section ref:ssec:detail_kinematics_cubic_static, the stiffness matrix is diagonal when the considered B frame is located at the cube's center. -Say a 100mm tall Stewart platform needs to be designed with the CoM of the payload 20mm above the top platform. -The cube's center therefore needs to be positioned 20mm above the top platform. +Or, typically the $\{B\}$ frame is taken above the top platform where forces are applied and where displacements are expressed. -The obtained design depends on the considered size of the cube +In this section, modifications of the Cubic architectures are proposed in order to be able to have the payload above the top platform while still benefiting from interesting dynamical properties of the cubic architecture. + +There are three key parameters: +- $H$ height of the Stewart platform (distance from fix base to mobile platform) +- $H_c$ height of the cube, as shown in Figure ref:fig:detail_kinematics_cubic_schematic_full +- $H_{CoM}$ height of the center of mass with respect to the mobile platform. It is also the cube's center. + +# Say a $H = 100\,mm$ tall Stewart platform needs to be designed with the CoM of the payload $H_{CoM} = 20\,mm$ above the top platform. +# The cube's center therefore needs to be positioned 20mm above the top platform. + +The obtained design depends on the considered size of the cube $H_c$ with respect to $H$ and $H_{CoM}$. #+begin_src matlab %% Cubic configurations with center of the cube above the top platform @@ -2338,160 +3213,331 @@ FOc = H + MO_B; % Center of the cube with respect to {F} **** Small cube -Similar to [[cite:&furutani04_nanom_cuttin_machin_using_stewar]], even though it is not mentioned that the system has a cubic configuration. +When the considered cube size is smaller than twice the height of the CoM, the obtained design looks like Figure ref:fig:detail_kinematics_cubic_above_small. +\begin{equation}\label{eq:detail_kinematics_cube_small} + H_c < 2 H_{CoM} +\end{equation} + +This is similar to [[cite:&furutani04_nanom_cuttin_machin_using_stewar]], even though it is not mentioned that the system has a cubic configuration. # TODO - Add link to Figure ref:fig:nhexa_stewart_piezo_furutani (page pageref:fig:nhexa_stewart_piezo_furutani) +Adjacent struts are parallel to each other, which is quite different from the typical architecture in which parallel struts are opposite to each other. + #+begin_src matlab %% Small cube Hc = 2*MO_B; % Size of the useful part of the cube [m] -stewart = initializeStewartPlatform(); -stewart = initializeFramesPositions(stewart, 'H', H, 'MO_B', MO_B); -stewart = generateCubicConfiguration(stewart, 'Hc', Hc, 'FOc', FOc, 'FHa', 5e-3, 'MHb', 5e-3); -stewart = computeJointsPose(stewart); -stewart = initializeStrutDynamics(stewart, 'k', 1); -stewart = computeJacobian(stewart); -stewart = initializeCylindricalPlatforms(stewart, 'Fpr', 1.1*max(vecnorm(stewart.platform_F.Fa)), 'Mpr', 1.1*max(vecnorm(stewart.platform_M.Mb))); +stewart_small = initializeStewartPlatform(); +stewart_small = initializeFramesPositions(stewart_small, 'H', H, 'MO_B', MO_B); +stewart_small = generateCubicConfiguration(stewart_small, 'Hc', Hc, 'FOc', FOc, 'FHa', 5e-3, 'MHb', 5e-3); +stewart_small = computeJointsPose(stewart_small); +stewart_small = initializeStrutDynamics(stewart_small, 'k', 1); +stewart_small = computeJacobian(stewart_small); +stewart_small = initializeCylindricalPlatforms(stewart_small, 'Fpr', 1.1*max(vecnorm(stewart_small.platform_F.Fa)), 'Mpr', 1.1*max(vecnorm(stewart_small.platform_M.Mb))); #+end_src #+begin_src matlab :exports none :results none -%% Example of a cubic architecture with cube's center above the top platform - Small cube size -displayArchitecture(stewart, 'labels', false, 'frames', false); -plotCube(stewart, 'Hc', Hc, 'FOc', FOc, 'color', [0,0,0,0.5], 'link_to_struts', true); +%% ISO View +displayArchitecture(stewart_small, 'labels', false, 'frames', false); +plotCube(stewart_small, 'Hc', Hc, 'FOc', FOc, 'color', [0,0,0,0.2], 'link_to_struts', true); scatter3(0, 0, FOc, 200, 'kh'); #+end_src -#+begin_src matlab :tangle no :exports results :results file replace -exportFig('figs/detail_kinematics_cubic_above_small.pdf', 'width', 'wide', 'height', 'normal'); +#+begin_src matlab :tangle no :exports results :results file none +exportFig('figs/detail_kinematics_cubic_above_small_iso.pdf', 'width', 'normal', 'height', 'full'); +#+end_src + +#+begin_src matlab :exports none :results none +%% Side view +displayArchitecture(stewart_small, 'labels', false, 'frames', false); +plotCube(stewart_small, 'Hc', Hc, 'FOc', FOc, 'color', [0, 0, 0, 0.2], 'link_to_struts', true); +scatter3(0, 0, FOc, 200, 'kh'); +view([90,0]) +#+end_src + +#+begin_src matlab :tangle no :exports results :results file none +exportFig('figs/detail_kinematics_cubic_above_small_side.pdf', 'width', 'half', 'height', 'full'); +#+end_src + +#+begin_src matlab :exports none :results none +%% Top view +displayArchitecture(stewart_small, 'labels', false, 'frames', false); +plotCube(stewart_small, 'Hc', Hc, 'FOc', FOc, 'color', [0, 0, 0, 0.2], 'link_to_struts', true); +scatter3(0, 0, FOc, 200, 'kh'); +view([0,90]) +#+end_src + +#+begin_src matlab :tangle no :exports results :results file none +exportFig('figs/detail_kinematics_cubic_above_small_top.pdf', 'width', 'half', 'height', 'full'); #+end_src #+name: fig:detail_kinematics_cubic_above_small -#+caption: Example of a cubic architecture with cube's center above the top platform - Small cube size -#+RESULTS: -[[file:figs/detail_kinematics_cubic_above_small.png]] - +#+caption: Cubic architecture with cube's center above the top platform. A cube height of 40mm is used. +#+attr_latex: :options [htbp] +#+begin_figure +#+attr_latex: :caption \subcaption{\label{fig:detail_kinematics_cubic_above_small_iso}Isometric view} +#+attr_latex: :options {0.36\textwidth} +#+begin_subfigure +#+attr_latex: :width 0.9\linewidth +[[file:figs/detail_kinematics_cubic_above_small_iso.png]] +#+end_subfigure +#+attr_latex: :caption \subcaption{\label{fig:detail_kinematics_cubic_above_small_side}Side view} +#+attr_latex: :options {0.30\textwidth} +#+begin_subfigure +#+attr_latex: :width 0.9\linewidth +[[file:figs/detail_kinematics_cubic_above_small_side.png]] +#+end_subfigure +#+attr_latex: :caption \subcaption{\label{fig:detail_kinematics_cubic_above_small_top}Top view} +#+attr_latex: :options {0.30\textwidth} +#+begin_subfigure +#+attr_latex: :width 0.9\linewidth +[[file:figs/detail_kinematics_cubic_above_small_top.png]] +#+end_subfigure +#+end_figure **** Medium sized cube -Similar to cite:yang19_dynam_model_decoup_contr_flexib (Figure ref:fig:detail_kinematics_yang19) +Increasing the cube size with an height close to the stewart platform height leads to an architecture in which the struts are crossing. + +\begin{equation}\label{eq:detail_kinematics_cube_medium} + 2 H_{CoM} < H_c < 2 (H_{CoM} + H) +\end{equation} + +This is similar to cite:yang19_dynam_model_decoup_contr_flexib (Figure ref:fig:detail_kinematics_yang19 in page pageref:fig:detail_kinematics_yang19), even though it is not cubic (but the struts are crossing). #+begin_src matlab :exports none :results none %% Example of a cubic architecture with cube's center above the top platform - Medium cube size Hc = H + 2*MO_B; % Size of the useful part of the cube [m] -stewart = initializeStewartPlatform(); -stewart = initializeFramesPositions(stewart, 'H', H, 'MO_B', MO_B); -stewart = generateCubicConfiguration(stewart, 'Hc', Hc, 'FOc', FOc, 'FHa', 5e-3, 'MHb', 5e-3); -stewart = computeJointsPose(stewart); -stewart = initializeStrutDynamics(stewart, 'k', 1); -stewart = computeJacobian(stewart); -stewart = initializeCylindricalPlatforms(stewart, 'Fpr', 1.1*max(vecnorm(stewart.platform_F.Fa)), 'Mpr', 1.1*max(vecnorm(stewart.platform_M.Mb))); +stewart_medium = initializeStewartPlatform(); +stewart_medium = initializeFramesPositions(stewart_medium, 'H', H, 'MO_B', MO_B); +stewart_medium = generateCubicConfiguration(stewart_medium, 'Hc', Hc, 'FOc', FOc, 'FHa', 5e-3, 'MHb', 5e-3); +stewart_medium = computeJointsPose(stewart_medium); +stewart_medium = initializeStrutDynamics(stewart_medium, 'k', 1); +stewart_medium = computeJacobian(stewart_medium); +stewart_medium = initializeCylindricalPlatforms(stewart_medium, 'Fpr', 1.1*max(vecnorm(stewart_medium.platform_F.Fa)), 'Mpr', 1.1*max(vecnorm(stewart_medium.platform_M.Mb))); +#+end_src -displayArchitecture(stewart, 'labels', false, 'frames', false); -plotCube(stewart, 'Hc', Hc, 'FOc', FOc, 'color', [0,0,0,0.5], 'link_to_struts', true); +#+begin_src matlab :exports none :results none +%% ISO View +displayArchitecture(stewart_medium, 'labels', false, 'frames', false); +plotCube(stewart_medium, 'Hc', Hc, 'FOc', FOc, 'color', [0,0,0,0.2], 'link_to_struts', true); scatter3(0, 0, FOc, 200, 'kh'); #+end_src -#+begin_src matlab :tangle no :exports results :results file replace -exportFig('figs/detail_kinematics_cubic_above_medium.pdf', 'width', 'wide', 'height', 'normal'); +#+begin_src matlab :tangle no :exports results :results file none +exportFig('figs/detail_kinematics_cubic_above_medium_iso.pdf', 'width', 'normal', 'height', 'full'); +#+end_src + +#+begin_src matlab :exports none :results none +%% Side view +displayArchitecture(stewart_medium, 'labels', false, 'frames', false); +plotCube(stewart_medium, 'Hc', Hc, 'FOc', FOc, 'color', [0, 0, 0, 0.2], 'link_to_struts', true); +scatter3(0, 0, FOc, 200, 'kh'); +view([90,0]) +#+end_src + +#+begin_src matlab :tangle no :exports results :results file none +exportFig('figs/detail_kinematics_cubic_above_medium_side.pdf', 'width', 'half', 'height', 'full'); +#+end_src + +#+begin_src matlab :exports none :results none +%% Top view +displayArchitecture(stewart_medium, 'labels', false, 'frames', false); +plotCube(stewart_medium, 'Hc', Hc, 'FOc', FOc, 'color', [0, 0, 0, 0.2], 'link_to_struts', true); +scatter3(0, 0, FOc, 200, 'kh'); +view([0,90]) +#+end_src + +#+begin_src matlab :tangle no :exports results :results file none +exportFig('figs/detail_kinematics_cubic_above_medium_top.pdf', 'width', 'half', 'height', 'full'); #+end_src #+name: fig:detail_kinematics_cubic_above_medium -#+caption: Example of a cubic architecture with cube's center above the top platform - Medium cube size -#+RESULTS: -[[file:figs/detail_kinematics_cubic_above_medium.png]] +#+caption: Cubic architecture with cube's center above the top platform. A cube height of 140mm is used. +#+attr_latex: :options [htbp] +#+begin_figure +#+attr_latex: :caption \subcaption{\label{fig:detail_kinematics_cubic_above_medium_iso}Isometric view} +#+attr_latex: :options {0.36\textwidth} +#+begin_subfigure +#+attr_latex: :width 0.9\linewidth +[[file:figs/detail_kinematics_cubic_above_medium_iso.png]] +#+end_subfigure +#+attr_latex: :caption \subcaption{\label{fig:detail_kinematics_cubic_above_medium_side}Side view} +#+attr_latex: :options {0.30\textwidth} +#+begin_subfigure +#+attr_latex: :width 0.9\linewidth +[[file:figs/detail_kinematics_cubic_above_medium_side.png]] +#+end_subfigure +#+attr_latex: :caption \subcaption{\label{fig:detail_kinematics_cubic_above_medium_top}Top view} +#+attr_latex: :options {0.30\textwidth} +#+begin_subfigure +#+attr_latex: :width 0.9\linewidth +[[file:figs/detail_kinematics_cubic_above_medium_top.png]] +#+end_subfigure +#+end_figure **** Large cube +When the cube's height is more than twice the platform height added to the CoM height, the architecture shown in Figure ref:fig:detail_kinematics_cubic_above_large is obtained. + +\begin{equation}\label{eq:detail_kinematics_cube_large} + 2 (H_{CoM} + H) < H_c +\end{equation} + #+begin_src matlab :exports none :results none %% Example of a cubic architecture with cube's center above the top platform - Large cube size Hc = 2*(H + MO_B); % Size of the useful part of the cube [m] -stewart = initializeStewartPlatform(); -stewart = initializeFramesPositions(stewart, 'H', H, 'MO_B', MO_B); -stewart = generateCubicConfiguration(stewart, 'Hc', Hc, 'FOc', FOc, 'FHa', 5e-3, 'MHb', 5e-3); -stewart = computeJointsPose(stewart); -stewart = initializeStrutDynamics(stewart, 'k', 1); -stewart = computeJacobian(stewart); -stewart = initializeCylindricalPlatforms(stewart, 'Fpr', 1.1*max(vecnorm(stewart.platform_F.Fa)), 'Mpr', 1.1*max(vecnorm(stewart.platform_M.Mb))); +stewart_large = initializeStewartPlatform(); +stewart_large = initializeFramesPositions(stewart_large, 'H', H, 'MO_B', MO_B); +stewart_large = generateCubicConfiguration(stewart_large, 'Hc', Hc, 'FOc', FOc, 'FHa', 5e-3, 'MHb', 5e-3); +stewart_large = computeJointsPose(stewart_large); +stewart_large = initializeStrutDynamics(stewart_large, 'k', 1); +stewart_large = computeJacobian(stewart_large); +stewart_large = initializeCylindricalPlatforms(stewart_large, 'Fpr', 1.1*max(vecnorm(stewart_large.platform_F.Fa)), 'Mpr', 1.1*max(vecnorm(stewart_large.platform_M.Mb))); +#+end_src -displayArchitecture(stewart, 'labels', false, 'frames', false); -plotCube(stewart, 'Hc', Hc, 'FOc', FOc, 'color', [0,0,0,0.5], 'link_to_struts', true); +#+begin_src matlab :exports none :results none +%% ISO View +displayArchitecture(stewart_large, 'labels', false, 'frames', false); +plotCube(stewart_large, 'Hc', Hc, 'FOc', FOc, 'color', [0,0,0,0.2], 'link_to_struts', true); scatter3(0, 0, FOc, 200, 'kh'); #+end_src -#+begin_src matlab :tangle no :exports results :results file replace -exportFig('figs/detail_kinematics_cubic_above_large.pdf', 'width', 'wide', 'height', 'normal'); +#+begin_src matlab :tangle no :exports results :results file none +exportFig('figs/detail_kinematics_cubic_above_large_iso.pdf', 'width', 'normal', 'height', 'full'); +#+end_src + +#+begin_src matlab :exports none :results none +%% Side view +displayArchitecture(stewart_large, 'labels', false, 'frames', false); +plotCube(stewart_large, 'Hc', Hc, 'FOc', FOc, 'color', [0, 0, 0, 0.2], 'link_to_struts', true); +scatter3(0, 0, FOc, 200, 'kh'); +view([90,0]) +#+end_src + +#+begin_src matlab :tangle no :exports results :results file none +exportFig('figs/detail_kinematics_cubic_above_large_side.pdf', 'width', 'half', 'height', 'full'); +#+end_src + +#+begin_src matlab :exports none :results none +%% Top view +displayArchitecture(stewart_large, 'labels', false, 'frames', false); +plotCube(stewart_large, 'Hc', Hc, 'FOc', FOc, 'color', [0, 0, 0, 0.2], 'link_to_struts', true); +scatter3(0, 0, FOc, 200, 'kh'); +view([0,90]) +#+end_src + +#+begin_src matlab :tangle no :exports results :results file none +exportFig('figs/detail_kinematics_cubic_above_large_top.pdf', 'width', 'half', 'height', 'full'); #+end_src #+name: fig:detail_kinematics_cubic_above_large -#+caption: Example of a cubic architecture with cube's center above the top platform - Large cube size -#+RESULTS: -[[file:figs/detail_kinematics_cubic_above_large.png]] +#+caption: Cubic architecture with cube's center above the top platform. A cube height of 240mm is used. +#+attr_latex: :options [htbp] +#+begin_figure +#+attr_latex: :caption \subcaption{\label{fig:detail_kinematics_cubic_above_large_iso}Isometric view} +#+attr_latex: :options {0.36\textwidth} +#+begin_subfigure +#+attr_latex: :width 0.9\linewidth +[[file:figs/detail_kinematics_cubic_above_large_iso.png]] +#+end_subfigure +#+attr_latex: :caption \subcaption{\label{fig:detail_kinematics_cubic_above_large_side}Side view} +#+attr_latex: :options {0.30\textwidth} +#+begin_subfigure +#+attr_latex: :width 0.9\linewidth +[[file:figs/detail_kinematics_cubic_above_large_side.png]] +#+end_subfigure +#+attr_latex: :caption \subcaption{\label{fig:detail_kinematics_cubic_above_large_top}Top view} +#+attr_latex: :options {0.30\textwidth} +#+begin_subfigure +#+attr_latex: :width 0.9\linewidth +[[file:figs/detail_kinematics_cubic_above_large_top.png]] +#+end_subfigure +#+end_figure -**** TODO Required size of the platforms +**** Platform size -The minimum size of the platforms depends on the cube's size and the height between the platform and the cube's center. +#+begin_src matlab +%% Get the analytical formula for the location of the top and bottom joints +% Define symbolic variables +syms k Hc Hcom alpha H -Let's denote: -- $H$ the height between the cube's center and the considered platform -- $D$ the size of the cube's edges +assume(k > 0); % k is positive real +assume(Hcom > 0); % k is positive real +assume(Hc > 0); % Hc is real +assume(H > 0); % H is real +assume(alpha, 'real'); % alpha is real -Let's denote by $a$ and $b$ the points of both ends of one of the cube's edge. +% Define si matrix (edges of the cubes) +si = 1/sqrt(3)*[ + [ sqrt(2), 0, 1]; ... + [-sqrt(2)/2, -sqrt(3/2), 1]; ... + [-sqrt(2)/2, sqrt(3/2), 1]; ... + [ sqrt(2), 0, 1]; ... + [-sqrt(2)/2, -sqrt(3/2), 1]; ... + [-sqrt(2)/2, sqrt(3/2), 1] ... +]; -Initially, we have: +% Define ci matrix (vertices of the cubes) +ci = Hc * [ + [1/sqrt(2), -sqrt(3)/sqrt(2), 0.5]; ... + [1/sqrt(2), -sqrt(3)/sqrt(2), 0.5]; ... + [1/sqrt(2), sqrt(3)/sqrt(2), 0.5]; ... + [1/sqrt(2), sqrt(3)/sqrt(2), 0.5]; ... + [-sqrt(2), 0, 0.5]; ... + [-sqrt(2), 0, 0.5] ... +]; + +% Apply vertical shift to ci +ci = ci + (H + Hcom) * [0, 0, 1]; + +% Calculate bi vectors (Stewart platform top joints) +bi = ci + alpha * si; + + +% Extract the z-component value from the first row of ci +% (all rows have the same z-component) +ci_z = ci(1, 3); + +% The z-component of si is 1 for all rows +si_z = si(1, 3); + +alpha_for_0 = solve(ci_z + alpha * si_z == 0, alpha); +alpha_for_H = solve(ci_z + alpha * si_z == H, alpha); + +% Verify the results +% Substitute alpha values and check the resulting bi_z values +bi_z_0 = ci + alpha_for_0 * si; +disp('Verification bi_z = 0:'); +disp(simplify(bi_z_0)); + +bi_z_H = ci + alpha_for_H * si; +disp('Verification bi_z = H:'); +disp(simplify(bi_z_H)); + +% Compute radius +simplify(sqrt(bi_z_H(:,1).^2 + bi_z_H(:,2).^2)) +simplify(sqrt(bi_z_0(:,1).^2 + bi_z_0(:,2).^2)) +#+end_src + +The top joints $\bm{b}_i$ are located on a circle with radius $R_{b_i}$ eqref:eq:detail_kinematics_cube_top_joints. +The bottom joints $\bm{a}_i$ are located on a circle with radius $R_{a_i}$ eqref:eq:detail_kinematics_cube_bot_joints. + +\begin{subequations}\label{eq:detail_kinematics_cube_joints} \begin{align} - a &= \frac{D}{2} \begin{bmatrix}-1 \\ -1 \\ 1\end{bmatrix} \\ - b &= \frac{D}{2} \begin{bmatrix} 1 \\ -1 \\ 1\end{bmatrix} + R_{b_i} &= \sqrt{\frac{3}{2} H_c^2 + 2 H_{CoM}^2} \label{eq:detail_kinematics_cube_top_joints} \\ + R_{a_i} &= \sqrt{\frac{3}{2} H_c^2 + 2 (H_{CoM} + H)^2} \label{eq:detail_kinematics_cube_bot_joints} \end{align} +\end{subequations} -We rotate the cube around its center (origin of the rotated frame) such that one of its diagonal is vertical. -\[ R = \begin{bmatrix} - \frac{2}{\sqrt{6}} & 0 & \frac{1}{\sqrt{3}} \\ - \frac{-1}{\sqrt{6}} & \frac{1}{\sqrt{2}} & \frac{1}{\sqrt{3}} \\ - \frac{-1}{\sqrt{6}} & \frac{-1}{\sqrt{2}} & \frac{1}{\sqrt{3}} -\end{bmatrix} \] - -After rotation, the points $a$ and $b$ become: -\begin{align} - a &= \frac{D}{2} \begin{bmatrix}-\frac{\sqrt{2}}{\sqrt{3}} \\ -\sqrt{2} \\ -\frac{1}{\sqrt{3}}\end{bmatrix} \\ - b &= \frac{D}{2} \begin{bmatrix} \frac{\sqrt{2}}{\sqrt{3}} \\ -\sqrt{2} \\ \frac{1}{\sqrt{3}}\end{bmatrix} -\end{align} - -Points $a$ and $b$ define a vector $u = b - a$ that gives the orientation of one of the Stewart platform strut: -\[ u = \frac{D}{\sqrt{3}} \begin{bmatrix} -\sqrt{2} \\ 0 \\ -1\end{bmatrix} \] - -Then we want to find the intersection between the line that defines the strut with the plane defined by the height $H$ from the cube's center. -To do so, we first find $g$ such that: -\[ a_z + g u_z = -H \] -We obtain: -\begin{align} - g &= - \frac{H + a_z}{u_z} \\ - &= \sqrt{3} \frac{H}{D} - \frac{1}{2} -\end{align} - -Then, the intersection point $P$ is given by: -\begin{align} - P &= a + g u \\ - &= \begin{bmatrix} - H \sqrt{2} \\ - D \frac{1}{\sqrt{2}} \\ - H -\end{bmatrix} -\end{align} - -Finally, the circle can contains the intersection point has a radius $r$: -\begin{align} - r &= \sqrt{P_x^2 + P_y^2} \\ - &= \sqrt{2 H^2 + \frac{1}{2}D^2} -\end{align} - -By symmetry, we can show that all the other intersection points will also be on the circle with a radius $r$. - -For a small cube: -\[ r \approx \sqrt{2} H \] +The size of the platforms increase with the cube's size and the height of the location of the center of mass (also coincident with the cube's center). +The size of the bottom platform also increases with the height of the Stewart platform. +As the rotational stiffness for the cubic architecture is scaled as the square of the cube's height eqref:eq:detail_kinematics_cubic_stiffness, the cube's size can be determined from the requirements in terms of rotational stiffness. +Then, using eqref:eq:detail_kinematics_cube_joints, the size of the top and bottom platforms can be determined. **** Conclusion @@ -2506,8 +3552,17 @@ Depending on the cube's size, we obtain 3 different configurations. :UNNUMBERED: t :END: +Cubic architecture can be interesting when specific payloads are being used. +In that case, the center of mass of the payload should be placed at the center of the cube. +For the classical architecture, it is often not possible. -* Nano Hexapod :noexport: +Architectures with the center of the cube about the top platform are proposed to overcome this issue. + +Cubic architecture are attributed a number of properties that were found to be incorrect: +- Uniform mobility +- Easy for decentralized control + +* Nano Hexapod :PROPERTIES: :HEADER-ARGS:matlab+: :tangle matlab/detail_kinematics_3_nano_hexapod.m :END: @@ -2590,7 +3645,7 @@ This geometry will be used for: - for control purposes It is only when the complete mechanical design is finished (Section ...), that the model will be updated. -** Actuator required stroke +** Required Actuator stroke The actuator stroke to have the wanted mobility is computed. @@ -2748,12 +3803,10 @@ xlim(2e6*[-L_max, L_max]); ylim(2e6*[-L_max, L_max]); zlim(2e6*[-L_max, L_max]); Therefore, in Section ..., the specification for actuator stroke is +/-100um -** Joint angular stroke +** Required Joint angular stroke Now that the mobility of the Stewart platform is know, the corresponding flexible joint stroke can be estimated. - - - conclude on the required joint angle: 1mrad? Will be used to design flexible joints. @@ -2921,6 +3974,25 @@ if args.link_to_struts end #+end_src +** =plotCylindricalPayload=: Plot a cylindrical Payload +#+begin_src matlab :tangle matlab/src/plotCylindricalPayload.m :comments none :mkdirp yes :eval no +function [] = plotCylindricalPayload(stewart, args) + +arguments + stewart + args.H (1,1) double {mustBeNumeric, mustBePositive} = 100e-3 + args.R (1,1) double {mustBeNumeric, mustBePositive} = 50e-3 + args.H_offset (1,1) double {mustBeNumeric} = 0 + args.color (3,1) double {mustBeNumeric} = [0.5,0.5,0.5] +end + +[X,Y,Z] = cylinder(args.R); +Z = args.H*Z + args.H_offset; +surf(X, Y, Z, 'facecolor', args.color, 'edgecolor', 'none') +fill3(X(1,:), Y(1,:), Z(1,:), 'k', 'facecolor', args.color) +fill3(X(2,:), Y(2,:), Z(2,:), 'k', 'facecolor', args.color) +#+end_src + ** =computeJacobian=: Compute the Jacobian Matrix #+begin_src matlab :tangle matlab/src/computeJacobian.m :comments none :mkdirp yes :eval no function [stewart] = computeJacobian(stewart) @@ -3667,7 +4739,6 @@ if strcmp(args.views, 'all') end #+end_src - ** =describeStewartPlatform=: Display some text describing the current defined Stewart Platform #+begin_src matlab :tangle matlab/src/describeStewartPlatform.m :comments none :mkdirp yes :eval no function [] = describeStewartPlatform(stewart) @@ -3940,6 +5011,57 @@ function [stewart] = initializeJointDynamics(stewart, args) end #+end_src +** =initializeSample=: Sample + +#+begin_src matlab :tangle matlab/src/initializeSample.m :comments none :mkdirp yes :eval no +function [sample] = initializeSample(args) + + arguments + args.type char {mustBeMember(args.type,{'none', 'cylindrical'})} = 'none' + args.H_offset (1,1) double {mustBeNumeric} = 0 % Vertical offset [m] + args.H (1,1) double {mustBeNumeric, mustBePositive} = 200e-3 % Height [m] + args.R (1,1) double {mustBeNumeric, mustBePositive} = 110e-3 % Radius [m] + args.m (1,1) double {mustBeNumeric, mustBePositive} = 1 % Mass [kg] + end + + sample = struct(); + + switch args.type + case 'none' + sample.type = 0; + sample.m = 0; + case 'cylindrical' + sample.type = 1; + + sample.H_offset = args.H_offset; + + sample.H = args.H; + sample.R = args.R; + sample.m = args.m; + end +end +#+end_src + +** =initializeController=: Initialize Controller +#+begin_src matlab :tangle matlab/src/initializeController.m :comments none :mkdirp yes :eval no +function [controller] = initializeController(args) + + arguments + args.type char {mustBeMember(args.type,{'open-loop', 'iff'})} = 'open-loop' + end + + controller = struct(); + + switch args.type + case 'open-loop' + controller.type = 1; + controller.name = 'Open-Loop'; + case 'iff' + controller.type = 2; + controller.name = 'Decentralized Integral Force Feedback'; + end +end +#+end_src * Helping Functions :noexport: ** Initialize Path @@ -3967,7 +5089,6 @@ addpath('./subsystems/'); % Path for Subsystems Simulink files mdl = 'nano_hexapod_model'; #+end_src - ** Initialize other elements #+NAME: m-init-other #+BEGIN_SRC matlab diff --git a/nass-geometry.pdf b/nass-geometry.pdf index de6d5fb..166b19c 100644 Binary files a/nass-geometry.pdf and b/nass-geometry.pdf differ diff --git a/nass-geometry.tex b/nass-geometry.tex index 6b0e8ef..54c4d8c 100644 --- a/nass-geometry.tex +++ b/nass-geometry.tex @@ -1,4 +1,4 @@ -% Created 2025-03-30 Sun 18:15 +% Created 2025-04-01 Tue 10:48 % Intended LaTeX compiler: pdflatex \documentclass[a4paper, 10pt, DIV=12, parskip=full, bibliography=totoc]{scrreprt} @@ -40,6 +40,7 @@ Geometry, Actuators, Sensors, Joints \end{itemize} \chapter{Review of Stewart platforms} +\label{sec:orga98587b} \label{sec:detail_kinematics_stewart_review} \begin{itemize} \item As was explained in the conceptual phase, Stewart platform have the following key elements: @@ -177,6 +178,7 @@ Conclusion: \end{itemize} \chapter{Effect of geometry on Stewart platform properties} +\label{sec:orgf04ec9c} \label{sec:detail_kinematics_geometry} \begin{itemize} \item As was shown during the conceptual phase, the geometry of the Stewart platform influences: @@ -192,6 +194,7 @@ Conclusion: One important tool to study this is the Jacobian matrix which depends on the \(\bm{b}_i\) (join position w.r.t top platform) and \(\hat{\bm{s}}_i\) (orientation of struts). The choice of frames (\(\{A\}\) and \(\{B\}\)), independently of the physical Stewart platform geometry, impacts the obtained kinematics and stiffness matrix, as it is defined for forces and motion evaluated at the chosen frame. \section{Platform Mobility} +\label{sec:org62e6343} The mobility of the Stewart platform (or any manipulator) is here defined as the range of motion that it can perform. It corresponds to the set of possible pose (i.e. combined translation and rotation) of frame \{B\} with respect to frame \{A\}. It should therefore be represented in a six dimensional space. @@ -226,6 +229,7 @@ As the mobility is of dimension six, it is difficult to represent. Depending on the applications, only the translation mobility or the rotation mobility may be represented. \paragraph{Mobility in translation} +\label{sec:orga53467d} Here, for simplicity, only translations are first considered: \begin{itemize} @@ -291,6 +295,7 @@ To better understand how the geometry of the Stewart platform impacts the transl \end{figure} \paragraph{Mobility in rotation} +\label{sec:org25f8d00} As shown by equation \eqref{eq:detail_kinematics_jacobian}, the rotational mobility depends both on the orientation of the struts and on the location of the top joints. @@ -337,6 +342,7 @@ Therefore, the designed Stewart platform should just have the necessary mobility \end{figure} \paragraph{Combined translations and rotations} +\label{sec:orge05b0c2} It is possible to consider combined translations and rotations. Displaying such mobility is more complex. @@ -346,6 +352,7 @@ For a fixed geometry and a wanted mobility (combined translations and rotations) It will be done in Section \ref{sec:detail_kinematics_nano_hexapod} to estimate the required actuator stroke for the nano-hexapod geometry. \section{Stiffness} +\label{sec:orgdbcd7f4} Stiffness matrix: \begin{itemize} \item defines how the nano-hexapod deforms (frame \(\{B\}\) with respect to frame \(\{A\}\)) due to static forces/torques applied on \(\{B\}\). @@ -372,6 +379,7 @@ Obtained stiffness matrix linearly depends on the strut stiffness \(k\) \eqref{e \end{equation} \paragraph{Translation Stiffness} +\label{sec:org4d7dc00} XYZ stiffnesses: \begin{itemize} @@ -393,6 +401,7 @@ If struts more vertical (Figure \ref{fig:detail_kinematics_stewart_mobility_vert Opposite conclusions if struts are not horizontal (Figure \ref{fig:detail_kinematics_stewart_mobility_hori_struts}). \paragraph{Rotational Stiffness} +\label{sec:orga650239} Rotational stiffnesses: \begin{itemize} @@ -408,9 +417,20 @@ Struts further apart: \end{itemize} \paragraph{Diagonal Stiffness Matrix} +\label{sec:org78eda0e} +Having the stiffness matrix \(\bm{K}\) diagonal can be beneficial for control purposes as it would make the plant in the cartesian frame decoupled at low frequency. -\section{Dynamics ?} +This depends on the geometry and on the chosen \{A\} frame. + +For specific configurations, it is possible to have a diagonal K matrix. + +This will be discussed in Section \ref{ssec:detail_kinematics_cubic_static}. + +\section{Dynamical properties} +\label{sec:org12cf271} +\paragraph{In the Cartesian Frame} +\label{sec:orgaa53b5e} Dynamical equations (both in the cartesian frame and in the frame of the struts) for the Stewart platform were derived during the conceptual phase with simplifying assumptions (massless struts and perfect joints). The dynamics depends both on the geometry (Jacobian matrix) but also on the payload being placed on top of the platform. @@ -422,6 +442,9 @@ These are studied in Section \ref{ssec:detail_kinematics_cubic_dynamic}. \frac{{\mathcal{X}}}{\bm{\mathcal{F}}}(s) = ( \bm{M} s^2 + \bm{J}^{T} \bm{\mathcal{C}} \bm{J} s + \bm{J}^{T} \bm{\mathcal{K}} \bm{J} )^{-1} \end{equation} +\paragraph{In the frame of the Struts} +\label{sec:org5d4c9d1} + In the frame of the struts, the equations of motion are well decoupled at low frequency. This is why most of Stewart platforms are controlled in the frame of the struts: bellow the resonance frequency, the system is decoupled and SISO control may be applied for each strut. @@ -429,17 +452,18 @@ This is why most of Stewart platforms are controlled in the frame of the struts: \frac{\bm{\mathcal{L}}}{\bm{f}}(s) = ( \bm{J}^{-T} \bm{M} \bm{J}^{-1} s^2 + \bm{\mathcal{C}} + \bm{\mathcal{K}} )^{-1} \end{equation} -For the NASS, the payloads can have various inertia, with masses ranging from 1 to 50kg. -It is therefore not possible to have one geometry that gives good dynamical properties for all the payloads. +Coupling between sensors (force sensors, relative position sensor, inertial sensors) in different struts may also be important for decentralized control. +Can the geometry be optimized to have lower coupling between the struts? +This will be studied with the cubic architecture. +\paragraph{Dynamic Isotropy} +\label{sec:org25ba974} -Coupling between force sensors in different struts may also be important. - -\begin{itemize} -\item[{$\square$}] Maybe study that for the cubic architecture, and then say that except for very specific conditions, coupling is similar for different geometries -\end{itemize} +\cite{afzali-far16_vibrat_dynam_isotr_hexap_analy_studies}: +``\textbf{Dynamic isotropy}, leading to equal eigenfrequencies, is a powerful optimization measure.'' \section*{Conclusion} +\label{sec:orgf4da83b} The effects of two changes in the manipulator's geometry, namely the position and orientation of the legs, are summarized in Table \ref{tab:detail_kinematics_geometry}. These results could have been easily deduced based on some mechanical principles, but thanks to the kinematic analysis, they can be quantified. @@ -470,8 +494,698 @@ Horizontal rotation stroke & \(\searrow\) & \(\searrow\)\\ \end{tabularx} \end{table} +\chapter{The Cubic Architecture} +\label{sec:orga162ee4} +\label{sec:detail_kinematics_cubic} +The Cubic configuration for the Stewart platform was first proposed in \cite{geng94_six_degree_of_freed_activ}. + +This configuration is quite specific in the sense that the active struts are arranged in a mutually orthogonal configuration connecting the corners of a cube Figure \ref{fig:detail_kinematics_cubic_architecture_examples}. + +Cubic configuration: +\begin{itemize} +\item The struts are corresponding to 6 of the 8 edges of a cube. +\item This way, all struts are perpendicular to each other (except sets of two that are parallel). +\end{itemize} + +Struts with similar size than the cube's edge (Figure \ref{fig:detail_kinematics_cubic_architecture_example}). +Similar to Figures \ref{fig:detail_kinematics_jpl}, \ref{fig:detail_kinematics_uw_gsp} and \ref{fig:detail_kinematics_uqp}. + +Struts smaller than the cube's edge (Figure \ref{fig:detail_kinematics_cubic_architecture_example_small}). +Similar to the Stewart platform of Figure \ref{fig:detail_kinematics_ulb_pz}. + +\begin{figure}[htbp] +\begin{subfigure}{0.49\textwidth} +\begin{center} +\includegraphics[scale=1,scale=1]{figs/detail_kinematics_cubic_architecture_example.png} +\end{center} +\subcaption{\label{fig:detail_kinematics_cubic_architecture_example}sub caption a} +\end{subfigure} +\begin{subfigure}{0.49\textwidth} +\begin{center} +\includegraphics[scale=1,scale=1]{figs/detail_kinematics_cubic_architecture_example_small.png} +\end{center} +\subcaption{\label{fig:detail_kinematics_cubic_architecture_example_small}sub caption b} +\end{subfigure} +\caption{\label{fig:detail_kinematics_cubic_architecture_examples}Caption with reference to sub figure (\subref{fig:detail_kinematics_cubic_architecture_example}) (\subref{fig:detail_kinematics_cubic_architecture_example_small})} +\end{figure} + + +The cubic configuration is attributed a number of properties that made this configuration widely used (\cite{preumont07_six_axis_singl_stage_activ,jafari03_orthog_gough_stewar_platf_microm}). +From \cite{geng94_six_degree_of_freed_activ}: +\begin{enumerate} +\item Uniformity in control capability in all directions +\item Uniformity in stiffness in all directions +\item Minimum cross coupling force effect among actuators +\item Facilitate collocated sensor-actuator control system design +\item Simple kinematics relationships +\item Simple dynamic analysis +\item Simple mechanical design +\end{enumerate} + +According to \cite{preumont07_six_axis_singl_stage_activ}, it ``minimizes the cross-coupling amongst actuators and sensors of different legs'' (being orthogonal to each other). + +Specific points of interest are: +\begin{itemize} +\item uniform mobility, uniform stiffness, and coupling properties +\end{itemize} + +In this section: +\begin{itemize} +\item Such properties are studied +\item Additional properties interesting for control? +\item It is determined if the cubic architecture is interested for the nano-hexapod +\end{itemize} +\section{Static Properties} +\label{sec:orgf15f5ef} +\label{ssec:detail_kinematics_cubic_static} +\paragraph{Stiffness matrix for the Cubic architecture} +\label{sec:org6999200} +Consider the cubic architecture shown in Figure \ref{fig:detail_kinematics_cubic_schematic_full}. + +The unit vectors corresponding to the edges of the cube are described by \eqref{eq:detail_kinematics_cubic_s}. + +\begin{equation}\label{eq:detail_kinematics_cubic_s} + \hat{\bm{s}}_1 = \begin{bmatrix} \sqrt{2}/\sqrt{3} \\ 0 \\ 1/\sqrt{3} \end{bmatrix} \quad + \hat{\bm{s}}_2 = \begin{bmatrix} -1/\sqrt{6} \\ -1/\sqrt{2} \\ 1/\sqrt{3} \end{bmatrix} \quad + \hat{\bm{s}}_3 = \begin{bmatrix} -1/\sqrt{6} \\ 1/\sqrt{2} \\ 1/\sqrt{3} \end{bmatrix} \quad + \hat{\bm{s}}_4 = \begin{bmatrix} \sqrt{2}/\sqrt{3} \\ 0 \\ 1/\sqrt{3} \end{bmatrix} \quad + \hat{\bm{s}}_5 = \begin{bmatrix} -1/\sqrt{6} \\ -1/\sqrt{2} \\ 1/\sqrt{3} \end{bmatrix} \quad + \hat{\bm{s}}_6 = \begin{bmatrix} -1/\sqrt{6} \\ 1/\sqrt{2} \\ 1/\sqrt{3} \end{bmatrix} +\end{equation} + +Coordinates of the cube's vertices relevant for the top joints, expressed with respect to the cube's center \eqref{eq:detail_kinematics_cubic_vertices}. + +\begin{equation}\label{eq:detail_kinematics_cubic_vertices} + \tilde{\bm{b}}_1 = \tilde{\bm{b}}_2 = H_c \begin{bmatrix} \frac{1}{\sqrt{2}} \\ \frac{-\sqrt{3}}{\sqrt{2}} \\ \frac{1}{2} \end{bmatrix}, \quad + \tilde{\bm{b}}_3 = \tilde{\bm{b}}_4 = H_c \begin{bmatrix} \frac{1}{\sqrt{2}} \\ \frac{ \sqrt{3}}{\sqrt{2}} \\ \frac{1}{2} \end{bmatrix}, \quad + \tilde{\bm{b}}_5 = \tilde{\bm{b}}_6 = H_c \begin{bmatrix} \frac{-2}{\sqrt{2}} \\ 0 \\ \frac{1}{2} \end{bmatrix} +\end{equation} + +\begin{figure}[htbp] +\begin{subfigure}{0.33\textwidth} +\begin{center} +\includegraphics[scale=1,width=0.9\linewidth]{figs/detail_kinematics_cubic_schematic_full.png} +\end{center} +\subcaption{\label{fig:detail_kinematics_cubic_schematic_full}Full cube} +\end{subfigure} +\begin{subfigure}{0.33\textwidth} +\begin{center} +\includegraphics[scale=1,width=0.9\linewidth]{figs/detail_kinematics_cubic_schematic.png} +\end{center} +\subcaption{\label{fig:detail_kinematics_cubic_schematic}Cube's portion} +\end{subfigure} +\begin{subfigure}{0.33\textwidth} +\begin{center} +\includegraphics[scale=1,width=0.9\linewidth]{figs/detail_kinematics_cubic_schematic_off_centered.png} +\end{center} +\subcaption{\label{fig:detail_kinematics_cubic_schematic_off_centered}Off Centered} +\end{subfigure} +\caption{\label{fig:detail_kinematics_cubic_schematic_cases}Struts are represented un blue. The cube's center by a dot.} +\end{figure} + +In that case (top joints at the cube's vertices), a diagonal stiffness matrix is obtained \eqref{eq:detail_kinematics_cubic_stiffness}. +Translation stiffness is twice the stiffness of the struts, and rotational stiffness is proportional to the square of the cube's size Hc. + +\begin{equation}\label{eq:detail_kinematics_cubic_stiffness} + \bm{K}_{\{B\} = \{C\}} = k \begin{bmatrix} + 2 & 0 & 0 & 0 & 0 & 0 \\ + 0 & 2 & 0 & 0 & 0 & 0 \\ + 0 & 0 & 2 & 0 & 0 & 0 \\ + 0 & 0 & 0 & \frac{3}{2} H_c^2 & 0 & 0 \\ + 0 & 0 & 0 & 0 & \frac{3}{2} H_c^2 & 0 \\ + 0 & 0 & 0 & 0 & 0 & 6 H_c^2 \\ + \end{bmatrix} +\end{equation} + +But typically, the top joints are not placed at the cube's vertices but on the cube's edges (Figure \ref{fig:detail_kinematics_cubic_schematic}). +In that case, the location of the top joints can be expressed by \eqref{eq:detail_kinematics_cubic_edges}. + +\begin{equation}\label{eq:detail_kinematics_cubic_edges} +\bm{b}_i = \tilde{\bm{b}}_i + \alpha \hat{\bm{s}}_i +\end{equation} + +But the computed stiffness matrix is the same \eqref{eq:detail_kinematics_cubic_stiffness}. + +The Stiffness matrix is diagonal for forces and torques applied on the top platform, but expressed at the center of the cube, and for translations and rotations of the top platform expressed with respect to the cube's center. + +\begin{itemize} +\item[{$\square$}] Should I introduce the term ``center of stiffness'' here? +\end{itemize} + +\paragraph{Effect of having frame \(\{B\}\) off-centered} +\label{sec:org6f5ebda} + +However, as soon as the location of the A and B frames are shifted from the cube's center, off diagonal elements in the stiffness matrix appear. + +Let's consider here a vertical shift as shown in Figure \ref{fig:detail_kinematics_cubic_schematic_off_centered}. +In that case, the stiffness matrix is \eqref{eq:detail_kinematics_cubic_stiffness_off_centered}. +Off diagonal elements are increasing with the height difference between the cube's center and the considered B frame. + +\begin{equation}\label{eq:detail_kinematics_cubic_stiffness_off_centered} + \bm{K}_{\{B\} \neq \{C\}} = k \begin{bmatrix} + 2 & 0 & 0 & 0 & -2 H & 0 \\ + 0 & 2 & 0 & 2 H & 0 & 0 \\ + 0 & 0 & 2 & 0 & 0 & 0 \\ + 0 & 2 H & 0 & \frac{3}{2} H_c^2 + 2 H^2 & 0 & 0 \\ + -2 H & 0 & 0 & 0 & \frac{3}{2} H_c^2 + 2 H^2 & 0 \\ + 0 & 0 & 0 & 0 & 0 & 6 H_c^2 \\ + \end{bmatrix} +\end{equation} + + +Such structure of the stiffness matrix is very typical with Stewart platform that have some symmetry, but not necessary only for cubic architectures. + +Therefore, the stiffness of the cubic architecture is special only when considering a frame located at the center of the cube. +This is not very convenient, as in the vast majority of cases, the interesting frame is located about the top platform. + +Note that the cube's center needs not to be at the ``center'' of the Stewart platform. +This can lead to interesting architectures shown in Section \ref{ssec:detail_kinematics_cubic_design}. + +\paragraph{Uniform Mobility} +\label{sec:orgc9ab766} + +Uniform mobility in X,Y,Z directions (Figure \ref{fig:detail_kinematics_cubic_mobility_translations}) +\begin{itemize} +\item This is somehow more uniform than other architecture +\item A cube is obtained +\item The length of the cube's edge is equal to the strut axial stroke +\item Mobility in translation does not depend on the cube's size +\end{itemize} + +Some have argue that the translational mobility of the Cubic Stewart platform is a sphere \cite{mcinroy00_desig_contr_flexur_joint_hexap}, and this is useful to be able to move equal amount in all directions. +As shown here, this is wrong. +It is possible the consider that the mobility is uniform along the directions of the struts, but usually these are not interesting directions. + + +Also show mobility in Rx,Ry,Rz (Figure \ref{fig:detail_kinematics_cubic_mobility_rotations}): +\begin{itemize} +\item more mobility in Rx and Ry than in Rz +\item Mobility decreases with the size of the cube +\end{itemize} + +\begin{figure}[htbp] +\begin{subfigure}{0.48\textwidth} +\begin{center} +\includegraphics[scale=1,scale=1]{figs/detail_kinematics_cubic_mobility_translations.png} +\end{center} +\subcaption{\label{fig:detail_kinematics_cubic_mobility_translations}Mobility in translation} +\end{subfigure} +\begin{subfigure}{0.48\textwidth} +\begin{center} +\includegraphics[scale=1,scale=1]{figs/detail_kinematics_cubic_mobility_rotations.png} +\end{center} +\subcaption{\label{fig:detail_kinematics_cubic_mobility_rotations}Mobility in rotation} +\end{subfigure} +\caption{\label{fig:detail_kinematics_cubic_mobility}Mobility of a Stewart platform with Cubic architecture. Both for translations (\subref{fig:detail_kinematics_cubic_mobility_translations}) and rotations (\subref{fig:detail_kinematics_cubic_mobility_rotations})} +\end{figure} + +\section{Dynamical Decoupling} +\label{sec:orgb6fc32b} +\label{ssec:detail_kinematics_cubic_dynamic} +\begin{itemize} +\item[{$\square$}] \cite{mcinroy00_desig_contr_flexur_joint_hexap} +Why is this here? +\end{itemize} + +In this section, the dynamics of the platform in the cartesian frame is studied. +This corresponds to the transfer function from forces and torques \(\bm{\mathcal{F}}\) to translations and rotations \(\bm{\mathcal{X}}\) of the top platform. +If relative motion sensor are located in each strut (\(\bm{\mathcal{L}}\) is measured), the pose \(\bm{\mathcal{X}}\) is computed using the Jacobian matrix as shown in Figure \ref{fig:detail_kinematics_centralized_control}. + +\begin{figure}[htbp] +\centering +\includegraphics[scale=1]{figs/detail_kinematics_centralized_control.png} +\caption{\label{fig:detail_kinematics_centralized_control}From Strut coordinate to Cartesian coordinate using the Jacobian matrix} +\end{figure} + +We want to see if the Stewart platform has some special properties for control in the cartesian frame. +\paragraph{Low frequency and High frequency coupling} +\label{sec:orge8c133d} + +As was derived during the conceptual design phase, the dynamics from \(\bm{\mathcal{F}}\) to \(\bm{\mathcal{X}}\) is described by \eqref{eq:detail_kinematics_transfer_function_cart} + +\begin{equation}\label{eq:detail_kinematics_transfer_function_cart} + \frac{{\mathcal{X}}}{\bm{\mathcal{F}}}(s) = ( \bm{M} s^2 + \bm{J}^{T} \bm{\mathcal{C}} \bm{J} s + \bm{J}^{T} \bm{\mathcal{K}} \bm{J} )^{-1} +\end{equation} + + +At low frequency: the static behavior of the platform depends on the stiffness matrix \eqref{eq:detail_kinematics_transfer_function_cart_low_freq}. + +\begin{equation}\label{eq:detail_kinematics_transfer_function_cart_low_freq} + \frac{{\mathcal{X}}}{\bm{\mathcal{F}}}(j \omega) \xrightarrow[\omega \to 0]{} \bm{K}^{-1} +\end{equation} + +In section \ref{ssec:detail_kinematics_cubic_static}, it was shown that for the cubic configuration, the stiffness matrix is diagonal if frame \(\{B\}\) is taken at the cube's center. +In that case, the ``cartesian'' plant is decoupled at low frequency. + +At high frequency, the behavior depends on the mass matrix (evaluated at frame B) \eqref{eq:detail_kinematics_transfer_function_high_freq}. + +\begin{equation}\label{eq:detail_kinematics_transfer_function_high_freq} + \frac{{\mathcal{X}}}{\bm{\mathcal{F}}}(j \omega) \xrightarrow[\omega \to \infty]{} - \omega^2 \bm{M}^{-1} +\end{equation} + +To have the mass matrix diagonal, the center of mass of the mobile parts needs to coincide with the B frame and the principal axes of inertia of the body also needs to coincide with the axis of the B frame. + +To verify that, +\begin{itemize} +\item CoM above the top platform (Figure \ref{fig:detail_kinematics_cubic_payload}) +\item The transfer functions from F to X are computed for two specific locations of the B frames: +\begin{itemize} +\item center of mass: coupled at low frequency due to non diagonal stiffness matrix (Figure \ref{fig:detail_kinematics_cubic_cart_coupling_com}) +\item center of stiffness: coupled at high frequency due to non diagonal mass matrix (Figure \ref{fig:detail_kinematics_cubic_cart_coupling_cok}) +\end{itemize} +\item In both cases, we would get similar dynamics for a non-cubic stewart platform. +\end{itemize} + +\begin{figure}[htbp] +\centering +\includegraphics[scale=1,width=0.6\linewidth]{figs/detail_kinematics_cubic_payload.png} +\caption{\label{fig:detail_kinematics_cubic_payload}Cubic stewart platform with top cylindrical payload} +\end{figure} + +\begin{figure}[htbp] +\begin{subfigure}{0.48\textwidth} +\begin{center} +\includegraphics[scale=1,width=0.95\linewidth]{figs/detail_kinematics_cubic_cart_coupling_com.png} +\end{center} +\subcaption{\label{fig:detail_kinematics_cubic_cart_coupling_com}$\{B\}$ at the center of mass} +\end{subfigure} +\begin{subfigure}{0.48\textwidth} +\begin{center} +\includegraphics[scale=1,width=0.95\linewidth]{figs/detail_kinematics_cubic_cart_coupling_cok.png} +\end{center} +\subcaption{\label{fig:detail_kinematics_cubic_cart_coupling_cok}$\{B\}$ at the cube's center} +\end{subfigure} +\caption{\label{fig:detail_kinematics_cubic_cart_coupling}Transfer functions for a Cubic Stewart platform expressed in the Cartesian frame. Two locations of the \(\{B\}\) frame are considered: at the cube's center (\subref{fig:detail_kinematics_cubic_cart_coupling_cok}) and at the center of mass of the moving body (\subref{fig:detail_kinematics_cubic_cart_coupling_com}).} +\end{figure} + +\paragraph{Payload's CoM at the cube's center} +\label{sec:orgb627cee} + +It is therefore natural to try to have the cube's center and the center of mass of the moving part coincide at the same location. + +\begin{itemize} +\item CoM at the center of the cube: Figure \ref{fig:detail_kinematics_cubic_centered_payload} +\end{itemize} + +This is what is physically done in \cite{mcinroy99_dynam,mcinroy99_precis_fault_toler_point_using_stewar_platf,mcinroy00_desig_contr_flexur_joint_hexap,li01_simul_vibrat_isolat_point_contr,jafari03_orthog_gough_stewar_platf_microm} +Shown in Figure \ref{fig:detail_kinematics_uw_gsp} + +The obtained dynamics is indeed well decoupled, thanks to the diagonal stiffness matrix and mass matrix as the same time. + +The main issue with this is that usually we want the payload to be located above the top platform, as it is the case for the nano-hexapod. +Indeed, if a similar design than the one shown in Figure \ref{fig:detail_kinematics_cubic_centered_payload} was used, the x-ray beam will hit the different struts during the rotation of the spindle. + +\begin{figure}[htbp] +\begin{subfigure}{0.49\textwidth} +\begin{center} +\includegraphics[scale=1,width=0.95\linewidth]{figs/detail_kinematics_cubic_centered_payload.png} +\end{center} +\subcaption{\label{fig:detail_kinematics_cubic_centered_payload}Payload at the cube's center} +\end{subfigure} +\begin{subfigure}{0.49\textwidth} +\begin{center} +\includegraphics[scale=1,width=0.95\linewidth]{figs/detail_kinematics_cubic_cart_coupling_com_cok.png} +\end{center} +\subcaption{\label{fig:detail_kinematics_cubic_cart_coupling_com_cok}Fully decoupled cartesian plant} +\end{subfigure} +\caption{\label{fig:detail_kinematics_cubic_com_cok}Cubic Stewart platform with payload at the cube's center (\subref{fig:detail_kinematics_cubic_centered_payload}). Obtained cartesian plant is fully decoupled (\subref{fig:detail_kinematics_cubic_cart_coupling_com_cok})} +\end{figure} + +\paragraph{Conclusion} +\label{sec:org398201c} + +\begin{itemize} +\item Some work to still be decoupled when considering flexible joint stiffness +\begin{itemize} +\item[{$\square$}] Find the reference +\end{itemize} + +\item Better decoupling between the struts? Next section +\end{itemize} + +Some conclusions can be drawn from the above analysis: +\begin{itemize} +\item Static Decoupling <=> Diagonal Stiffness matrix <=> \{A\} and \{B\} at the cube's center +\item Dynamic Decoupling <=> Static Decoupling + CoM of mobile platform coincident with \{A\} and \{B\}. +\item Not specific to the cubic architecture +\item Same stiffness in XYZ => Possible to have dynamic isotropy +\end{itemize} + +\section{Decentralized Control} +\label{sec:orgf7427df} +From \cite{preumont07_six_axis_singl_stage_activ}, the cubic configuration ``\emph{minimizes the cross-coupling amongst actuators and sensors of different legs (being orthogonal to each other)}''. +This would facilitate the use of decentralized control. + +\begin{figure}[htbp] +\centering +\includegraphics[scale=1]{figs/detail_kinematics_decentralized_control.png} +\caption{\label{fig:detail_kinematics_decentralized_control}From Strut coordinate to Cartesian coordinate using the Jacobian matrix} +\end{figure} + +In this section, we wish to study such properties of the cubic architecture. + +Here, the plant output are sensors integrated in the Stewart platform struts. +Two sensors are considered: a displacement sensor and a force sensor. + +We will compare the transfer function from sensors to actuators in each strut for a cubic architecture and for a non-cubic architecture (where the struts are not orthogonal with each other). + +The ``strut plant'' are compared for two Stewart platforms: +\begin{itemize} +\item with cubic architecture shown in Figure \ref{fig:detail_kinematics_cubic_payload} (page \pageref{fig:detail_kinematics_cubic_payload}) +\item with a Stewart platform shown in Figure \ref{fig:detail_kinematics_non_cubic_payload}. It has the same payload and strut dynamics than for the cubic architecture. +The struts are oriented more vertically to be far away from the cubic architecture +\end{itemize} + +\begin{figure}[htbp] +\centering +\includegraphics[scale=1,width=0.6\linewidth]{figs/detail_kinematics_non_cubic_payload.png} +\caption{\label{fig:detail_kinematics_non_cubic_payload}Stewart platform with non-cubic architecture} +\end{figure} + +\paragraph{Relative Displacement Sensors} +\label{sec:orgd6eec76} + +The transfer functions from actuator force included in each strut to the relative motion of the struts are shown in Figure \ref{fig:detail_kinematics_decentralized_dL}. +As expected from the equations of motion from \(\bm{f}\) to \(\bm{\mathcal{L}}\) \eqref{eq:nhexa_transfer_function_struts}, the \(6 \times 6\) plants are decoupled at low frequency. + +At high frequency, the plant is coupled as the mass matrix projected in the frame of the struts is not diagonal. + +No clear advantage can be seen for the cubic architecture (figure \ref{fig:detail_kinematics_cubic_decentralized_dL}) as compared to the non-cubic architecture (Figure \ref{fig:detail_kinematics_non_cubic_decentralized_dL}). + +Note that the resonance frequencies are not the same in both cases as having the struts oriented more vertically changed the stiffness properties of the Stewart platform and hence the frequency of different modes. + +\begin{figure}[htbp] +\begin{subfigure}{0.48\textwidth} +\begin{center} +\includegraphics[scale=1,width=0.95\linewidth]{figs/detail_kinematics_non_cubic_decentralized_dL.png} +\end{center} +\subcaption{\label{fig:detail_kinematics_non_cubic_decentralized_dL}Non cubic architecture} +\end{subfigure} +\begin{subfigure}{0.48\textwidth} +\begin{center} +\includegraphics[scale=1,width=0.95\linewidth]{figs/detail_kinematics_cubic_decentralized_dL.png} +\end{center} +\subcaption{\label{fig:detail_kinematics_cubic_decentralized_dL}Cubic architecture} +\end{subfigure} +\caption{\label{fig:detail_kinematics_decentralized_dL}Bode plot of the transfer functions from actuator force to relative displacement sensor in each strut. Both for a non-cubic architecture (\subref{fig:detail_kinematics_non_cubic_decentralized_dL}) and for a cubic architecture (\subref{fig:detail_kinematics_cubic_decentralized_dL})} +\end{figure} + +\paragraph{Force Sensors} +\label{sec:org876f014} + +Similarly, the transfer functions from actuator force to force sensors included in each strut are extracted both for the cubic and non-cubic Stewart platforms. + +The results are shown in Figure \ref{fig:detail_kinematics_decentralized_fn}. + +\begin{figure}[htbp] +\begin{subfigure}{0.48\textwidth} +\begin{center} +\includegraphics[scale=1,width=0.95\linewidth]{figs/detail_kinematics_non_cubic_decentralized_fn.png} +\end{center} +\subcaption{\label{fig:detail_kinematics_non_cubic_decentralized_fn}Non cubic architecture} +\end{subfigure} +\begin{subfigure}{0.48\textwidth} +\begin{center} +\includegraphics[scale=1,width=0.95\linewidth]{figs/detail_kinematics_cubic_decentralized_fn.png} +\end{center} +\subcaption{\label{fig:detail_kinematics_cubic_decentralized_fn}Cubic architecture} +\end{subfigure} +\caption{\label{fig:detail_kinematics_decentralized_fn}Bode plot of the transfer functions from actuator force to force sensor in each strut. Both for a non-cubic architecture (\subref{fig:detail_kinematics_non_cubic_decentralized_fn}) and for a cubic architecture (\subref{fig:detail_kinematics_cubic_decentralized_fn})} +\end{figure} + +\paragraph{Conclusion} +\label{sec:org3face46} + +The Cubic architecture seems to not have any significant effect on the coupling between actuator and sensors of each strut and thus provides no advantages for decentralized control. + +\section{Cubic architecture with Cube's center above the top platform} +\label{sec:orgdc7560d} +\label{ssec:detail_kinematics_cubic_design} +As was shown in Section \ref{ssec:detail_kinematics_cubic_dynamic}, the cubic architecture can have very interesting dynamical properties when the center of mass of the moving body is at the cube's center. + +This is because, both the mass and stiffness matrices are diagonal. +As shown in in section \ref{ssec:detail_kinematics_cubic_static}, the stiffness matrix is diagonal when the considered B frame is located at the cube's center. + +Or, typically the \(\{B\}\) frame is taken above the top platform where forces are applied and where displacements are expressed. + +In this section, modifications of the Cubic architectures are proposed in order to be able to have the payload above the top platform while still benefiting from interesting dynamical properties of the cubic architecture. + + +Say a 100mm tall Stewart platform needs to be designed with the CoM of the payload 20mm above the top platform. +The cube's center therefore needs to be positioned 20mm above the top platform. + +The obtained design depends on the considered size of the cube +\paragraph{Small cube} +\label{sec:org1cbf4d9} + +Similar to \cite{furutani04_nanom_cuttin_machin_using_stewar}, even though it is not mentioned that the system has a cubic configuration. + +\begin{itemize} +\item[{$\square$}] Maybe output also side view / top view ? +\item[{$\square$}] Specify the cube's size each time +\item[{$\square$}] At the end say that having the small cube means small rotational stiffnesses +\end{itemize} + +Cube: 40mm height + +\begin{figure}[htbp] +\begin{subfigure}{0.36\textwidth} +\begin{center} +\includegraphics[scale=1,width=0.9\linewidth]{figs/detail_kinematics_cubic_above_small_iso.png} +\end{center} +\subcaption{\label{fig:detail_kinematics_cubic_above_small_iso}Isometric view} +\end{subfigure} +\begin{subfigure}{0.30\textwidth} +\begin{center} +\includegraphics[scale=1,width=0.9\linewidth]{figs/detail_kinematics_cubic_above_small_side.png} +\end{center} +\subcaption{\label{fig:detail_kinematics_cubic_above_small_side}Side view} +\end{subfigure} +\begin{subfigure}{0.30\textwidth} +\begin{center} +\includegraphics[scale=1,width=0.9\linewidth]{figs/detail_kinematics_cubic_above_small_top.png} +\end{center} +\subcaption{\label{fig:detail_kinematics_cubic_above_small_top}Top view} +\end{subfigure} +\caption{\label{fig:detail_kinematics_cubic_above_small}Cubic architecture with cube's center above the top platform. A cube height of 40mm is used.} +\end{figure} + +\paragraph{Medium sized cube} +\label{sec:orgdc0102b} + +Similar to \cite{yang19_dynam_model_decoup_contr_flexib} (Figure \ref{fig:detail_kinematics_yang19}) + +\begin{figure}[htbp] +\begin{subfigure}{0.36\textwidth} +\begin{center} +\includegraphics[scale=1,width=0.9\linewidth]{figs/detail_kinematics_cubic_above_medium_iso.png} +\end{center} +\subcaption{\label{fig:detail_kinematics_cubic_above_medium_iso}Isometric view} +\end{subfigure} +\begin{subfigure}{0.30\textwidth} +\begin{center} +\includegraphics[scale=1,width=0.9\linewidth]{figs/detail_kinematics_cubic_above_medium_side.png} +\end{center} +\subcaption{\label{fig:detail_kinematics_cubic_above_medium_side}Side view} +\end{subfigure} +\begin{subfigure}{0.30\textwidth} +\begin{center} +\includegraphics[scale=1,width=0.9\linewidth]{figs/detail_kinematics_cubic_above_medium_top.png} +\end{center} +\subcaption{\label{fig:detail_kinematics_cubic_above_medium_top}Top view} +\end{subfigure} +\caption{\label{fig:detail_kinematics_cubic_above_medium}Cubic architecture with cube's center above the top platform. A cube height of 140mm is used.} +\end{figure} + +\paragraph{Large cube} +\label{sec:orgaa7e4eb} + +\begin{figure}[htbp] +\begin{subfigure}{0.36\textwidth} +\begin{center} +\includegraphics[scale=1,width=0.9\linewidth]{figs/detail_kinematics_cubic_above_large_iso.png} +\end{center} +\subcaption{\label{fig:detail_kinematics_cubic_above_large_iso}Isometric view} +\end{subfigure} +\begin{subfigure}{0.30\textwidth} +\begin{center} +\includegraphics[scale=1,width=0.9\linewidth]{figs/detail_kinematics_cubic_above_large_side.png} +\end{center} +\subcaption{\label{fig:detail_kinematics_cubic_above_large_side}Side view} +\end{subfigure} +\begin{subfigure}{0.30\textwidth} +\begin{center} +\includegraphics[scale=1,width=0.9\linewidth]{figs/detail_kinematics_cubic_above_large_top.png} +\end{center} +\subcaption{\label{fig:detail_kinematics_cubic_above_large_top}Top view} +\end{subfigure} +\caption{\label{fig:detail_kinematics_cubic_above_large}Cubic architecture with cube's center above the top platform. A cube height of 240mm is used.} +\end{figure} + +\paragraph{Required size of the platforms} +\label{sec:org1b13e30} + +The minimum size of the platforms depends on the cube's size and the height between the platform and the cube's center. + +Let's denote: +\begin{itemize} +\item \(H\) the height between the cube's center and the considered platform +\item \(D\) the size of the cube's edges +\end{itemize} + +Let's denote by \(a\) and \(b\) the points of both ends of one of the cube's edge. + +Initially, we have: +\begin{align} + a &= \frac{D}{2} \begin{bmatrix}-1 \\ -1 \\ 1\end{bmatrix} \\ + b &= \frac{D}{2} \begin{bmatrix} 1 \\ -1 \\ 1\end{bmatrix} +\end{align} + +We rotate the cube around its center (origin of the rotated frame) such that one of its diagonal is vertical. +\[ R = \begin{bmatrix} + \frac{2}{\sqrt{6}} & 0 & \frac{1}{\sqrt{3}} \\ + \frac{-1}{\sqrt{6}} & \frac{1}{\sqrt{2}} & \frac{1}{\sqrt{3}} \\ + \frac{-1}{\sqrt{6}} & \frac{-1}{\sqrt{2}} & \frac{1}{\sqrt{3}} +\end{bmatrix} \] + +After rotation, the points \(a\) and \(b\) become: +\begin{align} + a &= \frac{D}{2} \begin{bmatrix}-\frac{\sqrt{2}}{\sqrt{3}} \\ -\sqrt{2} \\ -\frac{1}{\sqrt{3}}\end{bmatrix} \\ + b &= \frac{D}{2} \begin{bmatrix} \frac{\sqrt{2}}{\sqrt{3}} \\ -\sqrt{2} \\ \frac{1}{\sqrt{3}}\end{bmatrix} +\end{align} + +Points \(a\) and \(b\) define a vector \(u = b - a\) that gives the orientation of one of the Stewart platform strut: +\[ u = \frac{D}{\sqrt{3}} \begin{bmatrix} -\sqrt{2} \\ 0 \\ -1\end{bmatrix} \] + +Then we want to find the intersection between the line that defines the strut with the plane defined by the height \(H\) from the cube's center. +To do so, we first find \(g\) such that: +\[ a_z + g u_z = -H \] +We obtain: +\begin{align} + g &= - \frac{H + a_z}{u_z} \\ + &= \sqrt{3} \frac{H}{D} - \frac{1}{2} +\end{align} + +Then, the intersection point \(P\) is given by: +\begin{align} + P &= a + g u \\ + &= \begin{bmatrix} + H \sqrt{2} \\ + D \frac{1}{\sqrt{2}} \\ + H +\end{bmatrix} +\end{align} + +Finally, the circle can contains the intersection point has a radius \(r\): +\begin{align} + r &= \sqrt{P_x^2 + P_y^2} \\ + &= \sqrt{2 H^2 + \frac{1}{2}D^2} +\end{align} + +By symmetry, we can show that all the other intersection points will also be on the circle with a radius \(r\). + +For a small cube: +\[ r \approx \sqrt{2} H \] + + +\paragraph{Conclusion} +\label{sec:org962f0e9} + +For each of the configuration, the Stiffness matrix is diagonal with \(k_x = k_y = k_y = 2k\) with \(k\) is the stiffness of each strut. +However, the rotational stiffnesses are increasing with the cube's size but the required size of the platform is also increasing, so there is a trade-off here. + +We found that we can have a diagonal stiffness matrix using the cubic architecture when \(\{A\}\) and \(\{B\}\) are located above the top platform. +Depending on the cube's size, we obtain 3 different configurations. + +\section*{Conclusion} +\label{sec:org1c5dc45} +Cubic architecture can be interesting when specific payloads are being used. +In that case, the center of mass of the payload should be placed at the center of the cube. +For the classical architecture, it is often not possible. + +Architectures with the center of the cube about the top platform are proposed to overcome this issue. + +Cubic architecture are attributed a number of properties that were found to be incorrect: +\begin{itemize} +\item Uniform mobility +\item Easy for decentralized control +\end{itemize} + +\chapter{Nano Hexapod} +\label{sec:org5dd05cd} +\label{sec:detail_kinematics_nano_hexapod} +For the NASS, the chosen frame \(\{A\}\) and \(\{B\}\) coincide with the sample's point of interest, which is \(150\,mm\) above the top platform. + +Requirements: +\begin{itemize} +\item The nano-hexapod should fit within a cylinder with radius of \(120\,mm\) and with a height of \(95\,mm\). +\item In terms of mobility: uniform mobility in XYZ directions (100um) +\item In terms of stiffness: ?? +\item In terms of dynamics: +\begin{itemize} +\item be able to apply IFF in a decentralized way with good robustness and performances (good damping of modes) +\item good decoupling for the HAC +\end{itemize} +\end{itemize} + +For the NASS, the payloads can have various inertia, with masses ranging from 1 to 50kg. +It is therefore not possible to have one geometry that gives good dynamical properties for all the payloads. +\section{Obtained Geometry} +\label{sec:org5ce1eba} + +Take both platforms at maximum size. +Make reasonable choice (close to the final choice). +Say that it is good enough to make all the calculations. +The geometry will be slightly refined during the detailed mechanical design for several reason: easy of mount, manufacturability, \ldots{} + +\begin{itemize} +\item[{$\square$}] Show the obtained geometry and the main parameters. +\end{itemize} + +This geometry will be used for: +\begin{itemize} +\item estimate required actuator stroke +\item estimate flexible joint stroke +\item when performing noise budgeting for the choice of instrumentation +\item for control purposes +\end{itemize} +It is only when the complete mechanical design is finished (Section \ldots{}), that the model will be updated. + +\section{Required Actuator stroke} +\label{sec:orgf89f26c} + +The actuator stroke to have the wanted mobility is computed. + +Wanted mobility: +\begin{itemize} +\item Combined translations in the xyz directions of +/-50um (basically ``cube'') +\item At any point of the cube, be able to do combined Rx and Ry rotations of +/-50urad +\item Rz is always at 0 +\item Say that it is frame B with respect to frame A, but it is motion expressed at the point of interest (at the focus point of the light) +\end{itemize} + +First the minimum actuator stroke to have the wanted mobility is computed. +With the chosen geometry, an actuator stroke of +/-94um is found. + +Considering combined rotations and translations, the wanted mobility and the obtained mobility of the Nano hexapod are shown in Figure \ldots{} + +It can be seen that just wanted mobility (displayed as a cube), just fits inside the obtained mobility. +Here the worst case scenario is considered, meaning that whatever the angular position in Rx and Ry (in the range +/-50urad), the top platform can be positioned anywhere inside the cube. + +Therefore, in Section \ldots{}, the specification for actuator stroke is +/-100um + +\section{Required Joint angular stroke} +\label{sec:org2799c77} + +Now that the mobility of the Stewart platform is know, the corresponding flexible joint stroke can be estimated. + +\begin{itemize} +\item conclude on the required joint angle: 1mrad? +Will be used to design flexible joints. +\end{itemize} \chapter{Conclusion} +\label{sec:org99763bc} \label{sec:detail_kinematics_conclusion} Inertia used for experiments will be very broad => difficult to optimize the dynamics