Whitworth Quick Return Mechanism

AIM: Create a MATLAB program for the Simulation of Whitworth Quick Return Mechanism.

OBJECTIVE:

• Plot a graph between crank angle and velocity of ram.
• Plot a graph between crank angle and acceleration of ram.

THEORY: 

The Whitworth quick return mechanism converts rotary motion into reciprocating motion, but unlike the crank and slider, the forward reciprocating motion is at a different rate than the backward stroke. At the bottom of the drive arm, the peg only has to move through a few degrees to sweep the arm from left to right, but it takes the remainder of the revolution to bring the arm back. This mechanism is most commonly seen as the drive for a shaping machine.

The difference between the crank and lever mechanism and Whitworth mechanism is that in Whitworth mechanism the return stroke is faster than forward stroke while in the crank and lever mechanism the forward stroke is of the same speed as that of the return stroke.

Parts Used in Whitworth Quick Return Mechanism:

1) Slotter Bar

2) Connecting Rod

3) Crank - Driver

4) Slider Ram

                                   Fig: PARTS USED IN WHITWORTH QUICK RETURN MECHANISM   

Whitworth's Quick Return Mechanism is the second inversion of the slider - crank mechanism in which the crank is fixed. In this mechanism, the slider in the slotter bar is connected to the crank. When the crank rotates, the slider will slide inside the slotter bar and the slotted bar will oscilate. As the slotted bar oscillates, the ram will move in a forwarding and backward direction. The return stroke or ideal is faster than the forward stroke in this mechanism.

In the above figure, AP is the slotted bar and it will be 'length4' in our code, CB is the crank which drives the entire system and it will be 'length2' in our code, PR is the connecting rod and it will be 'length5' in our code, AC is the fixed link. The crank CB revolves with unifrom angular velocity 5 rad/s with its center at A.

A sliding block attached to the crank pin at B slides along the slotted bar AP  and thus causes AP to oscillate about the pivoted point A. A short link PR transmits the motion from AP to the slider ram which carries the tool and thus forward stroke and backward stroke is obtained. The crank needs to rotate through an angle of (β) for the forward stroke and it needs to rotate through an angle of (α) for backward stroke. 

As the crank moves with unifrom angular velocity, the time taken to cover angle α will be less than the time taken to cover angle β. Hence time taken in return stroke will be less than the time for the forward stroke. In this way, the Quick Return Mechanism works.

The following figure represents the length of arms as well as the angles of the cranks and all arms:

                                                               Fig: Arm Length and Angles of Crank and Arms

In △ ABC

The following figure will help to find the velocity and accelaration of the slider ram:

Equation for velocity of the slider arm:

where r1 = Crank Radius, r2 = Slider Arm, r3 = Connecting Rod and ϕ21 = crank angle .

Equation for acceleration of the slider arm:

The following figure represents the angle of forward stroke and angle of return stroke:

               Fig: Angle of Forward Stroke and Return Stroke   

In a Crank Slotted Lever mechanism the distance between the fixed centers is 20 cm. The length of the Crank (i.e) crank radius is 10 cm. The length of the slotted bar is 56 mm.

Hence, length1 = 20 cm, length2 = 10 cm.

From the figure,

cos(α/2) = (length2/length1) = 10/20 = 0.5

∴  α/2 = 60 degree

∴  α = 120 degree

Total angle of single rotation is 360 degree

 ∴ β = 360 - 120 = 240 degree

 The ratio of time taken for forward stroke to that of backward stroke is called the Quick Return Ratio.

 ∴ Quick Return Ratio = 240/120 = 2

METHODOLOGY:

1) Intially all the basic commands are given in intial three lines.

2) Ask the user to input number of revolutions or number of strokes needed.

3) The number of revolutions or number of strokes is taken from the user using 'input' command.

4) Intializing all the length of different arms (i.e.) distance of tool from the base is 40 cm, distance between fixed centers is 20 cm, length of crank radius is 10 cm, length of slider arm is 56 cm, length of connecting rod is 20. They are declared in variable as 'length','length1','length2','length4','length5' respectivley.  

5) Intializing the variables needed for calculating velocity and accelaration of the slider arm.

6) The value of a counter variable (ct) is set at 1. This will be useful for capturing the figure to make the video.

7) Dividing the velocity equation into three terms where each term may have subterm, and multiplying the three terms to get velocity. We take only the absolute value of velocity.

8) The above procedure is done for the acceleration also but we donot take absolute value.

9) Using 'plot' command ploting the graph between crank angle and velocity.

10) Using 'plot' command ploting the graph between crank angle and accelaration.

11) The angle of the full stroke is 180 degrees or π. This angle is the value of θ1.

12) Using the above equation of Whitworth Quick Return Mechanism, will find 'length3','length6','theta2','theta3'.

13) Using the 'plot' command first we will plot the path of tool movement.

14) Then, we will plot the path of all arms. This is done under 'for' loop as the position of all the arms changes with the change in the movement of the crank.

15) We will also make a tool and material using simple plotting method.

16) Using 'title' command giving the title for the figure.

17) These figures will be stored in an array form in variable 'C'. The position of the array is determined by the counter number or ct value. To extract this frame into an array we will use 'getframe' command.

18) To the display, we will give the pause of 0.0005 sec.

19)  Using the 'movie' command we will make a video out of it and store in array 'C'.

20) From the 'VideoWriter' command we will give the name of the video as Whitworth Quick Return Mechanism in avi. format and uncompressed form. We will store this information in a variable 'videofile'.

21) Using the 'open' command we will open this file.

22) Then using 'writeVideo' command we will pass the data of videofile in the movie created from an array A.

23) In the end, using the 'close' command we will close the videofile.

THE MATLAB CODE FOR WHITWORTH QUICK RETURN MECHANISM:

%MATLAB PROGRAM FOR SIMULATION WHITWORTH QUICK RETURN MECHANISM

clear all
close all
clc

%User Inputs
fprintf('WELCOME TO WHITWORTH QUICK RETURN MECHANISM');
fprintf('nn');
r = input('ENTER THE NUMBER OF REVOLUTION: ');

%Defining lengths various links.
length = 40;
length1 = 20;                 %Distnace between fixed centers
length2 = 10;                 %Crank radius
length4 = 56;                 %Slider arm
length5 = 20;                 %Connecting rod

%Defining various inputs for velocity and accelaration
omega_crank = 5;             %Angular velocity of crank
phi_crank =linspace(0,360,360);
h = 20;
b = 20;
c = 0;
H = atand((c + length2.*sind(phi_crank))./(h + length2.*cosd(phi_crank)));
K = (c + length2*sind(phi_crank))./(h + length2*cosd(phi_crank));
L = b - length4.*cosd(atand(K)) + h;
M = (length2 + h*cosd(phi_crank) + c*sind(phi_crank))./(h + length2*cosd(phi_crank)).^2;

%Counter
ct = 1;

%Dividing the velocity equation to different terms.
term1 = omega_crank*length2*length4;

term21 = (length2 + h*cosd(phi_crank) + c*sind(phi_crank))/(h + length2*cosd(phi_crank)).^2;
term22 = 1 + (c + length2*sind(phi_crank)/(h + length2*cosd(phi_crank))).^2;
term2 = term21./term22;

term31 = b - (length4*cosd(atand(K))) + h;
term32 = sqrt(length^2 - (b - length4*cosd(atand(K)) + h).^2);
term3 = cosd(H) + sind(H)*(term31/term32);

velocity = term1*term2*term3;
velocity_ram = abs(velocity);

%Dividing the accelaration equation to different terms.  
term_acc1 = (length2*length4*omega_crank^2)./(1+K.^2);

term_acc211 = (c*cosd(phi_crank) - h*sind(phi_crank)).*(h + length2*cosd(phi_crank));
term_acc212 = 2*length2*sind(phi_crank).*(length2 + h*cosd(phi_crank) + c*sind(phi_crank));
term_acc213 = (h + length2*cosd(phi_crank)).^3;
term_acc22 = (2*K.*M.^2.*length2)./(1 + K.^2);
term_acc2 = (((term_acc211) + (term_acc212))./term_acc213) - term_acc22;

term_acc31 = (cosd(atand(K))) + sind(atand(K))*(L/sqrt(length5.^2 - L.^2));
term_acc32 = (length2*(M.^2))./(1 + K.^2);
term_acc3 = term_acc31 + term_acc32;

term_acc41 = -sind(atand(K));
term_acc42 = cosd(atand(K)).*(L/sqrt(length5.^2 - L.^2));
term_acc43 = length4.*(length5.^2)*(sind(atand(K))).^2.*(1./(sqrt(length5.^2 - L.^2).^3));
term_acc4 = term_acc41 + term_acc42 + term_acc43;

accelaration = term_acc1.*term_acc2.*term_acc3.*term_acc4;

%Plotting Crank angle v/s Velocity.
figure(1)
plot(phi_crank,velocity_ram,'color','r')
xlabel('CRANK ANGLE [phi]')
ylabel('VELOCITY OF RAM [m/s]')
title('CRANK ANGLE  v/s  VELOCITY OF RAM')
grid on

%Plotting Crank angle v/s accelaration.
figure(2)
plot(phi_crank,accelaration,'color','b')
xlabel('CRANK ANGLE [phi]')
ylabel('ACCELARATION OF RAM [m/s^2]')
title('CRANK ANGLE  v/s  ACCELARATION OF RAM')
grid on

%synthesizing of Mechanism
 for theta1 = 0:.1:r*2*pi
    
    %Finding Slotter length, Angle between Slider arm and horizontal, Angle between Connecting rod and horizontal, Length traced by the RAM Block 
    length3 = sqrt(((length1)^2 + (length2)^2 + 2*(length1)*(length2)*sin(theta1)));
    theta2 = acos((length2*cos(theta1)/length3));
    theta3 = asin(-1*(length4*sin(theta2) - length)/length5);
    length6 = (length4)*cos(theta2) - (length5)*cos(theta3);
    
    %Circle traced by the crank 
    R = 10;
    theta = 0:10:360;
    xcen = 0;
    ycen = 20;
    xcordinate = xcen + R*cosd(theta);
    ycordinate = ycen + R*sind(theta);
    
    figure(3)
    plot([0,0],[0,length],'--.k','LineWidth',0.5);
    hold on
    plot([-60,60],[40,40],'--.k','LineWidth',0.5);
    
    %Plotting the Links
    a = plot([0,length2*cos(theta1)],[length1,length1+length2*sin(theta1)],'o-','LineWidth',2,'color','r');
    plot(xcordinate,ycordinate,'LineStyle','--','LineWidth',0.5,'color','k')
    b = plot([0,length4*cos(theta2)],[0,length4*sin(theta2)],'o-','LineWidth',2,'color','y');
    c = plot([length4*cos(theta2),length6],[length4*sin(theta2),length],'o-','LineWidth',2);
    plot([0 0],[0 20],'LineWidth',2,'color','g');
    
    %Plotting the tool
    plot([length6+5,length6+5],[length-2,length+2],'k','LineWidth',1);
    plot([length6-5,length6-5],[length-2,length+2],'k','LineWidth',1);
    plot([length6+5,length6-5],[length+2,length+2],'k','LineWidth',1);
    plot([length6-5,length6+5],[length-2,length-2],'k','LineWidth',1);
    plot([length6-5,length6-6],[length-2,length-4],'k','LineWidth',1);
    plot([length6-6,length6-1],[length-4,length-2],'k','LineWidth',1);
    grid on
    
    %Plotting the Work Piece
    plot([-40,-50],[33.5,33.5],'k','LineWidth',13)
    
    title('Whitworth Quick Return Mechanism');
    xlabel('X-AXIS')
    ylabel('Y-AXIS')
    legend([a b c],{'CRANK','SLOTTED BAR','CONNECTING ROD'})
    hold off
    axis(gca,'equal');
    axis([-60 60 -10 80])
    C(ct) = getframe(gcf);
    ct = ct+1;
    pause(0.0005)
 end
 movie(C);
 videofile = VideoWriter('Whitworth Quick Return Mechanism.avi','Uncompressed AVI');
 open(videofile);
 writeVideo(videofile,C);
 close(videofile);

PLOTS:

1) CRANK ANGLE v/s VELOCITY OF RAM:

2) CRANK ANGLE v/s ACCELERATION OF RAM:

RESULT:

Successfully code in the MATLAB for the Simulation of Whitworth Quick Return Mechanism and plotted the graph between:

1) CRANK ANGLE v/s VELOCITY

2) CRANK ANGLE v/s ACCELERATION

ANIMATION OF WHITWORTH QUICK RETURN MECHANISM:

REFERENCE:

http://www.ijmerr.com/uploadfile/2020/0616/20200616051347881.pdf

https://journals.sagepub.com/doi/pdf/10.7227/IJMEE.32.2.2

https://library.wolfram.com/infocenter/TechNotes/5908/ 

https://www.mathworks.com/help/matlab/ref/gca.html?s_tid=srchtitle#d123e458511