Force Analysis Of A Basketball Goal Height Adjustment

This force analysis was done by Brandon Caradine

Introduction

After putting together a portable basketball goal, I was curious about the forces it takes to adjust to different heights. The goal has a mechanism to adjust the height that consists of two links on each side of the pole, a spring for each side, and the backboard. The pole acts as ground, and the backboard is the body. One of the poles is longer than the other and is the bottom link of the mechanism. The bottom link has a another pole than is used to exert an upward input force to move the mechanism and adjust the height. With this mechanism, the input force can be found using kinematics and force analysis techniques.

Sketch

flickr:5264700480

Analysis and Discussion

After using the mechanism, I realized that the spring used in the mechanism makes the goal more difficult to lower to the lower heights. When height is adjusted, the backboard remains at a constant angle throughout the motion of the mechanism, and this makes the bars of the mechanism move at the same angle. After deriving the vector loop, velocity, and acceleration equations and casting them into matrix form shown in hand calculations below, I used the MATLAB code below to solve for the velocity and acceleration of each component of the mechanism. With the velocity and acceleration, I solved for the input force using virtual work which is derived in the hand calculations. With the input force equation derived, I solved for the input force when the angles of the bars are varied from -60 to 60 degrees. From the results, I concluded that the spring forces are the contributing factors of what input force is needed. From the graph of input force vs. theta3a, the highest input force is at the -60 degree angle. This correlates with the real goal because the springs are displaced longer at the lowest height which is at the most negative angle from the horizontal for which the mechanism rotates, and when adjusting the height of the goal, it is much easier to adjust it to a higher height than a lower height.

Graphs and Results

flickr:5263899403

This graph shows the position of the mechanism at 60, 0, -60 degrees.

flickr:5264508704

This graph shows the input force versus the angle created by the input force.

The values used for spring constant, spring heights, angles, and link measurements were estimated. With correctly measured values, The MATLAB program could produce accurate values for the input force.

MATLAB Code

% This program carries out a kinematic position, velocity, and force
% analysis of a four-bar basketball height adjustment linkage
%Model*
% Position equations:
% L1: r1_vec + r2_vec + r3a_vec + r4_vec = 0;
% CE1: theta3b = theta3a + alpha3
%
% Velocity Equations:
% d(L1)/dt:
% r2*theta2_dot*iexp(i*theta2)+r3*theta3_dot*iexp(i*theta3)+
% r4*theta4_dot*iexp(i*theta4)=0
% d(CE1)/dt: theta3b_dot = theta3a_dot
%
% Acceleration Equations:
% d2(L1)/dt2:
% r2*theta2_ddot*iexp(i*theta2)-r2*theta2_dot^2*exp(i*theta2)
%+r3*theta3_ddot*iexp(i*theta3)-r3*theta3_dot^2*exp(i*theta3)
%+r4*theta4_ddot*iexp(i*theta4)-r4*theta4_dot^2*exp(i*theta4)=0
% d2(CE1)/dt2: theta3b_ddot = theta3a_ddot
%
*
clc
clear all;
close all
dtr = pi/180; %degrees to radians
%Enter constants***
r1 = 1;
r2 = 2;
r3a = 2;
r4 = 1;
r3b=1;
theta1=-90*dtr;
alpha3=0*dtr;
theta3a_dot=0.5;
theta3a_ddot=0;
branch=1;
x_intial = 0.5833;
x = 0.66667:0.024305:1.25;
delta_x = x - x_intial;

%** Drive theta3a from -60->60 in 5 deg. increments*
idx=1;
n=0;
for theta3a=-60*dtr:5*dtr:60*dtr
flag = 0;

%** Solve Position*
theta3b = theta3a;
theta2 = theta3a;
theta4 = -90*dtr;
P = r3a*exp(i*theta3a) + r3b*exp(i*theta3b);
%** Solve Velocity *
if flag==0
s2 = sin(theta2); c2 = cos(theta2);
s3a = sin(theta3a); c3a = cos(theta3a);
s4 = sin(theta4); c4 = cos(theta4);
A=[-r2*s2,0, -r4*s4
r2*c2,0, r4*c4
0 , 1 , 0];
b = [r3a*theta3a_dot*s3a
-r3a*theta3a_dot*c3a
theta3a_dot];
v=inv(A)*b;
theta2_dot = v(1); theta3b_dot = v(2); theta4_dot = v(3);
Vp_vec = r3a*theta3a_dot*exp(i*(theta3a+pi/2)) + r3b*theta3b_dot*exp(i*(theta3b+pi/2));
Vpx = real(Vp_vec); Vpy = imag(Vp_vec);
Vpx = -r3a*theta3a_dot*s3a- r3b*theta3b_dot*sin(theta3b);
Vpy = r3a*theta3a_dot*c3a+ r3b*theta3b_dot*cos(theta3b);
V4_vec = r4*theta4_dot*exp(i*(theta4+pi/2));
V4x = -r4*theta4_dot*s4;
V4y = r4*theta4_dot*c4;
V2_vec = r2*theta2_dot*exp(i*(theta2+pi/2));
V2x = -r2*theta2_dot*s4;
V2y = r2*theta2_dot*c4;

%** Solve Acceleration *
A=[-r2*s2,0, -r4*s4
r2*c2,0, r4*c4
0 1 0];
b = [r3a*theta3a_ddot*s3a+r2*theta2_dot^2*c2+r3a*theta3a_dot^2*c3a+r4*theta4_dot^2*c4
-r3a*theta3a_ddot*c3a+r2*theta2_dot^2*s2+r3a*theta3a_dot^2*s3a+r4*theta4_dot^2*c4
theta3a_ddot];
a=inv(A)*b;
theta2_ddot = a(1); theta3b_ddot = a(2); theta4_ddot = a(3);
Ap_vec = r3a*theta3a_ddot*exp(i*(theta3a+pi/2)) -r3a*theta3a_dot^2*exp(i*theta3a) …
+ r3b*theta3b_ddot*exp(i*(theta3b+pi/2))-r3b*theta3b_dot^2*exp(i*theta3b);
Apx = real(Ap_vec); Apy = imag(Ap_vec);
A4_vec = r4*theta4_ddot*exp(i*(theta4+pi/2)) -r4*theta4_dot^2*exp(i*theta4);
A4x = real(A4_vec); A4y = imag(A4_vec);
A2_vec = r2*theta2_ddot*exp(i*(theta2+pi/2)) -r2*theta2_dot^2*exp(i*theta2);
A2x = real(A2_vec); A2y = imag(A2_vec);
%Force Analysis***

g = 32.174; m4 = 50/g;
I4 = ((2/12)*(3^3))/12;
k = 4;
Fs = k *delta_x(25-n);
Fsx = Fs*cos(30*dtr);
Fsy = Fs*sin(30*dtr);
Fin =( -Fsx*V2x + Fsy*V2y + Fsx*V4x - Fsy*V4y + (m4*(A4x*V4x + A4y*V4y)) + I4*theta4_dot*theta4_ddot)/Vpy;
n=n+1;
figure(1)

hold on

p1 = r1*exp(i*theta1);
p2 = p1 + r2*exp(i*theta2);
p3 = p2 + r4*exp(i*theta4);
p4 = p3 - r3a*exp(i*theta3a);
p5 = p4 - r3b*exp(i*theta3b);

plot_pts = [p1,p2,p3,p4,p5];
plot(plot_pts)
axis([-1.5,2.5,-4,1])
title('Mechanism Animation')
xlabel('x axis')
ylabel('y axis')

pause;

%** Store variables *
theta3a_store(idx)=theta3a/dtr;
P_store(idx) = P;
theta2_dot_store(idx)=theta2_dot;
theta4_dot_store(idx)=theta4_dot;
Vp_mag_store(idx)=sqrt(Vpx^2+Vpy^2);
Vp_ang_store(idx)=atan2(Vpy,Vpx);
Vp_store(idx) = Vp_vec;
V4_store(idx) = V4_vec;;
theta2_ddot_store(idx)=theta2_ddot;
theta4_ddot_store(idx)=theta4_ddot;
Ap_mag_store(idx)=sqrt(Apx^2+Apy^2);
Ap_ang_store(idx)=atan2(Apy,Apx);
Ap_store(idx) = Ap_vec;
A4_store(idx) = A4_vec;
Fs_store(idx) = Fs;
Fin_store(idx) = Fin;
idx=idx+1;

%** If no solution exists, set parameters to nan *
else
theta2_store(idx)=nan;
P_store(idx) = nan;
theta3_dot_store(idx)=nan;
theta4_dot_store(idx)=nan;
Vp_mag_store(idx)=nan;
Vp_ang_store(idx)=nan;
theta3a_ddot_store(idx)=nan;
theta4_ddot_store(idx)=nan;
Ap_mag_store(idx)=nan;
Ap_ang_store(idx)=nan;
Ap_store(idx) = nan;
idx=idx+1;
end
end
hold off
figure(2)
hold on
plot(real(P_store), imag(P_store))
quiver(real(P_store), imag(P_store), real(Vp_store), imag(Vp_store),'r-');
quiver(real(P_store), imag(P_store), real(Ap_store), imag(Ap_store),'g:');
hold off
title('Coupler curve with velocity (red), acceleration (green) super-imposed')
xlabel('x axis')
ylabel('y axis')
figure(3)
plot(theta3a_store, Fin_store)
title('Input Force Vs. theta3a')
xlabel('theta 3a');
ylabel('input force')

Hand Calculations

flickr:5264638526flickr:5264642870