For the final project, I decided to make a little robot that paints to the user’s pulse rate. By attaching themselves to the sensor, they trigger the paint brush to move. Whilte it would have been nice to have a mechanical arm that could dabble more paint on the brush, I think that squeezing paint directly on the paper also really worked. Here are some images:
And Finally, a little video:
Pulse Painter from Elizabeth Clare on Vimeo.
These are some images of my rough prototype for using a pulse sensor to trigger a paintbrush. On the left is a picture of a brush hanging from a box, being vibrated by the pulse sensor. On the right is a painting created with two different heartbeats.
So, I am completely confused by the wires to switch states…..What I have now grabs each case and will use the speaker and the LED in the exact state its in when I press a number….
and here’s the code:
int speakerPin= 7;
int ledPin = 3;
int sensorPin = 5;
int potPin = 0;
int sensorVal;
int potVal;
int LEDbrightness;
int toneChange;
int sensorTime;
void setup()
{
pinMode(ledPin, OUTPUT);
Serial.begin(9600);
}
void loop() {
if ( Serial.available()) // Check to see if at least one character is available
{
char ch = Serial.read();
switch(ch) {
case ‘1’:
//1st State controls LED dim level with the POT, and Speaker with the the PhotoCell
sensorVal = analogRead(sensorPin);
potVal = analogRead(potPin);
LEDbrightness = map(potVal, 0, 1023, 0, 255);
analogWrite(ledPin, LEDbrightness);
analogWrite(ledPin, (potVal/4));
tone(speakerPin, sensorVal*4);
// Serial.print(sensorVal);
// Serial.print(” “);
// Serial.println(potVal);
delay(20);
break;
case ‘2’:
//*2nd State controls LED dim level with Photocell, and Speaker Tone with POT
sensorVal = analogRead(sensorPin);
potVal = analogRead(potPin);
// sensorVal = 1023 – sensorVal;
LEDbrightness = map(sensorVal, 0, 1023, 0, 255);
analogWrite(ledPin, LEDbrightness);
toneChange =map(potVal, 0, 1023, 0, 255);
tone(speakerPin, toneChange);
Serial.print(sensorVal);
Serial.print(” “);
Serial.println(potVal);
delay(20);
break;
case ‘3’:
//*3rd State controls LED blink-rate with the POT, Speaker Tone with POT, and Delay Rate (for both) with PhotoCell
sensorTime = ((sensorVal)/10);
Serial.println(“sensor reading = “);
Serial.println(sensorVal); // the raw analog reading
Serial.println(” “);
Serial.println(“TIME reading = “);
Serial.print(sensorTime);
//Serial.print(” “);
// Serial.println(potVal);
sensorVal = analogRead(sensorPin);
potVal = analogRead(potPin);
LEDbrightness = map(potVal, 0, 1023, 0, 255);
analogWrite(ledPin, LEDbrightness);
// toneChange =map(potVal, 0, 1023, 0, 255);
// tone(speakerPin, toneChange);
//
// Serial.print(sensorVal);
// Serial.print(” “);
// Serial.println(potVal);
//
// delay(sensorTime);
delay(sensorTime);
digitalWrite(ledPin, LOW);
delay(sensorTime);
break;
case ‘4’:
// *4rd State controls LED blink-rate with the PhotoCell, and Speaker tone with PhotoCell.
sensorTime = ((sensorVal)/10);
sensorVal = analogRead(sensorPin);
analogWrite(ledPin, (potVal/4));
tone(speakerPin, sensorVal*4);
digitalWrite(ledPin,HIGH);
delay(sensorTime);
digitalWrite(ledPin, LOW);
delay(sensorTime);
break;
default :
Serial.print(ch);
Serial.println(” was received but not expected”);
break;
}//switch
} //serial available
} //void loop
int RCtime(int RCpin) {
int reading=0; //startwith0
// set the pin to an output and pull to LOW (ground)
pinMode(RCpin, OUTPUT);
digitalWrite(RCpin, LOW);
// Now set the pin to an input and…
pinMode(RCpin, INPUT);
while (digitalRead(RCpin) == LOW) { // count how long it takes to rise up to HIGH
reading++; // increment to keep track of time
if (reading == 30000) {
// if we got this far, the resistance is so high // its likely that nothing is connected!
break; // leave the loop
} }
// OK either we maxed out at 30000 or hopefully got a reading, return the count
return reading; }
Here is my Simon Says game!!
<p><a
AND THE CODE:::
//buttons
const int greenSwitch = 10; //green
const int blueSwitch = 8;//blue
const int redSwitch = 4;//red
const int yellowSwitch = 6;//yellow
//leds
const int greenLED = 9;
const int blueLED = 7;
const int redLED = 3;
const int yellowLED = 5;
//values
//const int greenValue=1; // declare values for colors for buttons
//const int blueValue=2;
//const int redValue=3;
//const int yellowValue=4;
const int redValue = 1; // declare values for colors for buttons
const int yellowValue = 2;
const int blueValue = 3;
const int greenValue = 4;
const int speakerPin = 2;
int playerSays=0;//value to hold user imput
int playerStep=0;//user step counter;
boolean simonDone;
int simonSays[99]={
};// array that holds simon’s sequence, allows for 99 steps
int nextStep = 0; //var that counts how many steps in simon’s current sequence, used to move up in steps
int simonSpeed = 500;
void setup () {
Serial.begin(9600);
//Serial.println(“Try to Guest the Contents of simonArray, try a number between 1-4!”);
pinMode(greenLED, OUTPUT);
pinMode(blueLED, OUTPUT);
pinMode(redLED, OUTPUT);
pinMode(yellowLED, OUTPUT);
pinMode(speakerPin, OUTPUT);
pinMode(greenSwitch, INPUT_PULLUP); //set pull-up resistors on Buttons, So closing the switch will bring Pin to Ground.
pinMode(blueSwitch, INPUT_PULLUP);
pinMode(redSwitch, INPUT_PULLUP);
pinMode(yellowSwitch, INPUT_PULLUP);
randomSeed(analogRead(0)); //seed makes more random
}
void loop () {
if (simonDone ==false) { //did simon play sequence yet? bool is false by default
simonSays[nextStep] = random (1,5);
// Serial.println(“simonDone ==false”);
Serial.print(“nextStep: “); ///just to see whats happening
Serial.println(nextStep);
Serial.print(“simonSays: “);
// Serial.print(“simonSpeed: ” ); // Show how the new time feature works
// Serial.println(simonSpeed); // Show how the new time feature works
// Serial.print(“simonSays: “);
for(int i=0; i <=nextStep; i++) {
Serial.print(simonSays[i]); //to see count
Serial.print(",");
delay(simonSpeed);//controls speed that simonSays something
ToneAndLight(simonSays[i]);
}
//simonSpeed=(simonSpeed-(nextStep*5)); //THis speeds up simon on each turn by formula (500-(nextStep*5)
//Change the multiplier (5 here) to make game faster or slower
//multiplier=MAJOR factor in how hard game is
simonSpeed=max(simonSpeed, 200);//max() assigns simonTime to the larger of simonTime or 200 in this case
//Sets Simon's top speed. Also important in making game interesting yet winable
simonDone=true; //ok, simon done, set to true
//Serial.println(" ");
nextStep++; //add another to simon's sequence
playerStep=0; //make user step from first step
}
if (simonDone==true) {
if (playerStep =nextStep) {
simonDone=false; //user completeed successfully, give simon next turn
// nextStep++; //add another step to simons sequence
}
}
}
if(color == 1) // 1 = Red
{
digitalWrite( redLED,HIGH);
tone(speakerPin,1000);
delay(simonSpeed);
digitalWrite( redLED,LOW);
noTone(speakerPin);
}
if(color == 2)
{
digitalWrite( yellowLED,HIGH);
tone(speakerPin,2000);
delay(simonSpeed);
digitalWrite( yellowLED,LOW);
noTone(speakerPin);
}
if(color == 3)
{
digitalWrite( blueLED,HIGH);
tone(speakerPin,3000);
delay(simonSpeed);
digitalWrite( blueLED,LOW);
noTone(speakerPin);
}
if(color == 4)
{
digitalWrite( greenLED,HIGH);
tone(speakerPin,4000);
delay(simonSpeed);
digitalWrite( greenLED,LOW);
noTone(speakerPin);
}
}
void youLose() {
//LOSE SOUND #4*****
// tone(speakerPin,200);
// delay(400);
// tone(speakerPin,100);
// delay(600);
// tone(speakerPin,50);
// delay(1500); ///play with dealy “ratio”
// noTone(speakerPin);
for (int y=200; y>80; y-=50){
tone(speakerPin, y);
delay(150); ///play with dealy “ratio”
tone(speakerPin , (y-30));
delay(100);
noTone(speakerPin);
delay(50);
}
nextStep = 0;
playerStep = 0;
simonSpeed = 400;
simonDone = false;
delay(1500);
restartSeq();
delay(1500);
}
///DONT USE YET
void restartSeq(){
tone(speakerPin,600);//800
delay(100);
digitalWrite(redLED,HIGH);
digitalWrite(yellowLED,HIGH);
digitalWrite(blueLED,HIGH);
digitalWrite(greenLED,HIGH);
tone(speakerPin,700);//850
delay(100);
digitalWrite(redLED,LOW);
tone(speakerPin,900);
delay(400);
digitalWrite(yellowLED,LOW);
tone(speakerPin,1000);
delay(300);
digitalWrite(blueLED,LOW);
tone(speakerPin,2000);
delay(250);
digitalWrite(greenLED,LOW);
tone(speakerPin,3000);
delay(200);
noTone(speakerPin);
}
Here is the code I have so far in terms of the game: at the bottom is the tone and light (not sure how to otherwise upload the code)
///Attempt to get simon to listen for user imput
//program Arduino to listen for user imput and compare it to what Simon says.
//The out come should trigger a lose sound, or tell Simon to say something next.
//LOSE SOUND #4*****
// void loop() {
// for (int y=200; y>80; y-=5){
// for (int x=300; x>50; x-=25){
// tone(6, y);
// delay(200); ///play with dealy “ratio”
// noTone(6);
// delay(10);
// tone(6, x);
// delay(300); ///play with dealy “ratio”
// noTone(6);
// delay(10);
// }
// }
// delay(7000);
// }
//buttons
const int switch1 = 2; //green
const int switch2 = 3;//blue
const int switch3 = 4;//red
const int switch4 = 5;//yellow
//leds
const int greenLED = 8;
const int blueLED = 9;
const int redLED = 10;
const int yellowLED = 11;
//values
const int greenVal=1; // declare values for colors for buttons
const int blueVal=2;
const int redVal=3;
const int yellowVal=4;
const int speakerPin = 12;
int counter=0;
Serial.begin(9600);
Serial.println(“Try to Guest the Contents of simonArray, try a number between 1-4!”);
int playerSays;
boolean simonDone;
int simonSays[99]={};// array that holds simon’s sequence, allows for 99 steps
//int playerSays[99]={};
int nextStep = 0; //var that counts how many steps in simon’s current sequence, used to move up in steps
int simonSpeed = 500;
void setup () {
pinMode(greenLED, OUTPUT);
pinMode(blueLED, OUTPUT);
pinMode(redLED, OUTPUT);
pinMode(yellowLED, OUTPUT);
pinMode(speakerPin, OUTPUT);
// pinMode(switch1, INPUT);
// pinMode(switch2, INPUT);
// pinMode(switch3, INPUT);
//
// digitalWrite(switch1, HIGH); //turn on internal pull-up on siwtch1
// digitalWrite(switch2, HIGH);
// digitalWrite(switch3, HIGH);
// Serial.begin(9600);
randomSeed(analogRead(0)); //seed makes more random
}
void loop () {
if (simonDone ==false) { //did simon play sequence yet? bool is false by default
simonSays[nextStep] = random (1,5);
// Serial.println(“simonDone ==false”);
Serial.print(“nextStep: “); ///just to see whats happening
Serial.println(nextStep);
Serial.print(“simonSpeed: ” ); // Show how the new time feature works
Serial.println(simonSpeed); // Show how the new time feature works
Serial.print(“simonSays: “);
for(int i=0; i <=nextStep; i++) {
Serial.print(simonSays[i]); //to see count
Serial.print(“,”);
delay(simonSpeed);//controls speed that simonSays something
playToneAndLight(simonSays[i]);
}
simonSpeed=(simonSpeed-(nextStep*5)); //THis speeds up simon on each turn by formula (500-(nextStep*5)
//Change the multiplier (5 here) to make game faster or slower
//multiplier=MAJOR factor in how hard game is
simonSpeed=max(simonSpeed, 200);//max() assigns simonTime to the larger of simonTime or 200 in this case
//Sets Simon’s top speed. Also important in making game interesting yet winable
delay(500);
simonDone=true; //ok, simon done, set to true
Serial.println(” “);
}
if (simonDone==true) {
// int val1=digitalRead(switch1);
// int val2=digitalRead(switch2);
// int val3=digitalRead(switch3);
// int playerSays[99]={
// val1=1,
// val2=2,
// val3=3,
// };// array that holds player’s sequence, allows for 99 steps
// Serial.println(“playerSAYS”);
// if (simonSays==playerSays) {
// tone(6, 800, 500); ///sound for getting it right
// digitalWrite(greenLED, HIGH); //turn led on as TEST
// delay(500);
// }
//
void playToneAndLight(int color)
{
Serial.print(“inside PlayToneAndLight “);
Serial.print(” color = “);
Serial.println( color );
if(color == 1) // 1 = Red
{
digitalWrite( greenLED,HIGH);
tone(speakerPin,1000);
delay(simonSpeed);
digitalWrite( greenLED,LOW);
noTone(speakerPin);
}
if(color == 2)
{
digitalWrite( blueLED,HIGH);
tone(speakerPin,2000);
delay(simonSpeed);
digitalWrite( blueLED,LOW);
noTone(speakerPin);
}
if(color == 3)
{
digitalWrite( yellowLED,HIGH);
tone(speakerPin,3000);
delay(simonSpeed);
digitalWrite( yellowLED,LOW);
noTone(speakerPin);
}
if(color == 4)
{
digitalWrite( redLED,HIGH);
tone(speakerPin,4000);
delay(simonSpeed);
digitalWrite( redLED,LOW);
noTone(speakerPin);
}
}
// Serial.println(“simonDone ==true”);
delay(500);
Serial.println(“User got it right, add a new step and give Simon a Turn”);
simonDone=false; //user completeed successfully, give simon next turn
nextStep++; //add another step to simons sequence
}
}
I went and looked around at possible enclosures for the simon game.
I found some plastic and wooden boxes, and then later thought about halloween and beer.
Here are some of my sketches:
Having trouble uploading the arduino file for sounds…?
At maker Faire on Saturday, there were three projects I really liked:
1. The Most Useless Machine EVER!
This was made by Brett Coulthard from Canada. His machine is quite simple, when a person turns the switch on, the box opens and a small hook comes out and turns the switch off, then slowly retreats back into the box. I found this box to be really amuzing, and I kept turnign the switch on, as if I could somehow out wit the box. It reminded me a lot of human behavior, how we can constantly do the same thing hoping for a different outcome. Also the mechanism and machine was super simple, but really effective.
2. flipbookit
This was a beautiful art piece turned open-source kit made by Mark, Steve, and Wendy. Its actually on kickStarter now, in order to create it into a sellable kit. The aesthetics were beautiful; touching on the current trend of nostalgia and analog machines, they created these illustrated flip books housed in industrial metal boxes. The kind of thing you would want hanging on your wall. I really liked the way they set up three next to eachother, so that the story continued from one book to the next. Very captivating.
3. Solar Symphony
I’ve worked with photo sensor cells to play with the sound of light, but I think Solar Symphony really took this idea a lot further. Created by Chris Kaczmarek, he uses very small solar panels (that almost look like blown glass) to gain solar energy, and power circuits which create sound. Each of his objects were aesthetically different (though a lot of them used metal dowels) and also created different sounds. I was really drawn to the small egg installation, because although difficult to hear, it made a strong impact watching the delicate eggshells.
Evander Batson
xinhe feng
FluffyLeecy
frankiezek
gaboratparsons
giang063
gracegotlost
lauriewaxman
Siwen Li
Tim Xiaofeng Lin
Yury Gitman
mar28th
Max(TONG WEN)
Soohyun
sabotai
Susan Lin
Making Toys 
Reply