Category Archives: Rube Goldberg Challenge

Jack in the Box

This is the final version of our component of the Rube Goldberg Challenge, It is a “Jack in the Box” style foil crane that we controlled using a servo Motor and a box that we constructed out of paper. The movement of the box caused by the crane lifting will trigger a proximity sensor which was the input of our neighbors.

Our input is a light sensor which was triggered by our neighbors LED output.

v bnnjhbm,kbj

#include <Servo.h>
int photocellPin = A0;
int light = 0;
Servo jitbservo;
int pos = 0;
void setup() {
// put your setup code here, to run once:
void loop() {
// put your main code here, to run repeatedly:
light = analogRead (photocellPin);
light = light/2;
Serial.println (light);
if (light > 410)
{pos = 0; pos >= 90; pos += 1;
{pos = 90; pos <= 0; pos -=1;

Rube Goldberg – Ethan and Sama


As arranged with other groups, our input and outputs were both going to be servos. Because of the more simple nature of our input and output, we wanted to build something really cool for the in-between stage. After more than an hour and a half of brainstorming and ideating, we came up with the idea of doing a sailboat race inspired and powered by a blower fan, seen below in its final position, that we found on the discard shelf.

Blower Fan

Build Process

We started by figuring out what we could use as a water basin. After testing a couple different things we found on the junk shelf, we settled on my Arduino case as it had waterproof plastic ‘lanes’ in the case that we could use as channels for each boat. Next we started creating boats that could both float on the water and be properly pushed by the air. This was an especially long and laborious process, as it seemed that any design we came up with either sank, flipped over in the wind, or otherwise stopped working in some way. Eventually we came up with the boats seen below.


Concurrently with the boat development that Sama and a few helpers we found around the shop (namely Zoe) were working towards, I was working on the electronic components of the project. This included two ultrasonic sensors, LEDs, and a servo. The ultrasonic sensors were in place to determine the winner of the boat race and light up the corresponding LED before triggering the next stage of the race. The plan was originally to use one ultrasonic sensor to detect both boats, but it turned out to be quite inaccurate so we used two sensors. The final sensor and LED configuration can be seen below.

Ultrasonic Sensors

The programming was a fairly simple comparison of the two values, triggering the next stage of the Rube Goldberg if it detects one of the two boats to be close enough.

//Library Includes
#include <Servo.h>

//Pin Declaration
const int trigPin1 = 9;
const int echoPin1 = 10;
const int trigPin2 = 7;
const int echoPin2 = 8;
const int LED2 = 12;
const int LED1 = 13;
const int servoOuput = 6;
Servo servo;

//Variable Declaration

long duration;
int boat1Distance;
int boat2Distance;
bool raceOver = false;

int servoAngle = 0;

void setup() {
  //Ultrasonic Pins
    pinMode(trigPin1, OUTPUT); // Sets the trigPin1 as an Output
    pinMode(echoPin1, INPUT); // Sets the echoPin1 as an Input
    pinMode(trigPin2, OUTPUT); // Sets the trigPin1 as an Output
    pinMode(echoPin2, INPUT); // Sets the echoPin1 as an Input
  //Servo Attatchment
  //Open Serial Port
    Serial.begin(9600); // Starts the serial communication
  //Put servo in base position

void loop() {
    //BOAT ONE Distance Sensing
        // Clears the trigPin1
        digitalWrite(trigPin1, LOW);
        // Sets the trigPin1 on HIGH state for 10 micro seconds
        digitalWrite(trigPin1, HIGH);
        digitalWrite(trigPin1, LOW);
        // Reads the echoPin1, returns the sound wave travel time in microseconds
        duration = pulseIn(echoPin1, HIGH);
        // Calculating the distance
        boat1Distance= duration*0.034/2;
     //BOAT TWO Distance Sensing
        // Clears the trigPin2
        digitalWrite(trigPin2, LOW);
        // Sets the trigPin2 on HIGH state for 10 micro seconds
        digitalWrite(trigPin2, HIGH);
        digitalWrite(trigPin2, LOW);
        // Reads the echoPin2, returns the sound wave travel time in microseconds
        duration = pulseIn(echoPin2, HIGH);
        // Calculating the distance
        boat2Distance= duration*0.034/2;
      Serial.print("Boat 1 Distance: ");

      Serial.print("Boat 2 Distance: ");
      //If the race is over
        if(boat1Distance < 9 || boat2Distance < 9 ){
          raceOver = true;
          if(boat1Distance < boat2Distance){
            digitalWrite(LED1, HIGH);
            Serial.println("Boat 1 Wins!");
            digitalWrite(LED2, HIGH);
            Serial.println("Boat 2 Wins!");
   }//End if race not over

/* Sources for Code:
Ultrasonic Sensor HC-SR04 and Arduino Tutorial

Finally we worked the input and output into the mechanism- for input we had a block fall down triggered by an Arduino servo that completed a circuit to turn on the fan. For the output we had a servo that moved a piece of wood to hit the joystick that the next group was using as an input.


In the end however, all this work has been put in jeopardy  because the power supply unit that we were using suddenly decided that the fan wanted 26 volts of DC power instead of the 12 volts that it was happily providing for the seven hours beforehand. As far as I can tell, it shorted the internal circuitry of the fan just as we were doing our final tests of the night. We have a few different options for where to go from here. One is to buy a new fan ($8-15 on Amazon) and have it shipped here before Wednesday. Another is to find two smaller fans that we could possibly incorporate.  Or we can use one large, constantly blowing fan and two servos to hold the boats back from going before they circuit has been completed.


Zoe, Josh, Andri, Katie, Ruyi, and some ITP people for their help throughout the process.

Our Goldberg Piece (Aproova and I :) )

We created a machine that when given a light input, will roll a ball down a slide.

We started with a drawing:


At first we were going to have a pulley system, but then we decided that a flag would not be a sufficient output and then created a system in which when the motor turned, a little flap on the end would go back and swing forward so that we could knock the ball forward.

Here is the sketch!


And then we started testing it out!

First, to make sure that we got the light sensor plugged in correctly, we tested out the light sensor by seeing if we could light up an LED.

After we got the light sensor working, we hooked it up so that the when the light sensor was activated, we could get the motor to turn.


After that, we created a little flap that attached to the motor so that something would come in contact with the ball. At the same time we worked on creating a slide so that the ball would have something to roll down. After engineering all our parts together, we were able to create our piece of the Rube Goldberg Machine!

Here is our slide and the platform it would be later attached to.


And here is our video of our fun chicken slide in action!

Jack in the Box (WIP)

Still a work in progress with a lot of kinks, but it’s proof of concept at least. We decided to make a jack-in-the-box, with the item inside being of conductive material so that it could connect to the next group’s like a basic switch. We’ll probably add in the “Pop Goes the Weasel” tune on a buzzer or speaker just for fun.

We didn’t get a chance to test it out with the groups before and after  us, but we did know that the group before us used an LED as their output. We incorporated that into the schematic for now.

Photos and gifs:


vhjghjgjh fds


#include <Servo.h>

int photocellPin = A0;
int light = 0;
Servo jitbservo;
int pos = 0;

void setup() {
// put your setup code here, to run once:


void loop() {
// put your main code here, to run repeatedly:
light = analogRead (photocellPin);
light = light/2;
Serial.println (light);
if (light > 410)
{pos = 0; pos >= 90; pos += 1;
{pos = 90; pos <= 0; pos -=1;


Alison & Amin: Group 9

For our piece of the Rube Goldberg Machine, we decided to us an ultrasonic sensor for our input and an LED for our output. After hearing that group 8 was doing something that “pops up” and group 10 was using a light sensor, we decided the best way to go would be an ultrasonic sensor for motion and an LED for light.

First, we created a schematic for our machine.


Next, we assembled our machine.


Then, we created the code. We used pins 7, 11, and 13 for the LEDs, trigger pin, and echo pin respectively. The trig pin will receive a signal of 10uS from the Arduino to begin the ultrasonic sensor ranging. Next, the sensor will send out a cycle of 8 bursts at 40 khz and assume it’s maximum radius. An echo line is the width of an echo pulse that is equivalent to the distance to the object. Before detecting an object, the echo line starts at the sensor’s maximum detectable radius. After detecting an object, the sensor lowers its’ echo line to give a give pulse width in uS.

Pulse width is then converted to distance with the formula: distance = (traveltime/2) x speed of sound or cm = (duration/2)/29.1. Travel time/duration is divided by two because the wave had to be sent out, hit the object, then return to the sensor.

We chose a distance of 10 cm to set off the LED because it was close enough so other items would not be likely to effect the sensor, but far enough so the item would still be easily detectable. Our if else statement says if an item is farther then 10 cm, the LED would be off. If an item is closer than 10 cm, the LED would be on.

Lastly, we set our results to be printed in the serial monitor.


Here’s the device!

As you just saw in the video, as the hand gets closer, the serial monitor shows the cm decreasing. When the hand gets farther, the cm count increases.


Complete Guide for Ultrasonic Sensor HC-SR04 with Arduino



Rube Goldberg Machine-Group 4(Jeremy & Yulin)

This is the first draft of our group’s installation. Our group’s input is an activated fan, and output is a moving ball.

Plan A(first draft)

We tried to attach conductive strips to the sticky notepad like this.

Plan A switch

In this way, when group 3(Wuji & Tori) activate their output, which is a fan, the conductive strips on the notepad will connect the circuit. The notepad was supposed to be the switch. If the switch is on, the servo motor will rotate and push the ball to the next installation.

However, when we tested our installation, the strips on the notepad kept falling off, and the power of the fan is not large enough to activate the switch.

Plan A failed

Then we tried plan B. We made a track out of a piece of cardboard, and we used a small piece of cardboard attached to the servo motor as a door to block the ball at the end of the track. When the ball was stopped by the door, it would cover the photocell sensor inserted on the track. Because of the ball, the environment of the photocell got darker, and then the Arduino would turn on the LEDs on the breadboard and the servo motor to lift the door. The ball could then go to the next installation.


And yes, it worked quite well.


Rube Goldberg Machine: Group 4, Tori & Wuji

This is the diagram for our part of the Rube Goldberg Machine.


Our input, a joystick, will be triggered by the previous team’s output, which would be a motor. When the joystick is not pushed, the LED lights on our breadboard will lit up yellow. When the joystick is pushed it will make the lights flash red. This acts as an alert that the joystick was triggered. Our output will be a fan that blow something to trigger to next teams input.

First, we tested the LED lights to see if they worked. They did! After, we coded them to give them the behavior we wanted and added our inputs and outputs.


This is our final code to achieve our desired outcome.

This is the product.

Rube Goldberg Challenge

Hello all! Xuemei and I have been planning out our project and as we are waiting for the group before us, and we don’t have any full work out yet I wanted to explain what we have in mind.

The group before us is making a contraption that rolls down a ball, we will make the ball drag down a wire into water and cause an LED to light up, then our next group will need to make our LED set off a light sensor. More details will be specified when it is more developed.