Updates from February, 2011 Toggle Comment Threads | Keyboard Shortcuts

  • andywallace 11:23 pm on February 7, 2011 Permalink | Reply  

    Week 2 Writing Response 

    Original post: https://makingtoys.net/2011/02/07/space-squid-with-lee-williams/


    1) Explain (in a  nutshell) your code structure, logic, important parts.

    2) What did you do that you feel is new, non obvious, and useful.

    The code works by putting the creature in one of several states, each of which cause a sound and sometimes an addition effect based on how long it has been in that state. There is one additional state that takes precedence over all others: Dead. The behavior of the creature is completely different while it is dead.

    While alive, the creature will either be excited, neutral, or screaming. Each of these values are defined by the level of light going to the photoresistor. The code will only change the state (which is storred as a string for readability’s sake) if the value from the photoresistor corresponds to a state that it is not currently on. When this happens, the state changes and the counter is set to 0.

    The counter is used to effectively create two additional states: bliss and dying. If the counter gets high enough while the creature is excited, the bliss sound will play. And if the counter gets too high while the creature is screaming, the death sound will play and the creature will be set to dead.

    When dead, the creature makes a psuedo randomly generated death gurgle every so often and can only be revitalized by being kept in the dark uninterrupted for a set period of time. At this point it will play the revitalize sound and come back to life.

    One of the less obvious solutions we had was for the excited sound. We originally set it so that the pitch was affected by the level of light coming in. And this worked reasonably well, but if a user kept the same level of light, the creature would make almost the same sound over and over and it didn’t really sound like it was getting more excited before it played the bliss sound. To add to the effect, we had the pace of the tone be dependent on how long it had been in the excited state. The result is a fairly dynamic sound dependent on both the light level and the counter value. And no matter how the user accomplishes it, the creature definitely sounds like it is getting more and more excited before the bliss sound finally plays.

    I found that our code for setting the state was useful. We were constantly getting a value from the photoresistor, but didn’t want the state to be updated with every iteration of the loop because we wanted a counter to keep track of how long the creature has been in a given state. Although there are obviously many solutions to this, ours looked like this:

    if (reading<excitedPoint && state!=”excited”){

    This was repeated for all three of our potential states
    I liked this, because it required very little additional code. If the reading is still within the range of excited, the fact that the state is still “excited” means this section will simply be skipped. If the state was anything else, the new reading will be acknowledged, the state will be set to excited, and the counter will be reset.

    A final useful if not entirely innovative feature, was setting the piezo with a potentiometer to control the volume while testing. Very easy, and saves a lot of headache.

  • hilalkoyuncu 11:22 pm on February 7, 2011 Permalink | Reply  

    Victor and Hilal, photo resistor prototype 1 

    For our photo resistor device we decided to make two stoners who smoke different kinds of weeds, one GOOD weed, one BAD weed.

    Ours stoners would communicate how high they are by reflecting their state of mind in music.

    My part of the project was to design the BAD weed smoker.

    1) Explain the code in a nutshell: logic, important parts:

    The code was written so that it the stoner will get high as he smokes more weed. Lighting up the joint would intuitively establishes this. The stoner is always in a state of being moderately high, cause he smokes all the time. When he sobers up he would feel at the lowest level of his emotions, apathetic to world almost.

    To create the illusion of life, meaning life happens gradually, introduced the component of time into our code. To switch from the last state of emotion(blitzed) to the state of no emotion(sleep), the user has to generate the last state for a period of time(2 seconds) in order for it to finalize the program.

    This was originally planned to be applied to switch each state of emotion to the next one, hopefully this will be accomplished in the next iteration.

    2)what did you do that you feel is new, non obvious and useful.

    We felt that using the light sensor to create an analogy of a lighter, even though was obvious, it was innovative. I am not sure if anyone has tried to do it before. In any case this actually made the interaction better because of affordances, how would a user possibly interact with a smoker if he/she is given a lighter?

    It is a useful design to create entertainment.

    We hope to refine the code and the prototype further.

    Here is a link to the prototype:


    Here is the code:

    //*hilal koyuncu*//**shwag smoker-2011**
    #include "hilal_pitches.h"
    const int sensorPin = 0;
    int sensorValue = 0;     int sensorMin; // sensor minimum, discovered through experimentint sensorMax; // sensor maximum, discovered through experimentint time;//time that has passed since the melody started playing
    int lullaby[] = { NOTE_G6, NOTE_G6,  NOTE_AS6,  NOTE_G6, NOTE_G6,  NOTE_AS6,  NOTE_G6, NOTE_AS6, NOTE_DS7,  NOTE_D7, NOTE_C7, NOTE_C7,   NOTE_AS6,  NOTE_F6,  NOTE_G6,  NOTE_GS6, NOTE_F6,  NOTE_F6, NOTE_G6, NOTE_GS6, NOTE_F6,  NOTE_GS6,  NOTE_D7, NOTE_C7, NOTE_AS6,   NOTE_D7,  NOTE_DS7};int duration[] = {      6,       8,         2.5,        8,       4,         2,        6,        10,        4,        3,       8,       4,       4,        6,       8,         4,       4,        6,       8,       2.5,       6,         8,        8,       8,        4,         4,         2};
    int sober[]={NOTE_D4,  NOTE_G4, NOTE_B4, NOTE_G4};int duration3[] ={2,         3,       3,       2};
    int buzzed[]={NOTE_DS4,  NOTE_FS4, NOTE_C5, NOTE_B4};int duration4[] ={2,         3,       3,       2};
    int high[]={NOTE_G4,  NOTE_B4, NOTE_C5, NOTE_B4};int duration5[] ={2,         3,       3,       2};
    int stoned[]={NOTE_DS2,  NOTE_DS2,  NOTE_DS2,  NOTE_DS2,  NOTE_DS2, NOTE_DS2 };int duration6[] ={2,         2,       16,          16,        16,             2};
    int ripped[]={NOTE_G4,  NOTE_A4,  NOTE_B4,  NOTE_B4, NOTE_G4,  NOTE_A4,  NOTE_B4,  NOTE_B4, NOTE_FS4, NOTE_E4, NOTE_DS4, NOTE_B4, NOTE_B4, NOTE_C5,  NOTE_B4, NOTE_B4, NOTE_A4, NOTE_A4, NOTE_B4, NOTE_G4, NOTE_A4, NOTE_G4, NOTE_AS4, NOTE_G4 };int duration7[] ={7,         8,       8,          1,     7,         8,       8,          4,        4,       8,       1,        16,        16,       4,        8,       16,       8,      16,       1,       8,       8,       8,        4,       2 };
    int melody2[] = { NOTE_DS4 };int duration2[] = {0};
    void setup() {
    Serial.begin(9600);        // calibrate during the first five seconds     while (millis() &lt; 5000) {    sensorValue = analogRead(sensorPin);    sensorMin =sensorValue/4;    if (sensorMin*7&gt;=1024){      sensorMax=sensorValue+20;     }    else {    sensorMax = sensorMin*7;     }     Serial.println(sensorMax);    }
    void loop() {      // read the sensor:    sensorValue = analogRead(sensorPin);
    // apply the calibration to the sensor reading    sensorValue = map(sensorValue, sensorMin, sensorMax, 0, 5);
    // in case the sensor value is outside the range seen during calibration    sensorValue = constrain(sensorValue, 0, 6);       //start testing the range//      switch (sensorValue) {    case 0:    // your hand is on the sensor    Serial.println("sober");
    time=0;    for (int thisNote3 = 0; thisNote3 &lt; 4; thisNote3++) {        int noteDuration3 = 1000/duration3[thisNote3];        tone(8, sober[thisNote3],noteDuration3);        int pauseBetweenNotes3 = noteDuration3 * 3;        delay(pauseBetweenNotes3);        noTone(8);
    }       break;              case 1:    // your hand is close to the sensor    Serial.println("buzzed");    time=0;    for (int thisNote4 = 0; thisNote4 &lt; 4; thisNote4++) {        int noteDuration4 = 1000/duration4[thisNote4];        tone(8, buzzed[thisNote4],noteDuration4);        int pauseBetweenNotes4 = noteDuration4* 3;        delay(pauseBetweenNotes4);        noTone(8);
    }      break;       case 2:    // your hand is a few inches from the sensor    Serial.println("high");    time=0;    for (int thisNote5 = 0; thisNote5 &lt; 4; thisNote5++) {        int noteDuration5 = 1000/duration5[thisNote5];        tone(8, high[thisNote5],noteDuration5);        int pauseBetweenNotes5 = noteDuration5* 3;        delay(pauseBetweenNotes5);        noTone(8);
    }       break;        case 3:    // your hand is nowhere near the sensor    Serial.println("stoned");    time=0;    for (int thisNote6 = 0; thisNote6 &lt; 6; thisNote6++) {        int noteDuration6 = 1000/duration6[thisNote6];        tone(8, stoned[thisNote6],noteDuration6);        int pauseBetweenNotes6 = noteDuration6* 3;        delay(pauseBetweenNotes6);        noTone(8);
    }       break;
    case 4:    // medium light    Serial.println("ripped");    time=0;    for (int thisNote7 = 0; thisNote7&lt;24; thisNote7++) {        int noteDuration7 = 1000/duration7[thisNote7];        tone(8, ripped[thisNote7],noteDuration7);        int pauseBetweenNotes7 = noteDuration7* 3;        delay(pauseBetweenNotes7);        noTone(8);
    }    break;        case 5:// full on light    Serial.println("blitzed");    Serial.println(time);    time++;
    for (int thisNote = 0; thisNote &lt; 27; thisNote++) {      if (time &lt; 2){        // to calculate the note duration, take one second         // divided by the note type.        //e.g. quarter note = 1000 / 4, eighth note = 1000/8, etc.        int noteDuration = 1000/duration[thisNote];        tone(8, lullaby[thisNote],noteDuration);        // to distinguish the notes, set a minimum time between them.        // the note's duration + 30% seems to work well:        int pauseBetweenNotes = noteDuration * 2;        delay(pauseBetweenNotes);        // stop the tone playing:        //     noTone(8);      }      else {        for (int thisNote2 = 0; thisNote2 &lt; 4; thisNote2++){          int noteDuration2 = 1000/duration2[thisNote2];          tone(8, melody2[thisNote2], noteDuration2);
    int pauseBetweenNotes2 = noteDuration2 * 2;          delay(pauseBetweenNotes2);
    }      }
    break;  }
    #define NOTE_B0  31
    #define NOTE_C1  33
    #define NOTE_CS1 35
    #define NOTE_D1  37
    #define NOTE_DS1 39
    #define NOTE_E1  41
    #define NOTE_F1  44
    #define NOTE_FS1 46
    #define NOTE_G1  49
    #define NOTE_GS1 52
    #define NOTE_A1  55
    #define NOTE_AS1 58
    #define NOTE_B1  62
    #define NOTE_C2  65
    #define NOTE_CS2 69
    #define NOTE_D2  73
    #define NOTE_DS2 78
    #define NOTE_E2  82
    #define NOTE_F2  87
    #define NOTE_FS2 93
    #define NOTE_G2  98
    #define NOTE_GS2 104
    #define NOTE_A2  110
    #define NOTE_AS2 117
    #define NOTE_B2  123
    #define NOTE_C3  131
    #define NOTE_CS3 139
    #define NOTE_D3  147
    #define NOTE_DS3 156
    #define NOTE_E3  165
    #define NOTE_F3  175
    #define NOTE_FS3 185
    #define NOTE_G3  196
    #define NOTE_GS3 208
    #define NOTE_A3  220
    #define NOTE_AS3 233
    #define NOTE_B3  247
    #define NOTE_C4  262
    #define NOTE_CS4 277
    #define NOTE_D4  294
    #define NOTE_DS4 311
    #define NOTE_E4  330
    #define NOTE_F4  349
    #define NOTE_FS4 370
    #define NOTE_G4  392
    #define NOTE_GS4 415
    #define NOTE_A4  440
    #define NOTE_AS4 466
    #define NOTE_B4  494
    #define NOTE_C5  523
    #define NOTE_CS5 554
    #define NOTE_D5  587
    #define NOTE_DS5 622
    #define NOTE_E5  659
    #define NOTE_F5  698
    #define NOTE_FS5 740
    #define NOTE_G5  784
    #define NOTE_GS5 831
    #define NOTE_A5  880
    #define NOTE_AS5 932
    #define NOTE_B5  988
    #define NOTE_C6  1047
    #define NOTE_CS6 1109
    #define NOTE_D6  1175
    #define NOTE_DS6 1245
    #define NOTE_E6  1319
    #define NOTE_F6  1397
    #define NOTE_FS6 1480
    #define NOTE_G6  1568
    #define NOTE_GS6 1661
    #define NOTE_A6  1760
    #define NOTE_AS6 1865
    #define NOTE_B6  1976
    #define NOTE_C7  2093
    #define NOTE_CS7 2217
    #define NOTE_D7  2349
    #define NOTE_DS7 2489
    #define NOTE_E7  2637
    #define NOTE_F7  2794
    #define NOTE_FS7 2960
    #define NOTE_G7  3136
    #define NOTE_GS7 3322
    #define NOTE_A7  3520
    #define NOTE_AS7 3729
    #define NOTE_B7  3951
    #define NOTE_C8  4186
    #define NOTE_CS8 4435
    #define NOTE_D8  4699
    #define  R
  • Oylum 11:22 pm on February 7, 2011 Permalink | Reply  

    Week 2 Writing Response 

    The project link: https://makingtoys.net/2011/02/07/lucysam-are-brothers-and-sisters/

    1. Explain (in a nut shell) your code – structure, logic, important parts.

    My small teddy bear is sensitive to light, I use a photo resistor to measure the level of light. I wanted to code it in a way that he seems to like dark better than light by making calmer sounds when it’s dark and making crazy noise when it’s light. My code starts by defining the pins for the speaker and the LED light. It then reads values from the light sensor. Then i mapped the values that I read from the sensor to the frequencies the speaker can play using the “tone” function. I have 3 different frequency ranges that are changed with the values of the sensor.

    I also mapped the brightness of the LED light to the sensor values, so the LEd gets lighter when the light is up and sound is getting crazy. LED gets darker when the room gets darker, like the bear finally found some peace to go to sleep. I intentionally chose blue light as this is a boy.

    He actually has a sister, which is doing the reverse action, getting peaceful with light and go crazy with dark. It is programmed by my partner Kate.

    2. What did you do that you feel is new, non-obvious and useful?

    The bear looks cute and when you first look at it, it’s just a toy that makes a weird sound with a LED light on. However, the sound starts to change unexpectedly when you make even a little move towards it, as it gets affected by light changes. Suddenly, you feel like it somehow is talking to you, it is not a toy that sits there by itself, instead, it wants you to get involved  and play with it. It is not playing melodies and the sound it makes is very obnoxious, because, I wanted it to emphasize the importance of reaction in there. I dont know if it’s useful, but it’s somehow different than classic toy in a box.

  • Thom Hines 11:21 pm on February 7, 2011 Permalink | Reply  

    Pre-class Musings… 

    Explain your code structure, logic, important parts

    The code for my “creature” follows a very simple programming pattern. First of all, the loop() handles most of the logic, and depending on the current lighting conditions, it will run one of several functions that play a corresponding sound. By breaking the code up into chunks, each part could be created and tested separately.

    The loop() initially takes input from the photoresistor and evaluates whether this makes the creature happy or sad. The higher the light level, the “sadder” the creature becomes. When no extraordinary conditions are occurring, the program will run the normal sound function. This function will play a small sound sample that bases it’s top-most frequency and tempo on the excitement of the creature. The happier the creature, the faster and higher pitched the creature’s voice becomes. These changes are not immediate, but as a reaction to a higher or lower level of light. It is only over time that the mood really changes.

    If there is a sudden and large change in light, the creature will react much more abruptly and either scream out in rage (low to high light change), or a sigh of relief and joy (high to low light change). Furthermore, if the creature exists in the high light levels for a long time, there is a function that initiates the creatures death, after which it needs to be revived by hiding it from light for a short while.


    What did you do that you feel is new, non-obvious and useful

    One feature that my partner Bree and I did that I haven’t seen in other people’s work is to account for rapid changes in light. Essentially, we are not just looking at how light affects the sound of the creature, but the speed at which light changes. In many ways this is how most creatures are, including humans. We endure changes for the worse when they happen incrementally, and we take small positive changes for granted, but as soon as something big changes quickly, people and animals become quite vocal and the pain/elation is much more apparent. It’s a very recognizable aspect of life and we wanted to incorporate this tendency into our creatures. Furthermore, this gives time and the light level a certain active quality as well. Instead of just being a value that directs our creatures in a one-to-one sort of way, allowing for changes that happen at different speeds gives another avenue of interaction and depth, like moving from a static velocity to one with acceleration.

  • scottpeterman 11:21 pm on February 7, 2011 Permalink | Reply  

    Illusion of Life – Free Write Scott 

    View Whiny Baby Project

    1. Explain in a nutshell your code – structure, logic, important points

    Our code was based on the pitch-follow example from arduino.cc. Last week, we really enjoyed the oscillating sounds made by varying the tone back and forth with for loops and wanted to explore this more deeply. This also allowed use to create a device that utilized the full spectrum of sound the speaker could create.
    (More …)

  • Chris Piuggi 11:21 pm on February 7, 2011 Permalink | Reply  

    In class writing on illusion of life 

    1. Explain (in a nut shell) your code structure, logic, important parts.

    The lightbird works off of a complex series of conditional statements, based on the ambient light in the space it ‘lives in’. The reason for this is that the bird has seven varying emotional states – which allow it to express happy, unhappy, feeding, full, hunger, depression, and death. If the bird is in ideal light, the bird is happy, if it is too dark the bird is unhappy, and if the light is very bright, the bird will feed. This is where the complexity comes in, if the bird is unhappy for too long it will become hungry, and need food to eat. Conversely if you feed the bird too much, it will become full. If the bird remains full or hungry for too long, the bird becomes depressed. Once depressed, the bird has the chance to die, if you do not correct your mistakes.

    All the code is written using Object oriented code, all the melodies are stored in multi-dimensional arrays, and are accessed through a class of emotions.

    2. What did you do that you feel is new, non-obvious and useful.

    In this assignment Alvaro and I attempted to create a consistent voice, in order to grow the character. In doing this we were able to personify this object to have a variety of feelings and needs, which a user must attend to. This in turn could provide a user with a friend which could be cared for over long periods of time, to teach lessons about how to care and treat real animals. In the emotions we picked, we attempted to create a non-linear approach to how the ‘bird’ experiences the world around it personifying not only the sounds, but the actual emotions that it experiences. By creating levels within the emotions we were able to create a complex being with a variety of needs, similar to a real creature or pet.

    Read more about the project here »

  • catherine 11:20 pm on February 7, 2011 Permalink | Reply  

    Writing Assignment about Lucy – 02/07/2011 

    1) Explain (in a nutshell) your code structure, logic and/or important parts.

    The code structure starts with identifying all variables. Then pairs or maps pitches to the amount of light coming through. The most important part of the code is the Serial.print function because it provides information from the photocell so you know if it’s working!


    2) What did you do that you feel is new, non-obvious and/or useful?

    Lucy makes a high pitch annoying noise that no one has ever made before. It is wretched. Lucy & Sam together are new/non-obvious because one is afraid of the dark and the other is afraid of the light, therefore they work together to protect each other. .

  • minho 11:19 pm on February 7, 2011 Permalink | Reply  

    Minho Illusion of Life Project 


    1) My code is based on the first code of this link (http://www.arduino.cc/en/Tutorial/PlayMelody), I added melody arrays, then used switch and case object and If function.

    with If function it gets time line each dark an light situation has  3 steps. I also use map function, it controls time delay, so get more interaction with light.

    2) I think this structure what I made for my bug would be pretty useful for later, whenever I make things has a timeline and reaction by sensor.

  • Alvaro Soto 11:19 pm on February 7, 2011 Permalink | Reply  

    Questions week 3 

    link to Lightbird project

    1. Explain (in a nutshell) your code structure, logic, important, parts

    2. what did you do that you feel is new, non-obvious, and useful


    1.The code structure is written in multidimensional arrays that store each one of the melodies that are triggered by the light sensor. The logic is a set of conditionals that calculate the time in which the sensor is reading light. We used this time to change from one stage (mood) to another, same logic applies to the time the sensor is not reading any values or reads values bellow a margin defined in the code.

    Is important to note that thanks to multidimensional arrays we developed a much cleaner, simple code.  One thing to develop further is a threshold at the last step of the logic in which the mood (death of the bird) cant be resolved. In other words once the bird is in the mood before death is inevitable to stop the array so at the end Lightbird will always die. (Take a look at the video) .

    2. We felt very good with our simple approach to the project, defining one of our previous sounds as the starting point. We also chose to used another device (Ipad) to compose the sounds and then put them in the code.

    Is useful the way we decided to prototype since it has a good quality but still has a “in process feeling” that give us the freedom to iterate multiple times after this one.



  • Lee 11:18 pm on February 7, 2011 Permalink | Reply  

    Explanation Questions 02.07.2011 

    Space squid of doom!

    Explain (in a nutshell) your code, structure, logic, important parts.
    The logic behind our code structure is built around the states of our creature. Whether it’s happy, neutral or upset. We identified the levels of brightness in which each state should be active. When the creature is in full darkness it is most content, if it stays in the state for determined length of time it will go into bliss mode. If the creature is in shadow, so mostly in darkness it’s neutral, if it starts getting lighter it gets upset. While upset it’s vocalizations will increase in pitch and tempo based ont he length of time it is in light and how bright it is. If it stays int he light too long it will die. Once dead the creature needs to be placed in full darkness for a length of time for it to revive.

    What did you do you feel is new, non-obvious, and useful.
    What we accomplished that’s new/useful is creating tones and vocalizations that can be increased in tempo and pitch to indicate in a kind sliding scale how happy or sad the creature is before reaching it’s extreme states of bliss and death.

  • lpercifield 11:18 pm on February 7, 2011 Permalink | Reply  

    In Class Writing Feb 7 

    You can see the homework post here.

    1. Explain (in a nutshell) the code; structure, logic, important parts.

    Basically the code starts with the arduino playing a set note. This note modulates up and down over a set period of time. The arduino records the brightness of the ambient light using a photo resistor. This value is then added or subtracted from the original note. The addition or subtraction is set to allow the “creature” to either want light or dark. In our code the “creature” is happiest at a lower note and is upset at a higher note. At a set point in the low scale of the code a vibrating motor is triggered to create a “purr” effect.

    An important part of the code is calculating the amplitude of the sounds and to control the rate at which the sounds modulate up and down. This is done to create a soothing effect. This helps to represent the mood of the creatures.

    2. What did you do that you feel is new, non-obvious, and useful

    The nature of the interaction and the way in which the feedback is represented is new and useful. The feedback from the photo resistor is buffered so that sounds don’t change immediately. The notes are completely generative in nature except of the initial starting point and the minimum and maximum settings. The application of a vibrating motor and its placement in the enclosure add a second dimension of sound to the experience.

  • breegeek 11:17 pm on February 7, 2011 Permalink | Reply
    Tags: creature, , predator, prey   

    Creature prototype 1 freewriting 



    1 -Explain your code

    As a team, we decided to make one creature a predator and the other its prey. The code we attempted to write had varying levels of behavior based on the abruptness of changes to the creature’s situations in a way that made it have apparent character.

    Since I worked primarily with the “prey” model (I call him “Meat”), I wanted my guy to exhibit the behaviors of a dayturnal prey animal. So, he’s pretty happy when there’s light and begins to panic when darkness falls. If there is abrupt darkness, he screams and the shock kills him. I also wanted to add a “Lazarus function” to revive him with a bright burst of light.

    After monitoring “normal”, “bright”, and “dark” values from my photoresistor, I started to structure the logic around “if this … then this”, writing functions for each. Then, I tried testing different pitches and lengths of tones to determine what sounds made the most sense. For example, I have the scream raise in pitch as a steady tone until it is almost unbearable to hear. It is followed by a crunchy “death” sound and silence. When he’s happy, however, he plays a Major 3-note progression, kind of like happy whistling. As his panic rises, the speed of his sounds increases to simulate frantic fear.

    The code relies heavily on conditional statements in order for the creature to respond to his situation and the degrees of change in it.

    2-What did you do that was innovative, non-obvious, and useful?

    I think making a sense of panic from the sounds was a bit non-obvious. One might think he should only get less happy-sounding, but I think if we are going to sell the idea that he is afraid of the dark because he might get eaten, he should have a sense of panic, almost like rapid breathing or heart-beats. Whether or not it is innovative, I am not sure, but I definitely think it is useful in telling the story of “Meat” and his antagonist.

    I also think the idea of having two creatures, one predator and one prey, completes a fuller narrative than “Meat” could do by himself. The fact that there is another creature “Eater” stalking him in the dark adds dimension to his character.

  • thisisvictorkim 11:17 pm on February 7, 2011 Permalink | Reply  

    In Class Writing 02/07/11 

    My Project

    “Explain (in a nutshell) your code structure, logic, important parts.”

    My code starts out by reading the room’s light and then creates a limit, based on the code, as far as how dark and how bright of light it will read. By using these parameters, it then plays different sounds based on how dark or light the photocell resistor reads.  It is a bit broken now, but if the resistor reads the highest capacity of brightness for 10 seconds consecutively then the speaker plays the intro to Bob Marley’s (RIP) song “Buffalo Soldier”.  This is done to simulate the utmost euphoric state of THC highness.  At its darkest state, the program plays a disenchanted, depressed sound to simulate sobriety.  Between these two sounds there are 5 more levels of THC intoxication represented by different sounds.

    “What did you do that you feel is new, non-obvious, and useful”

    This project is not useful whatsoever, let’s just get that out there.  However as far as new and non-obvious, my project was a left field approach to an assignment that called for the construction of a “creature” that responds to light and dark.  In the context of my project, the creature is both the stoner’s joint and his state of being.  Instead of a creature or plant that receives light to grow or be happy, my project uses light as a metaphor for a stoner’s lighter that he or she would use to light up a joint.  I thought this was a creative approach to this assignment.

  • Alvaro Soto 11:05 pm on February 7, 2011 Permalink | Reply  


    This lightbird I made with Chris Piuggi needs to be fed with light and he would tell you if he is actually being fed. but you can not give him too much food because he can get full then depressed and finally die. although if you don’t give him food he will be angry and then sad. Eventually he will die. So lightbird you need to keep him in the right combinations.

    Download the code here:

  • Chris Piuggi 11:01 pm on February 7, 2011 Permalink | Reply  

    Light Bird 

    For this assignment we created a little bird who loves and feeds off of the light.

    The Bird has seven different emotions below is a chart of the emotions and how they work together.

    When the Bird is in ideal light he is happy, when he is in bright light he is feeding, and in dull light, he is unhappy. If you feed the bird too much light, he will become full, and if he says full for too long he will become depressed. Additionally, if the bird remains in dark light the bird gets hungry, and if it says hungry, the bird will become depressed. If depressed it is in danger of dying.

    Here are some shots of putting together our bird:

    download the code here »

  • scottpeterman 10:49 pm on February 7, 2011 Permalink | Reply  


    These are very noisy sonographs! These babies are yet unborn. But they are sooo whiny, crying so loud. One likes darkness. One likes light. If they get what they want they calm down and purr, like good babies do. If they don’t, they cry so loud!

    Arduino with photo resistor, 8 Ohm speakers, vibrating motor inside a plastic tub.

    (More …)

  • Oylum 10:38 pm on February 7, 2011 Permalink | Reply  

    Lucy&Sam are brothers and sisters… 

    Lucy loves being in light and she is so afraid of dark. On the other hand, Sam is a naughty boy that loves dark and gets crazy when it’s too light.

    Sam is my robot boy and Lucy is Kate’s robot girl.

    The sounds could have been much better I know, only if I could program sounds better in Arduino. Here is the code for it.

  • thisisvictorkim 10:36 pm on February 7, 2011 Permalink | Reply  

    Come On Baby Light My Fire 



    I composed a few of the sounds by just fiddling around with different types of chords using a MIDI keyboard and Garage band.


    After all the programming was done I laid the breadboard on top of two cigarette boxes in a Lipton tea box.  I also cut holes for the speaker and photocell.

    An illustration later and voila!  You got yourself a stoner!

    Here is the code

Compose new post
Next post/Next comment
Previous post/Previous comment
Show/Hide comments
Go to top
Go to login
Show/Hide help
shift + esc