Flower Power

Conlon, Nitesh, and Sydney

Submitted 12/7/2016

Video Link: https://www.youtube.com/watch?v=GHNPC9KZVsY

The finished product with all three glow flowers mounted and activated in the trellis.

• Abstract

For our project we created a set of acrylic “glow flowers” that light up and play music when plugged into pots. Our goal was to inspire wonder in children by having them be able to plug flowers into and remove them from pots, each with unique and different behaviors, bringing them to life in the process. We wanted each pot to feel distinct when activated by playing different chiptune-style songs and shining different shades of light through the flower via a multi-color LED in the pot and strands of fiber optic cable in the flower. Our project held up well during the museum visit and was mostly popular with younger children.

• Objectives

We programmed each of the three pots to have a range of colors (blue, green, and red respectively). The LED flashes a random color within the pot’s designated color range in time with the music playing through the pot’s internal speaker. We pre-programmed a small library of audio samples using the Arduino Tones library and transcribed short, identifiable sections of 8 different songs. They play back in a random order as long as a flower is plugged in, looping through the library as needed. Additionally, each pot played the songs at a different tempo, with blue being 25% slower, green being the “normal” default tempo of the tones library, and red being 25% faster. Finally, we included startup and shutdown sounds that play only when a flower is plugged in or taken out. These are programmed not to able to be interrupted or have their speed modified (read as: the tones are always identical no matter which pot is playing them) to make the associated “on/off” behavior more clear to the user via the audio queue.

• Implementation

The flower pots contain all of the electronics and wiring used in the project including an Arduino UNO, a speaker, and a multicolor Adafruit NeoPixel LED. We designed a system of acrylic spacers and a connector piece so that the bases of the flowers would be secure resting in the pots. Inserting a flower also pushes a switch that triggers the LED lighting and pre-programmed chiptune music.

A close-up of the LED illumination of the stem and the fiber optic strands’ illumination of the petals.

The flowers themselves were made from layers of laser-cut acrylic and a clear tube for a stem, through which we wired fiber optic cable strands to the “petals” of the acrylic flower between the individual layers of the blossom assembly.  We also decided to create our own connectors to attach the flowers to the the pots.  We based these off of basic lego design, as we believe children would understand that.  We also used a real trellis and flower pots from Lowes along with modeling moss to create a more believable environment for our fake flowers.  We wanted the flower to have many different refractive facets and have space for the fiber optic cables, so we decided to layer identical flower designs in descending size as it created a pleasing visual effect and to house the fiber optics. We also sanded the surface of these layers to create an effect similar to that of frosted glass.

A close-up of the layers of acrylic that make up the flower petals.

Additionally, we wanted to allow the children to plant and pluck the flower, which is detected by the pot via a standard mechanical switch. We wanted the children to receive positive feedback for planting flowers and so we made it so that when the flowers are plugged in, they light up and play music. 

• Outcomes

Our project was set up at the end of the Attic in the Carnegie Children’s Museum. This allowed us to have a dark space to show off our glowing flowers but is also a fairly low traffic area. It was very successful with younger children especially those around 4 years old who were captivated by the colors and sound. On the other hand, many older children were only interested in it briefly and quickly moved on after they tried plugging the flowers once or twice. Initially, many adults originally thought our project was a non-interactive display, and would dissuade their children from touching or pulling out the flowers until we showed them how to use it. Children also had a tendency to pull the flowers out by their acrylic petals rather than the stem, which resulted in a couple of flowers coming apart. We were able to swap out the broken flowers with spares we had prepared until all of the flowers could be repaired and reinforced on-site.

Top view of the finished product with all three glow flowers turned on.

• Contribution

We each had a part of the project which we focused on (Sydney worked on hardware, Nitesh on fabrication, and Conlon on software), but we all collaborated and overlapped on a large majority of the project. Notable contributions headed up by each person include the design of the flower attachment adapter by Nitesh, the implementation of the music library and light behavior by Conlon, and the wiring and replication of the electrical circuits by Sydney.

Electronic Schematic

Full Code Zip File: flowersongandcolor

Full Code Link: https://drive.google.com/open?id=0B_kXzZBfZJ5dTXh6eXZudWJzVms

Lit up cloud

Clouds by Al, Sina & Noreen, Submitted on Dec. 7th, 2016

The installation is made up of three *clouds, which emit thunder sounds and lightning while moving up and down.  These are light responsive creatures, so when they are *fed with lights by flashing a light at them, they respond with rumbling and bright flashes.

Out objective was to make a fun, playful and interactive installation which could engage children and capture their imagination.

Internal structure of cloud

The clouds are fabricated using a cardboard structure which houses circuits and an arduino.  Each cloud contains 3 LED strips that are controlled by an Arduino UNO and powered by a single 12V power supply.  A photoresistor measures the ambient light when the Arduino starts up. The threshold value is then set 50 points higher so that it takes a brighter light source to activate the LED’s.

When the threshold limit is hit by shining a flashlight on the photoresistor, a ‘lightning animation’ is run by blinking the LED’s. A Serial.println(“thunder”) is also sent at this time to communicate with the Raspberry Pi that it’s time to play the audio.

The Arduino’s are connected to one Raspberry Pi via USB cables. On startup the Pi runs a python script which reads the serial input from the Arduinos and looks for the word “thunder” at which point it uses the ‘pygame’ library to play a WAV file.

Central gear and motion mechanism

The three clouds are attached to a central gear, which is fixed to a powerful motor.  As the motor rotates, the clouds are lifted up.  In turn, they are pulled down by their own weight.  Each component of the movement mechanism was laser cut after carefully calculating various sizes, including that of the motor itself.

Inspiration of this project was drawn from a piece of work by Richard Clarkson.    We drew inspiration for the movement of the clouds from this work (3:06 to 3:22) by Laurent Debraux.

Looking back at the project, a lot of things went well, and a lot of things went wrong.  For one thing the motion seemed to work fine on the clouds at an early stage of the project.  However, adding a lot of fluff increased the weight of the clouds, and the motor began to stall.  The motion did not go as expected.  Although we experimented with the look of the clouds, nothing seemed to look effective, and in the end we decided to leave them plain, without the eyes and arms which we had planned earlier.  The sound and lights worked just the way we had intended, and gave the impact which we had originally planned.

Al’s contribution to the project began with ideation and brainstorming.  He was responsible for getting the lights and the sound of the clouds to work.  He also figured out all the wiring, and got the basic cloud working.  Noreen’s role in the project was that of fabrication and figuring out the motion mechanism of the clouds.  She made the drawings and laser cut any parts needed for the project.  She also contributed in writing text for various blogs and documentation.  Sina  helped in the fabrication and wiring.

Circuit diagram:

Circuit diagram

Link to pdf of cloud-drawings (click here)

Code for the serial import

import serial
import pygame
import time
import logging
logging.basicConfig(filename='example.log',level=logging.DEBUG)
logging.debug('This message should go to the log file')
logging.info('So should this')
logging.warning('And this, too')
pygame.mixer.init()
thunder1 = pygame.mixer.Sound("/home/pi/Desktop/thunder1.ogg")
thunder2 = pygame.mixer.Sound("/home/pi/Desktop/thunder1.ogg")
thunder3 = pygame.mixer.Sound("/home/pi/Desktop/thunder1.ogg")

ser0 = serial.Serial('/dev/ttyACM0', 9600)
ser1 = serial.Serial('/dev/ttyACM1', 9600)
ser2 = serial.Serial('/dev/ttyACM2', 9600)
while True:
    blah0 = ser0.readline().rstrip()
    blah1 = ser1.readline().rstrip()
    blah2 = ser2.readline().rstrip() 
    if(blah0 == "thunder"):
        thunder1.play()
        print "thunder 1 is playing"
    if(blah1 == "thunder"):
        thunder2.play()
        print "thunder 2 is playing"
    if(blah2 == "thunder"):
        thunder3.play()
        print "thunder 3 is playing"

Thunder code (python):

import serial
import pygame
import time
import logging
logging.basicConfig(filename='example.log',level=logging.DEBUG)
logging.debug('This message should go to the log file')
logging.info('So should this')
logging.warning('And this, too')

pygame.mixer.init()
thunder1 = pygame.mixer.Sound("/home/pi/Desktop/thunder1.ogg")
thunder2 = pygame.mixer.Sound("/home/pi/Desktop/thunder1.ogg")
thunder3 = pygame.mixer.Sound("/home/pi/Desktop/thunder1.ogg")

ser0 = serial.Serial('/dev/ttyACM0', 9600)
ser1 = serial.Serial('/dev/ttyACM1', 9600)
ser2 = serial.Serial('/dev/ttyACM2', 9600)
while True:
    blah0 = ser0.readline().rstrip()
    blah1 = ser1.readline().rstrip()
    blah2 = ser2.readline().rstrip() 
    if(blah0 == "thunder"):
        thunder1.play()
        print "thunder 1 is playing"
    if(blah1 == "thunder"):
        thunder2.play()
        print "thunder 2 is playing"
    if(blah2 == "thunder"):
        thunder3.play()
        print "thunder 3 is playing"

Code for the Arduino:

//photoresistor A Style Tech.

//Cloud 1 variables
int sensor1 = 0; // will be used for analog 0.
int sensor1Threshold = 0; // value of when light is on
int sensor1Value = 0; // value of output
int brightness = 255;    // how bright the LED is
int ledStatus1 = 0; //0 off 1 on
const int LEDPIN = 6;
unsigned long currentTime;
unsigned long loopTime;
unsigned long previousMillis = 0;        // will store last time LED was updated

// constants won't change :
const long interval = 1000;           // interval at which to blink (milliseconds)


//General Variables
int fadeAmount = 5;    // how many points to fade the LED by

void setup() {
  Serial.begin(9600 );
 // calibrate during the first five seconds 
 while (millis() < 2000) { sensor1Value = analogRead(sensor1); // Serial.print("so here it is sensor value: " ); // Serial.println(sensor1Value); // record the maximum sensor value if (sensor1Value > sensor1Threshold) {
     sensor1Threshold = sensor1Value + 60;
   }
 }
   
  currentTime = millis();
  loopTime = currentTime; 
  //Set blink cloud 1 to indicate calibration is done. Then set to off
  pinMode(LEDPIN, OUTPUT);
  analogWrite(LEDPIN, 1);
  delay(10);
  analogWrite(LEDPIN, 0);
}

void loop() {
//    unsigned long currentMillis = millis();
//  if (currentMillis - previousMillis >= interval) {
//    // save the last time you blinked the LED
//    previousMillis = currentMillis;

    Serial.println("shush");
//    }

  //Serial.println("shush");
  cloud1();
}
void cloud1(){
   //Check the photosensors value
  sensor1Value = analogRead(sensor1);
//  Serial.println(sensor1Value);

//If you are shining a light at the sensor
if (sensor1Value > sensor1Threshold) 
{

  //Lightning Animation
  if(ledStatus1 == 0){
    Serial.println("thunder");
  analogWrite(LEDPIN, 255);
  delay(120);
  analogWrite(LEDPIN, 0);
  delay(120);
    analogWrite(LEDPIN, 255);
  delay(200);
  analogWrite(LEDPIN, 0);
  delay(200);
      analogWrite(LEDPIN, 255);
    brightness = 255;
    ledStatus1 = 1;
  }
if(ledStatus1 == 1){
  analogWrite(LEDPIN, 255);
}
} 
if (sensor1Value < sensor1Threshold) { //If the sensor was previously uncovered then we need to do the fadeout if(ledStatus1 == 1){ //LED FADE OFF currentTime = millis(); if(currentTime >= (loopTime + 20)){  
    // set the brightness of pin 9:
    analogWrite(6, brightness);    

    // change the brightness for next time through the loop:
    brightness = brightness - fadeAmount;

    loopTime = currentTime;  // Updates loopTime

//        Serial.println(ledStatus1);

if(brightness == 0){
    ledStatus1 = 0;
    }
  }
    //Sensor has been covered so keep the light off
  if(ledStatus1 == 0){
    analogWrite(6, 0);
  }
  }
}
}

Johnny Wu, Matthew Gruber, Zain Islam-Hashmi

December 6, 2015

<https://youtu.be/_JC0-dpsvfo>

Abstract

The mission of our project was to teach the concept of being nocturnal to young children. Our idea was to vividly display the diverse amount of creatures that are active at night that children might not get the chance to see. We created a table filled with light responsive creatures. These animals would only become active with servos and LEDs when a shadow was cast over them, simulating the night time. The table was successful, with the LEDs and animal activities engaging children’s’ interest. While there were some minor bugs and troubles that are inevitable with such a first major project, these errors were corrected and provided minimal impact in regards to the children’s interest. Some children had favorite animals on the table, and they seemed to understand that they were “night creatures”.

Objectives

Our core goal was to demonstrate the notion of nocturnal animals to young children. To achieve this goal, we implemented carefully chosen features. The features within the scope of the project included a rotating light to simulate the day-night cycle. There were also animals that responded to shadow with servo-assisted movement and activation of LEDs for greater impact in the dark. These features in combination demonstrate the conditions for nocturnal activity, but also present it in a colorful and engaging way so children would be interested.

Implementation

The table was octogonal, as the shape would be simpler to fabricate than a smooth circle but more interesting than a regular square. The height was 1.5 feet to ensure that children could easily see and access the table. The light was 5 feet tall, to reduce the chance of children potentially grabbing or burning themselves on the light. The various animals we included were mounted on servos for movement and also had LEDs to further show activity but also for colorful immersion. We included some predator-prey pairs for the more astute children. In addition, the base plate of the table was colored various shades of green to simulate grass, and the material for the animals were chosen based on their color. Clear acrylic was a common material because of it’s versatility and the endless color and design possibilities achieved with paint. The rotating light was constructed with cardboard to reduce weight.

Outcomes

The outcome of the project was overall a success.  A full version of the table was fabricated, interactive features were wired and included, the prototype was somewhat successfully installed, and meaningful interactions between the artifact and children/users were able to occur.  Some challenges were faced with putting together the prototype, such as the power source/supply to the Arduinos and various motors, as well as a few wiring flaws and creatures not responding/functioning.  However, these factors did not deter from children being able to interact with the table and see it in a working state.  The table was able to attract a small handful of children for the short time that it was running.  Many kids were curious of the table from afar and approached it cautiously, at first gazing from it from the edge.  However, children would start to lean in forward to see the entire table and its creatures, and that was when a shadow would be cast from their entire bodies and  the sensors and LED’s would activate. After this step of realization, the children were noted to move there hands much slower and graciously above the table, as opposed to fast and quickly directly on the acrylic (these children were around the ages of 4-6).  Smaller children, such as in the 2-4 bracket, has a hard time seeing the table sometimes, but they were the ones who would hit the table immediately and stuck their hands inside the curtain to take creatures (this occurred twice).  The children seemed to especially enjoy the bat and owl, as they had the most movement and colorful lights that gained the children’s attention.  Average interaction was around 10-30 seconds.  

Contribution

Johnny Wu concentrated on overall planning/some designs and construction of certain animals and flowers, as well as the rotating light. Matthew Gruber focused on the wiring and programming of the project and helped with various construction and design tasks. Zain Islam-Hashmi’s focal point was with the construction of the overall table, as well as assorted fabrication work.

Photo Documentation

(Prototype of table top using laser cutter)

(Rough wiring of sensor to LED/Servo)

(Underside of table and prototype’s wiring hookup)

(Rotating Light hookup)

(reaction after successfully achieving rotating light mechanism)

(live interaction photo)

(prototype in progress)

(prototype installed)

Circuit Diagram

*We had essentially 3 of the same series of circuits. Each input 7 and 8 had multiple leds anchored to it however I only put 1 for simplicities sake*

Code

Arduino 1

Arduino 2

Arduino 3

Citations

Our project took inspiration from “Ephemera” by Austrian-firm Mischer’Traxler (https://www.mischertraxler.com/projects_ephemera.html).

https://youtu.be/StBXx9nf_Zc

Abstract
Our idea was to design and produce a robot arm controlled by external sensor input. On a table, we had a 2 degree of freedom (DOF) robot arm with four motors that was surrounded by 4 stations. Each station had parts of the robot arm that controlled the same part on the actual arm with a potentiometer. There were bins and blocks at each end of the arm that could be picked up and moved to different locations. During our exhibit at the Children’s Museum, Robby successfully facilitated teamwork amongst the children and their parents. They were able to realize the mechanisms of each station and were delighted by ability to freely control parts of the robot arm. They learned how to move the arm collaboratively from their individual stations to pick and place the blocks in bins. Through this task-oriented activity, we hope to have inspired fascination in robotics with an interactive interface.

Objectives

• Be able to control the robot arm from each of the stations at real time
• Facilitate teamwork amongst children

Implementation
The design really centered around answering two questions:

• How easy would it be to control this part of the robot from a station?
• Can all four stations be operated at the same time without the robot crashing into itself?

In terms of material, we chose ⅛” wood for the arm so that it would be lightweight and easy to laser cut. We did not enclose any of the wiring or motors so that the children could see how the arm was being controlled. We also designed the arm in such a way that it would move 180 degrees to maximize movement since developing a rotating base (adding a third degree of freedom) was out of the scope/time frame of this project.

One of the initial sketches of the arm.

A closer look at the robot arm.

Outcomes
We didn’t have any issues with the weight or robustness (to children’s abuse) that we were initially worried about. We did have an issue with the arm being wobbly due to they way we chose to connect parallel pieces of the arm.

The four stations in the front control various parts of the robot arm behind it. The two bins on the side are what the blocks must be placed into.

This is a picture taken at the children’s museum where two boys are working together to get the robot arm to pick up a block and place it in one of the bins.

Contribution
We both designed, laser cut, programmed, wired and tested the robot arm together. We decided that this was the best way to tackle the project instead of working on individual pieces and putting them together.

The circuit diagram for the robot arm and the stations controlling the arm.

SolidWorks/SVG files

Arduino Code

The gripper design was adopted from here

Our report: Rippling Bananas.

Panel Design:

Schematic:

Source code: banana

Surprisingly, parts of the museum that were extremely cool programmatically such as Text Rain and the Wooden turning blocks were absolutely zero interest to kids.   Our Night table would work in the area near the dodging lights because it is dark there, After seeing what kids gravitate towards however, I don’t know if kids will like our project a lot.  We’ll see though!

My biggest observation was that children’s attention to a particular exhibit wasn’t necessarily proportional to its complexity.  Rather, I saw that kids were really attracted to things that they could pick up, throw, kick or manipulate all by themselves.  It was the tactile quality of the exhibits that they loved most rather than the visual qualities.  I also saw that their attention was held if they got an immediate reaction (and hence reward) from the exhibits.  They seemingly did not have the patience to explore something if there was an obscure or hidden meaning.  They quickly got bored and moved on.

As we went through the museum we also earmarked the places which might be suitable for our own exhibits.  Since we need our work to be hung from the ceiling, this was a bit of a challenge.

These interactions let me to think more about our cloud project and how to improve the discovery and interaction amongst any children that are near.