Tri-Output Mechanism

The motion of spinning can be amazing. Through gears and axles, it can control multiple outputs at once. However, with limited resources at hand, I thought it would be interesting to experiment with the abilities of spinning through one input. What if a single motor could power multiple independent outputs? I thought it would be interesting to give it a try!

I hope these tools are easily accessible for you. Have fun! :)

1. DC motor (in hindsight, using a 3-6v DC motor for this project wasn't a good idea. Higher torque would have been a better decision, since simply taping the axle to the cardboard gear was enough to stop the 3-6v motor from spinning. Instead, I recommend a DC gear motor for easier DIY use :D)
2. 9v battery to power the motor
3. 9v battery connector
4. Breadboard
5. Jumper wires
6. Arduino Uno
7. USB port (that can transfer data)
8. L293D h-bridge
9. Compass (geometry)
10. Ruler
11. Glue / tape
12. Toothpicks (lots of them. They'll act as the gear axles!)
13. Cardboard. Even more cardboard!

The easiest step to examine first was using one input for two outputs. Putting two gears next to each other lets both spin in place. Place a gear (axle) through a slot, and it can move left and right in a circular motion, assuming the slot traces the path made by the gear. When the gear that stays in the same place----gear A----spins in a certain direction, the other gear, gear B, spins in the other direction. But with the freedom of movement provided by the slot, gear B as a whole moves along the direction that gear A is spinning. Limiting the area of this slot makes it so that gear B no longer moves along with gear A, but still spins! Placing output #1 and output #2 near the rightmost or leftmost position of gear B on the slot (so that B and the outputs can mesh and translate rotational motion) means that by changing the direction of gear A, we can use gear B to power 2 different outputs.

While this design is limited to only two outputs, it's a start!

(Using this concept, we can use our DC motor to power gear A)

The Geneva Mechanism is commonly used for rotation by increments, instead of constant rotation from meshing gears. The cam (the part with the pin) constantly spins. The gear (with the gaps/slots) stays still until the cam's pin goes smoothly through the slot, rotating the gear for a certain number of degrees before the pin comes out of contact. This is an interesting way to translate rotational motion, and its design comes with useful flexibility! The gear spins a certain number of degrees based on the number of slots. This can be represented by the equation y = 360/x, with 360 being a full rotation, x being the number of slots, and y being the number of degrees the gear would turn for every full rotation of the cam. For example, if I implemented 3 slots, I would have the gear rotate 120 degrees (360/3) every time the cam made a full rotation.

For this project, the number of slots is equivalent to the number of outputs.

Let's combine steps 1 and 2 to create the main mechanism behind our multi-independent-output design!

In step 1, I covered how we could use one motor to control outputs #1 and #2. We can use output #2 as a way to spin the cam. Controlling the number of rotations means controlling the rotational position of the Geneva gear, as covered in step two. Think back to step 1, about how two meshing gears in place only translate rotational motion, and not the position of the gears. If we connected an extending piece of cardboard to the Geneva gear and attached two new gears on top, if this extending piece were to move along with the steps of the Geneva drive, we would be able to translate a spinning motion to three different positions. You can imagine what you will put in these imaginary positions----maybe more gears----robotic claws?----spinning dust cleaners----you can imagine the possibilities!

But what's the point of output #1, then? If there were no other output, the DC motor would only be spinning the cam. The DC motor can thus control the cam in two ways: spinning left and right, or stopping. If we continued spinning the motor, the cam would continue to spin, making the Geneva gear spin, making the extending piece and gears spin (you get the gist >:D)...but the point of the Geneva mechanism was for this extended piece to move at incremented steps, stop, and spin in that position...whereas without another output, if we stopped, so would the gears on the extended piece, so that it would be impossible to translate the spinning motion at a stagnant position.

Therefore, we will use output #1 to combat these issues. We can place output #1 in such a way that it is possible for it to mesh with both gear B and one of the gears on the extending piece. First, the DC motor would spin towards the direction of output #2, to spin the cam until the Geneva gear is in the desired position. Then, it would spin towards the direction of output #1, to spin #1's gear and thus spin the gears on top of the extending piece. By making sure the extended piece and Geneva gear were firmly connected to the (same) axle, whereas the gears on the extended structure were loosely so, independently spinning the gears and then the Geneva drive was possible.

This has a similar layout to the design plans. This requires:

1. 6 gears!
2. A flat cardboard surface!
3. The DC motor!
4. 4 toothpicks!
5. And more!

There are outer rings taped down onto the gears, as to keep the gears flat on the surface while still having the ability to spin and rotate! Multiple layers of cardboard are used as to carefully layer the components of the design.

This illustrates the concept of the extended cardboard, acting as stability for the two main gears to transfer rotational motion in a variety of positions. Note that the gear spun by output A should be lower than the central gear, as to not interfere with the incremented rotation. A solution could be to make the central gear a bit thicker than the rest.

Remember that the DC motor spins gear A!

Here, I will demonstrate using the design autonomously----but expanding this project using IR receivers/remotes or Bluetooth could be cool! For example, pressing a different button indicating a unique output would be interesting. Unfortunately, as I don't have the materials, I hope this will suffice. :)

const int forwardPin = 8;

const int backwardPin = 12;

const int enablePin = 6;

void setup() {

pinMode(forwardPin,OUTPUT);

pinMode(backwardPin,OUTPUT);

pinMode(enablePin,OUTPUT);

}

void loop () {

analogWrite(enablePin, 255);

// Using analog Write and enablePin allows you

//to control the speed of the motor from a

//range of 1-255, with 255 being the fastest.

digitalWrite(forwardPin,HIGH);

digitalWrite(backwardPin,LOW);

// ForwardPin HIGH and backwardPin LOW makes the

//motor spin forward.

// ForwardPin LOW and backwardPin HIGH makes the

//motor spin backward.

delay(500); //There is no instruction for the motor to stop

//spinning, so the motor continues to spin for this

//amount of time in milliseconds.

digitalWrite(forwardPin,LOW);

digitalWrite(backwardPin,LOW); //This stops the motor.

delay(2000);

}

Just as a note, to determine the amount of time you want the motor to spin, you should measure the amount of time it takes for the cam to make a full rotation.

This may not be the most sightly project. Granted, it looks like layers of cardboard and toothpicks----along with the jumble of electronics----taped and wired together. It is exactly that.

>:)

But it's amazing how I could find so many opportunities in the simplicity of spinning. In attempting to design something more from the spinning motion, I learned new mechanisms, and how to use them to create something new. For that, I appreciate how this contest allowed me to expand my boundaries through the materials I had at home. I hope you had fun, and I want to thank you for reading.