tdehaeze/delta-robot
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add recommendation for flexible joints

Browse Source
This commit is contained in:
Thomas Dehaeze
2025-12-02 16:08:45 +01:00
parent fefeb505ee
commit 93e508f4f5
9 changed files with 592 additions and 548 deletions
Download Patch File Download Diff File Expand all files Collapse all files

382
delta-robot.org
View File

@@ -89,7 +89,7 @@
#+END_SRC
* The Delta Robot Kinematics :ignore:
<<sec:delta_robot_introduction>>
<<sec:delta_robot_kinematics>>
** Introduction :ignore:
** Matlab Init :noexport:ignore:
#+begin_src matlab :tangle no :exports none :results silent :noweb yes :var current_dir=(file-name-directory buffer-file-name)
@@ -116,7 +116,7 @@
<<m-init-other>>
#+end_src
** Geometry
** Studied Geometry
The Delta Robot geometry is defined as shown in Figure [[fig:delta_robot_schematic]].
The geometry is fully defined by three parameters:
@@ -157,12 +157,14 @@ Dynamical properties:
Let's initialize a Delta Robot architecture, and plot the obtained geometry (Figures [[fig:delta_robot_architecture]] and [[fig:delta_robot_architecture_top]]).
#+begin_src matlab
#+begin_src matlab :exports code
%% Geometry
d = 50e-3; % Cube's edge length [m]
b = 20e-3; % Distance between cube's vertices and top joints [m]
L = 50e-3; % Length of the struts [m]
#+end_src
#+begin_src matlab
%% Initialize the Delta Robot
delta_robot = initializeStewartPlatform();
delta_robot = generateDeltaRobot(delta_robot, 'd', d, 'b', b, 'L', L);
@@ -219,6 +221,7 @@ The Jacobian matrix is defined as shown in eqref:eq:delta_robot_jacobian.
\end{equation}
#+begin_src matlab
%% Jacobian matrix
s1 = delta_robot.geometry.As(:,1);
s2 = delta_robot.geometry.As(:,3);
s3 = delta_robot.geometry.As(:,5);
@@ -239,6 +242,7 @@ It links the small actuator displacement to the top platform displacement eqref:
The achievable workspace is a cube whose edge length is equal to the actuator stroke.
#+begin_src matlab
%% Estimation of the mobility
L_max = 50e-6; % Maximum actuator stroke (+/-) [m]
thetas = linspace(0, pi, 100);
@@ -312,7 +316,7 @@ L = 1/sqrt(2)*min(abs(rs(i,:)));
#+end_src
#+begin_src matlab :exports none :results none
%% 2D mobility for different orientations
%% 2D mobility for different orientations and worst case
figure;
hold on;
for i = 1:length(phis)
@@ -333,7 +337,7 @@ exportFig('figs/delta_robot_2d_workspace.pdf', 'width', 'normal', 'height', 'tal
#+end_src
#+name: fig:delta_robot_2d_workspace
#+caption: 2D mobility for different orientations
#+caption: 2D mobility for different orientations and worst case
#+RESULTS:
[[file:figs/delta_robot_2d_workspace.png]]
@@ -414,7 +418,7 @@ In the perfect case (flexible joints having no stiffness in bending, and infinit
In order to have some compliance in rotation, the flexible joints need to have some compliance in torsion *and* in the axial direction.
If only the torsional compliance is considered, or only the axial compliance, the top platform will still not be able to do any rotation.
This is shown below with the Simscape model:
This is shown below with the Simscape model.
Perfect Delta Robot:
- infinite axial stiffness
@@ -483,20 +487,10 @@ delta_robot = initializeJointDynamics(delta_robot, 'type_F', '3dof', 'type_M', '
G_kt = linearize(mdl, io);
G_kt.InputName = {'Fx', 'Fy', 'Fz', 'Mx', 'My', 'Mz'};
G_kt.OutputName = {'Dx', 'Dy', 'Dz', 'Rx', 'Ry', 'Rz'};
#+end_src
#+begin_src matlab :results value replace :exports results :tangle no
dcgain(G_kt)
#+end_src
#+RESULTS:
| 1.00000000008084e-06 | 5.61161767954149e-17 | 1.71532908969278e-16 | -5.07840362381474e-20 | 6.66481298362927e-20 | -2.97485996797085e-20 |
| 9.44550093013109e-17 | 9.99999999981042e-07 | -1.31365181854596e-16 | 2.20736442292089e-20 | -8.27761658859861e-20 | -5.51841106039072e-20 |
| 1.5172479677791e-16 | 7.57916759433382e-18 | 9.9999999983089e-07 | 2.71965732539802e-20 | -5.0088900526952e-21 | 4.20708731166142e-20 |
| 3.7990974483635e-15 | -1.49195278352597e-15 | 1.09166051384021e-15 | -4.60992688885629e-28 | 4.46894514064728e-28 | -6.04202812027976e-29 |
| 1.92223678174906e-15 | 3.62267008376981e-15 | -5.42452104276465e-15 | 3.7737029650938e-28 | -2.99601307180469e-28 | -3.30297132145485e-28 |
| 3.79407058351761e-16 | -3.46944690994006e-17 | 9.05659407516431e-16 | -1.33615244419949e-28 | 6.31115609464934e-29 | -1.07596265815569e-29 |
If we consider the axial of the flexible joints:
- finite axial stiffness
@@ -513,20 +507,10 @@ delta_robot = initializeJointDynamics(delta_robot, 'type_F', '2dof_a', 'type_M',
G_ka = linearize(mdl, io);
G_ka.InputName = {'Fx', 'Fy', 'Fz', 'Mx', 'My', 'Mz'};
G_ka.OutputName = {'Dx', 'Dy', 'Dz', 'Rx', 'Ry', 'Rz'};
#+end_src
#+begin_src matlab :results value replace :exports results :tangle no
dcgain(G_ka)
#+end_src
#+RESULTS:
| 1.0100082922792e-06 | -8.23544084894984e-12 | -1.12982601885747e-11 | -1.30123733161505e-19 | 3.61079565098929e-21 | -2.56479299609534e-20 |
| -8.23691147427908e-12 | 1.01002426764947e-06 | 1.16488393394949e-11 | -9.17271935353013e-20 | -1.39093131659514e-20 | -8.92049690205949e-21 |
| -1.12984563170605e-11 | 1.1646579416975e-11 | 1.01001628184113e-06 | -1.2624013403036e-19 | -4.41063676650963e-22 | 2.01282903077792e-20 |
| 3.25566266033832e-16 | 7.02470264849632e-18 | 1.34879235410707e-17 | -4.42814771779206e-29 | 1.06332319737688e-30 | -8.04051214064698e-30 |
| -2.34669385520782e-15 | 1.03658500184429e-16 | 2.10026418149746e-15 | 3.04125606965025e-29 | -1.07347740796227e-29 | 1.00530401393662e-28 |
| -2.76788049700945e-16 | -3.49174266014038e-17 | 1.36253386200494e-15 | -1.31490052587614e-28 | -1.10493913866777e-30 | 3.45058758900066e-29 |
No we consider both finite torsional stiffness and finite axial stiffness.
In that case we get some compliance in rotation.
So it is a combination of axial and torsion stiffness that gives some rotational stiffness of the top platform.
@@ -539,20 +523,10 @@ delta_robot = initializeJointDynamics(delta_robot, 'type_F', '3dof_a', 'type_M',
G_ka_kt = linearize(mdl, io);
G_ka_kt.InputName = {'Fx', 'Fy', 'Fz', 'Mx', 'My', 'Mz'};
G_ka_kt.OutputName = {'Dx', 'Dy', 'Dz', 'Rx', 'Ry', 'Rz'};
#+end_src
#+begin_src matlab :results value replace :exports results :tangle no
dcgain(G_ka_kt)
#+end_src
#+RESULTS:
| 1.01000347398415e-06 | 1.08760660507374e-12 | 6.48998902114602e-12 | -1.68758827983914e-12 | 2.72734564017018e-12 | -1.13327901508316e-12 |
| -1.7269667100718e-13 | 1.01000152837256e-06 | 4.09018170284123e-13 | -9.80286569772779e-13 | -9.94629340226498e-13 | 8.3468855003368e-13 |
| 5.40707734744154e-12 | -1.46859567258244e-12 | 1.0099981133678e-06 | 3.34755457607493e-12 | -6.56764113866634e-12 | 1.26237249518737e-12 |
| 2.67935189951885e-13 | -6.64493555908236e-14 | 7.44661955503977e-13 | 1.59744415094004e-05 | -6.97585818773949e-13 | 1.44845764745933e-13 |
| 1.91880640934689e-14 | -1.31284160978049e-13 | -5.83827721443037e-13 | 4.97550111979747e-13 | 1.5974440506229e-05 | 8.27388125221276e-14 |
| 1.63302978397554e-14 | -6.29948151015302e-14 | 1.11798835985125e-13 | -4.74438363934587e-14 | -1.39110944875938e-13 | 3.99840072236264e-06 |
Therefore, to model some compliance of the top platform in rotation, both the axial compliance and the torsional compliance of the flexible joints should be considered.
** Kinematics: Number of modes
@@ -608,17 +582,14 @@ size(G)
<<sec:delta_robot_flexible_joints>>
** Introduction :ignore:
The goal is to extract specifications for the flexible joints of the six struts.
The two most critical flexible joints imperfections are:
- The axial stiffness, that should be high enough
- The bending stiffness, that should be low enough
The shear and torsional stiffnesses are not foreseen to be very problematic, but their impact will be evaluated.
First, the dynamics of a "perfect" Delta-Robot is identified (i.e. with perfect 2DoF rotational joints).
First, in Section [[ssec:delta_robot_flexible_joints_geometry]], the dynamics of a "perfect" Delta-Robot is identified (i.e. with perfect 2DoF rotational joints).
Then, the impact of the flexible joint's imperfections will be studied.
The goal is to extract specifications for the flexible joints of the six struts, in terms of:
- bending stiffness (Section [[ssec:delta_robot_flexible_joints_bending]])
- axial stiffness (Section [[ssec:delta_robot_flexible_joints_axial]])
- torsional stiffness (Section [[ssec:delta_robot_flexible_joints_torsion]])
- shear stiffness (Section [[ssec:delta_robot_flexible_joints_shear]])
** Matlab Init :noexport:ignore:
#+begin_src matlab :tangle no :exports none :results silent :noweb yes :var current_dir=(file-name-directory buffer-file-name)
@@ -646,11 +617,12 @@ Then, the impact of the flexible joint's imperfections will be studied.
#+end_src
** Studied Geometry
<<ssec:delta_robot_flexible_joints_geometry>>
The cube's edge length is equal to 50mm, the distance between cube's vertices and top joints is 20mm and the length of the struts (i.e. the distance between the two flexible joints of the same strut) is 50mm.
The actuator stiffness is $1\,N/\mu m$.
The obtained geometry is shown in Figure [[fig:delta_robot_studied_geometry]].
The obtained geometry is shown in Figure [].
#+begin_src matlab
%% Geometry
@@ -749,7 +721,9 @@ exportFig('figs/delta_robot_dynamics_perfect.pdf', 'width', 'wide', 'height', 'n
#+RESULTS:
[[file:figs/delta_robot_dynamics_perfect.png]]
** Stiffness seen by the actuator
** Bending Stiffness
<<ssec:delta_robot_flexible_joints_bending>>
*** Stiffness seen by the actuator, and decrease of the achievable stroke
Because the flexible joints will have some bending stiffness, the actuator in one direction will "see" some stiffness due to the struts in the other directions.
This will limit its effective stroke.
@@ -799,7 +773,6 @@ Therefore, we should aim at $k_f < 50\,Nm/\text{rad}$.
This should be validated with the final geometry.
** Bending Stiffness
Then, the dynamics is identified for a bending Stiffness of $50\,Nm/\text{rad}$ and compared with a Delta robot with no bending stiffness in Figure [[fig:delta_robot_bending_stiffness_dynamics]].
@@ -854,7 +827,98 @@ exportFig('figs/delta_robot_bending_stiffness_dynamics.pdf', 'width', 'wide', 'h
#+RESULTS:
[[file:figs/delta_robot_bending_stiffness_dynamics.png]]
*** Effect on the coupling
Here, reasonable values for the flexible joints (modelled as a 6DoF joint) stiffness are taken:
- Torsional stiffness of 500Nm/rad
- Axial stiffness of 100N/um
- Shear stiffness of 100N/um
And the bending stiffness is varied from low to high values.
The obtained dynamics is shown in Figure [[fig:delta_robot_bending_stiffness_couplign]].
It can be seen that the low frequency coupling increases when the bending stiffness increases.
Therefore, the bending stiffness of the flexible joints should be minimized (10Nm/rad could be a reasonable objective).
#+begin_src matlab
%% Effect of bending stiffness on the plant dynamics
d = 50e-3; % Cube's edge length [m]
b = 20e-3; % Distance between cube's vertices and top joints [m]
L = 50e-3; % Length of the struts [m]
delta_robot = initializeStewartPlatform();
delta_robot = generateDeltaRobot(delta_robot, 'd', d, 'b', b, 'L', L);
delta_robot = computeJointsPose(delta_robot);
delta_robot = initializeActuatorDynamics(delta_robot, 'type', '1dof', 'k', k);
delta_robot = initializeCylindricalStruts(delta_robot);
delta_robot = computeJacobian(delta_robot);
delta_robot = initializeStewartPose(delta_robot);
joint_axial = 100e6; % [N/m]
joint_shear = 100e6; % [N/m]
joint_bending = 50; % [Nm/rad]
joint_torsion = 500; % [Nm/rad]
clear io; io_i = 1;
io(io_i) = linio([mdl, '/F'], 1, 'openinput'); io_i = io_i + 1; % Actuator Force Inputs [N]
io(io_i) = linio([mdl, '/delta_robot'], 1, 'openoutput'); io_i = io_i + 1; % Actuator Displacement [m]
Kfs = [1, 10, 100, 1000];
Gkf = {zeros(size(Kfs))};
for i = 1:length(Kfs)
delta_robot = initializeJointDynamics(delta_robot, 'type_F', '6dof', 'type_M', '6dof', 'Ka', joint_axial, 'Kf', Kfs(i), 'Kt', joint_torsion, 'Ks', joint_shear);
%% Run the linearization
G = linearize(mdl, io);
G.InputName = {'F1', 'F2', 'F3'};
G.OutputName = {'D1', 'D2', 'D3'};
Gkf(i) = {G};
end
#+end_src
#+begin_src matlab :exports none :results none
%% Effect of the bending stiffness of the flexible joints on the coupling
freqs = logspace(0, 4, 1000);
figure;
tiledlayout(1, 1, 'TileSpacing', 'Compact', 'Padding', 'None');
ax1 = nexttile();
hold on;
for i = 1:length(Kfs)
plot(freqs, abs(squeeze(freqresp(Gkf{i}(1, 1), freqs, 'Hz'))), ...
'DisplayName', sprintf('$D_i/F_i$, $k_f = %.0f Nm/rad$', Kfs(i)));
end
plot(freqs, abs(squeeze(freqresp(Gkf{1}(1, 2), freqs, 'Hz'))), 'color', [colors(1, :), 0.5], ...
'DisplayName', 'coupling');
plot(freqs, abs(squeeze(freqresp(Gkf{1}(1, 3), freqs, 'Hz'))), 'color', [colors(1, :), 0.5], ...
'HandleVisibility', 'off');
for i = 2:length(Kfs)
plot(freqs, abs(squeeze(freqresp(Gkf{i}(1, 2), freqs, 'Hz'))), 'color', [colors(i, :), 0.5], ...
'HandleVisibility', 'off');
plot(freqs, abs(squeeze(freqresp(Gkf{i}(1, 3), freqs, 'Hz'))), 'color', [colors(i, :), 0.5], ...
'HandleVisibility', 'off');
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
xlabel('Frequency [Hz]'); ylabel('Amplitude [m/N]');
leg = legend('location', 'northwest', 'FontSize', 8, 'NumColumns', 1);
leg.ItemTokenSize(1) = 15;
xlim([1, 1e4]);
ylim([1e-12, 1e-4])
#+end_src
#+begin_src matlab :tangle no :exports results :results file replace
exportFig('figs/delta_robot_bending_stiffness_couplign.pdf', 'width', 'wide', 'height', 'normal');
#+end_src
#+name: fig:delta_robot_bending_stiffness_couplign
#+caption: Effect of the bending stiffness of the flexible joints on the coupling
#+RESULTS:
[[file:figs/delta_robot_bending_stiffness_couplign.png]]
** Axial Stiffness
<<ssec:delta_robot_flexible_joints_axial>>
Now, the effect of the axial stiffness on the dynamics is studied (Figure [[fig:delta_robot_axial_stiffness_dynamics]]).
Additional modes can be observed on the plant dynamics, which could limit the achievable bandwidth.
@@ -909,6 +973,8 @@ exportFig('figs/delta_robot_axial_stiffness_dynamics.pdf', 'width', 'wide', 'hei
[[file:figs/delta_robot_axial_stiffness_dynamics.png]]
** Torsional Stiffness
<<ssec:delta_robot_flexible_joints_torsion>>
Now the compliance in torsion of the flexible joints is considered.
If we look at the compliance of the delta robot in rotation as a function of the torsional stiffness of the flexible joints (Figure [[fig:delta_robot_kt_compliance]]), we see almost no effect: the system is not made more stiff by increasing the torsional stiffness of the joints.
@@ -1032,6 +1098,7 @@ exportFig('figs/delta_robot_kt_dynamics.pdf', 'width', 'wide', 'height', 'normal
Therefore, the torsional stiffness is not a super important metric for the design of the delta robot.
** Shear Stiffness
<<ssec:delta_robot_flexible_joints_shear>>
As shown in Figure [[fig:delta_robot_shear_stiffness_compliance]], the shear stiffness of the flexible joints has some effect on the compliance in translation and almost no effect on the compliance in rotation.
@@ -1108,6 +1175,45 @@ exportFig('figs/delta_robot_shear_stiffness_compliance.pdf', 'width', 'full', 'h
[[file:figs/delta_robot_shear_stiffness_compliance.png]]
** Conclusion
#+name: tab:delta_robot_flexible_joints_recommendations
#+caption: Recommendations for the flexible joints
| Joint's Stiffness | Effect | Recommendation |
|-------------------+--------------------------------------------------+-------------------------------------------------------------------------------------------|
| Bending | Can reduce the stroke, and increase the coupling | Below 50 to 10 Nm/rad |
| Axial | Add modes that can limit the feedback bandwidth | As high as possible, at least 100 Nm/um |
| Torsion | Minor effect | No recommendation |
| Shear | Can limit the stiffness of the system | As high as possible (less important than the axial stiffness), above 100 N/um if possible |
* Effect of the Geometry
<<sec:delta_robot_flexible_geometry>>
** Introduction :ignore:
** Matlab Init :noexport:ignore:
#+begin_src matlab :tangle no :exports none :results silent :noweb yes :var current_dir=(file-name-directory buffer-file-name)
<<matlab-dir>>
#+end_src
#+begin_src matlab :exports none :results silent :noweb yes
<<matlab-init>>
#+end_src
#+begin_src matlab :tangle no :noweb yes
<<m-init-path>>
#+end_src
#+begin_src matlab :eval no :noweb yes
<<m-init-path-tangle>>
#+end_src
#+begin_src matlab :noweb yes
<<m-init-simscape>>
#+end_src
#+begin_src matlab :noweb yes
<<m-init-other>>
#+end_src
** Effect of cube's size
*** Introduction :ignore:
@@ -1268,7 +1374,7 @@ exportFig('figs/delta_robot_cube_size_compliance_rotation.pdf', 'width', 'wide',
With a cube size of 50mm, the resonance frequency is already above 1kHz with seems reasonable.
** Effect of the strut length ?
** Effect of the strut length
*** Introduction :ignore:
Let's choose reasonable values for the flexible joints:
- Bending stiffness of 50Nm/rad
@@ -1277,94 +1383,15 @@ Let's choose reasonable values for the flexible joints:
And we see the effect of changing the strut length.
*** Effect on the plant dynamics
As shown in Figure [[fig:delta_robot_strut_length_plant_dynamics]], having longer struts:
- decreases the main resonance frequency: this means that the stiffness in the X,Y and Z directions is decreased when the length of the strut is longer.
This is reasonable as the "lever" arm is getting larger, so the bending stiffness and compression of the flexible joints have a larger effect on the top platform compliance.
- decreases the low frequency coupling: this effect is more difficult to physically understand
But even with relatively short struts (20mm and above), the low frequency decoupling is already around two orders of magnitude, which is enough from a control point of view.
So, the struts length can be optimized to not decrease too much the stiffness of the platform while still getting good low frequency decoupling.
#+begin_src matlab
%% Effect of torsional stiffness on the plant dynamics
joint_axial = 100e6; % [N/m]
joint_bending = 50; % [Nm/rad]
joint_torsion = 500; % [Nm/rad]
% Geometry
d = 50e-3; % Cube's edge length [m]
b = 20e-3; % Distance between cube's vertices and top joints [m]
clear io; io_i = 1;
io(io_i) = linio([mdl, '/F'], 1, 'openinput'); io_i = io_i + 1; % Actuator Force Inputs [N]
io(io_i) = linio([mdl, '/delta_robot'], 1, 'openoutput'); io_i = io_i + 1; % Actuator Displacement [m]
% Cube's size
strut_length = [10e-3, 20e-3, 50e-3, 100e-3];
G_strut_length = {zeros(size(strut_length))};
for i = 1:length(strut_length)
delta_robot = initializeStewartPlatform();
delta_robot = generateDeltaRobot(delta_robot, 'd', d, 'b', b, 'L', strut_length(i));
delta_robot = computeJointsPose(delta_robot);
delta_robot = initializeActuatorDynamics(delta_robot, 'type', '1dof', 'k', k);
delta_robot = initializeJointDynamics(delta_robot, 'type_F', '3dof_a', 'type_M', '2dof_a', 'Ka', joint_axial, 'Kf', joint_bending, 'Kt', joint_torsion);
delta_robot = initializeCylindricalStruts(delta_robot);
delta_robot = computeJacobian(delta_robot);
delta_robot = initializeStewartPose(delta_robot);
%% Run the linearization
G = linearize(mdl, io);
G.InputName = {'F1', 'F2', 'F3'};
G.OutputName = {'D1', 'D2', 'D3'};
G_strut_length(i) = {G};
end
#+end_src
#+begin_src matlab :exports none :results none
%% Effect of the cube's size on the plant dynamics
freqs = logspace(0, 4, 1000);
figure;
tiledlayout(1, 1, 'TileSpacing', 'Compact', 'Padding', 'None');
ax1 = nexttile();
hold on;
for i = 1:length(strut_length)
plot(freqs, abs(squeeze(freqresp(G_strut_length{i}(1, 1), freqs, 'Hz'))), 'color', colors(i,:), ...
'DisplayName', sprintf('$D_1/F_1$, $L = %.0f$ mm', 1e3*strut_length(i)));
end
plot(freqs, abs(squeeze(freqresp(G_strut_length{1}(1, 2), freqs, 'Hz'))), 'color', [colors(1,:), 0.2], ...
'DisplayName', 'coupling');
for i = 2:length(strut_length)
plot(freqs, abs(squeeze(freqresp(G_strut_length{i}(1, 2), freqs, 'Hz'))), 'color', [colors(i,:), 0.2], ...
'HandleVisibility', 'off');
plot(freqs, abs(squeeze(freqresp(G_strut_length{i}(1, 3), freqs, 'Hz'))), 'color', [colors(i,:), 0.2], ...
'HandleVisibility', 'off');
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
xlabel('Frequency [Hz]'); ylabel('Amplitude [m/N]');
leg = legend('location', 'southwest', 'FontSize', 8, 'NumColumns', 1);
leg.ItemTokenSize(1) = 15;
% xlim([1, 1e4]);
ylim([1e-12, 1e-4])
#+end_src
#+begin_src matlab :tangle no :exports results :results file replace
exportFig('figs/delta_robot_strut_length_plant_dynamics.pdf', 'width', 'wide', 'height', 'normal');
#+end_src
#+name: fig:delta_robot_strut_length_plant_dynamics
#+caption: Effect of the cube's size on the plant dynamics
#+RESULTS:
[[file:figs/delta_robot_strut_length_plant_dynamics.png]]
*** Effect on the compliance
As shown in Figure [[fig:delta_robot_strut_length_compliance_rotation]], the strut length has an effect on the system stiffness in translation (left plot) but almost not in rotation (right plot).
Indeed, the stiffness in rotation is a combination of:
- The stiffness of the actuator
- The shear and axial stiffness of the flexible joints
- The bending and torsional stiffness of the flexible joints, combine with the strut length
#+begin_src matlab
%% Effect of torsional stiffness on the plant dynamics
joint_axial = 100e6; % [N/m]
@@ -1445,6 +1472,95 @@ exportFig('figs/delta_robot_strut_length_compliance_rotation.pdf', 'width', 'ful
#+RESULTS:
[[file:figs/delta_robot_strut_length_compliance_rotation.png]]
*** Effect on the plant dynamics
As shown in Figure [[fig:delta_robot_strut_length_plant_dynamics]], having longer struts:
- decreases the main resonance frequency: this means that the stiffness in the X,Y and Z directions is decreased when the length of the strut is longer.
This is reasonable as the "lever" arm is getting larger, so the bending stiffness and compression of the flexible joints have a larger effect on the top platform compliance.
- decreases the low frequency coupling: this effect is more difficult to physically understand
Probably: when pushing with one actuator, it induces some rotation of the struts corresponding to the other two actuators.
This rotation is proportional to the strut length.
Then, this rotation, combined with the limited compliance in bending of the flexible joints induces some force applied on the other actuators, hence the coupling.
This is similar to what was observed when varying the bending stiffness of the flexible joints: the coupling was increased with an increased of the bending stiffness (See Figure [[fig:delta_robot_bending_stiffness_couplign]])
*So we should also observed a decrease of the coupling when decreasing the bending stiffness of the actuators*
But even with relatively short struts (20mm and above), the low frequency decoupling is already around two orders of magnitude, which is enough from a control point of view.
So, the struts length can be optimized to not decrease too much the stiffness of the platform while still getting good low frequency decoupling.
#+begin_src matlab
%% Effect of torsional stiffness on the plant dynamics
joint_axial = 100e6; % [N/m]
joint_bending = 50; % [Nm/rad]
joint_torsion = 500; % [Nm/rad]
% Geometry
d = 50e-3; % Cube's edge length [m]
b = 20e-3; % Distance between cube's vertices and top joints [m]
clear io; io_i = 1;
io(io_i) = linio([mdl, '/F'], 1, 'openinput'); io_i = io_i + 1; % Actuator Force Inputs [N]
io(io_i) = linio([mdl, '/delta_robot'], 1, 'openoutput'); io_i = io_i + 1; % Actuator Displacement [m]
% Cube's size
strut_length = [10e-3, 20e-3, 50e-3, 100e-3];
G_strut_length = {zeros(size(strut_length))};
for i = 1:length(strut_length)
delta_robot = initializeStewartPlatform();
delta_robot = generateDeltaRobot(delta_robot, 'd', d, 'b', b, 'L', strut_length(i));
delta_robot = computeJointsPose(delta_robot);
delta_robot = initializeActuatorDynamics(delta_robot, 'type', '1dof', 'k', k);
delta_robot = initializeJointDynamics(delta_robot, 'type_F', '3dof_a', 'type_M', '2dof_a', 'Ka', joint_axial, 'Kf', joint_bending, 'Kt', joint_torsion);
delta_robot = initializeCylindricalStruts(delta_robot);
delta_robot = computeJacobian(delta_robot);
delta_robot = initializeStewartPose(delta_robot);
%% Run the linearization
G = linearize(mdl, io);
G.InputName = {'F1', 'F2', 'F3'};
G.OutputName = {'D1', 'D2', 'D3'};
G_strut_length(i) = {G};
end
#+end_src
#+begin_src matlab :exports none :results none
%% Effect of the cube's size on the plant dynamics
freqs = logspace(0, 4, 1000);
figure;
tiledlayout(1, 1, 'TileSpacing', 'Compact', 'Padding', 'None');
ax1 = nexttile();
hold on;
for i = 1:length(strut_length)
plot(freqs, abs(squeeze(freqresp(G_strut_length{i}(1, 1), freqs, 'Hz'))), 'color', colors(i,:), ...
'DisplayName', sprintf('$D_1/F_1$, $L = %.0f$ mm', 1e3*strut_length(i)));
end
plot(freqs, abs(squeeze(freqresp(G_strut_length{1}(1, 2), freqs, 'Hz'))), 'color', [colors(1,:), 0.2], ...
'DisplayName', 'coupling');
for i = 2:length(strut_length)
plot(freqs, abs(squeeze(freqresp(G_strut_length{i}(1, 2), freqs, 'Hz'))), 'color', [colors(i,:), 0.2], ...
'HandleVisibility', 'off');
plot(freqs, abs(squeeze(freqresp(G_strut_length{i}(1, 3), freqs, 'Hz'))), 'color', [colors(i,:), 0.2], ...
'HandleVisibility', 'off');
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
xlabel('Frequency [Hz]'); ylabel('Amplitude [m/N]');
leg = legend('location', 'southwest', 'FontSize', 8, 'NumColumns', 1);
leg.ItemTokenSize(1) = 15;
% xlim([1, 1e4]);
ylim([1e-12, 1e-4])
#+end_src
#+begin_src matlab :tangle no :exports results :results file replace
exportFig('figs/delta_robot_strut_length_plant_dynamics.pdf', 'width', 'wide', 'height', 'normal');
#+end_src
#+name: fig:delta_robot_strut_length_plant_dynamics
#+caption: Effect of the Strut length on the plant dynamics
#+RESULTS:
[[file:figs/delta_robot_strut_length_plant_dynamics.png]]
** Having the Center of Mass at the cube's center
To make things easier, we take a top platform with no mass, mass-less struts, and we put a payload on top of the platform.