Force Analysis Of A Rotating Foot Platform Leg Press

This analysis was done by: Jeff McGehee, Austin Parkison, and Jacob Phillips — TTU Mechanical Engineering, ME 4640

Introduction

In order to produce a mechanism that will be used in a real-world setting, the designer must take his analysis beyond that which only tells the story of the motion relationships as the mechanism travels through one cycle. A real mechanism must be analyzed to understand the forces that must exist in order to create that motion, because according to Newton's first law, every object in a state of uniform motion tends to remain in that state of motion unless an external force is applied to it. This means that a mechanism is useless without the forces imposing motion upon it.

Analysis

Force analysis on mechanisms can be done using three main techniques; super position, matrix, or virtual work. These techniques each have their own strengths and weaknesses, and after considering these, it was decided that the matrix technique would provide results that would be the most useful. This decision was based on the idea that the design of exercise equipment does not solely depend upon knowledge of input and output forces, but requires a true understanding of the forces in every part of the machine in order to ensure that a safe product can be produced.

In order to understand the forces acting upon a mechanism, the motion relationships must first be derived. For the design of a rotating foot platform leg press, it was desirable to understand the motion by using the displacement of the slider as the input to the system. This was done by making a vector model of the desired mechanism, choosing a position of the slider, then using MATLAB to solve for the corresponding angles. After the positions of each body were understood, it was possible to take the first and second derivatives of the vector loop equation in order to solve for the velocity and acceleration, respectively. A MATLAB plot of the vector model is below.

flickr:5261500669

Once the motion relationships were understood, it was possible to begin a force analysis to determine what sort of force was needed to generate such motion. As mentioned, the technique employed for the force analysis was the matrix method. To do this, a free body diagram of each body was analyzed, and equations of dynamic equilibrium were written for each. These equations were then solved using MATLAB and linear algebra techniques.
The MATLAB code and handwritten work used to find the solutions for the analysis can be found in Appendix A.

Conclusion

The force analysis on the leg press provided information that would be very useful in the design of such a mechanism. The forces for user input varied over the travel of the slider, which was to be expected. It was found that in the fully down position, the force required to move the slider was large compared to what was required towards full extension. This is because the nature of the mechanism causes the angle of the foot platform to approach that of the sliding path as the platform is lowered, which drives the input force (which was assumed to always be perpendicular to the foot platform) to infinity. This characteristic is very important to consider in the design of this mechanism in order to ensure that the required input force is never too large for the user to overcome. A plot of the input force required to produce a slider acceleration of .5 ft/s^2 with a load of 250lbs can be seen below.

flickr:5262108992

As mentioned, the user input force is not the only force that should be considered in the design of this leg press. The reaction forces at each joint are necessary to determine the types of stresses each member might undergo. The stresses that seemed most critical to understand were those on the slider, which would greatly influence the design of the sliding track. A plot of the torque and force normal to the sliding path is below.

flickr:5261500693

A plot of the magnitude of the reaction forces at each of the remaining joints can be found below.

flickr:5262109020

Appendix A

MATLAB Code

%Define knowns
r1 = 1.5;
theta1 = 45*dtr;
r2 = 3;
r3a = 1.2;
r3b = 1;
r4 = .5;
theta4 = 45*dtr;
theta5 = 315*dtr;
m2 = .155404751; %slugs
m3 = .155404751*50; %5 pounds * __ (slugs)
m4 = .155404751; %slugs
I_2 = 3.75;
I_3 = 3;
g = -32.2;
branch = -1;
idx = 1;

%Inputs
r5_dot = 1;
r5_ddot = .5;
theta5_dot = 0;

for r5=2:-.1:.1
r5_store(idx) = r5;

%Position: -r1-r2-r3-r4+r5=0
[theta3a,theta2]=two_uk_angles(r1,r5,r3a,r2,r4,theta1,theta5,theta4,branch);
if flag == 1
break
end

theta3b = theta3a-40*dtr;

theta2_store(idx) = theta2/dtr;
theta3a_store(idx) = theta3a/dtr;
theta3b_store(idx) = theta3b/dtr;

%Velocity
A = [ r2*sin(theta2), r3a*sin(theta3a), 0 ;
-r2*cos(theta2), -r3a*cos(theta3a), 0 ;
0, 1, -1];

B = [-r5_dot*cos(theta5) ;
-r5_dot*sin(theta5) ;
0 ];

vel = inv(A)*B;
vel_store(idx,:) = vel;

%Assign values for velocities
theta2_dot = vel(1);
theta3a_dot = vel(2);
theta3b_dot = vel(3);

%Store theta dots
theta2_dot_store(idx) = vel(1);
theta3a_dot_store(idx) = vel(2);
theta3b_dot_store(idx) = vel(3);

%Acceleration
C = [ r2*sin(theta2), r3a*sin(theta3a), 0 ;
-r2*cos(theta2), -r3a*cos(theta3a), 0 ;
0, 1, -1];

D = [-r2*theta2_dot^2*cos(theta2) - r3a*theta3a_dot^2*cos(theta3a) - r5_ddot*cos(theta5) + 2*r5_dot*theta5_dot*sin(theta5) ;
-r2*theta2_dot^2*sin(theta2) - r3a*theta3a_dot^2*sin(theta3a) - r5_ddot*sin(theta5) - 2*r5_dot*theta5_dot*cos(theta5) ;
0 ];

acc = inv(C)*D;
acc_store(idx,:) = acc;

%Assign values for angular acceleration
theta2_ddot = acc(1);
theta3a_ddot = acc(2);
theta3b_ddot = acc(3);

theta2_ddot_store(idx) = acc(1);
theta3a_ddot_store(idx) = acc(2);
theta3b_ddot_store(idx) = acc(3);

% %Accelerations of center of mass
% a_2x = theta2_ddot*(r2)*cos(theta2);
% a_2y = theta2_ddot*(r2)*sin(theta2);
% a_3x = theta3a_ddot*(r3a)*cos(theta3b);
% a_3y = theta3a_ddot*(r3a)*sin(theta3b);
% a_4x = r5_ddot*cos(theta5);
% a_4y = r5_ddot*sin(theta5);
% alpha2 = theta2_ddot;
% alpha3 = theta3b_ddot;

a_2x_cg = -(r2/2)*theta2_ddot*sin(theta2) - r2*theta2_dot^2*cos(theta2);
a_2y_cg = (r2/2)*theta2_ddot*cos(theta2) - r2*theta2_dot^2*sin(theta2);
a_3x_cg = -r2*theta2_ddot*sin(theta2) - r2*theta2_dot^2*cos(theta2) - r3a*theta3a_ddot*sin(theta3a) - r3a*theta3a_dot^2*cos(theta3a) - (r3b/2)*theta3b_ddot*sin(theta3b) - (r3b/2)*theta3b_dot^2*cos(theta3b);
a_3y_cg = r2*theta2_ddot*cos(theta2) - r2*theta2_dot^2*sin(theta2) + r3a*theta3a_ddot*cos(theta3a) - r3a*theta3a_dot^2*sin(theta3a) + (r3b/2)*theta3b_ddot*cos(theta3b) - (r3b/2)*theta3b_dot^2*sin(theta3b);
a_4x_cg = a_3x_cg;
a_4y_cg = a_3y_cg;
alpha2 = theta2_ddot;
alpha3 = theta3a_ddot;

%Force analysis
r21 = (r2/2);
r23 = -(r2/2);
r32 = 1;
r34 = -(r3b/2);
r43 = r4/2;
r14 = -r4/2;

% F12x F12y F32x F32y F23x F23y F43x F43y F34x F34y F14 T Fin

E = [1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0;
0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0;
r21*sin(theta2), r21*cos(theta2), r23*sin(theta2), r23*cos(theta2), 0, 0, 0, 0, 0, 0, 0, 0, 0;
0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, -cos(theta3b-90);
0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, sin(theta3b-90);
0, 0, 0, 0, r32*sin(theta3b+20), r32*cos(theta3b+20), r34*sin(theta3b), r34*cos(theta3b), 0, 0, 0, 0, 0;
0, 0, 0, 0, 0, 0, 0, 0, 1, 0, cos(theta5-90), 0, 0;
0, 0, 0, 0, 0, 0, 0, 0, 0, 1, sin(theta5-90), 0, 0;
0, 0, 0, 0, 0, 0, 0, 0, r43*sin(theta4), r43*cos(theta4), 0, 1, 0;
0, 0, 1, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0;
0, 0, 0, 1, 0, -1, 0, 0, 0, 0, 0, 0, 0;
0, 0, 0, 0, 0, 0, 1, 0, -1, 0, 0, 0, 0;
0, 0, 0, 0, 0, 0, 0, 1, 0, -1, 0, 0, 0];

G = [m2*a_2x_cg;
m2*a_2y_cg + m2*g;
I_2*alpha2;
m3*a_3x_cg;
m3*a_3y_cg + m3*g;
I_3*alpha3;
m4*a_4x_cg;
m4*a_4y_cg + m4*g;
0;
0;
0;
0;
0];

%F = [F12x; F12y; F32x; F32y; F34x; F34y; F14x; F14y; Fin]

F = inv(E)*G;
F_store(idx,:) = F;
F_store_2(idx,:) = F*-1;
%Resultant Forces
F1 = sqrt((F(1))^2 + (F(2))^2);
F2 = sqrt((F(3))^2 + (F(4))^2);
F3 = sqrt((F(5))^2 + (F(6))^2);
F4 = sqrt((F(7))^2 + (F(8))^2);
F5 = sqrt((F(9))^2 + (F(10))^2);

Resultant = [F1,F2,F3,F4,F5,F(11)];
Resultant_store(idx,:) = Resultant;

Fin_x(idx) = F(13)*cos(theta3b - 90*dtr);
Fin_y(idx) = F(13)*sin(theta3b - 90*dtr);

p1 = 0;
p2 = p1 - r2*exp(j*theta2);
p3 = p2 - r3a*exp(j*theta3a);
pp = p3 + (r3b/2)*exp(j*theta3b);
p4 = p3 + r3b*exp(j*theta3b);
p5 = p3 - r4*exp(j*theta4);
p6 = p5 - r5*exp(j*theta5);

p_store(idx) = pp;

figure(1)
plot_pts = [p1,p2,p3,p4,p2,p3,p5,p6,p1];
plot(plot_pts)
hold on
plot(pp,'go')
axis([-.5,4,-1,3])
pause(.075)
hold off
idx = idx + 1;
pause
end

Displacement = [r5_store(1,20), r5_store(1,19), r5_store(1,18), r5_store(1,17), r5_store(1,16), r5_store(1,15), r5_store(1,14), r5_store(1,13), r5_store(1,12), r5_store(1,11), r5_store(1,10), r5_store(1,9), r5_store(1,8), r5_store(1,7), r5_store(1,6), r5_store(1,5), r5_store(1,4), r5_store(1,3), r5_store(1,2), r5_store(1,1)];
r5_new(:,1) = linspace(2,.1,20);

figure (2)
plot(Displacement, F_store(:,13))
xlabel('Slider Displacement (ft)')
ylabel('Input Force (lb)')
title('Exerted Force vs Slider Displacement (L_0 = 2 ft)')

figure (3)
subplot(2,2,1)
plot(Displacement, Resultant_store(:,1))
xlabel('Slider Displacement (ft)')
ylabel('Force (lb)')
title('Force on Joint 1')

subplot(2,2,2)
plot(Displacement, Resultant_store(:,2))
xlabel('Slider Displacement (ft)')
ylabel('Force (lb)')
title('Force on Joint 2')

subplot(2,2,3)
plot(Displacement, Resultant_store(:,3))
xlabel('Slider Displacement (ft)')
ylabel('Force (lb)')
title('Force on Joint 3')

subplot(2,2,4)
plot(Displacement, Resultant_store(:,4))
xlabel('Slider Displacement (ft)')
ylabel('Force (lb)')
title('Force on Joint 5')

figure(4)
%subplot(2,2,1); plot(Displacement,F_store(:,11));
subplot(2,1,2); plot(Displacement, F_store(:,12)); %torque on slider
xlabel('Slider Displacement (ft)')
ylabel('Torque (ft*lb)')
title('Torque on Slider Joint')
subplot(2,1,1); plot(Displacement, Resultant_store(:,5)) %force on slider
xlabel('Slider Displacement (ft)')
ylabel('Force (lb)')
title('Force on Slider Joint')

Hand Calculations