Quick Return Mechanism (ch Software) 2q422v

Computer-Aided Design and Analysis of the Whitworth Quick Return Mechanism

Matt Campbell Stephen S. Nestinger Computer-Aided Mechanism Design, Project Department of Mechanincal and Aeronautical Engineering University of California Davis, CA 95616

March 2004

Table of Contents Section

Page

1 Introduction

2

2 Kinematic Analysis of the Whitworth Quick Return Mechanism 2.1 Position Analysis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.2 Velocity Analysis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.3 Acceleration Analysis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

3 3 5 5

3 Dynamic Analysis of the Whitworth Quick Return Mechanism 3.1 Forces on Each Member . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

6 7

4 Description of the Software Package CQuickReturn 12 4.1 Getting Started with the Software Package CQuickReturn . . . . . . . . . . . . . . . . . . . 13 4.2 Solving Complex Equations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 5 Conclusion

16

6 Acknowledgments

16

7 Reference

16

8 Appendix A: CQuickReturn API

17

CQuickReturn — Documentation on the Whitworth Quick Return Mechanism CQuickReturn Class 17 CQuickReturn Class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17 ˜CQuickReturn . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19 animation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19 CQuickReturn . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 getAngAccel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 getAngPos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22 getAngVel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23 getForces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24 getPointAccel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25 getPointPos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26 getPointVel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 getRequiredTorque . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28 plotAngAccel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29 plotAngPos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31 plotAngVel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33 plotCGaccel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35 plotForce . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39 plotSliderAccel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41 plotSliderPos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43 plotSliderVel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44 plotTorque . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46 setAngVel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47 setForce . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48 i

setGravityCenter setInertia . . . . setLinks . . . . . setMass . . . . . setNumPoints . . sliderAccel . . . sliderPos . . . . . sliderRange . . . sliderVel . . . . . uscUnit . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

48 49 50 51 51 52 53 54 55 56

9 Appendix B: Source Code 57 9.1 Source Code of Classes and Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57 Index

90

ii

Abstract This report discusses the design and implementation of a software package for the computer-aided design and analysis of the Whitworth Quick Return Mechanism. The kinematic analysis of the Whitworth Quick Return Mechanism is discussed with details on how the position, velocity, and accerleration were calculated. The dynamic anaylsis of the Whitworth Quick Return Mechanism follows. A description of the software package is given as well as the package API. A Whitworth Quick Return Mechanism class was created that allows s to easily calculate the position, velocity, acceleration, and forces at each linkage point given an input torque. The class also allows s to find the required input torque given an input force. The class utilizes the available xlinkage software to display an animation of the Whitworth Quick Return Mechanism.

1

1 Introduction The implementation of a Whitworth Quick Return Mechanism can be useful for applications requiring slow initial force and a quick reset operation. The design of such a Whitworth Quick Return Mechanism can be tedious to do by hand. High-end commercial computer applications are available that can help in deg a Whitworth Quick Return Mechanism but these applications are usually large and come with other packages that are not essential to the specified task. These commercial applications are also expensive for the general . For students earning a degree in mechanical engineering, these black-box commercial software packages are suitable for explaining some basic principals and concepts with traditional graphic methods. In order to fully comprehend the subject matter, students must utilize numerical and analytical methods to solve complicated engineering problems. A general purpose Whitworth Quick Return Mechanism software package is required that allows the general public to be able to quickly design and implement a Whitworth Quick Return Mechanism. Such a package would require a simple front end and easy to understand API. s should be allowed to fully integrate the software package into their own code with the ability to either choose to specify an input torque or required output force. Students most benefit from an open software package as compared to a black-box software package. Students are able to go through and examine the available source code and modify it to solve similar problems. By learning from examples, students will better understand the principles and numerical aspects of the subject matter. Utilizing the C/C++ interpreter, Ch, a Whitworth Quick Return Mechanism software package has been created to facilitate in the design and analysis of a Whitworth Quick Return Mechanism [1]. The package contains the CQuickReturn class giving s the ability calculate the position, velocity, and acceleration of each linkage. The fundamental methods used to analyze a Whitworth Quick Return Mechanism can be found in [2]. s can also plot the output motion of any linkage. Utilizing the xlinkage software available in the Ch Mechanism toolkit, the class provides a function to create an animation file that can be displayed by xlinkage showing the movements of the Whitworth Quick Return Mechanism over time [3].

2

2 Kinematic Analysis of the Whitworth Quick Return Mechanism

Figure 1: Vector representation of the Whitworth Quick Return Mechanism. Looking at Figure 1 the Whitworth Quick Return Mechanism can be broken up into multiple vectors and two loops. Utilizing these two loops, the following sections will go through the kinematic analysis of the Whitworth Quick Return Mechanism.

2.1 Position Analysis For the Whitworth Quick Return Mechanism shown in Figure 1, the displacement analysis can be formulated by the following loop-closer equations r1 + r2 = r3 (1a) r3 + r8 + r5 = r6 + r7

(1b)

Using complex numbers, Equations 1 become r1 eiθ1 + r2 eiθ2 = r3 eiθ3

(2a)

r3 eiθ3 + r8 eiθ8 + r5 eiθ5 = r6 eiθ6 + r7 eiθ7

(2b)

where the link lengths r1 , r2 , r5 , r7 , and angular positions θ1 , θ6 , and θ7 are constants. Angular position θ2 is an independent variable; angular positions θ3 , θ8 , θ4 , and θ5 are dependent variables. Looking at Figure 1, it can be seen that θ8 = θ3 = θ4 and r4 = r3 + r8 . Substituting and rearranging Equations 2 to have all of the unknowns on the left hand side and all of the knowns on the right hand side gives r3 eiθ4 = r1 eiθ1 + r2 eiθ2

(3a)

r4 eiθ4 + r5 eiθ5 − r6 eiθ6 = r7 eiθ7

(3b)

3

Looking at Equations 3, it can be seen that Equation 3a has 2 unknowns and Equation 3b has 3 unknowns. Utilizing Euler’s equation, eiθ = cos θ + i sin θ, Equation 3a can be broken up into two equations, one comprising of the real numbers and the other comprising of the imaginary numbers. r3 cos θ4 = r1 cos θ1 + r2 cos θ2

(4a)

r3 sin θ4 = r1 sin θ1 + r2 sin θ2

(4b)

Squaring Equations 4, adding them together, and simplifying gives r3 =

q

(r1 cos θ1 + r2 cos θ2 )2 + (r1 sin θ1 + r2 sin θ2 )2

(5)

Dividing Equation 4b by Equation 4a and simplifying gives r1 sin θ1 + r2 sin θ2 θ4 = arctan r1 cos θ1 + r2 cos θ2



(6)

Knowing θ4 , Equation 3b now only has 2 unknowns and becomes r6 eiθ6 − r5 eiθ5 = r4 eiθ4 − r7iθ7

(7)

Since the right hand side of Equation 7 is constant, we let reiθ = r4 eiθ4 − r7 eiθ7 and use it in the rest of the calculations. Breaking Equation 7 up into real and imaginary parts gives r6 cos θ6 − r5 cos θ5 = r cos θ

(8a)

r6 sin θ6 − r5 sin θ5 = r sin θ

(8b)

Solving Equations 8 for r6 gives r6 =

r cos θ + r5 cos θ5 cos θ6

(9a)

r6 =

r sin θ + r5 sin θ5 sin θ6

(9b)

where Equation 9a is used when cos θ6 > 0 and Equation 9b is used when cos θ6 = 0. Substituting Equation 9a into Equation 8b gives sin(θ5 − θ6 ) = Solving for θ5 we find θ5a θ5b

r cos θ sin θ6 − r sin θ cos θ6 r5

r cos θ sin θ6 − r sin θ cos θ6 = θ6 + arcsin r5

(10)



r sin θ cos θ6 − r cos θ sin θ6 = θ6 + π − arcsin r5

(11a)

(11b)

Knowing all of the angular positions and the length of r6 , we can find the position of the output slider, link 6, using P6 = r4 + r5 (12)

4

2.2 Velocity Analysis For the Whitworth Quick Return Mechanism shown in Figure 1, the velocity analysis can be formulated by taking the time derivative of the loop-closer equations. Taking the time derivative of Equations 2 gives r˙3 eiθ4 + r3 iω4 eiθ4 = r˙1 eiθ1 + r1 iω1 eiθ1 + r˙2 eiθ2 + r2 iω2 eiθ2

(13a)

r˙6 eiθ6 + r6 iω6 eiθ6 = r˙4 eiθ4 + r4 iω4 eiθ4 + r˙5 eiθ5 + r5 iω5 eiθ5 − r˙7 eiθ7 − r7 iω7 eiθ7

(13b)

Equations 13 can be simplified since r˙1 = r˙2 = r˙4 = r˙5 = 0, the links are assumed to be rigid that may not elongate, ω1 = 0, link 1 is a rigid link that is unable to rotate, ω6 = ω7 = 0 and θ6 = 0 as links 6 and 7 are assumed to be non-rotating imaginary , and r˙7 = 0 because the output slider 6 is assumed to remain on the ground at all times. Applying these simplifications, we have r˙3 eiθ4 + r3 iω4 eiθ4 = r2 iω2 eiθ2

(14a)

r˙6 = r4 iω4 eiθ4 + r5 iω5 eiθ5

(14b)

Equation 14a has 2 unknowns while Equation 14b has 3 unknowns. Breaking up Equation 14a into imaginary and real parts, solving each for r˙3 , setting them equal to each other and solving it for ω4 gives ω4 =

r2 ω2 cos θ2 cos θ4 + r2 ω2 sin θ2 sin θ4 r3

(15)

r˙3 can be found by plugging the found ω4 into either the imaginary or real equation of Equation 14a. With the known ω4 , Equation 14b now only has 2 unknowns, r˙6 and ω5 . Breaking it up into its real and imaginary parts we have r˙6 = −r4 ω4 sin θ4 − r5 ω5 sin θ5 (16a) 0 = r4 ω4 sin θ4 + r5 ω5 sin θ5 Solving Equation 16b for ω5 , we find ω5 =

−r4 ω4 cos θ4 r5 cos θ5

(16b)

(17)

r˙6 can now be found by plugging the found ω5 and ω4 into Equation 16a. We can find the velocity of the output slider, link 6, using V6 = r˙6 + r˙7 (18) Breaking Equation 18 into its X and Y components, we find V6x = r˙6

(19a)

V6y = 0

(19b)

2.3 Acceleration Analysis For the Whitworth Quick Return Mechanism shown in Figure 1, the acceleration analysis can be formulated by taking the second time derivative of the loop-closer equations or by taking the first time derivative of Equations 14 giving r¨3 eiθ4 + 2r˙3 iω4 eiθ4 − r3 ω42 eiθ4 + r3 iα4 eiθ4 = r˙2 iω2 eiθ2 + r2 iα2 eiθ2 − r2 ω22 eiθ2

(20a)

r¨6 = r˙4 iω4 eiθ4 + r4 iα4 eiθ4 − r4 ω42 eiθ4 + r˙5 iω5 eiθ5 + r5 iα5 eiθ5 − r5 ω52 eiθ5

(20b)

5

Equations 20 can be simplified since r˙2 = r˙4 = r˙5 = 0 as links 2, 4 and 5 are assumed to be a rigid links that are unable to elongate. Breaking Equation 20a into real and imaginary parts gives r¨3 cos θ4 − 2r˙3 ω4 sin θ4 − r3 ω42 cos θ4 − r3 α4 sin θ4 = −r2 α2 sin θ2 − r2 ω22 cos θ2

(21a)

r¨3 sin θ4 + 2r˙3 ω4 cos θ4 − r3 ω42 sin θ4 + r3 α4 cos θ4 = r2 α2 cos θ2 − r2 ω22 sin θ2

(21b)

Solving Equations 21 for r3 , setting them equal to each other and solving for α4 gives α4 =

o r˙3 r2 n 2 −ω2 cos (θ2 − θ4 ) + α2 sin (θ2 − θ4 ) − 2 ω4 r3 r3

(22)

r¨3 can now be found by plugging the found α4 into Equation 21a. With the known α4 , Equation 20b now only has 2 unknowns, r¨6 and α5 . Breaking it up into real and imaginary parts gives r¨6 = −r4 α4 sin θ4 − r4 ω42 cos θ4 − r5 α5 sin θ5 − r5 ω52 cos θ5

(23a)

0 = r4 α4 cos θ4 − r4 ω42 sin θ4 + r5 α5 cos θ5 − r5 ω52 sin θ5

(23b)

Solving Equation 23b for α5 we find r4 ω42 sin θ4 − α4 cos θ4 + r5 ω52 sin θ5 α5 = r5 cos θ5

(24)

We can now find r¨6 by plugging α5 into Equation 23a. The acceleration of the output slider, link 6, can now be found with a6 = r¨6 + r¨7 (25) Breaking Equation 25 into its X and Y components, we find a6x = r¨6

(26a)

a6y = 0

(26b)

3 Dynamic Analysis of the Whitworth Quick Return Mechanism Utilizing the previous analysis of position, velocity, and acceleration along with the inertia properties, such as mass and mass moment of inertia of each moving body, we are now able to perform force analysis on the Whitworth Quick Return Mechanism. This is done by pulling apart the Whitworth Quick Return Mechanism and determining the static force equations of each member. This model will neglect friction forces. When the force equations for all have been found, a matrix equation can be formulated and the required torque input for a wanted force output of the output slider, link 6, can be found.

6

3.1 Forces on Each Member

Figure 2: External Forces Acting on the Whitworth Quick Return Mechanism. For the Whitworth Quick Return Mechanism shown in Figure 2, dynamic formulations can be derived to calculate the required input torque Ts and t reaction forces. A free body diagram is given for each link. Three static equilibrium equations can be written in therms of forces in X and Y directions and moment about the center of gravity for links 2, 4, and 5. The static equilibrium equations for links 3 and 6 are different since they are sliders. The equilibrium equations for each link is given.

7

Figure 3: Free Body Diagram of Link 2. For link 2, we get F12x + F32x + Fg2 x = 0

(27a)

−m2 g + F12y + F32y + Fg2 y = 0

(27b)

Ts + (−rg2 ) × F12 + (r2 − rg2 ) × F32 + Tg2 = 0

(27c)

where F12 and F32 are the t forces acting on link 2 from the ground and link3, Fg2 and Tg2 are the inertia force and inertia moment of link 2, m2 is the mass of link 2, rg2 = rg2 ei(θ2 +δ2 ) is the position vector of the center of gravity of link 2 from t O2 , and Ts is the driving torque.

Figure 4: Free Body Diagram of Link 3. 8

For link 3, we get F23x + F43 cos φ + Fg3 x = 0

(28a)

−m3 g + F23y + F43 sin φ + Fg3 y = 0

(28b)

where φ = θ4 − π2 , F23 and F43 are the t forces acting on link 3 from links 2 and 4, and m3 is the mass of link 3. There are no torques on link 3 since it is assumed to be a point mass.

Figure 5: Free Body Diagram of Link 4. For link 4, we get F14x + F34 cos φ + F54x + Fg4 x = 0

(29a)

−m4 g + F14y + F34 sin φ + F54y + Fg4 y = 0

(29b)

(−rg4 ) × F14 + (r3 − rg4 ) × F34 + (r4 − rg4 ) × F54 + Tg2 = 0

(29c)

where φ = θ4 − π2 , F14 , F34 , and F54 are the t forces acting on link 4 from links 1, 3, and 5, Fg4 and Tg4 are the inertia force and inertia moment of link 4, m4 is the mass of link 4, and rg4 = rg4 ei(θ4 +δ4 ) is the position vector of the center of gravity of link 4 from t O1 . Since link 3 is a slider and the dynamic analysis is neglecting friction, the force F34 will always be normal to link 4. Therefore it is not necessary to break this force into x and y components and instead use the angle φ for this purpose when forming the dynamics equations.

9

Figure 6: Free Body Diagram of Link 5. For link 5, we get F45x + F65x + Fg5 x = 0

(30a)

−m5 g + F45y + F65y + Fg6 y = 0

(30b)

(−rg5 ) × F45 + (r5 − rg5 ) × F65 + Tg5 = 0

(30c)

where F45 and F65 are the t forces acting on link 5 from links 4 and 6, Fg5 and Tg5 are the inertia force and inertia moment of link 5, m5 is the mass of link 5, and rg5 = rg5 ei(θ5 +δ5 ) is the position vector of the center of gravity of link 5 from t B.

Figure 7: Free Body Diagram of Link 6. 10

For link 6, we get F16x + F56x + Fg6 x + FL = 0

(31a)

−m6 g + F16y + F56y + Fg6 y = 0

(31b)

where F16 and F56 are the t forces acting on link 6 from the ground and link 5, FL is the output force on link 6 due to the input torque Ts , and m6 is the mass of link 6. There are no torques on link 6 since it is assumed to be a point mass. Equations 27c, 29c, and 30c can be expressed explicitly as Ts − rg2 cos (θ2 + δ2 )F12y + rg2 sin (θ2 + δ2 )F12x + [r2 cos θ2 − rg2 cos (θ2 + δ2 )] F32y − [r2 sin θ2 − rg2 sin (θ2 + δ2 )] F32x + Tg2 = 0

(32a)

−rg4 cos (θ4 + δ4 )F14y + rg4 sin (θ4 + δ4 )F14x + [r3 cos θ4 − rg4 cos (θ4 + δ4 )] sin (φ)F34 − [r3 sin θ4 − rg4 sin (θ4 + δ4 )] cos (φ)F34 + [r4 cos θ4 − rg4 cos (θ4 + δ4 )] F54y − [r4 sin θ4 − rg4 sin (θ4 + δ4 )] F54x + Tg4 = 0

(32b)

−rg5 cos (θ5 + δ5 )F45y + rg5 sin (θ5 + δ5 )F45x + [r5 cos θ2 − rg5 cos (θ5 + δ5 )] F65y − [r5 sin θ2 − rg5 sin (θ5 + δ5 )] F65x + Tg5 = 0

(32c)

Note that Fijx = −Fjix and Fijy = −Fjiy . Equations 27-31 can be rewritten as 13 linear equations in of 14 unknowns F12x , F12y , F23x , F23y , F14x , F14y , F34 , F45x , F45y , F56x , F56y , F16x , F16y and Ts (13 t reaction forces and one input torque). Since this model assumes a fictionless at all ts, the ground can not exert a horizontal force on the output slider (link 6), therefore F16x = 0. This reduces the number of needed equations to 13 and the problem can thus be solved. The equations can now be collectively expressed as the symbolic matrix eqaution Ax = b

(33)

where x = (F12x , F12y , F23x , F23y , F14x , F14y , F34 , F45x , F45y , F56x , F56y , F16y , Ts )T is a vector consisting of the unknown forces and the input torque, b = (Fg2 x , Fg2 y − m2 g, Tg2 , Fg3 x , Fg3 y − m3 g, Fg4 x , Fg4 y − m4 g, Tg4 , Fg5 x , Fg5 y − m5 g, Tg5 , Fg6 x + FL , −m6 g)T is a vector that contains the external load, inertia forces, and inertia torques, and A is the 13x13 square matrix                         

−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   a b c d 0 0 0 0 0 0 0 0 −1    0 0 −1 0 0 0 e 0 0 0 0 0 0   0 0 0 −1 0 0 f 0 0 0 0 0 0   0 0 0 0 −1 0 g 1 0 0 0 0 0    0 0 0 0 0 −1 h 0 1 0 0 0 0   0 0 0 0 i j k l m 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 0 0 0 0 0 0 n p q r 0 0   0 0 0 0 0 0 0 0 0 −1 0 0 0  0 0 0 0 0 0 0 0 0 0 −1 −1 0 

11

where a = −rg2 sin (θ2 + δ2 ) b = +rg2 cos θ2 + δ2 ) c = − [r2 sin θ2 − rg2 sin (θ2 + δ2 )] d = + [r2 cos θ2 − rg2 cos (θ2 + δ2 )] π e = cos θ4 − 2 π f = sin θ4 − 2 π g = − cos θ4 − 2 π h = − sin θ4 − 2 i = −rg4 sin (θ4 + δ4 ) j = +rg4 cos (θ4 + δ4 ) π k = [r3 sin θ4 − rg4 sin (θ4 + δ4 )] cos θ4 − 2 l = − [r4 sin θ4 − rg4 sin (θ4 + δ4 )]





π − [r3 cos θ4 − rg4 cos (θ4 + δ4 )] sin θ4 − 2





m = + [r4 cos θ4 − rg4 cos (θ4 + δ4 )] n = −rg5 sin (θ5 + δ5 ) p = +rg5 cos (θ5 + δ5 ) q = − [r5 sin θ5 − rg5 sin (θ5 + δ5 )] r = + [r5 cos θ5 − rg5 cos (θ5 + δ5 )] formed by using the angular position of each link and link parameters.

4 Description of the Software Package CQuickReturn The CQuickReturn software package allows s to quickly analyze a Whitworth Quick Return Mechanism. It can be used by engineers or as teaching guide to students learning about computer aided design and analysis or mechanisms. The software utilizes the programming paradigm Ch which is a free C/C++ interpreter.

12

4.1 Getting Started with the Software Package CQuickReturn

Figure 8: Example configuration of a Whitworth Quick Return Mechanism. An example program, Program 1, is given to illustrate the basic features of the CQuickReturn software package. Figure 8 shows the configuration used for the example. The link lengths are given as r1 = 2.5cm, r2 = 1.0cm, r4 = 6.5cm, and r5 = 3.0cm. The output slider, link 6, is located 5.0cm above the lowest ground pin, O1 . The phase angle for the ground link is θ1 = 90◦ . This is a Whitworth quick return mechanism. The velocity profile of the output slider will be plotted and an animation of the mechanism will be created. Program 1: A sample program for using the CQuickReturn software package. #include int main(void) { bool unit = SI; double r1 = .025, r2 = .010, r4 = .065, r5 = .030, r7 = .050; double theta1 = M_PI/2, theta2 = -30*M_PI_180; double omega2 = -15; class CQuickReturn mechanism; class lot plot; mechanism.uscUnit(unit); mechanism.setLinks(r1, r2, r4, r5, r7, theta1); mechanism.setAngVel(omega2); mechanism.setNumPoints(360); mechanism.plotSliderVel(&plot); mechanism.setNumPoints(50); mechanism.animation(); return 0; }

13

The first line of the program #include

includes the header file quickreturn.h which defines the CQuickReturn class, macros, and prototypes of member functions. Like all C/C++ programs, the program is started with the main() function. The next four lines bool unit = SI; double r1 = .025, r2 = .010, r4 = .065, r5 = .030, r7 = .050; double theta1 = M_PI/2, theta2 = -30*M_PI_180; double omega2 = -15;

define the unit type, link lengths, ground and input link angles (in rad), and input link angular velocity (in rad/s) of the quick return mechanism. The lines class CQuickReturn mechanism; class lot plot;

constructs an object of the CQuickReturn class for the calculations and the lot class to display the output. The following three lines mechanism.uscUnit(unit); mechanism.setLinks(r1, r2, r4, r5, r7, theta1); mechanism.setAngVel(omega2);

set the units, dimensions of each link, phase angle for link 1, and velocity of the input link as defined above. One line mechanism.setNumPoints(360);

is needed to set the number of points to be used for plotting. The line mechanism.plotSliderVel(&plot);

plots the velocity profile of the output slider, link 6. Figure 9 shows the velocity profile of the output slider after Program 1 has been executed.

Figure 9: Program 1 output slider velocity plot. The last two lines 14

mechanism.setNumPoints(50); mechanism.animation();

resets the number of points and creates a animation file that runs using qanimate. Fewer points are used because the animation doesn’t need as many as a plot to create decent output. The animation shown in Figure 10 is displayed when Program 1 is executed. The menu bar in the qanimate window contains two menus, File and Options, and a series of buttons which manipulate the mechanism. The File menu allows s to quit the program and the Options menu allows s to change various display settings. The Next and Prev buttons control the mechanism’s position, and the All button displays all mechanism positions at once. The Fast and Slow buttons change the speed of animation while the Go and Stop buttons start and stop animation.

Figure 10: Program 1 animation output.

4.2 Solving Complex Equations Complex numbers are used for analysis and design of the Whitworth quick return mechanism. A complex equation can be represented in a general form of R1 eiφ1 + R2 eiφ2 = z3

(34)

where z3 can be expressed in either Cartesian coordinates x3 + iy3 as complex(x3, y3), or polar coordinates R3 eiφ3 as polar(R3, phi3). Many analysis and design problems for planar mechanisms can be formulated in this form. Because a complex equation can be partitioned into real and imaginary parts, two unknowns out of four parameters R1 , φ1 , R2 , and φ2 can be solved in this equation. Function complexsolve() in ch can be conveniently used to solve Equation 34. Detailed use of the function can be found in the Ch Mechanism Toolkit ’s Guide [3].

15

5 Conclusion This report presented a software package for the analysis and design of a Whitworth Quick Return Mechanism. The CQuickReturn class can be used to calculate or plot the position, velocity, and acceleration of the mechanism. The CQuickReturn class also provides a function to create an Xlinkage animation file display the changes in configuration of the mechanism overtime. This package is well suitable for rapid prototyping, distance learning, and as a teaching aid.

6 Acknowledgments We would like to thank professor Harry Cheng for providing this project.

7 Reference 1. Cheng, H. H., 2004. The Ch Language http://www.softintegration.com.

Environment

’s

Guide.

URL

2. Erdman, A. G., and Sandor, G. N., 1997. Mechanism design: Analysis and synthesis, volume 1, 3rd edition. 3. Cheng, H. H., 2004. The Ch http://www.softintegration.com.

Mechanism

16

Toolkit

’s

Guide.

URL

quickreturn.h

CQuickReturn

8 Appendix A: CQuickReturn API

quickreturn.h The headerfile quickreturn.h contains the definition of the Whitworth Quick Return Mechanism CQuickReturn class, defined macros used with the CQuickReturn class, and definitions of the CQuickReturn class member functions. The Whitworth Quick Return Mechanism class CQuickReturn is suitable for rapid integration into any standard code. It gives s the ability to easily compute the position, velocity, acceleration, and forces of a Whitworth Quick Return Mechanism making it suitable for rapid prototyping and as a teaching aid.

CQuickReturn The CQuickReturn class can be used in the analysis and design of a Whitworth Quick Return Mechanism. The member functions of the CQuickReturn class allows for the calculation of the position, velocity, acceleration, and forces of a given Whitworth Quick Return Mechanism.

Public Data None

Public Member Functions Functions

Descriptions

˜CQuickReturn() animation() displayPosition() CQuickReturn() getAngAccel() getAngPos() getAngVel() getForces() getPointAccel() getPointPos() getPointVel() getRequiredTorque() plotAngAccel() plotAngPos() plotAngVel() plotCGaccel() plotForce() plotSliderAccel() plotSliderPos()

Class destructor. Create a qanimate file to animate the mechanism. Create a qanimate file to display the configuration of the mechanism. Class constructor. Creates an instance of the class and initializes all private data . Get the angular acceleration of a link. Get the angular position of a link. Get the angular velocity of a link. Get the forces acting on the mechanism. Get the point acceleration of a link. Get the point position of a link. Get the point velocity of a link. Get the required torque for the mechanism. Plot the angular acceleration of a link versus time. Plot the angular position of a link versus time. Plot the angular velocity of a link versus time. Plot the acceleration of the CQ of a link versus time. Plot all of the forces versus time. Plot the acceleration of the output slider versus time. Plot the position of the output slider versus time. 17

quickreturn.h

plotSliderVel() plotTorque() setAngVel() setForce() setGravityCenter() setInertia() setLinks() setMass() setNumPoints() sliderAccel() sliderPos() sliderRange() sliderVel() uscUnit()

CQuickReturn

Plot the velocity of the output slider versus time. Plot the required input torque versus time. Set angular velocity of link 2. Set the load force on the mechanism. Set the center of gravity parameters of the links. Set the inertial parameters of the links. Set lengths of links. Set the mass of the links. Set the number of points for plotting and animating. Get the output slider’s acceleration. Get the output slider’s position. Get the poition range of the slider. Get the output slider’s velocity. Set to output in USC units or SI units.

Constants The following macros are defined for the CQuickReturn class. Macros

Descriptions

ALL MAG PLOTS ALL FORCE PLOTS F12X F12Y F14X F14Y F16Y F23X F23Y F45X F45Y F56X F56Y MAG F12 MAG F14 MAG F23 MAG F34 MAG F56 MAG F45 QR LINK 2 QR LINK 4 QR LINK 5 QR LINK 2 CG QR LINK 4 CG QR LINK 5 CG QR POINT A QR POINT B

Identifier for all of the force magnitude plots. Identifier for all of the force plots. Identifier for the force plot of F12x . Identifier for the force plot of F12y . Identifier for the force plot of F14x . Identifier for the force plot of F14y . Identifier for the force plot of F16y . Identifier for the force plot of F23x . Identifier for the force plot of F23y . Identifier for the force plot of F45x . Identifier for the force plot of F45y . Identifier for the force plot of F56x . Identifier for the force plot of F56y . Identifier for the force plot of the magnitude of F12 . Identifier for the force plot of the magnitude of F14 . Identifier for the force plot of the magnitude of F23 . Identifier for the force plot of the magnitude of F34 . Identifier for the force plot of the magnitude of F56 . Identifier for the force plot of the magnitude of F45 . Identifier for link 2. Identifier for link 4. Identifier for link 5. Identifier for the CG of link 2. Identifier for the CG of link 4. Identifier for the CG of link 5. Identifier for point A. Identifier for point B.

18

quickreturn.h

CQuickReturn::animation

CQuickReturn::˜CQuickReturn Synopsis #include ˜CQuickReturn(); Purpose Reserved for future use. Return Value None Parameters None Description None Example None Output None

CQuickReturn::animation Synopsis #include void animation( void ); Purpose Creates a qanimate animation file of the Whitworth quick return mechanism. Return Value None Parameters None Description Creates a qanimate animation file of the Whitworth quick return mechanism by writing out the required primatives for a qanimate file. This functions calculates the position of all of the points of the mechanism as the angle of link 2 is changed from 0 to 2 ∗ π. It then writes the required primative descriptions to the file animation.qnm that can then be run with qanimate. Example #include

19

quickreturn.h

CQuickReturn::CQuickReturn

int main(void) { /* Set up required parameters */ double r1 = .025, r2 = .010, r4 = .065, r5 = .030, r7 = .050; //meters double theta1 = M_PI/2; //rad double theta2 = 0.0; //rad double omega2 = -15.0; //rad/sec double rg2 = 0.0125, rg4 = 0.0275, rg5 = 0.0250; //meters double delta2 = 30*M_PI/180, delta4 = 15*M_PI/180, delta5 = 30*M_PI/180; //rad double ig2 = 0.012, ig4 = 0.119, ig5 = 0.038; //kg*mˆ2 double m2 = 0.8, m3 = 0.3, m4 = 2.4, m5 = 1.4, m6 = 0.3; //kg double fl = -100; //N int numpoints = 360; bool unit = SI; /* Create CQuickReturn Object */ CQuickReturn mechanism; mechanism.setLinks(r1, r2, r4, r5, r7, theta1); mechanism.setAngVel(omega2); mechanism.setGravityCenter(rg2, rg4, rg5, delta2, delta4, delta5); mechanism.setInertia(ig2, ig4, ig5); mechanism.setMass(m2, m3, m4, m5, m6); mechanism.setForce(fl); mechanism.setNumPoints(numpoints); mechanism.uscUnit(unit); mechanism.animation(); return 0; }

Output

20

quickreturn.h

CQuickReturn::getAngAccel

CQuickReturn::CQuickReturn Synopsis #include CQuickReturn(); Purpose Class constructor of the CQuickReturn class. Return Value None Parameters None Description Constructs on object of CQuickReturn class type. This function also initailizes all of the private data memebers. Example None Output None

CQuickReturn::getAngAccel Synopsis #include double getAngAccel(double theta2, int link); Purpose Acquires the angular acceleration of any link. Return Value Returns the wanted angular acceleration. Parameters theta2 The angle of link 2 used to calculate the instantaneous angular acceleration of a link. link enumerated value identifying which link to calculate the angular accerleration of. Description This function calculates the angular acceleration of any link and returns the calculated value. Example #include <stdio.h> #include int main(void) { /* Set up required parameters */

21

quickreturn.h

CQuickReturn::getAngPos

double r1 = .025, r2 = .010, r4 = .065, r5 = .030, r7 = .050; double theta1 = M_PI/2; double theta2 = 0.0; double omega2 = -15.0; bool unit = SI; double angularaccel= 0;

//meters //rad //rad //rad/sec

/* Create CQuickReturn Object */ CQuickReturn mechanism; mechanism.setLinks(r1, r2, r4, r5, r7, theta1); mechanism.setAngVel(omega2); mechanism.uscUnit(unit); angularaccel = mechanism.getAngAccel(theta2, QR_LINK_5); printf("The angular acceleration of link 5 = %f\n", angularaccel); return 0; }

Output The angular acceleration of link 5 = 37.836011

CQuickReturn::getAngPos Synopsis #include double getAngPos(double theta2, int link); Purpose Acquires the angular position of any link. Return Value Returns the wanted angular position. Parameters theta2 The angle of link 2 used to calculate the instantaneous angular position of a link. link enumerated value identifying which link to calculate the angular position of. Description This function calculates the angular position of any link and returns the calculated value. Example #include <stdio.h> #include int main(void) { /* Set up required parameters */ double r1 = .025, r2 = .010, r4 = .065, r5 = .030, r7 = .050; double theta1 = M_PI/2; double theta2 = 0.0;

22

//meters //rad //rad

quickreturn.h

CQuickReturn::getAngVel

bool unit = SI; double angularpos = 0; /* Create CQuickReturn Object */ CQuickReturn mechanism; mechanism.setLinks(r1, r2, r4, r5, r7, theta1); mechanism.uscUnit(unit); angularpos = mechanism.getAngPos(theta2, QR_LINK_5); printf("The angular position of link 5 = %f\n", angularpos); return 0; }

Output The angular position of link 5 = -0.352274

CQuickReturn::getAngVel Synopsis #include double getAngVel(double theta2, int link); Purpose Acquires the angular velocity of any link. Return Value Returns the wanted angular velocity. Parameters theta2 The angle of link 2 used to calculate the instantaneous angular velocity of a link. link enumerated value identifying which link to calculate the angular velocity of. Description This function calculates the angular velocity of any link and returns the calculated value. Example #include <stdio.h> #include int main(void) { /* Set up required parameters */ double r1 = .025, r2 = .010, r4 = .065, r5 = .030, r7 = .050; double theta1 = M_PI/2; double theta2 = 0.0; double omega2 = -15.0; bool unit = SI; double angularvel = 0; /* Create CQuickReturn Object */

23

//meters //rad //rad //rad/sec

quickreturn.h

CQuickReturn::getForces

CQuickReturn mechanism; mechanism.setLinks(r1, r2, r4, r5, r7, theta1); mechanism.setAngVel(omega2); mechanism.uscUnit(unit); angularvel = mechanism.getAngVel(theta2, QR_LINK_5); printf("The angular velocity of link 5 = %f\n", angularvel); return 0; }

Output The angular velocity of link 5 = 1.773780

CQuickReturn::getForces Synopsis #include void getForces(double theta2, arraydouble forces); Purpose Acquires the forces acting on the mechanism. Return Value None Parameters theta2 The angle of link 2 used to calculate the forces on all the links. forces An array of 12 elements to store the calculated forces Description This function calculates the forces acting on the mechanism and stored the calculated values in the array forces. Example #include <stdio.h> #include int main(void) { /* Set up required parameters */ double r1 = .025, r2 = .010, r4 = .065, r5 = .030, r7 = .050; //meters double theta1 = M_PI/2; //rad double theta2 = 0.0; //rad double omega2 = -15.0; //rad/sec double rg2 = 0.0125, rg4 = 0.0275, rg5 = 0.0250; //meters double delta2 = 30*M_PI/180, delta4 = 15*M_PI/180, delta5 = 30*M_PI/180; //rad double ig2 = 0.012, ig4 = 0.119, ig5 = 0.038; //kg*mˆ2 double m2 = 0.8, m3 = 0.3, m4 = 2.4, m5 = 1.4, m6 = 0.3; //kg double fl = -100; //N

24

quickreturn.h

CQuickReturn::getPointAccel

int numpoints = 360; bool unit = SI; array double forces[12] = {0}; /* Create CQuickReturn Object */ CQuickReturn mechanism; mechanism.setLinks(r1, r2, r4, r5, r7, theta1); mechanism.setAngVel(omega2); mechanism.setGravityCenter(rg2, rg4, rg5, delta2, delta4, delta5); mechanism.setInertia(ig2, ig4, ig5); mechanism.setMass(m2, m3, m4, m5, m6); mechanism.setForce(fl); mechanism.setNumPoints(numpoints); mechanism.uscUnit(unit); mechanism.getForces(theta2, forces); printf("Force Name printf("F12x printf("F12y printf("F23x printf("F23y printf("F14x printf("F14y printf("F34 printf("F45x printf("F45y printf("F56x printf("F56y printf("F16y

Value (N)\n"); %f\n", forces[0]); %f\n", forces[1]); %f\n", forces[2]); %f\n", forces[3]); %f\n", forces[4]); %f\n", forces[5]); %f\n", forces[6]); %f\n", forces[7]); %f\n", forces[8]); %f\n", forces[9]); %f\n", forces[10]); %f\n", forces[11]);

return 0; }

Output Force Name F12x F12y F23x F23y F14x F14y F34 F45x F45y F56x F56y F16y

Value (N) -162.639205 73.672264 -160.690648 66.949264 70.111066 58.739047 -172.342129 93.816762 -86.189132 99.042701 -102.746351 105.689351

CQuickReturn::getPointAccel Synopsis #include double complex getPointAccel(double theta2, int point);

25

quickreturn.h

CQuickReturn::getPointPos

Purpose Acquires the acceleration of any point. Return Value Returns the wanted acceleration. Parameters theta2 The angle of link 2 used to calculate the acceleration of a point. point An enumerated value identifying which point to calculate the acceleration of. Description This function calculates the acceleration of any point and returns the calculated value. Example #include <stdio.h> #include int main(void) { /* Set up required parameters */ double r1 = .025, r2 = .010, r4 = .065, r5 = .030, r7 = .050; double theta1 = M_PI/2; double theta2 = 0.0; double omega2 = -15.0; bool unit = SI; double complex pointaccel = 0; /* Create CQuickReturn Object */ CQuickReturn mechanism; mechanism.setLinks(r1, r2, r4, r5, r7, theta1); mechanism.setAngVel(omega2); mechanism.uscUnit(unit); pointaccel = mechanism.getPointAccel(theta2, QR_POINT_A); printf("The acceleration of point A is %f\n", pointaccel); return 0; }

Output The acceleration of point A is complex(-2.250000,0.000000)

CQuickReturn::getPointPos Synopsis #include double complex getPointPos(double theta2, int point);

26

//meters //rad //rad //rad/sec

quickreturn.h

CQuickReturn::getPointVel

Purpose Acquires the position of any point. Return Value Returns the wanted position. Parameters theta2 The angle of link 2 used to calculate the position of a point. point An enumerated value identifying which point to calculate the position of. Description This function calculates the position of any point and returns the calculated value. Example #include <stdio.h> #include int main(void) { /* Set up required parameters */ double r1 = .025, r2 = .010, r4 = .065, r5 = .030, r7 = .050; double theta1 = M_PI/2; double theta2 = 0.0; bool unit = SI; double complex pointpos = 0; /* Create CQuickReturn Object */ CQuickReturn mechanism; mechanism.setLinks(r1, r2, r4, r5, r7, theta1); mechanism.uscUnit(unit); pointpos = mechanism.getPointPos(theta2, QR_POINT_A); printf("The position of point A is %f\n", pointpos); return 0; }

Output The position of point A is complex(0.010000,0.025000)

CQuickReturn::getPointVel Synopsis #include double complex getPointVel(double theta2, int point); Purpose Acquires the velocity of any point.

27

//meters //rad //rad

quickreturn.h

CQuickReturn::getRequiredTorque

Return Value Returns the wanted velocity. Parameters theta2 The angle of link 2 used to calculate the velocity of a point. point An enumerated value identifying which point to calculate the velocity of. Description This function calculates the velocity of any point and returns the calculated value. Example #include <stdio.h> #include int main(void) { /* Set up required parameters */ double r1 = .025, r2 = .010, r4 = .065, r5 = .030, r7 = .050; double theta1 = M_PI/2; double theta2 = 0.0; double omega2 = -15.0; bool unit = SI; double complex pointvel = 0; /* Create CQuickReturn Object */ CQuickReturn mechanism; mechanism.setLinks(r1, r2, r4, r5, r7, theta1); mechanism.setAngVel(omega2); mechanism.uscUnit(unit); pointvel = mechanism.getPointPos(theta2, QR_POINT_A); printf("The velocity of point A is %f\n", pointvel); return 0; }

Output The velocity of point A is complex(0.010000,0.025000)

CQuickReturn::getRequiredTorque Synopsis #include double getRequiredTorque(double theta2); Purpose Calculates the required input torque at a given angle theta2. Return Value Returns the calculated required input torque. 28

//meters //rad //rad //rad/sec

quickreturn.h

CQuickReturn::plotAngAccel

Parameters theta2 The angle of link 2 used to calculate the required input torque. Description Calculates the required input torque at a given angle of link 2 and returns the calculated value. Example #include <stdio.h> #include int main(void) { /* Set up required parameters */ double r1 = .025, r2 = .010, r4 = .065, r5 = .030, r7 = .050; //meters double theta1 = M_PI/2; //rad double theta2 = 0.0; //rad double omega2 = -15.0; //rad/sec double rg2 = 0.0125, rg4 = 0.0275, rg5 = 0.0250; //meters double delta2 = 30*M_PI/180, delta4 = 15*M_PI/180, delta5 = 30*M_PI/180; //rad double ig2 = 0.012, ig4 = 0.119, ig5 = 0.038; //kg*mˆ2 double m2 = 0.8, m3 = 0.3, m4 = 2.4, m5 = 1.4, m6 = 0.3; //kg double fl = -100; //N int numpoints = 360; bool unit = SI; double requiredtorque = 0; /* Create CQuickReturn Object */ CQuickReturn mechanism; mechanism.setLinks(r1, r2, r4, r5, r7, theta1); mechanism.setAngVel(omega2); mechanism.setGravityCenter(rg2, rg4, rg5, delta2, delta4, delta5); mechanism.setInertia(ig2, ig4, ig5); mechanism.setMass(m2, m3, m4, m5, m6); mechanism.setForce(fl); mechanism.setNumPoints(numpoints); mechanism.uscUnit(unit); requiredtorque = mechanism.getRequiredTorque(theta2); printf("The required torque is %f\n", requiredtorque); return 0; }

Output The required torque is -0.006734

CQuickReturn::plotAngAccel Synopsis #include void plotAngAccel( void );

29

quickreturn.h

CQuickReturn::plotAngAccel

Purpose Plots the angular acceleration of links 4 and 5 over time. Return Value None Parameters None Description Calculates the angular acceleration of links 4 and 5 as the angle of link 2 changes over time. It then creates plots of the angular accerleration of links 4 and 5 over time. Example #include int main(void) { /* Set up required parameters */ double r1 = .025, r2 = .010, r4 = .065, r5 = .030, r7 = .050; double theta1 = M_PI/2; double theta2 = 0.0; double omega2 = -15.0; int numpoints = 360; bool unit = SI; /* Create CQuickReturn Object */ CQuickReturn mechanism; mechanism.setLinks(r1, r2, r4, r5, r7, theta1); mechanism.setAngVel(omega2); mechanism.uscUnit(unit); mechanism.plotAngAccel(); return 0; }

Output

30

//meters //rad //rad //rad/sec

quickreturn.h

CQuickReturn::plotAngPos

CQuickReturn::plotAngPos Synopsis #include void plotAngPos( void );

31

quickreturn.h

CQuickReturn::plotAngPos

Purpose Plots the angular position links 4 and 5 over time. Return Value None Parameters None Description Calculates the angular position of links 4 and 5 as the angle of link 2 changes over time. It then creates plots of the position of links 4 and 5 over time. Example #include int main(void) { /* Set up required parameters */ double r1 = .025, r2 = .010, r4 = .065, r5 = .030, r7 = .050; double theta1 = M_PI/2; double theta2 = 0.0; int numpoints = 360; bool unit = SI; /* Create CQuickReturn Object */ CQuickReturn mechanism; mechanism.setLinks(r1, r2, r4, r5, r7, theta1); mechanism.uscUnit(unit); mechanism.plotAngPos(); return 0; }

Output

32

//meters //rad //rad

quickreturn.h

CQuickReturn::plotAngVel

CQuickReturn::plotAngVel Synopsis #include void plotAngVel( void );

33

quickreturn.h

CQuickReturn::plotAngVel

Purpose Plots the angular velocity of links 4 and 5 over time. Return Value None Parameters None Description Calculates the angular velocity of links 4 and 5 as the angle of link 2 changes over time. It then creates plots of the angular velocity of links 4 and 5 over time. Example #include int main(void) { /* Set up required parameters */ double r1 = .025, r2 = .010, r4 = .065, r5 = .030, r7 = .050; double theta1 = M_PI/2; double theta2 = 0.0; double omega2 = -15.0; int numpoints = 360; bool unit = SI; /* Create CQuickReturn Object */ CQuickReturn mechanism; mechanism.setLinks(r1, r2, r4, r5, r7, theta1); mechanism.setAngVel(omega2); mechanism.uscUnit(unit); mechanism.plotAngVel(); return 0; }

Output

34

//meters //rad //rad //rad/sec

quickreturn.h

CQuickReturn::plotCGaccel

CQuickReturn::plotCGaccel Synopsis #include void plotCGaccel( void );

35

quickreturn.h

CQuickReturn::plotCGaccel

Purpose Plots the CG acceleration of links 2, 4, and 5. Return Value None Parameters None Description Calculates the CG acceleration of links 2, 4, and 5 as the angle of link 2 changes over time. It then creates plots of the CG acceleration of links 2, 4, and 5 over time. Example #include int main(void) { /* Set up required parameters */ double r1 = .025, r2 = .010, r4 = .065, r5 = .030, r7 = .050; //meters double theta1 = M_PI/2; //rad double theta2 = 0.0; //rad double omega2 = -15.0; //rad/sec double rg2 = 0.0125, rg4 = 0.0275, rg5 = 0.0250; //meters double delta2 = 30*M_PI/180, delta4 = 15*M_PI/180, delta5 = 30*M_PI/180; //rad int numpoints = 360; bool unit = SI; /* Create CQuickReturn Object */ CQuickReturn mechanism; mechanism.setLinks(r1, r2, r4, r5, r7, theta1); mechanism.setAngVel(omega2); mechanism.setGravityCenter(rg2, rg4, rg5, delta2, delta4, delta5); mechanism.setNumPoints(numpoints); mechanism.uscUnit(unit); mechanism.plotCGaccel(); return 0; }

Output

36

quickreturn.h

CQuickReturn::plotCGaccel

37

quickreturn.h

CQuickReturn::plotCGaccel

38

quickreturn.h

CQuickReturn::plotForce

CQuickReturn::plotForce Synopsis #include void plotForce( int plot);

39

quickreturn.h

CQuickReturn::plotForce

Purpose Plots all of the forces acting on the mechanism over time. Return Value None Parameters plot An enumerated which determins what force plots to create. Parameter Discussion plot is an integer that represents which force plots to create. The enumerated values of F12X, F12Y, MAG F12, and so on have been defined in the header file quickreturn.h. plot is bitwise checked to see which force plots are wanted. For more option, see the MACRO definitions in the quickreturn.h section. Description Calculates all of the forces acting on the mechanism as the angle of link 2 changes over time. It then creates plots of the forces over time. Example #include int main(void) { /* Set up required parameters */ double r1 = .025, r2 = .010, r4 = .065, r5 = .030, r7 = .050; //meters double theta1 = M_PI/2; //rad double theta2 = 0.0; //rad double omega2 = -15.0; //rad/sec double rg2 = 0.0125, rg4 = 0.0275, rg5 = 0.0250; //meters double delta2 = 30*M_PI/180, delta4 = 15*M_PI/180, delta5 = 30*M_PI/180; //rad double ig2 = 0.012, ig4 = 0.119, ig5 = 0.038; //kg*mˆ2 double m2 = 0.8, m3 = 0.3, m4 = 2.4, m5 = 1.4, m6 = 0.3; //kg double fl = -100; //N int numpoints = 360; bool unit = SI; /* Create CQuickReturn Object */ CQuickReturn mechanism; mechanism.setLinks(r1, r2, r4, r5, r7, theta1); mechanism.setAngVel(omega2); mechanism.setGravityCenter(rg2, rg4, rg5, delta2, delta4, delta5); mechanism.setInertia(ig2, ig4, ig5); mechanism.setMass(m2, m3, m4, m5, m6); mechanism.setForce(fl); mechanism.setNumPoints(numpoints); mechanism.uscUnit(unit); mechanism.plotForce(MAG_F12 | F16Y); return 0; }

Output

40

quickreturn.h

CQuickReturn::plotSliderAccel

CQuickReturn::plotSliderAccel Synopsis #include void plotSliderAccel( void );

41

quickreturn.h

CQuickReturn::plotSliderAccel

Purpose Plots the acceleration of the output slider over time. Return Value None Parameters None Description Calculates the acceleration of the output silder as the angle of link 2 changes with time. It then creates a plot of the acceleration of the output slider over time. Example #include int main(void) { /* Set up required parameters */ double r1 = .025, r2 = .010, r4 = .065, r5 = .030, r7 = .050; double theta1 = M_PI/2; double theta2 = 0.0; double omega2 = -15.0; int numpoints = 360; bool unit = SI; /* Create CQuickReturn Object */ CQuickReturn mechanism; mechanism.setLinks(r1, r2, r4, r5, r7, theta1); mechanism.setAngVel(omega2); mechanism.uscUnit(unit); mechanism.plotSliderAccel(); return 0; }

Output

42

//meters //rad //rad //rad/sec

quickreturn.h

CQuickReturn::plotSliderPos

CQuickReturn::plotSliderPos Synopsis #include void plotSliderPos( void ); Purpose Plots the Position of the output slider over time. Return Value None Parameters None Description Calculates the position of the output silder as the angle of link 2 changes with time. It then creates a plot of the position of the output slider over time. Example #include int main(void) { /* Set up required parameters */ double r1 = .025, r2 = .010, r4 = .065, r5 = .030, r7 = .050; double theta1 = M_PI/2; double theta2 = 0.0;

43

//meters //rad //rad

quickreturn.h

CQuickReturn::plotSliderVel

int numpoints = 360; bool unit = SI; /* Create CQuickReturn Object */ CQuickReturn mechanism; mechanism.setLinks(r1, r2, r4, r5, r7, theta1); mechanism.setNumPoints(numpoints); mechanism.uscUnit(unit); mechanism.plotSliderPos(); return 0; }

Output

CQuickReturn::plotSliderVel Synopsis #include void plotSliderVel( void ); Purpose Plots the velocity of the output slider over time. Return Value None Parameters None 44

quickreturn.h

CQuickReturn::plotTorque

Description Calculates the velocity of the output silder as the angle of link 2 changes with time. It then creates a plot of the velocity of the output slider over time. Example #include int main(void) { /* Set up required parameters */ double r1 = .025, r2 = .010, r4 = .065, r5 = .030, r7 = .050; double theta1 = M_PI/2; double theta2 = 0.0; double omega2 = -15.0; int numpoints = 360; bool unit = SI; /* Create CQuickReturn Object */ CQuickReturn mechanism; mechanism.setLinks(r1, r2, r4, r5, r7, theta1); mechanism.setAngVel(omega2); mechanism.setNumPoints(numpoints); mechanism.uscUnit(unit); mechanism.plotSliderVel(); return 0; }

Output

45

//meters //rad //rad //rad/sec

quickreturn.h

CQuickReturn::plotTorque

CQuickReturn::plotTorque Synopsis #include void plotTorque( void ); Purpose Plots the required input torque over time. Return Value None Parameters None Description Calculates the required input torque for link 2 as the angle of link2 changes over time. It then creates a plot of the torque over time. Example #include int main(void) { /* Set up required parameters */ double r1 = .025, r2 = .010, r4 = .065, r5 = .030, r7 = .050; //meters double theta1 = M_PI/2; //rad double theta2 = 0.0; //rad double omega2 = -15.0; //rad/sec double rg2 = 0.0125, rg4 = 0.0275, rg5 = 0.0250; //meters double delta2 = 30*M_PI/180, delta4 = 15*M_PI/180, delta5 = 30*M_PI/180; //rad double ig2 = 0.012, ig4 = 0.119, ig5 = 0.038; //kg*mˆ2 double m2 = 0.8, m3 = 0.3, m4 = 2.4, m5 = 1.4, m6 = 0.3; //kg double fl = -100; //N int numpoints = 360; bool unit = SI; /* Create CQuickReturn Object */ CQuickReturn mechanism; mechanism.setLinks(r1, r2, r4, r5, r7, theta1); mechanism.setAngVel(omega2); mechanism.setGravityCenter(rg2, rg4, rg5, delta2, delta4, delta5); mechanism.setInertia(ig2, ig4, ig5); mechanism.setMass(m2, m3, m4, m5, m6); mechanism.setForce(fl); mechanism.setNumPoints(numpoints); mechanism.uscUnit(unit); mechanism.plotTorque(); return 0; }

Output 46

quickreturn.h

CQuickReturn::setAngVel

CQuickReturn::setAngVel Synopsis #include void setAngVel(double omega2); Purpose Sets the angular velocity of link 2. Return Value None Parameters omega2 The angular velocity of link 2. Description Sets the angular velocity of link 2. This is used in velocity calculations. Example #include int main(void) { /* Set up required parameters */ double omega2 = -15.0;

//rad/sec

/* Create CQuickReturn Object */ CQuickReturn mechanism;

47

quickreturn.h

CQuickReturn::setGravityCenter

mechanism.setAngVel(omega2); return 0; }

Output None

CQuickReturn::setForce Synopsis #include void setForce(double fl); Purpose Sets the load force. Return Value None Parameters fl The load force on the mechanism. Description Sets the load force that acts on the output slider. Example #include int main(void) { /* Set up required parameters */ double fl = -100;

//N

/* Create CQuickReturn Object */ CQuickReturn mechanism; mechanism.setForce(fl);

return 0; }

Output None

CQuickReturn::setGravityCenter Synopsis #include void setGravityCenter(double rg2, double rg4,double rg5,double delta2,double delta4,double delta5); Purpose Sets the gravity center parameters of all of the links.

48

quickreturn.h

CQuickReturn::setInertia

Return Value None Parameters rg2 Length of the CG phasor of link 2. rg4 Length of the CG phasor of link 4. rg5 Length of the CG phasor of link 5. delta2 Angle of the CG phasor of link 2. delta4 Angle of the CG phasor of link 4. delta5 Angle of the CG phasor of link 5. Description Sets the gravity center parameters of all of the links. These are used for force calculations. Example #include int main(void) { /* Set up required parameters */ double rg2 = 0.0125, rg4 = 0.0275, rg5 = 0.0250; double delta2 = 30*M_PI/180, delta4 = 15*M_PI/180, delta5 = 30*M_PI/180; /* Create CQuickReturn Object */ CQuickReturn mechanism; mechanism.setGravityCenter(rg2, rg4, rg5, delta2, delta4, delta5); return 0; }

Output None

CQuickReturn::setInertia Synopsis #include void setInertia(double ig2, double ig4, double ig5); Purpose Sets the inertia properties of all of the links. Return Value None Parameters ig2 The moment of inertia of link 2. ig4 The moment of inertia of link 4. ig5 The moment of inertia of link 5. Description Sets the inertia properties of all of the links. These are used in the force calculations.

49

//meters //rad

quickreturn.h

CQuickReturn::setLinks

Example #include int main(void) { /* Set up required parameters */ double ig2 = 0.012, ig4 = 0.119, ig5 = 0.038;

//kg*mˆ2

/* Create CQuickReturn Object */ CQuickReturn mechanism; mechanism.setInertia(ig2, ig4, ig5); return 0; }

Output None

CQuickReturn::setLinks Synopsis #include void setLinks(double r1, double r2,double r4,double r5,double r7,double theta1); Purpose Sets the length of the links and the phase angle of the ground link. Return Value None Parameters r1 The length of gound. r2 The length of link 2. r4 The length of link 4. r5 The length of link 5. r7 The vertical height of the output slider with respect to the lowest groundpin. theta1 The phase angle of the ground phasor. Description Sets the length of the links and the phase angle of the ground link. These are used for all of the other calculations. Example #include int main(void) { /* Set up required parameters */ double r1 = .025, r2 = .010, r4 = .065, r5 = .030, r7 = .050; double theta1 = M_PI/2; /* Create CQuickReturn Object */

50

//meters //rad

quickreturn.h

CQuickReturn::setNumPoints

CQuickReturn mechanism; mechanism.setLinks(r1, r2, r4, r5, r7, theta1); return 0; }

Output None

CQuickReturn::setMass Synopsis #include void setMass(double m2, double m3, double m4, double m5, double m6); Purpose Sets the mass parameters of all of the links. Return Value None Parameters m2 The mass of link 2. m3 The mass of link 3. m4 The mass of link 4. m5 The mass of link 5. m6 The mass of link 6. Description Sets the mass parameters of all of the links. This is mainly used to calculate the forces acting on the mechanism. Example #include int main(void) { /* Set up required parameters */ double m2 = 0.8, m3 = 0.3, m4 = 2.4, m5 = 1.4, m6 = 0.3; /* Create CQuickReturn Object */ CQuickReturn mechanism; mechanism.setMass(m2, m3, m4, m5, m6); return 0; }

Output None

CQuickReturn::setNumPoints 51

//kg

quickreturn.h

CQuickReturn::sliderAccel

Synopsis #include void setNumPoints(double numpoints); Purpose Set the number of points. Return Value None Parameters numpoints The number of points to use when plotting and creating the animation file. Description Set the number of points used when creating plots and creating the animation file. Example #include int main(void) { /* Set up required parameters */ int numpoints = 360; /* Create CQuickReturn Object */ CQuickReturn mechanism; mechanism.setNumPoints(numpoints); return 0; }

Output None

CQuickReturn::sliderAccel Synopsis #include double sliderAccel(double theta2); Purpose Calculates the acceleration of the output slider. Return Value Returns the accerleration of the output slider. Parameters theta2 The angle of link 2 used to calculate the acceleration the output slider. Description Calculates the acceleration of the output slider and returns the calculated value. Example 52

quickreturn.h

CQuickReturn::sliderPos

#include <stdio.h> #include int main(void) { /* Set up required parameters */ double r1 = .025, r2 = .010, r4 = .065, r5 = .030, r7 = .050; double theta1 = M_PI/2; double theta2 = 0.0; double omega2 = -15.0; bool unit = SI; double slideraccel = 0; /* Create CQuickReturn Object */ CQuickReturn mechanism; mechanism.setLinks(r1, r2, r4, r5, r7, theta1); mechanism.setAngVel(omega2); mechanism.uscUnit(unit); slideraccel = mechanism.sliderAccel(unit); printf("The acceleration of the output slider is %f\n", slideraccel); return 0; }

Output The acceleration of the output slider is -3.190996

CQuickReturn::sliderPos Synopsis #include double sliderPos(double theta2); Purpose Calculates the position of the output slider. Return Value The calculated position of the output slider Parameters theta2 The angle of link 2 used to calculate the position of the output slider. Description Calculates the position of the output slider and returns the calculated value. Example #include <stdio.h> #include int main(void) {

53

//meters //rad //rad //rad/sec

quickreturn.h

CQuickReturn::sliderRange

/* Set up required parameters */ double r1 = .025, r2 = .010, r4 = .065, r5 = .030, r7 = .050; double theta1 = M_PI/2; double theta2 = 0.0; bool unit = SI; double sliderpos = 0;

//meters //rad //rad

/* Create CQuickReturn Object */ CQuickReturn mechanism; mechanism.setLinks(r1, r2, r4, r5, r7, theta1); mechanism.uscUnit(unit); sliderpos = mechanism.sliderPos(theta2); printf("The position of the output slider is %f\n", sliderpos); return 0; }

Output The position of the output slider is 0.052298

CQuickReturn::sliderRange Synopsis #include void sliderRange(double &max, double &min); Purpose Calculates the range of the output slider. Return Value None Parameters max A variable ed by reference used to store the maximum attained position of the output slider. min A variable ed by reference used to store the minimum attained position of the output slider. Description Calculates the maximum and minimum position of the output slider and saves them into the variabled ed by reference. Example #include <stdio.h> #include int main(void) { /* Set up required parameters */ double r1 = .025, r2 = .010, r4 = .065, r5 = .030, r7 = .050; double theta1 = M_PI/2; bool unit = SI;

54

//meters //rad

quickreturn.h

CQuickReturn::sliderVel

double max = 0, min = 0; /* Create CQuickReturn Object */ CQuickReturn mechanism; mechanism.setLinks(r1, r2, r4, r5, r7, theta1); mechanism.uscUnit(unit); mechanism.sliderRange(max, min); printf("The range of the output slider is from %f to %f\n", min, max); return 0; }

Output The range of the output slider is from 0.002444 to 0.054414

CQuickReturn::sliderVel Synopsis #include double sliderVel(double theta2); Purpose Calculates the velocity of the output slider. Return Value Returns the velocity of the output slider. Parameters theta2 The angle of link 2 used to calculate the acceleration the output slider. Description Calculates the velocity of the output slider and returns the calculated value. Example #include <stdio.h> #include int main(void) { /* Set up required parameters */ double r1 = .025, r2 = .010, r4 = .065, r5 = .030, r7 = .050; double theta1 = M_PI/2; double theta2 = 0.0; double omega2 = -15.0; bool unit = SI; double slidervel = 0; /* Create CQuickReturn Object */ CQuickReturn mechanism; mechanism.setLinks(r1, r2, r4, r5, r7, theta1);

55

//meters //rad //rad //rad/sec

quickreturn.h

CQuickReturn::uscUnit

mechanism.setAngVel(omega2); mechanism.uscUnit(unit); slidervel = mechanism.sliderVel(theta2); printf("The velocity of the output slider is %f\n", slidervel); return 0; }

Output The velocity of the output slider is 0.143224

CQuickReturn::uscUnit Synopsis #include void uscUnit(bool unit); Purpose Determines what units are used. Return Value None Parameters unit An enumerated value of either USC or SI. Description Determines what units are used. This allows s to input in either SI or USC units. Any output after this function has been used to changed the units will reflect the new units chosen. Example #include int main(void) { /* Set up required parameters */ bool unit = SI; /* Create CQuickReturn Object */ CQuickReturn mechanism; mechanism.uscUnit(unit); return 0; }

Output !! You’re using SI UNITS !!

56

9 Appendix B: Source Code

9.1 Source Code of Classes and Functions

quickreturn.h #ifndef _QUICKRETURN_H_ #define _QUICKRETURN_H_ #include #include #include #include #include #include #include

<stdio.h> <stdbool.h> <stdarg.h>

enum { SI, USC, QR_LINK_2, QR_LINK_4, QR_LINK_5, QR_POINT_A, QR_POINT_B, QR_LINK_2_CG, QR_LINK_4_CG, QR_LINK_5_CG };

// // // // // // // // // //

SI units, use with uscUnit() USC units, " " " Link 2 Link 4 Link 5 Point A: point of slider 3 Point B: end of Link 4 Center of Mass of Link 2 Center of Mass of Link 4 Center of Mass of Link 5

enum // Pick which plots to output for plotForce() { F12X = 1, F12Y = 2, MAG_F12 = 4, ALL_F12 = 7, F23X = 8, F23Y = 16, MAG_F23 = 32, ALL_F23 = 56, F14X = 64, F14Y = 128, MAG_F14 = 256, ALL_F14 = 448, MAG_F34 = 512, F45X = 1024, F45Y = 2048, MAG_F45 = 4096, ALL_F45 = 7168, F56X = 8192, F56Y = 16384,

57

MAG_F56 = 32768, ALL_F56 = 57344, F16Y = 65536, ALL_MAG_PLOTS = 103204, ALL_FORCE_PLOTS = 131071 }; /********************************************** * CQuickReturn class definition *********************************************/ class CQuickReturn { private: // Private data double m_delta[1:5]; double m_inertia[1:5]; double m_mass[1:6]; double m_omega[1:5]; double m_alpha[1:5]; double m_r[1:8]; double m_rg[1:5]; double m_theta[1:7]; double m_r3_dot; double m_r6_dot; double m_r3_double_dot; double m_r6_double_dot; double m_load; double complex m_v3; double complex m_a3; double complex m_ag2; double complex m_ag4; double complex m_ag5; int m_numpoints; bool m_uscunit;

// // // // // // // // // // // // // // // // // // // //

phase angle of CG of links inertia of the links mass of the links angular velocity angular acceleration lengths of links distance to CG of links phase angles for the links first derivative of r7 first derivative of r9 second derivative of r7 second derivative of r9 external force or return slider velocity of slider 3 acceleration of slider 3 acceleration of mass center of link 2 acceleration of mass center of link 4 acceleration of mass center of link 5 number of points to plot or for animation unit choice

// Private function void m_initialize(void); // initialize private void calosition(double theta2); // calc. ang. pos. and m_r9 void calcVelocity(double theta2); // calc. ang. vel. and r9 dot void calcAcceleration(double theta2); // calc. ang. accel. and r9 ddot void calcForce(double theta2, array double x[13]); // calc. forces public: // Constructor and Destructor CQuickReturn(); ˜CQuickReturn(); // Setting information functions void setLinks(double r1, r2, r4, r5, r7, theta1); void setAngVel(double initomega2); void setGravityCenter(double rg2, rg4, rg5, delta2, delta4, delta5); void setInertia(double ig2, ig4, ig5); void setMass(double m2, m3, m4, m5, m6); void setForce(double fl); void setNumPoints(int numpoints); void uscUnit(bool unit); // Output information functions

58

double sliderPos(double theta2); double sliderVel(double theta2); double sliderAccel(double theta2); double getRequiredTorque(double theta2); void sliderRange(double& max, double& min); // Output display functions void displayPosition(double theta2, ...); void animation(...); // Plot information functions void plotSliderPos(lot *plot); void plotSliderVel(lot *plot); void plotSliderAccel(lot *plot); void plotAngPos(lot *plot); void plotAngVel(lot *plot); void plotAngAccel(lot *plot); void plotCGaccel(lot *plot); void plotForce(int plot_output, lot *plot); void plotTorque(lot *plot); // Information for specified point or link double getAngPos(double theta2, int link); double getAngVel(double theta2, int link); double getAngAccel(double theta2, int link); double complex getPointPos(double theta2, int point); double complex getPointVel(double theta2, int point); double complex getPointAccel(double theta2, int point); void getForces(double theta2, array double y[12]); }; #pragma importf #endif

59

CQuickReturn.chf /************************************************************ * File name: CQuickReturn.chf * member functions of class CQuickReturn ************************************************************/ #include void CQuickReturn::m_initialize(void) { /* defaults */ m_r[1] = 0.025; m_r[2] = 0.010; m_r[4] = 0.065; m_r[5] = 0.030; m_r[7] = 0.050;

// // // // //

m_theta[1] m_theta[6] m_theta[7]

// angle of link 1 // angle of link 9 // angle of link 10

= M_PI/2; = 0; = M_PI/2;

length length length length length

of of of of of

link link link link link

1 2 4 5 10

m_omega[2] = -15;

// input angular velocity

m_mass[2] m_mass[3] m_mass[4] m_mass[5] m_mass[6]

// // // // //

= = = = =

0.8; 0.3; 2.4; 1.4; 0.3;

mass mass mass mass mass

of of of of of

link link link link link

2 3 4 5 6

in in in in in

kg kg kg kg kg

m_inertia[2] = 0.012; m_inertia[4] = 0.119; m_inertia[5] = 0.038;

// mass inertia of link 2 // mass inertia of link 4 // mass inertia of link 5

m_rg[2] = 0.0125; m_rg[4] = 0.0275; m_rg[5] = 0.0250;

// CG distance of link 2 in m // CG distance of link 4 in m // CG distance of link 5 in m

m_delta[2] = 30*M_PI_180; m_delta[4] = 15*M_PI_180; m_delta[5] = 30*M_PI_180;

// phase angle for CG of link 2 // phase angle for CG of link 4 // phase angle for CG of link 5

m_load = -100;

// exeternal load on return slider

m_numpoints = 50;

// number of points for animation

m_uscunit = 0;

// selection SI units

} /****************************************** * Constructor of class CQuickReturn ******************************************/ CQuickReturn::CQuickReturn() { m_initialize(); }

60

/****************************************** * Destructor of class CQuickReturn ******************************************/ CQuickReturn::˜CQuickReturn() {} /******************************************************************* * setAngVel() * * Set angular velocity. * * Arguments: omega2 ... angular velocity of input link *******************************************************************/ void CQuickReturn::setAngVel(double omega2) { m_omega[2] = omega2; } /********************************************************************* * setGravityCenter() * * Set the distances and offset angles for center of mass * for each link. * * Arguments: rg2 ... distance to center of mass for link 2 * rg4 ... " " " " " " " 4 * rg5 ... " " " " " " " 5 * delta2 ... anglular offset of center of mass for link 2 * delta4 ... " " " " " " " " 4 * delta5 ... " " " " " " " " 5 *********************************************************************/ void CQuickReturn::setGravityCenter(double rg2, rg4, rg5, delta2, delta4, delta5) { m_rg[2] = rg2; m_rg[4] = rg4; m_rg[5] = rg5;

// CG distance of link 2 in m // CG distance of link 4 in m // CG distance of link 5 in m

m_delta[2] = delta2; m_delta[4] = delta4; m_delta[5] = delta5; if(m_uscunit) { m_rg[2] *= M_FT2M; m_rg[4] *= M_FT2M; m_rg[5] *= M_FT2M; }

// phase angle for CG of link 2 // phase angle for CG of link 4 // phase angle for CG of link 5

// ft --> m // ft --> m // ft --> m

} /*************************************************** * setInertia() * * Set the Moment of Inertia for each link. * * Arguments: ig2 ... Moment of Inertia for link 2 * ig4 ... " " " " " 4 * ig5 ... " " " " " 5 ***************************************************/

61

void CQuickReturn::setInertia(double ig2, ig4, ig5) { m_inertia[2] = ig2; m_inertia[4] = ig4; m_inertia[5] = ig5; if(m_uscunit) { m_inertia[2] *= M_LBFTSS2KGMM; m_inertia[4] *= M_LBFTSS2KGMM; m_inertia[5] *= M_LBFTSS2KGMM; }

// lb-ft-sˆ2 --> kg-mˆ2 // lb-ft-sˆ2 --> kg-mˆ2 // lb-ft-sˆ2 --> kg-mˆ2

} /*************************************************************** * setLinks() * * Set the Length for each link and angle between ground pins. * * Arguments: r1 ... length Link 1 * r2 ... " " 2 * r4 ... " " 4 * r5 ... " " 5 * r7 ... " " 7 * theta 1 ... angle of Link 1 ***************************************************************/ void CQuickReturn::setLinks(double r1, r2, r4, r5, r7, theta1) { int characteristic; // Check geometry input for values that will make the // mechanism not work if((int)(1000000*r2) >= (int)(1000000*r1)) { printf("r2 must be less than r1.\n" "Try resetting the geometry and trying agian.\n\n"); exit(1); } if((int)(1000000*r4) < (int)(1000000*r1) + (int)(1000000*r2)) { printf("r4 must be greater than r1 + r2.\n" "Try resetting the geometry and trying agian.\n\n"); exit(1); } if((int)(1000000*r4) > (int)(1000000*r5) + (int)(1000000*abs(r7))) { printf("r4 must be less than r5 + r7.\n" "Try resetting the geometry and trying agian.\n\n"); exit(1); } // If geometry valid assign parameters m_r[1] = r1; m_r[2] = r2; m_r[4] = r4; m_r[5] = r5; m_r[7] = r7; m_theta[1] = theta1; if(m_uscunit)

62

{ m_r[1] m_r[2] m_r[4] m_r[5] m_r[7]

*= *= *= *= *=

M_FT2M; M_FT2M; M_FT2M; M_FT2M; M_FT2M;

// // // // //

ft ft ft ft ft

--> --> --> --> -->

m m m m m

} } /****************************************** * setMass() * * Set the Mass for each link. * * Arguments: m2 ... mass of Link 2 * m3 ... " " " 3 * m4 ... " " " 4 * m5 ... " " " 5 * m6 ... " " " 6 ******************************************/ void CQuickReturn::setMass(double m2, m3, m4, m5, m6) { m_mass[2] = m2; m_mass[3] = m3; m_mass[4] = m4; m_mass[5] = m5; m_mass[6] = m6; if(m_uscunit) { m_mass[2] *= m_mass[3] *= m_mass[4] *= m_mass[5] *= m_mass[6] *= }

M_SLUG2KG; M_SLUG2KG; M_SLUG2KG; M_SLUG2KG; M_SLUG2KG;

// // // // //

slug slug slug slug slug

--> --> --> --> -->

kg kg kg kg kg

} /********************************************* * setForce() * * Set the external force on return slider. * * Arguments: fl ... exteral load on slider *********************************************/ void CQuickReturn::setForce(double fl) { m_load = fl; if(m_uscunit) { m_load *= M_LB2N; }

// lb --> N

} /***************************************************** * setNumPoints() * * Set the number of points for calcs & animation.

63

* * Arguments: numpoints ... number of points used *****************************************************/ void CQuickReturn::setNumPoints(int numpoints) { m_numpoints = numpoints; } /****************************************** * uscUnit() * * Set the units preference. * * Arguments: unit ... true for USC units * false for SI units ******************************************/ void CQuickReturn::uscUnit(bool unit) { m_uscunit = unit; /* uncomment for visual output of Unit Type */ /* if(m_uscunit) printf("\n!! You’re using ENGLISH UNITS !!\n\n"); else printf("\n!! You’re using SI UNITS !!\n\n"); */ } /*************************************************************** * calosition() * * Computes the angular positions & * unknown lengths for a given angle of the driving link * of the quick return mechanism. * * Arguments: theta2 ... drive link positions ***************************************************************/ void CQuickReturn::calosition(double theta2) { int n1, n2; double temp1, temp2; double complex z; m_theta[2] = theta2; // Solve First Loop: r1 + r2 = r3 -> r3 - r2 = r1 // z = r1 n1 = 1; n2 = 2; z = polar(m_r[1], m_theta[1]); // find r3, theta4 complexsolve(n1, n2, -m_r[2], m_theta[2], z, m_r[3], m_theta[4], temp1, temp2); // Solve Second Loop: r4 + r5 = r6 + r7 -> r6 - r5 = r4 - r7 // z = r4 - r7 n1 = 1; n2 = 4; z = polar(m_r[4], m_theta[4]) - polar(m_r[7], m_theta[7]); // find r6, theta5

64

complexsolve(n1, n2, m_theta[6], -m_r[5], z, m_r[6], m_theta[5], temp1, temp2); // Solve r8: r3 + r8 = r4 -> r8 = r4 - r3 m_r[8] = m_r[4] - m_r[3]; } /************************************************ * calcVelocity() * * Computes the velocities for * the quick return mechanism. * * Arguments: theta2 ... drive link positions ************************************************/ void CQuickReturn::calcVelocity(double theta2) { calosition(theta2); // omega4 m_omega[4] = (m_r[2]/m_r[3])*(cos(m_theta[2] - m_theta[4]))*m_omega[2]; // omega5 m_omega[5] = -(m_r[4]/m_r[5])*(cos(m_theta[4])/cos(m_theta[5]))*m_omega[4]; // velocity r7 m_r3_dot = m_r[2]*m_omega[2]*(sin(m_theta[4]-m_theta[2])); // velocity r9 m_r6_dot = (m_r[4]*m_omega[4]*(sin(m_theta[5]-m_theta[4])))/(cos(m_theta[5])); // Velocity of slider 3 m_v3 = I*polar((m_r[3]*m_omega[4]), m_theta[4]) + polar(m_r3_dot, m_theta[4]); } /*************************************************************** * calcAcceleration() * * Computes the accelerations for * the quick return mechanism. * * Arguments: theta2 ... drive link positions ***************************************************************/ void CQuickReturn::calcAcceleration(double theta2) { double a,b,c,d; double complex w,x,y,z; calcVelocity(theta2); // alpha 4 a = -m_r[2]*m_omega[2]*m_omega[2]*(sin(m_theta[2] - m_theta[4])); b = m_r[2]*m_alpha[2]*(cos(m_theta[2] - m_theta[4])); c = -2*m_r3_dot*m_omega[4]; d = m_r[3]; m_alpha[4] = (a + b + c)/d; // alpha 5 a = m_r[4]*m_omega[4]*m_omega[4]*(sin(m_theta[4])); b = -m_r[4]*m_alpha[4]*(cos(m_theta[4]));

65

c = m_r[5]*m_omega[5]*m_omega[5]*(sin(m_theta[5])); d = m_r[5]*(cos(m_theta[5])); m_alpha[5] = (a + b + c)/d; // acceleration r3 a = m_r[3]*m_omega[4]*m_omega[4]; b = -m_r[2]*m_omega[2]*m_omega[2]*(cos(m_theta[2] - m_theta[4])); c = -m_r[2]*m_alpha[2]*(sin(m_theta[2] - m_theta[4])); m_r3_double_dot = a + b + c; // acceleration r6 a = -m_r[4]*m_omega[4]*m_omega[4]*(cos(m_theta[4])); b = -m_r[4]*m_alpha[4]*(sin(m_theta[4])); c = -m_r[5]*m_omega[5]*m_omega[5]*(cos(m_theta[5])); d = -m_r[5]*m_alpha[5]*(sin(m_theta[5])); m_r6_double_dot = a + b + c + d; // Acceleration of slider 3 w = I*polar((m_r[3]*m_alpha[4]), m_theta[4]); x = -polar((m_r[3]*m_omega[4]*m_omega[4]), m_theta[4]); y = polar(m_r3_double_dot, m_theta[4]); z = I*polar((2*m_r3_dot*m_omega[4]), m_theta[4]); m_a3 = w + x + y + z; // Acceleration of the Centers of Mass x = I*polar((m_rg[2]*m_alpha[2]), (m_theta[2] + m_delta[2])); y = polar((m_rg[2]*m_omega[2]*m_omega[2]), (m_theta[2] + m_delta[2])); m_ag2 = x - y; x = I*polar((m_rg[4]*m_alpha[4]), (m_theta[4] + m_delta[4])); y = polar((m_rg[4]*m_omega[4]*m_omega[4]), (m_theta[4] + m_delta[4])); m_ag4 = x - y; w = I*polar((m_r[4]*m_alpha[4]), m_theta[4]); x = polar((m_r[4]*m_omega[4]*m_omega[4]), m_theta[4]); y = I*polar((m_rg[5]*m_alpha[5]), (m_theta[5] + m_delta[5])); z = polar((m_rg[5]*m_omega[5]*m_omega[5]), (m_theta[5] + m_delta[5])); m_ag5 = w - x + y - z; } /********************************************************************************* * calcForce() * * Calculate force on links of quick return mechanism at a specific * position of the input link. * * Arguments: theta2 ... drive link positions * x[13] = f12x,f12y,f23x,f23y,f14x,f14y,f34,f45x,f45y,f56x,f56y,f16y,Ts *********************************************************************************/ void CQuickReturn::calcForce(double theta2, array double x[13]) { array double B[13], A[13][13] = {0}; double fl = m_load; double g = 9.81; // m/sˆ2 double phi; double fg2x, fg2y, fg3x, fg3y, fg4x, fg4y, fg5x, fg5y, fg6x, tg2, tg4, tg5; if(m_uscunit) fl *= M_LBFT2NM;

// lb-ft --> N-m

66

calcAcceleration(theta2); phi = m_theta[4] - (M_PI/2); fg2x = -m_mass[2]*real(m_ag2); fg2y = -m_mass[2]*imag(m_ag2); tg2 = -m_inertia[2]*m_alpha[2]; fg3x = -m_mass[3]*real(m_a3); fg3y = -m_mass[3]*imag(m_a3); fg4x = -m_mass[4]*real(m_ag4); fg4y = -m_mass[4]*imag(m_ag4); tg4 = -m_inertia[4]*m_alpha[4]; fg5x = -m_mass[5]*real(m_ag5); fg5y = -m_mass[5]*imag(m_ag5); tg5 = -m_inertia[5]*m_alpha[5]; fg6x = -m_mass[6]*m_r6_double_dot; B[0] = fg2x; B[1] = fg2y - m_mass[2]*g; B[2] = tg2; B[3] = fg3x; B[4] = fg3y - m_mass[3]*g; B[5] = fg4x; B[6] = fg4y - m_mass[4]*g; B[7] = tg4; B[8] = fg5x; B[9] = fg5y - m_mass[5]*g; B[10] = tg5; B[11] = fg6x + fl; B[12] = -m_mass[6]*g; A[0][0] A[0][2] A[1][1] A[1][3] A[2][0] A[2][1] A[2][2] A[2][3] A[2][12] A[3][2] A[3][6] A[4][3] A[4][6] A[5][4] A[5][6] A[5][8] A[6][5] A[6][6] A[6][9] A[7][4] A[7][5] A[7][6]

= = = = = = = = = = = = = = = = = = = = = =

-1; 1; -1; 1; -m_rg[2]*sin(m_theta[2] + m_delta[2]); m_rg[2]*cos(m_theta[2] + m_delta[2]); -(m_r[2]*sin(m_theta[2]) - m_rg[2]*sin(m_theta[2] + m_delta[2])); m_r[2]*cos(m_theta[2]) - m_rg[2]*cos(m_theta[2] + m_delta[2]); -1; -1; cos(phi); -1; sin(phi); -1; -cos(phi); 1; -1; -sin(phi); 1; -m_rg[4]*sin(m_theta[4] + m_delta[4]); m_rg[4]*cos(m_theta[4] + m_delta[4]); ((m_r[3]*sin(m_theta[4]) - m_rg[4]*sin(m_theta[4] + m_delta[4])) *(cos(phi)))

67

A[7][7] A[7][8] A[8][7] A[8][9] A[9][8] A[9][10] A[10][7] A[10][8] A[10][9] A[10][10] A[11][9] A[12][10] A[12][11]

= = = = = = = = = = = = =

- ((m_r[3]*cos(m_theta[4]) - m_rg[4]*cos(m_theta[4] + m_delta[4])) *(sin(phi))); -( m_r[4]*sin(m_theta[4]) - m_rg[4]*sin(m_theta[4] + m_delta[4])); m_r[4]*cos(m_theta[4]) - m_rg[4]*cos(m_theta[4] + m_delta[4]); -1; 1; -1; 1; -m_rg[5]*sin(m_theta[5] + m_delta[5]); m_rg[5]*cos(m_theta[5] + m_delta[5]); -(m_r[5]*sin(m_theta[5]) - m_rg[5]*sin(m_theta[5] + m_delta[5])); m_r[5]*cos(m_theta[5]) - m_rg[5]*cos(m_theta[5] + m_delta[5]); -1; -1; -1;

x = inverse(A)*B; } /************************************************ * sliderPos() * * Return postion of slider for given theta2. * * Arguments: theta2 ... drive link positions * * Return value: slider position ************************************************/ double CQuickReturn::sliderPos(double theta2) { calosition(theta2); if(m_uscunit) { return (m_r[6] /= M_FT2M); // m --> ft } else { return m_r[6]; } } /***************************************************** * sliderVel() * * Return Velocity of slider for given theta2. * * Arguments: theta2 ... drive link positions * * Return value: slider velocity *****************************************************/ double CQuickReturn::sliderVel(double theta2) { calcVelocity(theta2); if(m_uscunit) { return m_r6_dot /= M_FT2M; // m --> ft }

68

else { return m_r6_dot; } } /********************************************************** * sliderAccel() * * Return Acceleration of slider for given theta2. * * Arguments: theta2 ... drive link positions * * Return value: slider acceleration **********************************************************/ double CQuickReturn::sliderAccel(double theta2) { calcAcceleration(theta2); if(m_uscunit) { return m_r6_double_dot /= M_FT2M; // m --> ft } else { return m_r6_double_dot; } } /******************************************************************* * sliderRange() * * Calculate the maximum and minimum distances * that the slider travels. * * Arguments: max ... storage for maximum position of the range * min ... storage for minimum position of the range *******************************************************************/ void CQuickReturn::sliderRange(double& max, double& min) { double max_pos=-100; double min_pos=100; double interval = 2*M_PI / (m_numpoints); int i; for(i=0; i<=m_numpoints; i++) { calosition(i*interval); max_pos = (m_r[6] > max_pos) ? m_r[6] : max_pos; min_pos = (m_r[6] < min_pos) ? m_r[6] : min_pos; } max = max_pos; min = min_pos; if(m_uscunit) { max /= M_FT2M; min /= M_FT2M; }

// m --> ft // m --> ft

69

} /********************************************************** * getRequiredTorque() * * Return Torque needed at input link for given theta2. * * Arguments: theta2 ... drive link positions * * Return value: input torque **********************************************************/ double CQuickReturn::getRequiredTorque(double theta2) { array double x[13]; calcForce(theta2, x); if(m_uscunit) { return x[12] /= 1.355818991; // N-m --> lb-ft } else { return x[12]; } } /***************************************************************** * getAngPos() * * Return angular position for given theta2 & link number. * * Arguments: theta2 ... drive link positions * link ... link angle desired * * Return value: theta for desired link *****************************************************************/ double CQuickReturn::getAngPos(double theta2, int link) { double output; calosition(theta2); switch(link) { case QR_LINK_2: output = m_theta[2]; break; case QR_LINK_4: output = m_theta[4]; break; case QR_LINK_5: output = m_theta[5]; break; } return output; } /***************************************************************** * getAngVel()

70

* * Return angular velocity for given theta2 & link number. * * Arguments: theta2 ... drive link positions * link ... link angular velocity desired * * Return value: omega for desired link *****************************************************************/ double CQuickReturn::getAngVel(double theta2, int link) { double output; calcVelocity(theta2); switch(link) { case QR_LINK_2: output = m_omega[2]; break; case QR_LINK_4: output = m_omega[4]; break; case QR_LINK_5: output = m_omega[5]; break; } return output; } /***************************************************************** * getAngAccel() * * Return angular acceleration for given theta2 & link number. * * Arguments: theta2 ... drive link positions * link ... link angular acceleration desired * * Return value: alpha for desired link *****************************************************************/ double CQuickReturn::getAngAccel(double theta2, int link) { double output; calcAcceleration(theta2); switch(link) { case QR_LINK_2: output = m_alpha[2]; break; case QR_LINK_4: output = m_alpha[4]; break; case QR_LINK_5: output = m_alpha[5]; break; } return output; } /*****************************************************************

71

* getPointPos() * * Return position of a point for given theta2 & point number. * * Arguments: theta2 ... drive link positions * point ... point position desired * * Return value: position for desired point as complex number *****************************************************************/ double complex CQuickReturn::getPointPos(double theta2, int point) { double complex output; calosition(theta2); switch(point) { case QR_POINT_A: output = polar(m_r[3], m_theta[4]); break; case QR_POINT_B: output = polar(m_r[4], m_theta[4]); break; case QR_LINK_2_CG: output = polar(m_r[1], m_theta[1]) + polar(m_rg[2], m_theta[2]); break; case QR_LINK_4_CG: output = polar(m_rg[4], m_theta[4]); break; case QR_LINK_5_CG: output = polar(m_r[4], m_theta[4]) + polar(m_rg[5], m_theta[5]); break; } if(m_uscunit) { output /= 0.304800609; }

// m --> ft

return output; } /***************************************************************** * getPointVel() * * Return velocity of a piont for given theta2 & point number. * * Arguments: theta2 ... drive link positions * point ... point velocity desired * * Return value: velocity for desired point as complex number *****************************************************************/ double complex CQuickReturn::getPointVel(double theta2, int point) { double complex output, x, y; calcVelocity(theta2); switch(point) { case QR_POINT_A:

72

output = I*polar(m_r[3]*m_omega[4], m_theta[4]); break; case QR_POINT_B: output = I*polar(m_r[4]*m_omega[4], m_theta[4]); break; case QR_LINK_2_CG: output = I*polar(m_rg[2]*m_omega[2], m_theta[2]); break; case QR_LINK_4_CG: output = I*polar(m_rg[4]*m_omega[4], m_theta[4]); break; case QR_LINK_5_CG: x = I*polar(m_r[4]*m_omega[4], m_theta[4]); y = I*polar(m_rg[5]*m_omega[5], m_theta[5]); output = x + y; break; } if(m_uscunit) { output /= 0.304800609; }

// m --> ft

return output; } /******************************************************************** * getPointAccel() * * Return acceleration of a point for given theta2 & point number. * * Arguments: theta2 ... drive link positions * point ... point acceleration desired * * Return value: acceleration for desired point as complex number ********************************************************************/ double complex CQuickReturn::getPointAccel(double theta2, int point) { double complex output, x, y; calcAcceleration(theta2); switch(point) { case QR_POINT_A: x = I*polar((m_r[2]*m_alpha[2]), m_theta[2]); y = -polar((m_r[2]*m_omega[2]*m_omega[2]), m_theta[2]); output = x + y; break; case QR_POINT_B: x = I*polar((m_r[4]*m_alpha[4]), m_theta[4]); y = -polar((m_r[4]*m_omega[4]*m_omega[4]), m_theta[4]); output = x + y; break; case QR_LINK_2_CG: output = m_ag2; break; case QR_LINK_4_CG: output = m_ag4; break;

73

case QR_LINK_5_CG: output = m_ag5; break; } if(m_uscunit) { output /= 0.304800609; }

// m --> ft

return output; } /****************************************************************************** * getForces() * * Calculates internal forces of mechanism at a give angle * of the input link. * * Arguments: theta2 ... drive link positions * y[13] = f12x,f12y,f23x,f23y,f14x,f14y,f34x,f34y,f45x,f45y,f56x,f56y,f16y ******************************************************************************/ void CQuickReturn::getForces(double theta2, array double y[12]) { int i; array double x[13]; calcForce(theta2, x); for(i = 0; i < 12; i++) { y[i] = x[i]; } if(m_uscunit) { y /= 4.448221615; }

// N --> lb

} /************************************************************** * plotSliderPos() * * Plot slider position as function of time. * * Arguments: *plot ... pointer to plot defined * in the calling program ***************************************************************/ void CQuickReturn::plotSliderPos(lot *plot) { int i; double increment; string_t xlabel, ylabel, title; array double time[m_numpoints + 1], Position[m_numpoints + 1]; increment = 2*M_PI/m_numpoints; if(m_omega[2] < 0) increment = -increment;

74

for(i = 0; i <= m_numpoints; i++) { time[i] = (i*increment/m_omega[2]); Position[i] = sliderPos(i*increment); } title = "Slider Position vs. Time"; xlabel = "time (s)"; if(m_uscunit) { ylabel = "Position (ft)"; } else { ylabel = "Position (m)"; } plotxy(time, Position, title, xlabel, ylabel, plot); plot->plotting(); } /********************************************************** * plotSliderVel() * * Plot slider velocity as function of time. * * Arguments: *plot ... pointer to plot defined * in the calling program **********************************************************/ void CQuickReturn::plotSliderVel(lot *plot) { int i; double increment; string_t xlabel, ylabel, title; array double time[m_numpoints + 1], Velocity[m_numpoints + 1]; increment = 2*M_PI/m_numpoints; if(m_omega[2] < 0) increment = -increment; for(i = 0; i <= m_numpoints; i++) { time[i] = (i*increment/m_omega[2]); Velocity[i] = sliderVel(i*increment); } title = "Slider Velocity vs. Time"; xlabel = "time (s)"; if(m_uscunit) { ylabel = "Velocity (ft/s)"; } else { ylabel = "Velocity (m/s)"; } plotxy(time, Velocity, title, xlabel, ylabel, plot); plot->plotting(); }

75

/********************************************************** * plotSliderAccel() * * Plot slider acceleraion as function of time. * * Arguments: *plot ... pointer to plot defined * in the calling program **********************************************************/ void CQuickReturn::plotSliderAccel(lot *plot) { int i; double increment; string_t xlabel, ylabel, title; array double time[m_numpoints + 1], Acceleration[m_numpoints + 1]; increment = 2*M_PI/m_numpoints; if(m_omega[2] < 0) increment = -increment; for(i = 0; i <= m_numpoints; i++) { time[i] = (i*increment/m_omega[2]); Acceleration[i] = sliderAccel(i*increment); } title = "Slider Acceleration vs. Time"; xlabel = "time (s)"; if(m_uscunit) { ylabel = "Acceleration (ft/sˆ2)"; } else { ylabel = "Acceleration (m/sˆ2)"; } plotxy(time, Acceleration, title, xlabel, ylabel, plot); plot->plotting(); } /*************************************************************** * plotAngPos() * * Plot angular position of links 4 & 5 as function of time. * * Arguments: *plot ... pointer to plot defined * in the calling program ***************************************************************/ void CQuickReturn::plotAngPos(lot *plot) { int i; double increment; string_t xlabel, ylabel, title; array double time[m_numpoints + 1]; array double Theta4[m_numpoints + 1], Theta5[m_numpoints + 1]; increment = 2*M_PI/m_numpoints; if(m_omega[2] < 0) increment = -increment;

76

for(i = 0; i <= m_numpoints; i++) { calosition(i*increment); time[i] = (i*increment/m_omega[2]); Theta4[i] = m_theta[4]; Theta5[i] = m_theta[5]; } title = "Theta 4 vs. Time"; xlabel = "time (s)"; ylabel = "Theta 4 (rad)"; plotxy(time, Theta4, title, xlabel, ylabel, plot); plot->plotting(); title = "Theta 5 vs. Time"; xlabel = "time (s)"; ylabel = "Theta 5 (rad)"; plotxy(time, Theta5, title, xlabel, ylabel, plot); plot->plotting(); } /*************************************************************** * plotAngVel() * * Plot angular velocity of links 4 & 5 as function of time. * * Arguments: *plot ... pointer to plot defined * in the calling program ***************************************************************/ void CQuickReturn::plotAngVel(lot *plot) { int i; double increment; string_t xlabel, ylabel, title; array double time[m_numpoints + 1]; array double Omega4[m_numpoints + 1], Omega5[m_numpoints + 1]; increment = 2*M_PI/m_numpoints; if(m_omega[2] < 0) increment = -increment; for(i = 0; i <= m_numpoints; i++) { calcVelocity(i*increment); time[i] = (i*increment/m_omega[2]); Omega4[i] = m_omega[4]; Omega5[i] = m_omega[5]; } title = "Omega 4 vs. Time"; xlabel = "time (s)"; ylabel = "Omega 4 (rad/s)"; plotxy(time, Omega4, title, xlabel, ylabel, plot); plot->plotting(); title = "Omega 5 vs. Time"; xlabel = "time (s)"; ylabel = "Omega 5 (rad/s)"; plotxy(time, Omega5, title, xlabel, ylabel, plot); plot->plotting(); } /******************************************************************** * plotAngAccel() * * Plot angular acceleration of links 4 & 5 as function of time. * * Arguments: *plot ... pointer to plot defined

77

* in the calling program ********************************************************************/ void CQuickReturn::plotAngAccel(lot *plot) { int i; double increment; string_t xlabel, ylabel, title; array double time[m_numpoints + 1]; array double Alpha4[m_numpoints + 1], Alpha5[m_numpoints + 1]; increment = 2*M_PI/m_numpoints; if(m_omega[2] < 0) increment = -increment; for(i = 0; i <= m_numpoints; i++) { calcAcceleration(i*increment); time[i] = (i*increment/m_omega[2]); Alpha4[i] = m_alpha[4]; Alpha5[i] = m_alpha[5]; } title = "Alpha 4 vs. Time"; xlabel = "time (s)"; ylabel = "Alpha 4 (rad/sˆ2)"; plotxy(time, Alpha4, title, xlabel, ylabel, plot); plot->plotting(); title = "Alpha 5 vs. Time"; xlabel = "time (s)"; ylabel = "Alpha 5 (rad/sˆ2)"; plotxy(time, Alpha5, title, xlabel, ylabel, plot); plot->plotting(); } /*************************************************************** * plotCGaccel() * * Plot acceleration of centers of mass for links 2, 4, & 5 * as functions of time for X & Y components of acceleration * and magnitude of acceleration. * * Arguments: *plot ... pointer to plot defined * in the calling program ***************************************************************/ void CQuickReturn::plotCGaccel(lot *plot) { int i; double increment; string_t xlabel, ylabel, title; array double time[m_numpoints + 1]; array double complex ag2[m_numpoints + 1], ag4[m_numpoints + 1]; array double complex ag5[m_numpoints + 1], mag_ag[m_numpoints + 1]; increment = 2*M_PI/m_numpoints; if(m_omega[2] < 0) increment = -increment; for(i = 0; i <= m_numpoints; i++) { calcAcceleration(i*increment); time[i] = (i*increment/m_omega[2]); ag2[i] = m_ag2; ag4[i] = m_ag4;

78

ag5[i] = m_ag5; } if(m_uscunit) { ag2 /= 0.304800609; ag4 /= 0.304800609; ag5 /= 0.304800609; }

// m --> ft // m --> ft // m --> ft

title = "Ag2x vs. Time"; xlabel = "time (s)"; if(m_uscunit) ylabel = "Ag2x (ft/sˆ2)"; else ylabel = "Ag2x (m/sˆ2)"; plotxy(time, real(ag2), title, xlabel, ylabel,plot); plot->plotting(); title = "Ag2y vs. Time"; xlabel = "time (s)"; if(m_uscunit) ylabel = "Ag2y (ft/sˆ2)"; else ylabel = "Ag2y (m/sˆ2)"; plotxy(time, imag(ag2), title, xlabel, ylabel, plot); plot->plotting(); title = "Magnitude of Ag2 vs. Time"; xlabel = "time (s)"; if(m_uscunit) ylabel = "Ag2 (ft/sˆ2)"; else ylabel = "Ag2 (m/sˆ2)"; mag_ag = abs(ag2); plotxy(time, mag_ag, title, xlabel, ylabel, plot); plot->plotting(); title = "Ag4x vs. Time"; xlabel = "time (s)"; if(m_uscunit) ylabel = "Ag4x (ft/sˆ2)"; else ylabel = "Ag4x (m/sˆ2)"; plotxy(time, real(ag4), title, xlabel, ylabel, plot); plot->plotting(); title = "Ag4y vs. Time"; xlabel = "time (s)"; if(m_uscunit) ylabel = "Ag4y (ft/sˆ2)"; else ylabel = "Ag4y (m/sˆ2)"; plotxy(time, imag(ag4), title, xlabel, ylabel, plot); plot->plotting(); title = "Magnitude of Ag4 vs. Time"; xlabel = "time (s)"; if(m_uscunit) ylabel = "Ag4 (ft/sˆ2)"; else ylabel = "Ag4 (m/sˆ2)"; mag_ag = abs(ag4); plotxy(time, mag_ag, title, xlabel, ylabel, plot); plot->plotting();

79

title = "Ag5x vs. Time"; xlabel = "time (s)"; if(m_uscunit) ylabel = "Ag5x (ft/sˆ2)"; else ylabel = "Ag5x (m/sˆ2)"; plotxy(time, real(ag5), title, xlabel, ylabel, plot); plot->plotting(); title = "Ag5y vs. Time"; xlabel = "time (s)"; if(m_uscunit) ylabel = "Ag5y (ft/sˆ2)"; else ylabel = "Ag5y (m/sˆ2)"; plotxy(time, imag(ag5), title, xlabel, ylabel, plot); plot->plotting(); title = "Magnitude of Ag5 vs. Time"; xlabel = "time (s)"; if(m_uscunit) ylabel = "Ag5 (ft/sˆ2)"; else ylabel = "Ag5 (m/sˆ2)"; mag_ag = abs(ag5); plotxy(time, mag_ag, title, xlabel, ylabel, plot); plot->plotting(); } /*************************************************************** * plotForce() * * Plot specified internal force of quick return * mechanism as function of time. * * Arguments: plot_output ... specifies which forces to plot * *plot ... pointer to plot defined * in the calling program ***************************************************************/ void CQuickReturn::plotForce(int plot_output, lot *plot) { int i; double increment; string_t xlabel, ylabel, title; array double time[m_numpoints + 1], Forces[12][m_numpoints + 1]; array double F_array[13], (*F_plot)[:]; array double complex F_mag[1][m_numpoints + 1]; increment = 2*M_PI/m_numpoints; if(m_omega[2] < 0) increment = -increment; for(i = 0; i <= m_numpoints; i++) { // time for constant omega time[i] = (i*increment/m_omega[2]); calcForce(i*increment, F_array); Forces[0][i] = F_array[0]; Forces[1][i] = F_array[1]; Forces[2][i] = F_array[2]; Forces[3][i] = F_array[3];

80

Forces[4][i] = F_array[4]; Forces[5][i] = F_array[5]; Forces[6][i] = F_array[6]; Forces[7][i] = F_array[7]; Forces[8][i] = F_array[8]; Forces[9][i] = F_array[9]; Forces[10][i] = F_array[10]; Forces[11][i] = F_array[11]; } if(m_uscunit) Forces /= 4.448221615; // N --> lb // F12 Plots F_plot = (array double [:][:])(double [1][m_numpoints + 1])&Forces[0][0]; real(F_mag) = F_plot; if(plot_output & F12X) { title = "F12 x vs. Time"; xlabel = "time (s)"; if(m_uscunit) ylabel = "F12 x (lbs)"; else ylabel = "F12 x (N)"; plotxy(time, F_plot, title, xlabel, ylabel, plot); plot->plotting(); } F_plot = (array double [:][:])(double [1][m_numpoints + 1])&Forces[1][0]; imag(F_mag) = F_plot; if(plot_output & F12Y) { title = "F12 y vs. Time"; xlabel = "time (s)"; if(m_uscunit) ylabel = "F12 y (lbs)"; else ylabel = "F12 y (N)"; plotxy(time, F_plot, title, xlabel, ylabel, plot); plot->plotting(); } if(plot_output & MAG_F12) { title = "Magnitude F12 vs. Time"; xlabel = "time (s)"; if(m_uscunit) ylabel = "F12 (lbs)"; else ylabel = "F12 (N)"; plotxy(time, abs(F_mag), title, xlabel, ylabel, plot); plot->plotting(); } // F23 Plots F_plot = (array double [:][:])(double [1][m_numpoints + 1])&Forces[2][0]; real(F_mag) = F_plot; if(plot_output & F23X) { title = "F23 x vs. Time"; xlabel = "time (s)"; if(m_uscunit) ylabel = "F23 x (lbs)";

81

else ylabel = "F23 x (N)"; plotxy(time, F_plot, title, xlabel, ylabel, plot); plot->plotting(); } F_plot = (array double [:][:])(double [1][m_numpoints + 1])&Forces[3][0]; imag(F_mag) = F_plot; if(plot_output & F23Y) { title = "F23 y vs. Time"; xlabel = "time (s)"; if(m_uscunit) ylabel = "F23 y (lbs)"; else ylabel = "F23 y (N)"; plotxy(time, F_plot, title, xlabel, ylabel, plot); plot->plotting(); } if(plot_output & MAG_F23) { title = "Magnitude F23 vs. Time"; xlabel = "time (s)"; if(m_uscunit) ylabel = "F23 (lbs)"; else ylabel = "F23 (N)"; plotxy(time, abs(F_mag), title, xlabel, ylabel, plot); plot->plotting(); } // F14 Plots F_plot = (array double [:][:])(double [1][m_numpoints + 1])&Forces[4][0]; real(F_mag) = F_plot; if(plot_output & F14X) { title = "F14 x vs. Time"; xlabel = "time (s)"; if(m_uscunit) ylabel = "F14 x (lbs)"; else ylabel = "F14 x (N)"; plotxy(time, F_plot, title, xlabel, ylabel, plot); plot->plotting(); } F_plot = (array double [:][:])(double [1][m_numpoints + 1])&Forces[5][0]; imag(F_mag) = F_plot; if(plot_output & F14Y) { title = "F14 y vs. Time"; xlabel = "time (s)"; if(m_uscunit) ylabel = "F14 y (lbs)"; else ylabel = "F14 y (N)"; plotxy(time, F_plot, title, xlabel, ylabel, plot); plot->plotting(); } if(plot_output & MAG_F14) {

82

title = "Magnitude F14 vs. Time"; xlabel = "time (s)"; if(m_uscunit) ylabel = "F14 (lbs)"; else ylabel = "F14 (N)"; plotxy(time, abs(F_mag), title, xlabel, ylabel, plot); plot->plotting(); } // F34 Plots F_plot = (array double [:][:])(double [1][m_numpoints + 1])&Forces[6][0]; if(plot_output & MAG_F34) { title = "Magnitude F34 vs. Time"; xlabel = "time (s)"; if(m_uscunit) ylabel = "F34 (lbs)"; else ylabel = "F34 (N)"; plotxy(time, F_plot, title, xlabel, ylabel, plot); plot->plotting(); } // F45 Plots F_plot = (array double [:][:])(double [1][m_numpoints + 1])&Forces[7][0]; real(F_mag) = F_plot; if(plot_output & F45X) { title = "F45 x vs. Time"; xlabel = "time (s)"; if(m_uscunit) ylabel = "F45 x (lbs)"; else ylabel = "F45 x (N)"; plotxy(time, F_plot, title, xlabel, ylabel, plot); plot->plotting(); } F_plot = (array double [:][:])(double [1][m_numpoints + 1])&Forces[8][0]; imag(F_mag) = F_plot; if(plot_output & F45Y) { title = "F45 y vs. Time"; xlabel = "time (s)"; if(m_uscunit) ylabel = "F45 y (lbs)"; else ylabel = "F45 y (N)"; plotxy(time, F_plot, title, xlabel, ylabel, plot); plot->plotting(); } if(plot_output & MAG_F45) { title = "Magnitude F45 vs. Time"; xlabel = "time (s)"; if(m_uscunit) ylabel = "F45 (lbs)"; else ylabel = "F45 (N)"; plotxy(time, abs(F_mag), title, xlabel, ylabel, plot); plot->plotting(); }

83

// F56 Plots F_plot = (array double [:][:])(double [1][m_numpoints + 1])&Forces[9][0]; real(F_mag) = F_plot; if(plot_output & F56X) { title = "F56 x vs. Time"; xlabel = "time (s)"; if(m_uscunit) ylabel = "F56 x (lbs)"; else ylabel = "F56 x (N)"; plotxy(time, F_plot, title, xlabel, ylabel, plot); plot->plotting(); } F_plot = (array double [:][:])(double [1][m_numpoints + 1])&Forces[10][0]; imag(F_mag) = F_plot; if(plot_output & F56Y) { title = "F56 y vs. Time"; xlabel = "time (s)"; if(m_uscunit) ylabel = "F56 y (lbs)"; else ylabel = "F56 y (N)"; plotxy(time, F_plot, title, xlabel, ylabel, plot); plot->plotting(); } if(plot_output & MAG_F56) { title = "Magnitude F56 vs. Time"; xlabel = "time (s)"; if(m_uscunit) ylabel = "F56 (lbs)"; else ylabel = "F56 (N)"; plotxy(time, abs(F_mag), title, xlabel, ylabel, plot); plot->plotting(); } // F16 Plots F_plot = (array double [:][:])(double [1][m_numpoints + 1])&Forces[11][0]; if(plot_output & F16Y) { title = "F16 y vs. Time"; xlabel = "time (s)"; if(m_uscunit) ylabel = "F16 y (lbs)"; else ylabel = "F16 y (N)"; plotxy(time, F_plot, title, xlabel, ylabel, plot); plot->plotting(); } } /*************************************************************** * plotTorque() * * Plot input torque to the quick return mechanism * as function of time. *

84

* Arguments: *plot ... pointer to plot defined * in the calling program ***************************************************************/ void CQuickReturn::plotTorque(lot *plot) { int i; double increment; string_t xlabel, ylabel, title; array double time[m_numpoints + 1], Ts[m_numpoints + 1]; increment = 2*M_PI/m_numpoints; if(m_omega[2] < 0) increment = -increment; for(i = 0; { // time time[i] Ts[i] = }

i <= m_numpoints; i++) for constant omega = (i*increment/m_omega[2]); getRequiredTorque(i*increment);

title = "Input Torque vs. Time"; xlabel = "time (s)"; if(m_uscunit) ylabel = "Torque (ft-lb)"; else ylabel = "Torque (N-m)"; plotxy(time, Ts, title, xlabel, ylabel, plot); plot->plotting(); } /*************************************************************** * displayPosition() * * This function will write a file that can be run with * qanimate to display the configuration of the mechanism. * * Arguments: theta2 ... determines the configuration ***************************************************************/ void CQuickReturn::displayPosition(double theta2, ...) { complex R[1:8]; double sliderlength = m_r[4] / 8; double sliderwidth = sliderlength / 2; string_t QnmFileName; FILE *positionpipe; int outputType = QANIMATE_OUTPUTTYPE_DISPLAY; // default display va_list ap; int vacount; va_start(ap, theta2); vacount = va_count(ap); if(vacount > 0) outputType = va_arg(ap, int); if(outputType == QANIMATE_OUTPUTTYPE_STREAM) positionpipe = stdout; else { if(outputType == QANIMATE_OUTPUTTYPE_FILE) QnmFileName = va_arg(ap, string_t);

85

else QnmFileName = tmpnam(NULL); // Try to open output file if(!(positionpipe = fopen(QnmFileName, "w"))) { fprintf(stderr, "displayPosition(): unable to open output file ’%s’\n", QnmFileName); return; } } va_end(ap); // Call calosition() to calculate everything calosition(theta2); // Create complex to make it easier to use R[1] = polar(m_r[1], m_theta[1]); R[2] = R[1] + polar(m_r[2], m_theta[2]); R[4] = polar(m_r[4], m_theta[4]); R[5] = R[4] + polar(m_r[5], m_theta[5]); R[3] = polar(m_r[3]-sliderlength/2, m_theta[4]) + polar(sliderwidth/2, m_theta[4]-M_PI/2); R[7] = polar(m_r[3]-sliderlength/2, m_theta[4]); R[8] = polar(m_r[3]+sliderlength/2, m_theta[4]); /* display position */ fprintf(positionpipe, "#qanimate position data\n"); fprintf(positionpipe, "title \"Position of the Whitworth" " Quick Return Mechanism\"\n\n"); fprintf(positionpipe, "fixture\n"); fprintf(positionpipe, "groundpin 0 0 %f %f\n\n", real(R[1]), imag(R[1])); fprintf(positionpipe, "t 0 0 \\\n"); fprintf(positionpipe, "ground %f %f %f %f\n\n", real(R[5])-sliderlength, imag(R[5])-sliderwidth/2, real(R[5])+sliderlength, imag(R[5])-sliderwidth/2); fprintf(positionpipe, "link %f %f %f %f \\\n", real(R[1]), imag(R[1]), real(R[2]), imag(R[2])); fprintf(positionpipe, "line 0 0 %f %f \\\n", real(R[7]), imag(R[7])); fprintf(positionpipe, "line %f %f %f %f \\\n", real(R[8]), imag(R[8]), real(R[4]), imag(R[4])); fprintf(positionpipe, "link %f %f %f %f \\\n", real(R[4]), imag(R[4]), real(R[5]), imag(R[5])); fprintf(positionpipe, "rectangle %f %f %f %f angle %f pen red \\\n", real(R[3]), imag(R[3]), sliderlength, sliderwidth, M_RAD2DEG(m_theta[4])); fprintf(positionpipe, "rectangle %f %f %f %f angle %f pen blue \\\n", real(R[5])-sliderlength/2, imag(R[5])-sliderwidth/2, sliderlength, sliderwidth, 0.0); fprintf(positionpipe, "text %f %f \"01\" \\\n", -sliderwidth/8, -sliderwidth); fprintf(positionpipe, "text %f %f \"02\" \\\n", (abs(m_theta[2]) > M_PI/2 && abs(m_theta[2]) < 3*M_PI/2) ?(real(R[1])+sliderwidth):(real(R[1])-sliderwidth),imag(R[1])); fprintf(positionpipe, "text %f %f \"A\" \\\n", real(polar(m_r[3]+sliderlength/4,m_theta[4])

86

+polar(sliderwidth, -M_PI/2+m_theta[4])), imag(polar(m_r[3]+sliderlength/4,m_theta[4]) +polar(sliderwidth, -M_PI/2+m_theta[4]))); fprintf(positionpipe, "text %f %f \"B\" \\\n", real(R[4]), imag(R[4])+sliderwidth/2); fprintf(positionpipe, "text %f %f \"r_5\" \\\n", real(R[4]+polar(m_r[5]/2, m_theta[5]) +polar(sliderwidth/2, M_PI/2+m_theta[5])), imag(R[4]+polar(m_r[5]/2, m_theta[5]) +polar(sliderwidth/2, M_PI/2+m_theta[5]))); fprintf(positionpipe, "text %f %f \"6\" \\\n", real(R[5]), imag(R[5])+sliderwidth); fprintf(positionpipe, "text %f %f \"r_4\" \\\n", real(polar(sliderwidth, m_theta[4]) +polar(sliderwidth/2, m_theta[4]-M_PI/2)), imag(polar(sliderwidth, m_theta[4]) +polar(sliderwidth/2, m_theta[4]-M_PI/2))); fprintf(positionpipe, "text %f %f \"r_2\"\n\n", real(R[1]+polar(m_r[2]/3, m_theta[2]) +polar(sliderwidth/3, M_PI/2-m_theta[2])), imag(R[1]+polar(m_r[2]/3, m_theta[2]) +polar(sliderwidth/3, M_PI/2-m_theta[2]))); if(outputType == QANIMATE_OUTPUTTYPE_FILE) { fclose(positionpipe); } else if(outputType == QANIMATE_OUTPUTTYPE_DISPLAY) { fclose(positionpipe); qanimate $QnmFileName remove(QnmFileName); } } /*************************************************************** * animation() * * This function will write a file that can be run with * qanimate to display an animation of the mechanism as * the second link is rotated. ***************************************************************/ void CQuickReturn::animation(...) { complex R[1:8]; double interval = 2*M_PI / (m_numpoints); double sliderlength = m_r[4] / 8; double sliderwidth = sliderlength / 2; double max, min; int i; string_t QnmFileName; int outputType = QANIMATE_OUTPUTTYPE_DISPLAY; // default display FILE *animationpipe; va_list ap; int vacount; va_start(ap, VA_NOARG); vacount = va_count(ap); if(vacount > 0)

87

outputType = va_arg(ap, int); if(outputType == QANIMATE_OUTPUTTYPE_STREAM) animationpipe = stdout; else { if(outputType == QANIMATE_OUTPUTTYPE_FILE) QnmFileName = va_arg(ap, string_t); else QnmFileName = tmpnam(NULL); // Try to open output file if(!(animationpipe = fopen(QnmFileName, "w"))) { fprintf(stderr, "animation(): unable to open output file ’%s’\n", QnmFileName); return; } } va_end(ap); sliderRange(max, min); R[1] = polar(m_r[1], m_theta[1]); /* Write header part */ fprintf(animationpipe, "#qanimate animation data\n"); fprintf(animationpipe, "title \"Animation of the Whitworth Quick" " Return Mechanism\"\n\n"); fprintf(animationpipe, "fixture\n"); fprintf(animationpipe, "groundpin 0 0 %f %f\n\n", real(R[1]), imag(R[1])); fprintf(animationpipe, "ground %f %f %f %f \n\n" ,min-sliderlength ,m_r[7]-sliderwidth/2 ,max+sliderlength ,m_r[7]-sliderwidth/2); fprintf(animationpipe, "animate restart\n"); for(i=0; i < m_numpoints; i++) { // Call calosition() to calculate everything calosition(i*interval*m_omega[2]/abs(m_omega[2])); // Create complex to make it easier to use R[2] = R[1] + polar(m_r[2], m_theta[2]); R[4] = polar(m_r[4], m_theta[4]); R[5] = R[4] + polar(m_r[5], m_theta[5]); R[3] = polar(m_r[3]-sliderlength/2, m_theta[4]) + polar(sliderwidth/2, m_theta[4]-M_PI/2); R[7] = polar(m_r[3]-sliderlength/2, m_theta[4]); R[8] = polar(m_r[3]+sliderlength/2, m_theta[4]); /* Write animation part */ fprintf(animationpipe, "link %f %f %f %f \\\n", real(R[1]), imag(R[1]), real(R[2]), imag(R[2])); fprintf(animationpipe, "line 0 0 %f %f \\\n", real(R[7]), imag(R[7])); fprintf(animationpipe, "line %f %f %f %f \\\n", real(R[8]), imag(R[8]), real(R[4]), imag(R[4])); fprintf(animationpipe, "link %f %f %f %f \\\n",

88

real(R[4]), imag(R[4]), real(R[5]), imag(R[5])); fprintf(animationpipe, "rectangle %f %f %f %f angle %f pen red \\\n", real(R[3]), imag(R[3]), sliderlength, sliderwidth, M_RAD2DEG(m_theta[4])); fprintf(animationpipe, "rectangle %f %f %f %f angle %f pen blue \\\n", real(R[5])-sliderlength/2, imag(R[5])-sliderwidth/2, sliderlength, sliderwidth, 0.0); fprintf(animationpipe, "t 0 0 \\\n"); fprintf(animationpipe, "stopped \\\n"); fprintf(animationpipe, "text %f %f \"01\" \\\n", -sliderwidth/8, -sliderwidth); fprintf(animationpipe, "text %f %f \"02\" \\\n", (abs(m_theta[2]) > M_PI/2 && abs(m_theta[2]) < 3*M_PI/2) ?(real(R[1])+sliderwidth):(real(R[1])-sliderwidth),imag(R[1])); fprintf(animationpipe, "text %f %f \"A\" \\\n", real(polar(m_r[3]+sliderlength/4,m_theta[4]) +polar(sliderwidth, -M_PI/2+m_theta[4])), imag(polar(m_r[3]+sliderlength/4,m_theta[4]) +polar(sliderwidth, -M_PI/2+m_theta[4]))); fprintf(animationpipe, "text %f %f \"B\" \\\n", real(R[4]), imag(R[4])+sliderwidth/2); fprintf(animationpipe, "text %f %f \"r_5\" \\\n", real(R[4]+polar(m_r[5]/2, m_theta[5]) +polar(sliderwidth/2, M_PI/2+m_theta[5])), imag(R[4]+polar(m_r[5]/2, m_theta[5]) +polar(sliderwidth/2, M_PI/2+m_theta[5]))); fprintf(animationpipe, "text %f %f \"6\" \\\n", real(R[5]), imag(R[5])+sliderwidth); fprintf(animationpipe, "text %f %f \"r_4\" \\\n", real(polar(sliderwidth, m_theta[4]) +polar(sliderwidth/2, m_theta[4]-M_PI/2)), imag(polar(sliderwidth, m_theta[4]) +polar(sliderwidth/2, m_theta[4]-M_PI/2))); fprintf(animationpipe, "text %f %f \"r_2\"\n\n", real(R[1]+polar(m_r[2]/3, m_theta[2]) +polar(sliderwidth/3, M_PI/2-m_theta[2])), imag(R[1]+polar(m_r[2]/3, m_theta[2]) +polar(sliderwidth/3, M_PI/2-m_theta[2]))); } if(outputType == QANIMATE_OUTPUTTYPE_FILE) { fclose(animationpipe); } else if(outputType == QANIMATE_OUTPUTTYPE_DISPLAY) { fclose(animationpipe); qanimate $QnmFileName remove(QnmFileName); } }

89

Index ˜CQuickReturn(), 17, see CQuickReturn animation(), 17, 19 CQuickReturn, 17 ˜CQuickReturn(), 19 animation(), 17, 19 CQuickReturn(), 17, 21 displayPosition(), 17 getAngAccel(), 17, 21 getAngPos(), 17, 22 getAngVel(), 17, 23 getForces(), 17, 24 getPointAccel(), 17, 25 getPointPos(), 17, 26 getPointVel(), 17, 27 getRequiredTorque(), 17, 28 plotAngAccel(), 17, 29 plotAngPos(), 17, 31 plotAngVel(), 17, 33 plotCGaccel(), 17, 35 plotForce(), 17, 39 plotSliderAccel(), 17, 41 plotSliderPos(), 17, 43 plotSliderVel(), 18, 44 plotTorque(), 18, 46 setAngVel(), 18, 47 setForce(), 18, 48 setGravityCenter(), 18, 48 setInertia(), 18, 49 setLinks(), 18, 50 setMass(), 18, 51 setNumPoints(), 18, 51 sliderAccel(), 18, 52 sliderPos(), 18, 53 sliderRange(), 18, 54 sliderVel(), 18, 55 uscUnit(), 18, 56 CQuickReturn(), 17, 21

getPointPos(), 17, 26 getPointVel(), 17, 27 getRequiredTorque(), 17, 28 plotAngAccel(), 17, 29 plotAngPos(), 17, 31 plotAngVel(), 17, 33 plotCGaccel(), 17, 35 plotForce(), 17, 39 plotSliderAccel(), 17, 41 plotSliderPos(), 17, 43 plotSliderVel(), 18, 44 plotTorque(), 18, 46 setAngVel(), 18, 47 setForce(), 18, 48 setGravityCenter(), 18, 48 setInertia(), 18, 49 setLinks(), 18, 50 setMass(), 18, 51 setNumPoints(), 18, 51 sliderAccel(), 18, 52 sliderPos(), 18, 53 sliderRange(), 18, 54 sliderVel(), 18, 55 uscUnit(), 18, 56

displayPosition(), 17 getAngAccel(), 17, 21 getAngPos(), 17, 22 getAngVel(), 17, 23 getForces(), 17, 24 getPointAccel(), 17, 25 90