Simulation of Whitworth Quick Return Mechanism using MATLAB

                                                                                                     Whitworth Quick Return Mechanism

Aim: Creating a MATLAB program for Simulation of Whitworth Quick Return Mechanism.

Objective:

• Understanding the Mechanics of Whitworth Quick Return Mechanism.
• Creating a MATLAB program for the Mechanism.
• Creating a video file to demonstrate the working of the Mechanism.

Theory:

This mechanism changes the rotary motion to oscillatory motion like the crank and lever mechanism.
The difference between the crank and lever mechanism and the Whitworth mechanism is that in the Whitworth mechanism the return stroke is faster than the forward stroke while in the crank and lever mechanism the forward stroke is of the same speed as that of the return stroke.

Fig: Working of Whitworth Quick Return Mechanism

Parts used in Whitworth mechanism:-

1) Slotted Bar.
2) Slider
3) Crank – It will rotate.

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 slotted bar is connected to the crank. When the crank rotates, the slider will slide inside the slotter bar and the slotted bar will oscillate. As the slotted bar oscillate, 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 link 1, the CD is link 2, AC which is a crank is link 3 and link 4 is the slider.
In this mechanism, the link CD i.e link 2 forming the turning pair is fixed as shown in the figure above.
The crank AC revolves with uniform velocity 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 pint A. A short link PR transmits the motion from AP to the 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 forwarding stroke.
As the crank moves with uniform angular velocity, the time taken to cover angle α will be less than the time taken to cover angle β. Hence time taken in return for stroke will be less than the time is taken in the forward stroke. In this way, the quick return mechanism works.

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

Fig: Arm lengths and angles of crank & arms

In `Delta` ABC

`cos(frac{pi}{2}+theta_1) = frac{l_1^2+l_2^2-l_3^2}{2*l_1*l_2}`

`l_3^2 = l_1^2 + l_2^2 - cos(frac{pi}{2}+theta_1)*2*l_1*l_2`

`l_3^2 = l_1^2 + l_2^2 - sintheta_1*2*l_1*l_2`

`l_3^2 = l_1^2 + l_2^2 - 2*sintheta_1*l_1*l_2` .................................................................(1)

X Co-ordinate of P

`l_3*costheta_2 = l_2*costheta_1`

`theta_2 = cos^-1(frac{l_2*costheta_1}{l_3})`..............................................................................(2)

`l_5^2*sin^2theta_1 = l_1^2 + l_2^2*sin^2theta_1 - 2*sintheta_1*l_1*l_2`

Y Co-ordinate of P

`l_4*sintheta_2 = a + l_5*costheta_3`

`theta_3 = sin^-1(frac{l_4*sintheta_2 - a}{l_5})`.......................................................................(3)

`l_6 + l_5costheta_3 = l_4costheta_2`

`l_6 = l_4costheta_2 - l_5costheta_3`.....................................................................................(4)

 For the MATLAB program we will take `l_1` as 20 mm, `l_2` as 10 mm, `l_4` as 20 mm, `l_5` as 56 mm and `a` as 40 mm

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

Fig: Angle of forward stroke and return stroke

That is, in a crank slotted lever mechanism the distance between the fixed centers is 20 mm. The length of the crank is 10 mm. The length of the slotted bar is 56 mm.

Hence, `l` = 20 mm, `r` = 10 mm.

From the figure,

`cosfrac{alpha}{2} = frac{r}{l} = frac{10}{20} = 0.5`

`therefore frac{alpha}{2} = 60^o`

`therefore alpha = 120^o`

Total angle of single rotation is `360^o`

`therefore beta = 360 - 120 = 240^o`

The ratio of the velocity of Return-Stroke to Forward-Stroke is:
`Q_(rr) = frac{240}{120} = 2`

`therefore Q_(rr) = 2`

Methodology:

The idea here is to take the number of strokes from the user.

The number of strokes is taken from the user using the input command.

That is, in a crank slotted lever mechanism the distance between the fixed centers is 20 mm. The length of the crank is 10 mm. The length of the slotted bar is 56 mm. The length of the ram is taken as 20 mm. The distance tool from the base is 40 mm. They are declared in variable len1, len2, len4, len5, and len respectively.

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

The number of strokes is taken by the user. And the angle of the full stroke is 180 degrees or pi. This angle is the value of `theta1`

Using the above equation of Whitworth Quick Return Mechanism, we will find len3, len6, `tehta2`, and `theta3`.

Using the plot command first we will plot the path of tool movement and then using viscircle command we will plot the trajectory of crank movement.

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

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

Lastly, we will give the title to this figure.

These figures will be stored in an array form in variable A. 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.

To the display, we will give the pause of 0.1 sec.

Using the movie command we will make a video from the figures stored in array A.

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.

Using the open command we will open this variable that is data.

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

In the end, using the close command we will close the videofile.

The MATLAB program for WHITWORTH QUICK RETURN MECHANISM is as follow:

%A program to Simulate Whiworth Quick Return Mechanism
clear all
close all
clc

%User Input
fprintf('%50snn','Whitworth Quick Return Mechanism');
r = input('Enter the number of Revolutionn');
len = 40;
len1 = 20;
len2 = 10;
len4 = 56;
len5 = 20;

%Default Values
ct =1;
   
%Mechanism
for theta1 = 0:0.1:r*2*pi
    len3 = sqrt(((len1)^2 + (len2)^2 + 2*(len1)*(len2)*sin(theta1)));
    theta2 = acos((len2)*cos(theta1) / (len3));
    theta3 = asin(-1*(len4*sin(theta2) - len) / (len5));
    len6 = (len4)*cos(theta2) - (len5)*cos(theta3);
   
    %Plotting
    figure(1)
    plot([0,0],[0,len],'--.k','LineWidth',0.5);
    hold on
    plot([-60,60],[40,40],'--.k','LineWidth',0.5);
    viscircles([0,len1],len2,'LineStyle','--','LineWidth',0.5,'Color','k');
    plot([0,len2*cos(theta1)],[len1,len1+len2*sin(theta1)],'o-','LineWidth',2);
    plot([0,len4*cos(theta2)],[0,len4*sin(theta2)],'o-','LineWidth',2);
    plot([len4*cos(theta2),len6],[len4*sin(theta2),len],'o-','LineWidth',2);
   
    %Tool
    plot([len6+5,len6+5],[len-2,len+2],'k','LineWidth',1);
    plot([len6-5,len6-5],[len-2,len+2],'k','LineWidth',1);
    plot([len6+5,len6-5],[len+2,len+2],'k','LineWidth',1);
    plot([len6-5,len6+5],[len-2,len-2],'k','LineWidth',1);
    plot([len6-5,len6-6],[len-2,len-4],'k','LineWidth',1);
    plot([len6-6,len6-1],[len-4,len-2],'k','LineWidth',1);
   
    %Material
    plot([-40,-50],[33.5,33.5],'k','LineWidth',13);
    plot([-40,-50],[33.5,33.5],'k','LineWidth',13);
    plot([-40,-40],[33.5,33.5],'k','LineWidth',13);
    plot([-50,-50],[33.5,33.5],'k','LineWidth',13);
   
    title('Whitworth Quick Return Mechanism');
    hold off
    axis(gca,'equal');
    axis([-60,60,-10,80]);
    A(ct) = getframe(gcf);
    ct=ct+1;
pause(0.1)
end
             
%Making Video
movie(A);
videofile = VideoWriter('Whitworth Quick Return Mechanism.avi','Uncompressed AVI');
open(videofile);
writeVideo(videofile, A);
close(videofile);

Result:

The following is the Simulation video of the Whitworth Quick Return Mechanism:

Conclusion:

Created a MATLAB program for Simulation of Whitworth Quick Return Mechanism.