Unique Pendulum Wave and Release Mechanism

40,976

127

10

Introduction: Unique Pendulum Wave and Release Mechanism

This is the first half of a two-part instructable. This first half deals primarily with the math (algebra, trigonometry, geometry) involved in creating a pendulum wave and the release, deriving the pendulum wave design and dimensions. Part 2 will detail the process of constucting the pendulum wave. Although the math in this section is fairly easy, it can be very tedious at times. If you have a hard time following the math or even choose to skip the math altogether, you can still build the pendulum wave shown. I have all the necessary models and dimensioned drawings posted in steps 8 and 9, so no worries. :)

Below are a few pictures of the pendulum wave and release mechanism.

Pendulum wave at rest: Release mechanism beginning to collect pendulums: Just before releasing the wave:  Pendulum waves are simply a series of pendulums that are pulled back, then released at some angle(s). If the lengths and angles are just right, then each pendulum will cycle back and forth between its release position at a slightly different frequency than its neighbor. This results in some pretty neat alternating waveforms. Wave pendulums make great desktop toys for your rich dads, and have even been known to keep children quiet for up to 60 seconds. In addition, the can make nice props in classroom settings for illustrating physics principles such as potential and kinetic energy, air resistance, aliasing, and more.

About the Uniqueness of My Pendulum Wave

To my knowlege, the design for the pendulum wave in this instructable is unique for a number of reasons. First, the wave is intended to be viewed primarily from the top rather than a side (although it looks cool from the side, too). Consequently, it is important that the amplitude of each pendulum appears the same from above. While this requires a more complex release mechanism (instead of the typical flat board), it also leads to a very cool look. As far as I am concerned, a little extra coolness is worth a little extra effort, any day.

Release Mechanism

In order to release the pendulums at the varying release angles required for a top view, I designed a very original release mechanism. Each arm of the mechanism grabs its respective pendulum at a different time. This creates a wave effect as the mechanism curves up and around the pendulums. Once all pendulums have been selected and brought to their proper positions, the mechanism releases them all at the same time, creating the pendulum wave. The math for this is a little tedious, but the concept is pretty straightforward.

Here is a very crappy SolidWorks video demonstrating two arms of the release module in action:

Final Design

Here is an animation of the final design in action. Air resistance was neglected in this animation, which is why no damping occurs. However, since air resistance will not affect the period of the pendulum wave, that is fine.

Step 1: Where the Waves Come From

As I touched on already, a wave pendulum is a series of pendulums with incremented frequencies. One way to think of the pendulum wave is as a series of points used to sample a wave of increasing frequency. This effect is shown in the video below, which I created using Matlab:

The Nyquist Sampling Theory (NST) states that to sample a wave of a given frequency, one needs to measure points at one-half cycle of that frequency. Or, for a given frequency f, one needs points spaced 1/(2*f) units of time apart (since T = 1/f). When the number of sampling points becomes less than the number required by the NST, aliasing occurs. This aliasing is the reason for the alternating waveforms present in a pendulum wave.

Step 2: Choosing the Wave

In order to get a nice, smooth pendulum wave, the frequency of each consecutive pendulum should evenly increase. For my wave, I chose 18 pendulums. I chose value this because during a pendulum wave sequence, about one-third and two-thirds of the way through a complete cycle, the pendulums split into three groups. Halfway through the cycle, the pendulums split into two groups. Thus, to have an even number of pendulums in each group, I chose a value that was a multiple of both 2 and 3. 12 pendulums wasn't enough for me, so I chose 18. I set the frequency of my first to 57 cycles per minute, and made each consecutive pendulum's frequency increase by 1 cpm up to 74 cycles per minute. These values are arbitrary (choose whatever looks best to you). Just make sure that frequencies are incremented by a constant value.

In order to make sure that everything looked right, I made a function in Matlab to animate a plot of a pendulum wave. Below are the function (PWT.m) and a video of what the wave should look like from the top view.

In addition to animating a plot of the wave, this finction also records a video. Due to everyone's systems running at different speeds, the "pause()" function in the script will almost inevitably need to be adjusted to give an accurate representation of the animated wave by accounting for computer delay. The video recorder function, however, will record at the actual speed, so I suggest using it to fine tune your pendulum wave rather than the animation.

To generate the movie shown above, after the function is copied into your matlab directory, type:

>> PWT(18,57/60,1/60,60)

To better understand the function, type

>> help PWT()

in Matlab after the function has been imported.

Step 3: The Pendulum Period Equation

With the periods of each pendulum selected, the next step is to figure out the lengths and release angles of the pendulums. In order to do this, we'll take a look at some equations.

The equation for the period of a pendulum is given by

T=2*pi*sqrt(L/g)*K(θ).

Here is a figure demonstrating L and θ. R and S are variables for the release mechanism, to be solved later. Explanation of terms:

pi = 3.1415926..., etc.

L = the distance from the top of the string to the center of mass (the center of the pendulum bob, assuming the string is massless)

g = the acceleration due to gravity (approximately 9.81 m/s^2 or 32.17 ft/s^2)

θ =  the release angle of the pendulum (the angle between the string when  the pendulum is at rest and when the pendulum is released).

K(θ) = a correcting function that takes into account the effects of the release angle on the period. It is an infinite power series, but the successive terms grow very small very rapidly. A few terms suffice to get an accurate approximation.

K(θ) = 1 + θ^2/16 + 11*θ^4/3072+173*θ^6/737280+...

For angles significantly less than 1 radian, K(θ) approaches 1 and can be neglected. To test whether an angle is "significantly less" than 1 radian, take the sine of the angle in question, then compare it to the original angle. If both the angle and the sine of the angle are nearly the same, then K(θ) can likely be neglected without greatly affecting the performance of the pendulum wave.

Assuming that the release angles are small and K(θ) can be neglected, then the only variable in the equation that must be solved for is L.

As somewhat of a perfectionist, I am against neglecting K(θ), even for smaller angles. I decided to do go the harder of the two routes, suffering the lengthier calculations for (hopefully) greater accuracy and a better-performing pendulum wave.

Why do some pendulum waves that ignore K(θ) yet have large release angles still look so good?

Here's a random example I found on YouTube:

In this example, all angles are constant, and thus K(θ) is also constant. As a result, all pendulum periods are equally wrong, making all of them look right relative to each other. For my pendulum wave, K(θ) will not be constant since the release angles vary. Because of this, not taking K(θ) into account will definitely affect things.

Step 4: More Math: Calculating Lengths of Pendulums

So far, we have the required periods needed for each pendulum. We also have one equation (from the previous step) which describes the period as a function of constants and two variables, L and θ:

T=2*pi*sqrt(L/g)*K(θ).

Since I want to view my pendulum wave from the top, and need the amplitudes of each wave to appear equal from that view, I further have the constraint:

L*sin(θ) = C

where C is the constant amplitude for all waves.

Here is a figure demonstrating this simple concept: My method for solving the lengths of the pendulums was as follows:

1) I started with pendulum #18 in the series (the pendulum with the highest frequency and shortest length), choosing a the value that I wanted for the max release angle of the entire series. I chose pi/4 radians, or 45 degrees. All other release angle will be smaller than this value.

2) I plugged this value for the release angle into the pendulum equation, then solved L for the required period.

3) With L and θ now solved, I calculated L*sin(θ) = constant.

4) For the 17 pendulums remaining, I used Excel's solver add-in to set the period equation equal to the required period by changing the release angle when the length = C/sin(θ). I have an image of this process attached. To learn more about solver, click here. Step 5: Release Mechanism Math - Part 1

In order for the release mechanism to work, each release has to do two things: grab the pendulum, then release at the same time when all the pendulums are the same distance (Lsinθ) away from the support beam.

Before dealing with the timing for each release, let's figure out the geometry first. We need to find the length of the release arm and the horizontal distance between the release arm and the pendulum attachment point.

The pendulum scenario is depicted in the diagram below: In the figure,

Lis the distance from the pendulum support beam to the center of the pendulum bob. This value is known for each pendulum.

W is the horizontal distance from the pendulum attachment point to the center of the pendulum bob at release (L*sin(θ), anyone?).

R is the distance from the arm attachment point to the underside of the pendulum bob. This value is very unknown.

D is the distance that I want the arm to extend past the bob when the arm collects it. For my pendulum wave, I chose 0.5".

S is the horizontal distance from the pendulum attachment point to the arm attachment point. This value is also very unknown.

C is the vertical distance from the arm attachment point to the bottom of the pendulum bob. This value is selected arbitrarily (I chose 4").

H is the vertical distance the arm attachment to the bottom of the pendulum bob at release. From inspection, this value is L-L*cos(θ)+C.

Solving for R and S

We define the arm by two values: the length of the arm (R+D) and its required offset (S). Lets solve for these values in terms of the driving (known) variables.

For starters, we know that the distance W is equal the the sum of S and the horizontal distance between S and the pendulum release point. By using Pythagorean's theorem, we can say that

W=SQRT(R^2-C^2)+SQRT((R+D)^2-H^2)

Squaring both sides of this equation and isolating zero gives the quadratic equation:

((W^2-R^2+C^2-(R+D)^2+H^2)^2)/4-(R^2-C^2)((R+D)^2-H^2)=0

This is a painful calculation to solve by hand, so I suggest using a program like Matlab. Here is how I solved this equation in Matlab for R:

>> syms R C H W D                                                                                               % Define variables
>> solve([W^2-R^2+C^2-(R+D)^2+H^2]^2/4-(R^2-C^2)*((R+D)^2-H^2),R)                         % Solve for R

ans =

(W*(C^4 - 2*C^2*D^2 - 2*C^2*H^2 + 2*C^2*W^2 + D^4 - 2*D^2*H^2 - 2*D^2*W^2 + H^4 + 2*H^2*W^2 + W^4)^(1/2) - C^2*D + D*H^2 + D*W^2 - D^3)/(2*D^2 - 2*W^2)

-(W*(C^4 - 2*C^2*D^2 - 2*C^2*H^2 + 2*C^2*W^2 + D^4 - 2*D^2*H^2 - 2*D^2*W^2 + H^4 + 2*H^2*W^2 + W^4)^(1/2) + C^2*D - D*H^2 - D*W^2 + D^3)/(2*D^2 - 2*W^2)

Note that Matlab gives us two answers because we solved a quadratic. Which solution do we choose? To decide, plug in reasonable, positive values into both expressions and see which solution gives us a reasonable, positive answer (the second equation).

Thus,

R = -(W*(C^4 - 2*C^2*D^2 - 2*C^2*H^2 + 2*C^2*W^2 + D^4 - 2*D^2*H^2 - 2*D^2*W^2 + H^4 + 2*H^2*W^2 + W^4)^(1/2) + C^2*D - D*H^2 - D*W^2 + D^3)/(2*D^2 - 2*W^2).

Adding D to this value (as shown in the diagram) gives us the diagonal length of the arm from the arm attachment point to the bottom of the pendulum. This is because the arm will be a rectangle rather than a line.

With R solved, we can now use Pythagorean Theorem to solve for S:

S = SQRT(R^2-C^2).

Simple enough.

Note that the diagonal distance from the center of the arm pin location to the pendulum at release is R+D. The actual length of the arm from the pin is

R_actual = SQRT((R+D)^2-t^2/4)

where t is the width of the arm.

Step 6: Release Mechanism Math - Part 2

So far, we have the dimensions that we need to ensure that each arm grabs the pendulum at the right location and releases it at the right location. Now, we need to make sure that all arms release all pendulums at the same time.

After doing a little sketching, I came up with a simple mechanism that works. Other than the arm, there are two components in this mechanism. To mess with the electrical engineers, I will call them the rotor and stator. If the picture doesn't do it justice, here's a breakdown of how the thing works:

Each arm (red) has a slot cut into its side. The rotor (green) has two dowels, one on each side, which extend into the slots of both neighboring arms. It is pinned to the backs of two stators (blue). All rotors are attached to a dowel at a constant distance from the stator pin. Thus, when one rotor moves, all rotors move at the same angular velocity. With the right dimensions for the rotors and stators (the arm dimensions have already been calculated), all pendulums can be released at the same time.

The setup for this problem is easier than it might sound.

Solving for z and Q We need to find values for z and Q such that at a given angle, Ï, the tip of the arm is a horizontal distance L*sin(θ) from the pendulum attachment point.

We already have S from the previous problem. J is an arbitrary value (it determines the width of the pendulum wave frame).
R_c is a value that we will solve for later. It is the distance from the pendulum release point to the line S. It runs parallel to z.

To solve this problem, we will use 3 equations:

z/h = R_c/H
Q*sin(Ï) = h
J = Q*cos(Ï) + SQRT(z^2-h^2)

We solve:

z/h = R_c/H => h = z*H/R_c;

Q*sin(Ï) = h => Q = z*H/(R_c*sin(Ï));

J = Q*cos(Ï) + SQRT(z^2-h^2) => J = z*H*cos(Ï)/(R_c*sin(Ï)) + SQRT(z^2-(z*H/R_c)^2)
=> J = z*H*cot(Ï)/R_c + z*SQRT(R_c^2-H^2)/R_c => J = (z/R_c)*[H*cot(Ï) + SQRT(R_c^2-H^2)]
=> z = J/(R_c*(SQRT(R_c^2-H^2) + H*cot(Ï)))

And

Q = z*H/(R_c*sin(Ï))

Solving for R_c R_c is the sum of s (not big S from the previous problems) and the edge length of the arm (not shown) beginning at the pin. As mentioned on the previous step, the actual length of the arm is different than the value R we calculated previously. Additionally, the angle Ï is different than the angle Ï just calculated above. Sorry for any confusion.

The actual length, by Pythagoras, is:

R_actual= SQRT((R^2-t^2/4)

where t is the thickness of the arm.

So,

R_c = R_actual + s.

In order to find s, we need to find the value for α, the angle opposite of s.

From the diagram, we see that α = 180 - (Ï + 90 - β/2) => α = 90 - Ï + β/2

where Ï = asin(h/R), and β/2 = asin(t/(2*r)).

So, α = 90 - asin(h/R) + asin(t/(2*r)).

tan(α) = 2*s/t => s = t*tan(α)/2 => s = t*tan(90 - asin(h/R) + asin(t/(2*R)))/2

Thus,

R_c = SQRT(R^2-t^2/4) + t*tan(90 - asin(h/R) + asin(t/(2*R)))/2

For my pendulum wave, I chose the release thickness (t) to be 1/2".

We designed each arm in the release mechanism to let go of its respective pendulum when the rotor is at a constant angle (Ï). Thus, each rotor can be coupled to all other rotors. The implication of this is that since all rotors (when coupled) have the same angular velocity, and all pendulums will be released when the rotor is at angle Ï, all pendulums will be released at the same time.

Step 7: Designing the Frame

Below is the frame design I chose for the pendulum wave. We now have all the geometry that we need in terms of driven dimensions to design the frame. This is 3rd grade math (addition, subtraction). From the figure, we see that Leg Height must be

Leg Height = L + c + D/2 + t/2 - W/2 + B/2 - W

or

Leg Height = L + c + D/2 + t/2 - 1.5*W + B/2

where

D is the diameter of the pendulum bob,
t is the arm/rotor/stator thickness,
W is the thickness of the Leg/Width frame supports, and
B is the block height.

For my pendulum wave, I chose the frame beams to have 1"x1" cross sections, so W was 1". I chose each block (B) to be 1.5" in height. This results in:

Leg Height = L + c + D/2 + t/2 - 0.75

For the shorter of the two legs, L is obviously the shortest pendulum length (pendulum #18). For the longer, L corresponds to the longest pendulum (#1).

No explanation needed for the base width:

Base Width = 2*(S+J+t/2+0.5) = 2*(S+J) + t + 1

I chose to use a series of eighteen 0.5"x1"x1.5" blocks to support the pendulums. The nice thing about this is that during construction, each block can be manually adjusted to its required position before being secured. It's a more forgiving approach than trying to cut the entire beam from wood, and looks cooler than using a horizontal beam. With 1"x1" cross-sectional beams, this results in the entire pendulum wave being exactly 20" long, with each short and long leg pair being connected by 18" long beams (1/2"x1"x18" and 1"x1"x18"). The thinner of the two beams backs the release mechanism.

For the pendulums, I chose 1/2" diameter steel balls, giving a 1/2" gap between each pendulum (plenty of clearance).

I modeled the Pendulum Wave in SolidWorks and have included all files. The dimensions in the SolidWorks models that are dependent on calculated dimensions incorporate design tables. These design tables link to external Excel files which contain variable dimensions for each configuration for that part. In turn, the Excel files each link to the same master Excel file. In this master file I have included all calculations and dimensions covered in this instructable. This setup--using design tables to control part dimensions--makes the assembly very customizable and saves an incredible amount of time, especially when modifications are required. Rather than manually changing the dimensions in each model of the assembly, all that needs to be done is change a driving dimension in the master spreadsheet. When this happens, all dimensions in the model automatically update (after opening and saving the part files).

For each type of part in the SolidWorks assembly, only one actual part file exists. This is accomplished through the use of configurations. Instead of having 96 unique part files in the assembly, there are 11 with multiple configurations driven by the master Excel file (excluding the .25" dowels which are not modeled). Efficient, no?

The master Excel file works independently of the SolidWorks files. You can use it to calculate all the dimensions you need. Driving dimensions are highlighted in orange, while dimensions which are linked to the design tables (outputs) are highlighted in green. Again, all calculations covered in this instructable are solved in the master spreadsheet.

Attached is a zipped folder containing the assembly, part files, Excel tables, and master Excel spreadsheet. The excel tables reference the master Excel file using absolute references, please be sure to change them to your local directory upon upening. Similarly, the design tables require the full path to the linked Excel sheet, so after opening the part files, you will need to link the excel table to part file's design table. SolidWorks should bring up a dialogue box for you to find them. The Excel files have the same names as their corresponding part file, minus the extension.

Step 9: Design Drawings and Construction Suggestions

Attached are the Bill of Materials and design drawings for all parts excluding 0.25" diameter dowels. This document includes all configurations for the rotor, stator, and arm. With these drawings, you can build the entire pendulum wave if you just follow the dimensions and reference the master Excel file listed on the previous step for pendulum lengths.

If you decide to go ahead and begin building your wave pendulum before I release part 2, here are a few suggestions for construction:

1. MAKE THE DIMENSIONS AS ACCURATE AS POSSIBLE!
See above. There is nothing that can ruin your day like getting everything assembled, then finding that one pesky component that is slightly too long and throws everything else off.

2. Connecting the frame components, blocks, and block supports:
Drill .25" holes, then connect components with dowels and wood glue. This looks so many levels nicer than screws or nails, and greatly minimizes the chance of splitting the wood. Use common sense for hole/dowel placement.

3. Getting the pendulums' lengths correct:
Once the frame is in place, I suggest building a calibration block for getting pendulum lengths correct. Make the block as thick as the distance from the bottom of the pendulum bobs to the ground needs to be. Pull each pendulum straight down until it just comes in contact with the block, then lock the threads in place, possibly by tapping the tip of a toothpick into the thread holes.

4. Fabricating the release arm:
When fabricating the arms, it is critical that their lengths are just right. Otherwise, the pendulums won't be released at the same time and all your work will be ruined. Your misery will know no bounds. I suggest that, after getting the pendulum lengths correct, you make the release arms slightly too long. Then, gently sand down the tips of the arms until each pendulum releases exactly when it is supposed to.

6. Attaching the release mechanism to the frame:
This is a topic I did not cover in the instructable. I suggest drilling holes through the back of the "release backing" into the stators, then using 0.25" dowels and wood glue. Also, put a dowel through the width beams and the rotor/stator joints on either side of the release mechanism.

7. Tag the components.
Several of the components are very similar in size, but have one or two dimensions which are slightly different (arms, rotors, stators). Getting these components jumbled up could potential be a pain, to say the least.

I hope you enjoyed my first instructable as much as I did writing it. I apologize if anything was unclear. If it was, feel free to ask me anything in the comments or by message. Thanks!

Stay tuned for Part 2: Assembly. Coming later this summer 2012! I will post a link here when it is ready.

References:

I found the following document  helpful in understanding the pendulum equations:

http://fy.chalmers.se/~f7xiz/TIF080/pendulum.pdf.

It also included some information on air resistance, if you want to take things a step further. Participated in the
Make It Real Challenge Participated in the
Education Contest