Group members:

David Lackey – dlackey@

John O’Neill – jconeill@

Horia Radoi – hradoi@

(Santhosh Balasubramanian)

Playing Simon Sees

The aim of our project was to create a wearable version of the classic game of Simon Says. As such, the goal of Simon Sees is to remember and duplicate the sequence of lights generated by the microcontroller. The player wears a pair of glasses with two lights, one on each side, which are diffused via straws to create a visible beam of light. The game begins by showing a light sequence of length 1, which the player must duplicate by pressing the corresponding buttons – lighting the straws to indicate his or her decision. After each successful level, an additional light is added to the sequence. When the user makes a mistake, a red LED light notifies the user, and he or she has to restart the game. Overall, we found our final implementation fairly successful, especially after decreasing the time between the lights in the sequence, which increased the amount of attention needed by the player. After spending time with our prototype and inviting additional users to participate, we discovered that future iterations should contain more than two sources of input/ouput and that the current interface for user input (two buttons) could be transformed into something more engaging and unique, such as auditory- or motion-based forms of interaction.

Click here to view our project in action!

Initial Design Sketch

The Simon Sees interface. Note the red light used to notify a user when they make an incorrect move.

Players use the controller to indiciate which light they think is next in the sequence.

Additional Designs

1. Contextual Disco Ball

If our disco ball senses a low-light environment, it begins increasing the brightness of our LED’s (one red, one green, one blue,) which are placed inside of a semitransparent ball. The lights are pulsating, and the frequency at which these lights pulsate is determined by an interactive Processing interface.

2. Slit Experiment

Using an LED light and a dark box with two thin vertical cuts in one side (at a known distance), generate an interference pattern on a wall by turning the LED light on inside the black box and pointing the side with the two cuts towards a wall (requires a dark room).

List of Parts

• 1 Arduino
• 2 Breadboards
• 2 Buttons
• 3 LEDs (1 blue, 1 green, 1 red)
• Alligator clips
• 1 Pair of glasses
• 2 Straws

Instructions

1. Begin by properly placing the circuitry elements on the Arduino board. One button, which is used to trigger the left light, must use pin 13 and should be arranged to a schematic similar to that as described in the Arduino blogs. The button for the right light should be using pin 12. Our left, right, and red LEDs should be using pins 10, 11, and 9, respectively.
2. In order to attach the LED’s to the glasses, use long wires that have been braided together. These allow us to alter where we place our LEDs while being fairly unobtrusive.
3. Place LEDs in straws and tape them to the corresponding side of the glasses.
4. Load the Arduino with the following code, observe the first light in the sequence, and copy – enjoy!

Code

/*
 Simon Says
 Repeat the sequence of lights given by the button inputs.
 */

// Constants 
int N = 10;
int RED_LED = 9;
int LEFT_LED = 10;
int RIGHT_LED = 11;
int LEFT_BUTTON = 13;
int RIGHT_BUTTON = 12;
int DELAY = 200;
int RED_DELAY = 1000;
// State variables
boolean isShowing; // Are we showing lights?
boolean leftLights[10]; // Each element is true for left, false for right
int i; // leftLights index
int level; // Game level

// the setup routine runs once when you press reset:
void setup() {

 // LEDs
 pinMode(RED_LED, OUTPUT);
 pinMode(LEFT_LED, OUTPUT);
 pinMode(RIGHT_LED, OUTPUT);

// Buttons
 pinMode(LEFT_BUTTON, INPUT);
 pinMode(RIGHT_BUTTON, INPUT);

// Init game
 reset();
}

// Reset game
void reset() {
 i = 0;
 level = 1;
 isShowing = true;
 generateLights();
}

// generate lights array
void generateLights() {
 randomSeed(analogRead(0));
 for (int j = 0; j < N; j++){
 leftLights[j] = random(0, 2);
 } 
}

// the loop routine runs over and over again forever:
void loop() {
 if (!isShowing) {
 checkInput();
 }
 else if (i < level && level <= N) {
 showLights();
 }
 else {
 // Stop showing lights
 isShowing = false;
 i = 0;
 }
}

// Check player input
void checkInput() {
 // Collect input
 int leftButtonState = digitalRead(LEFT_BUTTON);
 int rightButtonState = digitalRead(RIGHT_BUTTON);
 // Check
 if (leftButtonState == HIGH && leftLights[i]) {
 // Left hit
 i++;
 show(LEFT_LED);
 }
 else if (rightButtonState == HIGH && !leftLights[i]) {
 // Right hit
 i++;
 show(RIGHT_LED);
 }
 else if (rightButtonState == HIGH || leftButtonState == HIGH) {
 // Miss
 show(RED_LED);
 reset();
 }

 // Check level completion
 if (i == level) {
 i = 0;
 level++;
 isShowing = true;
 }
}

// Show lights
void showLights() {
 // Show lights
 if (leftLights[i++]) {
 show(LEFT_LED);
 }
 else {
 show(RIGHT_LED);
 }
}

// play light
void show(int led) {
 int d = DELAY;
 if (led == RED_LED) {
 d = RED_DELAY;
 }

 digitalWrite(led, HIGH);
 delay(d);
 digitalWrite(led, LOW);
 delay(d);
}

Group: Bonnie Eisenman (bmeisenm), Mario Alvarez (mmcgil), Erica Portnoy (eportnoy), Valentina Barboy (vbarboy)

Description: We built a cardboard “robot” that responds to having its hand held and its nose tweaked. When you hold its hand, its heart glows and it burbles in robot-speak. Its nose is a potentiometer which controls the color of its eyes. We built PitchSqueak because we wanted to build a puppy, but we couldn’t with the given materials, so we figured that an interactive robot was a decent second choice. We’re all kids at heart and we like kids’ toys. (Also, we wanted to experiment with the buzzer.) While we don’t have any kids on hand to test PitchSqueak with, we all find him quite delightful, so we judge this project to be a success. Improvements we would include if possible would be making the cardboard construction better, and making the potentiometer easier to turn. Originally we had also envisioned having PitchSqueak respond to having his head petted, using the linear Softpot.

Photos of sketches:

A mini-weather-station with sensors that record the ambient light and temperature, and periodically tweets them.

A “musical instrument” whose pitch and volume can be controlled using the Softpot and the potentiometer.

PitchSqueak! An interactive robot/toy whose heart glows and he babbles when you hold his hand. You can also change the color of his eyes.

Storyboard:

Our storyboard. Little Timmy learns to be nice to people / robots!

PitchSqueak in Action:

List of parts:

• 1 buzzer
• 1 potentiometer
• 1 FSR
• 1 red LED
• 1 RGB LED
• 1 breadboard
• 1 cardboard box
• Electrical tape
• Wires
• Paper
• 1 Arduino
• 1 USB cable

Instructions for Recreation:

We constructed PitchSqueak out of a cardboard box. We cut out a rectangle of cardboard for the face, and cut holes for the eyes, heart, and nose. The holes for the eyes and heart were covered with paper to diffuse the light from the LEDs. The potentiometer was placed in the hole for the nose and secured with electrical tape. We then used a second piece of cardboard for a “shelf” between the heart and the eyes, to shield the two LEDs from each other. The red LED was taped to the hole for the heart. Electrical tape was used for connecting the wires to the potentiometer. We then cut out a second piece of cardboard for the body, as well as cardboard arms. We taped the FSR to one of the arms, and then attached the arms to the body. Next we connected the body to the face. We taped the LED for the eyes to the top of the robot’s body, inside. Finally, we connected all the sensors according to our circuit diagram with the breadboard.

Circuit diagram.

Source code:

/* Pitch squeak! */

// Pins:
int greenPin = 10;     // analog pin for the green component of RGB LED
int heart = 7;        // the analog pin for the red LED (heart)
int fsrPin = 2;       // the FSR and 10K pulldown are connected to this pin
int potPin = 0;       // the potentiometer is connected to this pin
int music = 3;        // pin that connects to music

// Input: 
int fsrReading;       // the analog reading from the FSR resistor
int potRead;          // the analog reading from the potentiometer

// Constants: 
int brightness = 255;   // the brightness the LED glows with

void setup(void) {
  // We'll send debugging information via the Serial monitor
  Serial.begin(9600);

  // Set the modes of the pins
  pinMode(heart, OUTPUT);
  pinMode(music, OUTPUT); 
  pinMode(greenPin, OUTPUT);
  pinMode(potPin, INPUT);
  pinMode(fsrPin, INPUT);
}

void loop(void) 
{
  fsrReading = analogRead(fsrPin);
  potRead = analogRead(potPin);
  /*
  Serial.print("FSR reading = ");
  Serial.println(fsrReading);     // the raw analog reading  
  Serial.print("Pot reading = ");
  Serial.println(potRead);     // the raw analog reading
  */
  int greenVal = potRead/4.0; // convert 0-255 to 0-1023
  analogWrite(greenPin, greenVal);

  // Light up heart and make noise if hand squeezed
  if (fsrReading >= 500)
  {
    analogWrite(heart, brightness);
    digitalWrite(music, HIGH);
    for(int i=0; i<10; i++) {
      int r = random(0,255);
      analogWrite(music,r);
      delay(100);
     }
     digitalWrite(music, LOW);
     analogWrite(heart, 0);
  }
  else {
    digitalWrite(music, LOW);
  }
}

Team members: Kiran Vodrahalli, Collin Stedman, Raymond Zhong, Dale Markowitz

02/19/2013

We created an Internet-enabled companion cube for your computer, which displays different kinds of information by glowing red or green. Depending on its orientation, and which labeled face is oriented upwards, our companion cube displays either stock readings of the NASDAQ or the outside temperature in Princeton. As the temperature or stock index changes, the Arduino inside the cube fetches updated data from the host computer it is connected to, and modulates the brightness of red and green LED arrays inside. We thought it would be a perfect match for the topic of the first lab, LED diffusors, and that it also makes a useful and elegant desktop accent.

Ideation and Design

We started by thinking about LED diffusers, and found that the most interesting applications for us related to using them to display or convey information. We then considered a number of physical interfaces, including a tree, a panel, and various geometric shapes. We settled on a cube because we expected users to want multiple sources of information from the cube, and we thought rotating the cube was a better interface than configuring it by computer, since it would make use of the different sides of the cube. Since we have some Arduino experience, adding Internet connectivity so the Arduino and computer could talk to each other followed rather naturally.

Construction

We found that there was scrap foam in many different places we looked – the upper levels of the E-Quad, the Architecture building, and Frist among others. We went with that, instead of making our cube out of paper, because foam seemed like an excellent prototyping material. It was easy to cut, already pre-formed into sheets, and most importantly fit together like a jigsaw puzzle, allowing us to assemble the foam simply by pushing metal leads into the joints. Eventually we would want to use a laser-cut enclosure for this kind of box.

Concerns and Conclusions

We would have preferred a better spectrum of colors from our cube, but we did not have enough tricolored LEDs to produce enough light to be visible through our cube. We ran into a number of problems because of the differences in brightness and voltage between red vs. green LEDs and indicator vs. lighting LEDs, but we managed to circumvent most of those because foam was such a great diffusing material and blocked little light. Finally, we observed that the Cube is sometimes slow to respond as we scrape data from the web, because of latency. So, we’d like to make it faster if possible.

We think our companion cube is pretty and works well. If we had developed the cube further, it would have more applications — possibly one for each side of the cube, including email notifications, facebook notifications, etc. — and it would use an orientation sensor rather than photoresistors on each side to figure out its orientation.

Design Sketches

Tetrahedron, Prism, some ideas for functionality

Initial Designs: The Tree of Tweets

Perhaps a rotating cube? With a base?

More Designs for the Cube

Initial Design for LEDs inside the Cube

LED inside the Cube

Rice paper in the middle, cardboard outside

Parts of the Cube

More detailed description of how the cube fits together

Dimensions of the Cube Side

Arduino and Breadboard inside the Cube

Circuit Design:

Arduino Circuit for Port 5: The Red LED array

Circuit for Arduino Port 3, the Green LED

The photocell input circuit

The Final Product! :

The stock market is going down today 🙁

The weather is warmish! (At least, more than 33 degrees F! Winter at Princeton.)

Video:

Our Companion Cube Working!

Parts we used:

4 Red LEDs, 1 White LED,  Green marker, Arduino Board, USB Cable, MacBook Air, Wires, 5.6 KOhm resistor, 560 Ohm resistor, photosensor, glue, styrofoam, breadboard

Tools we used: Wire strippers, Multimeter, Scissors, Razor

We also used some Python libraries, as documented in the code.

How to make your very own Wondrous Weather Cube:

You’ll need the parts given above, as well as the code given on the GitHub repo listed below. Assemble the circuit given in the circuit diagram included above. Hopefully the product should look similar to the picture of the completed circuit provided above. Then, build the cube by cutting the Styrofoam squares as shown in the design pictures. Glue the sides of the foam together. You may have to cut a small hole for the USB cable. Then, put the Arduino into the cube, and connect to a computer. First run the arduino code (weather_nasdaqCube.ino), then run the Python code (cube_handler.py). Flip the cube over to test modes. Voila! You now have your own working Wondrous Weather Cube!

Some sources:

http://apexlogic.net/code-bank/python/pyserial-example/ http://docs.python.org/2/library/re.html http://pyserial.sourceforge.net/pyserial_api.html#module-serial

Documented Source code: https://github.com/kiranvodrahalli/WondrousWeatherCube

John Subosits

Here are some ideas for the third part of the lab.  Finding a way to make the diffuser useful was difficult.

Click on the picture for a better view.

I decided to build the first idea, a device to improve the reaction times of people who drag race.  Three LED’s, red, yellow, and green were used to simulate the “tree” of lights that is used to signal the beginning of a race.  Several pieces of cellophane tape were used as a diffuser for the LED’s although napkins and a water bottle were also considered.  The red light illuminates, the yellow flashes three times, and then the green light comes on.  When this happens the person using the device pushes and holds the switch button supplied in the kit as they would the accelerator pedal if they were racing.  If they false start, only the red light illuminates while a clean start lights all three lights.  After a few seconds, the sequence begins again.  The system was reasonably fun to play with, and I consider it a success.  Some improvements would be adding additional yellow LED’s to allow them to stay lit for the countdown (more realistic), using a switch that mounts to the breadboard or one that has a form factor like a clutch pedal, and using the computer to report reaction times to track improvements.

Here are some videos of the system in action and a few pictures of its layout.

Video9

Video10

Parts used:

Yellow, green, and red LED 1 each

330 ohm resistor x 3

10 k resistor

12 mm button switch

Miscellaneous jumper wires and clip leads

Breadboard

Arduino

Instructions for construction:

Connect pins 11, 10, and 9 through independent 330 ohm resistors and red, green and yellow LED’s respectively to ground.  Also connect the switch between 5V and Pin 2.  A 10 k pull-down resistor connected to ground was used on Pin 2.  Clip leads should be used, as the switch does not make good contact with the breadboard.  The code below was used to control everything.

// This code is inspired by the Blink example included with the Arduino.
// Also some inspiration is taken from the Button tuturial available at
// http://www.arduino.cc/en/Tutorial/Button
  int red = 11;
  int green = 10;
  int yellow = 9;
  const int buttonPin = 2;     // the number of the pushbutton pin
  int buttonState = 0;

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

  pinMode(red, OUTPUT);   // sets the pin as output
  pinMode(green, OUTPUT);   // sets the pin as output
  pinMode(yellow, OUTPUT);   // sets the pin as output
  pinMode(buttonPin, INPUT); 
 }

void loop() {
  // put your main code here, to run repeatedly: 
  for (int i = yellow; i <= red; i++) {
    digitalWrite(i, LOW);
  }
  delay(5000);
  digitalWrite(red, HIGH);
  delay(500);
  for (int i = 0; i < 3; i++) {
    digitalWrite(yellow, HIGH);
    delay(150);
    digitalWrite(yellow, LOW);
    delay(350) ;
  }
  buttonState = digitalRead(buttonPin);
  if (buttonState == HIGH) {
    delay(4000);
  }
  else if (buttonState == LOW) {
  digitalWrite(green, HIGH);
  digitalWrite(yellow, HIGH);
  delay(3000);
  }

}

Group Members: Matthew Drabick, Adam Suczewski, Andrew Callahan, Peter Grabowski

High Level Description:

For part 3 of the lab, our group decided to build a “Simon” game. Our game setup uses 3 buttons and 4 LEDs. Each button corresponds to one LED and the 4th LED is used to indicate an error. The game starts with the arduino flashing one of the 3 lights, chosen randomly. The user must then press the button corresponding to that light. If the user’s input is correct,  the arduino extends the pattern by one and the user must then match that extended pattern. If the user’s input is incorrect, the error light goes off and the user loses the game. This process repeats until the pattern reaches length 7, in which case the user wins the game.

Our game is mounted a paper plate for support and uses origami balloons to diffuse light from the leds.

Here is a video of the game in action:

High Level Design Process:

We began with brainstorming. Our initial ideas included interactive and non-interactive designs. These ideas included pre-set light display patterns (Morse code or musical patterns), diffusers using various translucent paper and plastic covers, and a binary counter.

We decided to first make the binary counter, as we thought it would be both technically and visually interesting. We also would have the opportunity to use our origami balloon/lantern diffusers which we thought were pretty cool.

The binary counter consisted of two buttons (an increment and a decrement) as well four LEDs to display a 4 bit number. With those four LEDs, we could count from 0 to fifteen, and display a fun pattern on overflow or underflow.

We began by sketching our design and drawing the circuitry. Here are our initial brainstorming sketches:

Drawing of the binary counter interface.

Diagram of the binary counter circuitry.

We then assembled our circuit and wrote the code to power our binary counter (technical details given below). In the end we built this:

After completing the binary counter though, we considered our design choices and thought about what we could do to make our circuit better. After making modifications and iterating through different design choices, we decided that what our circuit was lacking was an interesting method of interacting with the counter.  We liked how the binary counter was interactive; however, it was limited to single presses doing the same thing every time. With this in mind, we considered various ways of expanding on our counter, such as using the counter to select and play one of 16 different pre-set light patterns (which could be Morse code messages or other interesting displays) or to play a game. In the end we decided to create the Simon game described above.

An initial drawing of the simon interface

Initial design decisions for Simon included how to organize the user interface and how many lights and buttons to include. We decided to use a paper plate as the body of our game as it was easy to manipulate but also gave sufficient support. We initially planned to make the game with 4 lights and 4 buttons, but reduced those numbers to 3 as we continued in the design process and faced limitations due to the availability of resources and bulkiness of alligator clips.

A look at the alligator clips connecting the leds and buttons to the bread board

Once the basic layout of the game was implemented, we made gameplay decisions like how long to wait between flashes of light and how long the pattern should be for the user to win. We made these decisions by playing the game ourselves, and by having other people play our game. We also had to work out bugs such as a single button press being registered twice. After trying our game with different parameters, we arrived at our final design.

A top view of the final simon game

Technical Documentation / Technical Design Choices:

There were 2 main circuit components that we used to power our game: LEDs and buttons (these were used with resistors, as needed). In the first 2 parts of the lab, we became familiar with using LEDs. Helpful information about using LEDs with arduinos is found at http://arduino.cc/en/Tutorial/blink.

LEDs are implemented by creating a connection between an Arduion pin and ground. (Image from arduino.cc/en/tutorial/blink) 

We then looked up how to use buttons with arduino at http://arduino.cc/en/tutorial/button. To use a button, we needed to provide a path from ground to 5v (with a resistor) as well as a path to an input pin to sense when the button is closed.

Buttons are implemented by creating a path between ground, 5v, and an input pin. (Image from arduino.cc/en/tutorial/button)

With an understanding of buttons and LEDs, we were able to get started with the technical side of the design process.

We started by drawing the circuitry for our game. There are four LED’s and three buttons in the final implementation but only 3 leds in the diagram below. The fourth LED is an indicator light for when you incorrectly input a sequence.

An initial drawing of simon circuitry

With these design sketches, we were then able to implement our design on the breadboard and mount the buttons and lights on the plate. Though the organization of wires in our pictures looks complicated, it is essentially 4 leds/resistors connected to a digital input pin and ground, and 3 button/resistors connected to a digital input pin, ground, and 5v.

We did not reach our final design immediately though. Our initial design had the LED’s on the inside; we eventually decided to move them to the outside of paper plate for the final prototype. This allowed the diffusers to fit better and also made room for our center failure indication LED. We also attempted to incorporate a 4th LED/button pair but found we were limited on resources.

With the circuitry in place, we then focused on the physical construction. For the led diffusers, we chose to uses the origami ballons/lanterns that we had used previously for the binary counter. We used these origami instructions to make four balloons out of dum-dum wrappers.

A single origami balloon used to diffuse light.

For the base of the game, we took a paper plate and poked four holes for each button (one for each leg) and a single hole for each LED. We then could insert the switches and LEDs and attach alligator clips to the bottom to make the circuits displayed in the tutorials and our diagrams. By following those design diagrams, we constructed what you see in the picture below.

Wiring of simon interface to arduino

As you can see, we have supported the plate with three stationary clamps (“helping hands”). This allows the alligator clips to hang down, making the circuits easy to connect and prevent them from touching accidentally. This also allowed us easy access during debugging. After some cleaning up of our wires we finished our simon design. Here is a walkthrough of the finished project:

How to:

1) After reading over the blink tutorial, connect LEDs to your bread board so they connect to digital input pins 9, 10, 11, and 12, a resistor, and ground.

2) After reading over the button tutorial, connect your buttons to your bread board so they connect to digital input pins 2, 3, and 4, ground and 5v.

Our simon breadboard.

3) Run some test code on you Arduino. Start by running blink on each led to check that you leds and connections are working. Then, try the button code  to test that each button is working. Finally, upload the code below to check that the simon game works.

4) Construct the base of the game using a paper plate or similar material. Arrange the buttons/leds in the manner shown below with the electrical contacts sticking through the plate.

5) Construct 4 origami balloons to act as diffusers.

6) Move the 4 leds and 3 buttons on your breadboard over to the plate setup one by one by running aligator clips from the plate setup to the breadboard.

7) Repeat set 3.

8) Cover each led with an origami balloon diffuser. Hot glue to balloons to the plate for support.

Hot gluing origami balloon diffusers to leds

9) You’re done!

The Code:

Our code starts by initializing a random array, with length equal to the number of button presses needed to win. It flashes the first color in the sequence, and then falls into the main loop, continually checking for button presses. When a button is pressed, the Arduino checks if it corresponds to the next color in the sequence. If it is the expected color, it advances the position in the sequence by 1. Otherwise, it flashes the sad face led and resets. When the user has reentered the sequence correctly, the next element is added to the sequence, and the game repeats until the user has succeeded on the maximum level.

Here is the code we used for the project:

const int numButtons   = 3;
    const int buttonPins[] = {2,3,4}; // arduino input pins
    const int ledPins[]    = {9,10,11}; // arduino output pins
    const int errorLed     = 12;

    const int maxLength    = 5;

    int randSeq[maxLength]; // contains randomly gen'd game seq
    int level; // current level
    int numCorrect; // how many pins you've pressed correctly so far
                    // always less than level

    int lastStates[numButtons]; // to check button input

    void setup() {
      victory();
      delay(250);
      resetState();      
      randomSeed(analogRead(0));
    }

    //initialize randSeq with random values between 0 and numButtons
    int makeArray(void) {
      int i;
      for (i = 0; i < maxLength; i++) {
       randSeq[i] = random(numButtons); 
     }
   }

   // flash a given led
   void flashLed (int ledNum) {
    analogWrite(ledNum, 0);
    delay(50);
    analogWrite(ledNum, 255);
    delay(200);
    analogWrite(ledNum, 0);
    delay(50);
  }

  // handle input
  void checkInput(int i) {

    // wrong button was pressed
    if (randSeq[numCorrect] != i) {
      flashLed(errorLed);
      flashLed(errorLed);
      flashLed(errorLed);
      delay(250);
      resetState();
      return;
    }
    // correct button was pressed
    else {
      numCorrect++;
      // check for last button in level
      if (numCorrect == level) {
        // check for last level in game
        if (level == maxLength) {
          victory();
          delay(250);
          resetState();
        }
        // not last level in game
        else {
          delay(500);
          numCorrect = 0;
          level++;
          flashSeq();
        }
      }
      // not last button in level
      else {
        delay(100);
      }
    }
  }

  // determine which button was pressed
  void checkButtons () {
    int i;
    for (i = 0; i < numButtons; i++) {
      int state = digitalRead(buttonPins[i]);
      if (state != lastStates[i]) {
        if (state == HIGH) {
          checkInput(i);
          delay(100);
        }
        lastStates[i] = state;
      }
    }
  }

  // flash the sequence of leds up to current level
  void flashSeq(){
    int i;
    for (i = 0; i < level; i++){
      flashLed(ledPins[randSeq[i]]);
      delay(250);
    }

  }

  // turn all leds off
  void setAllOff() {
    analogWrite(ledPins[0], 0);
    analogWrite(ledPins[1], 0);
    analogWrite(ledPins[2], 0);
  }

  // turn all leds on
  void setAllOn() {
    analogWrite(ledPins[0], 255);
    analogWrite(ledPins[1], 255);
    analogWrite(ledPins[2], 255);
  }

  // flash all leds
  void flashLeds(){
    setAllOff();
    delay(100);
    setAllOn();
    delay(100);
    setAllOff();
  }

  // flash the leds in a circle
  void circle() {
    setAllOff();
    delay(100);
    analogWrite(ledPins[0], 255);
    delay(100);
    analogWrite(ledPins[0], 0);
    analogWrite(ledPins[1], 255);
    delay(100);
    analogWrite(ledPins[1], 0);
    analogWrite(ledPins[2], 255);
    delay(100);
    analogWrite(ledPins[2], 0);
    delay(100);
  }

  // special victory flash sequence
  void victory() {
    flashLeds();
    flashLeds();
    flashLeds();
    circle();
    circle();
    circle();
    flashLeds();
    flashLeds();
    flashLeds();
  }

  // reset for a new game
  void resetState() {
    makeArray();
    level = 1;
    numCorrect = 0;
      // delay(500);
    flashSeq();
  }

  // main loop
  void loop() {
    checkButtons();
  }

by Farhan Abrol (fabrol),  Kuni Nagakura (nagakura@), Yaared-Al-Mehairi (kyal@) and Joe Turchiano (jturchia)

Concept:

For our diffuser, we designed an authentic tri-color Bedside Floral Lamp. The lamp was constructed from tree branch (spine of lamp), CD casing (base of lamp), six single-colored LED lights (red, green, and yellow), several wires, 6 short-size rolling papers, strips of aluminum foil, and a hot glue gun. Three potentiometers control the LED lights on the lamp (one for red, one for green, and one for yellow). When users wish to turn the lamp on, they simply twist the potentiometers to increase the brightness of the potentiometer’s corresponding color. With the LED lights on, the rolling papers, i.e.  ‘light shades’, act as effective diffusers, which combined with the reflective strips of aluminum foil create visually attractive light patterns. Users can modify the lamps color and brightness with the potentiometers to set the appropriate mood. When users wish to turn the lamp off, they simply must reset the potentiometers, which turns all the lights off.

We decided to build a tri-color Bedside Floral Lamp because we wanted to create an aesthetically pleasing light source that users could tune to their mood. Conceptually, the LED lights represent the seeds of the flower and the aluminum strips the petals. Collectively, we are pleased with the result of our design. We especially like the addition of aluminum strips, which enhances the light diffusion process and therefore creates even more optically enjoyable effects.

One problem with our design though is that the aluminum strips are not rigid enough, and so tend to keep falling down, thereby failing to reflect the LED lights. An improvement that could be made would be to add some kind of support to the aluminum strips to keep them in place, and therefore acting as effective reflectors.
At first, we tried to build a Bedside CD Lamp because we thought CDs would be effective diffractors of light. It turned out that due to the limited power of our LED lights, CDs would only create a rather underwhelming light diffusion effect.

Design:

Through our design process, we considered 3 prototypes. Of these sketches, we actually conceived 2 of our prototypes and ultimately decided on our final design.

We began with the idea of the lamp and considered various ways to diffuse the light. Our first two prototypes used CDs to diffuse the light and our final prototype makes use of rolling papers and aluminum foil.

Initial rough sketch for our first prototype

This initial model was discarded because of structural issues. The 8 CDs would not stay together without adding additional structural supports. Our second prototype, which incorporates 3 CDs instead of 8 simplifies the structure of our lamp.

We finished building our second prototype; however upon testing in various lighting conditions, we decided that the CDs were not adequate diffusers for our LED lights. Thus, for our final prototype, we chose to use different materials for our diffuser, and our final design incorporates rolling papers that wrap around the LED light and aluminum strips that surround the lights. A potentiometer that corresponds to the 3 sets of LED lights (red, green, yellow) give the user control over the mood and color of the lamp.

Sketch of prototype 3

Final design sketch

3 Potentiometer for each color (red, green, yellow)

The Finished Prototype

Close-up of the diffuser

Yellow LED’s

Red LED’s

Green LED’s

Demo:

Parts List:

1. 6 LED’s (20mA, 2V) – 2 red, 2 yellow, 2 green
2. Green and Brown insulated copper wire
3. 3 Compact discs
4. 1 Flex sensor
5. Pack of short-size rolling papers
6. 1 roll Aluminium foil
7. 3 rotary potentiometers
8. 1 Tree branch for support
9. CD-holder base (or similar rigid base)
10. 1 Soldering iron
11. 3 Alligator clips
12. 1 Glue gun
13. 1 Arduino board

Instructions:

1. Start by gluing the wires that will connect the led’s from the top of the branch to the Arduino. Glue the brown wires first. Run the wire along the side of the support leaving about 3″ at the top and about 6″ at the bottom extra for making electrical connections. Then wrap the green wire around these wires and glue it, again leaving extra wire at the ends for connections.
2. Cut a hole in the center of the CD-holder base and run all the wires through it. Make the support stand upright on the base and glue the bottom to fix it in position.
3. For each pair of LED’s of the same color, solder the negative of one to the positive of the other. These pair’s will act as the building blocks for the LED pattern at the top of the support. Strip the ends of all the wires at the top of the support. For each pair of LED’s, connect the positive end to one of the brown wires and the negative end to the green wire (which acts as ground). Make a note of which brown wire connects to which color.
4. Connect the other end of the wires to the Arduino pins through a 330 ohm resistor in series with each, in the following manner –
   Red LED’s – Pin 9
   Green LED’s – Pin 10
   Yellow LED’s – Pin 11.
5. Make conical light shades using the rolling papers and cover each LED with one conical shade.
6. Cut out 6 – 5″ X 1″ strips of aluminium foil and layer them to make each strip stiffer. Then, attach each of the strips around the support in a floral pattern, with the bottom end taped below the LED’s and the upper ends hanging loose.
7. Attach the leftmost pin of each potentiometer to ground, and the rightmost pin of each to 5V. Attach the middle pins to A0, A1 and A2 for yellow, green and red led’s respectively.

Source Code:

/* Radiate
* Group: Yaared Al-Mehairi, Kuni Nagakura, Farhan Abrol, Joe Turchiano
* ------------------
* The circuit:
* LED's (red, green, and yellow) are attached from digital pins 8, 9,
* and 10 to ground. We connect potentiometers to analog in pins 9,10,11.
*/

// These constants won't change. They're used to give names
// to the pins used:
const int analogInPinY = A0; // Analog input pin that the potentiometer is attached to
const int analogInPinG = A1; // Analog input pin that the potentiometer is attached to
const int analogInPinR = A2; // Analog input pin that the potentiometer is attached to

const int analogOutPinY = 9; // Analog output pin that the LED is attached to
const int analogOutPinG = 10; // Analog output pin that the LED is attached to
const int analogOutPinR = 11; // Analog output pin that the LED is attached to

int sensorValueY = 0; // value read from the pot
int sensorValueG = 0; // value read from the pot
int sensorValueR = 0; // value read from the pot

int outputValueY = 0; // value output to the PWM (analog out)
int outputValueG = 0; // value output to the PWM (analog out)
int outputValueR = 0; // value output to the PWM (analog out)

void setup() {
// initialize serial communications at 9600 bps:
Serial.begin(9600);
}

void loop() {
// read the analog in value:
sensorValueY = analogRead(analogInPinY);
sensorValueG = analogRead(analogInPinG);
sensorValueR = analogRead(analogInPinR);

// map it to the range of the analog out:
outputValueY = map(sensorValueY, 0, 1023, 0, 255);
outputValueG = map(sensorValueG, 0, 1023, 0, 255);
outputValueR = map(sensorValueR, 0, 1023, 0, 255);

// change the analog out value:
analogWrite(analogOutPinY, outputValueY);
analogWrite(analogOutPinG, outputValueG);
analogWrite(analogOutPinR, outputValueR);

// wait 2 milliseconds before the next loop
// for the analog-to-digital converter to settle
// after the last reading:
delay(2);
}