Response to Part 3 of Remix | Zeerak Fayiz

In Part 3 of the Remix by Lawrence Lessig, he basically talks about how copyright laws should be changed, in order to make them more efficient. One of the ways he tells us about is by waiving amateur use of materials with copyright. He explains that this would not only reduce the copyright stress from big companies, but will also make things a lot easier; it will give a creativity a chance to survive.

He gives us examples, such as those from the old copyright laws very far back, when people had to register and pay for copyright, and then have to renew it after a while, but then many people would just not renew it for various reasons (many would just forget). As a result, a lot of the content that was created back then would just become public, and anyone could use them in whatever way they wanted. Hence, they changed the law and made all content, regardless of who created it as entitled to having copyright. This seemed like a very good move, but this is what actually made things complicated. I feel this example gave me a very good insight into how the copyright law started off, and how it got to where it stands today.

The example for misuse of content (of Warner) also made me further understand (more clearly than before) what problems one may encounter with the content that one has produced, and how the solution that the author is proposing is very practical – if copyright would just exempt the noncommercial use of content, then Warner would not be responsible for how someone else (amateur) is using their content.

All in all, I feel that the solution proposed by the author is very practical, and there is actually a live example that can prove it. In 2014, Elon Musk, the CEO of Tesla Motors, “released patents to ‘good faith’ use” (Forbes). Musk talked on a line of thinking that is similar to that of Lessig, where his company “felt compelled to create patents out of concern that the big car companies would copy [their] technology and then use their massive manufacturing, sales and marketing power to overwhelm Tesla” (Forbes). However, he goes on to say that “[they] couldn’t have been more wrong” (Forbes) – by doing this Tesla basically exempted itself from complications, and made things easier for everyone (and more efficient for themselves), in order to have a better and sustainable future for all of us.

Hence, reflecting on the example, I would say that changing the copyright laws and making exemptions from them would be a great thing, only if everyone believed in and implemented ‘good faith use’, like Tesla did – which would also give more freedom to remix culture, and hence, creativity as a whole for generations to come.


Week 7: Audio Project by Kevin and Sherry

Partner: Kevin

Link to our interactive DJ set

Codes: javascript, css (I have modified the name of variables and functions in the codes and hope you can understand how it works better:) )

For the audio project we made an interactive DJ set in which people can make their own remix of songs by choosing the background tempo, the beginning, the middle and the ending song. Our inspiration came from this youtube video.

Audio: To make the remix song sound coherent and not abrupt, we picked songs all of the same succession of chords “C-G-Am-F” so that they can somehow fit in the background music harmoniously. I used “smart guitar” on the app Garage Band to generate background music with the four chords looping. It was the first time that I had played around with the app. I didn’t know how to export the clip I made (I finally figured it out though) so I just recorded it with tascam recorder. I downloaded vocals-only version of the songs. Then I adjusted these songs to the same speed and pitch as the background music in Adobe Audition (which is like the most time-consuming part in this project). The ending whistle was separated from Flo Rida’s song using paintbrush selection tool (and it worked amazingly well).

Kevin didn’t have that much time to help with the audio editing because of his midterm, therefore I reduced the choices of songs that people can make. So in the final version of webpage of our interactive DJ set users can only change the middle part of this remix.

Webpage: Kevin built the style sheet and basic framework of the webpage and part of the playback javascript code. Continuing on his code, I completed the playback function and managed to play two sound files (one is background+song1+song3, the other is song2 decided by user )and add fade-in effects when song2 comes in.


Week 8 Storyboard

For this video project, Jesse and I have decided to do a short documentary on his hair. For the opening scene, using LED panels, we will film Jesse sitting in front of a white background while we create different hairstyles. We’ll edit the footage in Premiere to speed up the process (similar to this). The video will then display a title and a voice over where Jesse explains his inspiration from his dad will begin. We wan’t to create shots where you’ll see Jesse flipping through old pictures of the evolution of his hair, as well as him actually face-timing his dad (to allow the viewer to better connect with the subject). We also will use the white background to film some scenes where Jesse is directly facing the camera (with rule of thirds in mind) and talking about his story.


Midterm Documentation: Audio Visualizer

Anna Perez
IMA Interaction Lab: Midterm Documentation

Instructor: JH Moon

Elevator Pitch

Has anyone ever used the iTunes music visualizer whenever they stream music on their computer? My project has taken the visualizer out of the computer screen. I’ve made an audio-visualizer box that connects to my music library, and as the volume of the music increases, the visuals in the box change. Inside the box, I have two motors that are connected to a feather installation that are beneath 8 LED lights; as the volume increases, the motors run faster and the lights blink at a faster pace, creating a visual pattern that syncs with the music. Its value? Simple! Pairing auditorial interaction with visual interaction. My music visualizer box captures the viewer and transports them into their imagination inspired by the music, creating the most lively, interactive experience with not just one sensory interaction, but two: visual and auditory.


Conceptual Development (Ideation)

My original idea stemmed from thinking about how I could make my own lava lamp (with using something different and a little less dangerous than lava) that would still give a visual effect. After reading some blogs and watching a few YouTube videos, what I was thinking of was making a cube with colorful strobe light effects that would fade according to music sounds. I wanted to make the box opaque so that you couldn’t see the inside wiring and lights, just the effect it would make shining through. When I met with Moon, he suggested that I could do a shape that is more similar to a vase or a cylinder, and try inserting LED lights into a round-brush like shape that lets me just sit it up vertically and then would shine in an order complementary to the outer shape. In terms of creating opacity, I read about a project where a woman used a regular glass cube and melted white candle wax on the inside to create a finished, opaque effect on the outside.

After doing a bit more research, I came across a YouTube video that showed a visualizer that created an effect in response to the volume/frequency of the music being played, which was mostly what I had planned, but instead of just LED lights, they used a fan to blow from the bottom of the box and put a lightweight, small, white, ball, styrofoam-like material that would blow upwards depending on the strength of the fan, therefore creating an ‘atom-like’ pattern visualization. Also, because of how the visualization worked with the fan, the box had to be clear. I really thought this experiment looked sleek and very soothing, so I decided to adapt my project to be more similar to this tutorial.

The link to this video is here:

The video further explained that they used a code called FFT (Fast Fourier Transform). FFT is an algorithm that computes a sequence and transforms it from a function of time to a function of frequency. It’s useful for time-dependent projects, most specifically those measuring the frequency of sound, in things like songs.

I spoke to Jiwon about my project ideas, and she told me that though this visualizer on YouTube looks simple, sleek, and clean- it is a lot more complicated to build something like this than it looks. He seems to have a huge amount of LEDs at the top, and multiple fans at the bottom that all require individual wiring and coding and it might be smart to think about something of that size for the final project, but for the midterm to start smaller. I decided I could stick with my original cube-form idea, but incorporating the same model, so just maybe one or two fans and a few LEDs. She also suggested that I use the laser cutter and hot glue my structure together, rather than elaborately trying to cut or redesign a glass box I could find on Taobao or at the supermarket. I hadn’t thought about the possibility of the laser cutter, but this seemed like an easy alternative that would save time and planning and enable me to really think about how to customize this down to the millimeter.


Once I found the YouTube tutorial that suggested using FFT, I began to research how to do this in my project to add the sound measuring component into my processing code. I decided to use Serial to communicate between Processing and Arduino rather than Firmata- everyone I asked in the Lab seemed to recommend Serial over Firmata, and it seemed the easiest to import, so I tried with that first instead.

Then, I went into the Processing library and actually found that you can already import the FFT code ready to go into your processing. This is what I did, which saved a lot of time and research with the potential of having to do the code manually.




This is the tutorial that first directed me on how to control the speed of the motor on the Arduino side. I set up two motors on one breadboard, except I didn’t use a potentiometer. I experimented with the potentiometer, but in the end decided that I didn’t need it. Also, originally I was using the regular Arduino Uno to set up my circuits, but once I decided to double the amount of LEDs in the box I switched to the Arduino Mega. This enabled me to be way less restricted on the available PWMs. My motor connections looked like this without the potentiometer, which was a bit simpler:


thumb_img_2735_1024thumb_img_2738_1024 thumb_img_2740_1024


Here you can see both the LED lights on and the fans spinning at the same time. It worked!



Here is what it looked like when I transferred it to the larger Arduino board and also larger breadboard. Later, I changed to two smaller breadboards, since the  LED lights were going at the top of the box and the fans at the bottom, but this was still during the testing period. As you can see below, there are a lot more PWMs available.



Looking back on the outcome of the project, I need to make the voltage higher than 5V so that the motors are more powerful. So, perhaps the circuits will change slightly. However, this setup is still able to direct the speed of the motor from my headphone built-in speaker when the motors aren’t inside the box, but just plugged into the board.

This is the board after I added four more LED lights!

thumb_img_2782_1024 thumb_img_2784_1024



After putting the circuits together through what I read online about how to make the motors work, and how to control the LED blinking, Jiwon told me about the application Fritzing, where I could make a visual of what goes where on the Arduino and breadboards for future reference for myself and for others who I share the project with. For the motors, I had already found a Fritzing sketch online that I followed. I copied it in below the LED sketch. Here is what I created:


Here is a video of it working:


The technical implementation as the most time consuming. I focused most of my time creating the dialog between Arduino and Processing using the FFT. I continued to test the speed of the fans as a result of the FFT measurements, as well as the LED lights. In the end, I decided to add four extra LED lights because the box was measuring out larger than I anticipated, so I decided that more clear LEDs would be beneficial as spotlights.

The speaker detection seemed to be quite troublesome when testing the FFT. I mainly tested with the speaker in my headphones, which seemed to have the most successful effect on the reaction. This is problematic, however, because it wasn’t playing the music out loud, but through headphones, and the reaction came from me adding noise into the speaker. I read about an application called Soundflower which was a useful addition to this project. Basically, it is a system that downloads as another input/output port that you can reroute sound to. Rather than route my sound to this input output system and import it into the Processing app.

The physical fabrication was probably the funnest part. Once I had everything set up between Processing and Arduino, and the boards made, I focused on making the box. I used Adobe Illustrator to create each side piece for the box and measured to exact precision. I was able to add little cut outs that helped the box fit together and minimized the amount of hot gluing I had to do. I planned to put the LED lights at the top, so I made the height of the top to the box just large enough where it would show the tops of the LEDs but hide the breadboard and circuits.

The exact measuring of each part of the box started mostly with the bottom; I measured the smallest possible space I could make that would fit the Arduino and my breadboard. Once I had that, I calculated the height I would need to cover it. Then, I planned to put the motors on top of this on a floor that would be covered by another layer that had multiple holes poked through that led to the clear, acrylic part with the material inside. Once I measured the height of the arduino and circuits, I measured how much height I would need for the layer with the motors, and how much space needed to be in between the motors so that they wouldn’t touch. I added two cut outs in Adobe Illustrator (AI) that would let me glue the motors into the board, so they stayed situated. I also made sure I added a hole at the bottom back side of the board for the arduino cord to go through so I could connect it.  Also, to make the wires neater I cut new ones that were bendable and much smaller than the ones that came in my kit, and I pressed them down to keep them from standing up everywhere, and this made the breadboard a lot clearer to understand and the LED lights easier to shine without being blocked by wires.

Once everything was measured out in AI, I printed it through the laser cutter, and then the next day glued it together with the hot glue gun. First to understand how the laser cutter works, I read the IMA Laser Cutting Resource to understand roughly how it works, and Jiwon also helped explain it to me and supervise to make sure it all went well. Everything went smoothly until it became time to run the fans, and nothing moved. Instead, we had to add feathers to the motors, take off the fan blades, and take out the top bottom piece with the cut out holes for the air to blow through. The pattern made by the feathers was actually quite cool (unexpectedly) and since the two feather bunches are different heights and shapes, the patterns they make are slightly different, and complement each other.

Here are pictures of the laser cutting process:




Here are pictures of me putting it together (I first use tape to hold it all in place before I used the hot glue gun)

thumb_img_2845_1024 thumb_img_2848_1024

Here are pictures of me gluing the box together and also after I stuck the LED breadboard on the lid of the box.

thumb_img_2854_1024 thumb_img_2857_1024 thumb_img_2860_1024

Here are pictures of 1. The box after I had to drill a hole in the sides for the wires to fit through the layer. Also you can see the box with the motors glued in, and the top of the box once the LED board was stuck in, and I added smaller wires to make the board less messy and connected the longer wires down the side of the box into the bottom where the Arduino was.


Here is a picture of once we realized the motor wasn’t strong enough, and tried to trap the air to create a concentrated and faster wind coming out of the holes, and once that didn’t work, we took that layer of the box out and added feathers onto the motor instead of the fan so that we still had a visual effect with a slower speed from the motors.

thumb_img_2871_1024 thumb_img_2875_1024


Lessons Learned

This project was a learning experiment to say the least, there were many lessons learned, many failures, and many trial and errors that we had to do until we finally achieved the result we were looking for. There were things that went wrong up until the very last minute.

The most major thing that went wrong was that I focused way too much on testing the fans and lights in response to the FFT and how it worked with the code dialogue between Arduino and Processing. As you can see in the video below, the motors and lights did successfully blink and change in speed, but what I wasn’t thinking about was how it would react once inside the box.

What I failed to really emphasize on was how the fan speed would work in relationship to the material I decided to use to create an interactive pattern. When I finished the box, I decided to try a few different materials to see what would look best design-wise. The sad reality was that the max power of the fans didn’t blow enough air power to make anything fly in the box. What a disaster! So we tried a variety of potential fixes – and I had two of my best friends trying to brainstorm as well as half of the fellows in the lab- we cut parts of plastic bag in super thin strips, tried cutting small bits of string, really small tears of thin fabrics, and also tried a paper-bag effect to see if it would create a parachute-like reaction. None of it worked. Matt came by and suggested we make almost like an octagon shape around the fans to trap the air in a more concentrated area so that it would have a fuller force blowing straight up. This almost worked, it made the small reaction a bit better, but still wasn’t strong enough to make anything blow up. What we ended up having to do was cut the part of the box with the holes cut out of it that would originally be what the fans blew through to make the visual reaction, and just tie things directly to the motors or fans and see what happened from that. The best resource I found was a bag of feathers, and ended up taping the fans in a vertical direction on the motor and removing the fan blades. The feathers were multiple colors which ended up working nicely as a color pattern once they began to move with the motor. I actually do like the visual effect a lot, even though it wasn’t what I ever anticipated on doing. Still, I’d like to figure out a way to increase the motor speed so in the future I could create something more powerful that had a higher range from low-high when using FFT.

Another failure came along with the designing of the box and using the laser cutter. There were components that I didn’t think about when I first cut majority of the pieces. For example, I had wires from the top of the box that controlled the LED lights that would be hot glued to the side of the box and wired down to the arduino at the bottom. What I didn’t realize, is that though they could fit through the holes on the hole board, the board below that which held the motors in place didn’t have holes put in them for the wires to go through. This required taking this piece out and drilling three larger holes on two sides for the wires to come down. Also, the acrylic glass cut from the laser cutter is 3mm thick on each side, so we had to plan to make the other parts of the box that would fit it in about 6 mm larger so that there was space for it. There were a few slight adjustments that had to be made on the laser cutter, mainly the pieces that had inserts cut out in their center that made it fit in like a lego piece to minimize parts we’d have to glue gun, that held the motors in. The slits were slightly off and didn’t fully align, which required going back and readjusting the cut so it all clicked in together.

Also, when I cut the longer wires to reach from the top of the box to the bottom, I decided to cut extra than I thought I needed (which was 35 cm) and cut 40 just in case there was more length that I needed. This ended up being too short and didn’t reach the PMW pins. It was just a few centimeters off, and I’m not sure how exactly I miscalculated. But this required me to cut more of the wires, and then connect them to the wires that were too short with electrical tape to be able to reach the PWMs. They were already set in the box, so it was easier to do this rather than dismantle everything and add newer cords that were long enough.

My biggest lesson learned is that trial and error in the physical, final outcome is vital and I think I spent way too much time focusing on the planning aspect and the computing part that I didn’t give myself as much time as I needed to work on the physical, final project. This was the part that I expected to take the least time, and once I mastered the connection between Processing and Arduino and had it work with motors and lights just on the board, I considered myself “basically done”. What I learned was, I wasn’t. I was half way, and I definitely underestimated how many tedious mistakes and  unexpected hurdles you come to when trying to put together the physical component.

Here are my codes for both Arduino and Processing:


char v; // Data received from the serial port

char val;

int brightness = 0;    // how bright the LED is

int fadeAmount = 5;

int ledPin = 9;           // the PWM pin the LED is attached to

int ledPin2 = 6;           // the PWM pin the LED is attached to

int ledPin3 = 5;

int ledPin4 = 3;

int ledPin5 = 8;

int ledPin6 = 7;

int ledPin7 = 4;

int ledPin8 = 2;

int motor1 = 10;

int motor2 = 11;

// the setup routine runs once when you press reset:

void setup() {

 pinMode(ledPin, OUTPUT);

 pinMode(ledPin2, OUTPUT);

 pinMode(ledPin3, OUTPUT);

 pinMode(ledPin4, OUTPUT);

 pinMode(ledPin5, OUTPUT);

 pinMode(ledPin6, OUTPUT);

 pinMode(ledPin7, OUTPUT);

 pinMode(ledPin8, OUTPUT);

 pinMode(motor1, OUTPUT);

 pinMode(motor2, OUTPUT);

 Serial.begin(9600); // Start serial communication at 9600 bps


void loop() {

 if (Serial.available()) { // If data is available to read,

   v =; // read it and store it in val

   if(v == ‘H’){

         analogWrite(motor1, 255);

   analogWrite(motor2, 255);

   analogWrite(ledPin, HIGH);

   analogWrite(ledPin2, val);

   analogWrite(ledPin3, val);

   analogWrite(ledPin4, val);

   analogWrite(ledPin5, val);

   analogWrite(ledPin6, val);

   analogWrite(ledPin7, val);

   analogWrite(ledPin8, val);



import processing.sound.*;

import processing.serial.*;

Serial myPort;  // Create object from Serial class

int val;        // Data received from the serial port

FFT fft;

AudioIn in;

SoundFile file;

int bands = 512;

float[] spectrum = new float[bands];

float total_specleft = 0;

float averageleft;

float total_specright = 0;

float averageright;

void setup() {


 //port 2 or 5

 String portName = Serial.list()[5];


 myPort = new Serial(this, portName, 9600);

 size(512, 360);



 //  Serial.begin(9600);


 // Create an Input stream which is routed into the Amplitude analyzer

 fft = new FFT(this, bands);

 in = new AudioIn(this, 0);

 // start the Audio Input


 // patch the AudioIn



void draw() {



 for (int i = 0; i < bands; i++) {

   // The result of the FFT is normalized

   // draw the line for frequency band i scaling it up by 5 to get more amplitude.

   line( i, height, i, height – spectrum[i]*height*5 );

   //total_specleft += spectrum[i];

   total_specleft = total_specleft +  spectrum[i];


 //for (int i = bands/2; i < bands; i++) {

 //  line( i, height, i, height – spectrum[i]*height*5 );

 //  total_specright = total_specright +  spectrum[i];



 averageleft = total_specleft / (bands);

 println(“left average: ” + averageleft);

 int mapped_left_av = int(map(averageleft, 0, 0.1, 0, 1023));

 println(“mapped left average: ” + mapped_left_av);





 //averageright = (total_specright / (bands/2))*10;

 //println(“right average: ” + averageright);

 total_specleft = 0;

 total_specright = 0;


//  {  

//    if (mouseOverRect() == true) {  // If mouse is over square,

//      fill(204);                    // change color and

//      myPort.write(‘H’);              // send an H to indicate mouse is over square

//    } else {                        // If mouse is not over square,

//      fill(0);                      // change color and

//      myPort.write(‘L’);              // send an L otherwise

//    }

//    rect(50, 50, 100, 100);         // Draw a square

//  }

Nico Chan W9: In Class Assignment


Write 200 words describing the project you created in class. We will start next class by reading through these descriptions and discuss how best to approach describing our installation projects going forward.

The project Rewant and I created in class used an ambient light sensor as a trigger for the DC motor. Inthe spirit of the holidays, our overarching objective was to create a Halloween Haunted House display in which a users flashlight would trigger a monster’s path. We took inspiration from the movie Home Alone, specifically this scene where the main character hosts a fake party to misguide the burglars.

Our development process was as follows:

  1. Set up the ambient light sensor on the breadboard, connected to the arduino
  2. Upload code to the arduino
  3. Verify the ambient light sensor is reading by looking at the serial monitor
  4. Connect the DC motor to the opposite side of the breadboard, connected to the arduino but powered via a 12V battery
  5. Reupload the updated code
  6. Testing

Below is a video of the final stage we reached in class.

As you can see in the video, the motor is running, although the ambient light sensor was wildly unreliable. Towards the end we tried swapping out the ambient light sensors to test if we simply were using a faulty sensor, and results were inconclusive.

Below is a photo of our overall project hardware:


And our sad feelings:

Rewant Nicole 10.31.2016


int Motor= 4;
int timer= 0; 
int motorOn = 5000; 
int photolight = A0;
int sensorValue = 0;

void setup(){
  pinMode(Motor, OUTPUT);
void loop(){
  sensorValue = analogRead(photolight);
  if (sensorValue < 20)
    digitalWrite(Motor, LOW);
    digitalWrite(Motor, HIGH);

Lab 5: Documentation

Documentation Notes

Lab: 5

Documented by: Anna Perez

Date: Oct 14th

Partner: Jarred Kubas

Instructor: JH Moon

For Lab 5, Jarred and I worked as partners to exchange data using Serial communication between Processing and Arduino. Once we opened the two applications and used SimpleRead to get the code for the Serial communication, we started by playing around with changing the background color in Processing from black to light gray with the command mouse y, mouse x function. After that, we decided to use a previous sketch from Jarred’s library, and play around with it and enhance it.

One of our first problems that we encountered was that we had an issue with the transistor which was connected to ground, and caused the button to only read zero. Once we solved this, we started trying to manipulate Jarred’s old code, to substitute the white eclipse background to change to a random color as the button on the Arduino was pressed. We wanted to make it more interactive. First, the code was set to where the button being held down would rapidly change the color of eclipse and the eclipses following the button from a white to random colors.

Then, to challenge ourselves more, we modified the sketch to change to one random color when the button is pressed, and stays that color until it is pressed again using a Serial function through Arduino to Processing. Before, the color change would move from white to a multitude of random colors in a random order. We did this by controlling the color change in the for loop by making a subroutine “if” to fill the eclipse with a random color. We used the color (clr) function instead of the fill, and instead of float x y = random(255) we used r,g,b for color. We put this function in the void draw so that a white eclipse would show up before the button was pressed, then once it was pressed, the eclipses would turn random colors changing each time the button was pressed.

This is the old code that we started out with:

Old Code:

int[] x_pos_history = new int [10];

int[] y_pos_history = new int [10];

void setup() {

 size (800, 600);


void draw () {


 x_pos_history[frameCount % 10] = mouseX;

 y_pos_history[frameCount % 10] = mouseY;


 for (int i=0; i < x_pos_history.length; i ++) {

   float x = random(255);

   float y = random(255);

   float z = random(255);


   ellipse(x_pos_history[i], y_pos_history[i], 50, 50);



This is the new code that we created from modifying the old code:

New Code:


* Simple Read


* Read data from the serial port and change the color of a rectangle

* when a switch connected to a Wiring or Arduino board is pressed and released.

* This example works with the Wiring / Arduino program that follows below.


import processing.serial.*;

Serial myPort;  // Create object from Serial class

int val;      // Data received from the serial port

int[] x_pos_history = new int [10];

int[] y_pos_history = new int [10];

color clr = color(255);

void setup()


 size (800, 600);

 // I know that the first port in the serial list on my mac

 // is always my  FTDI adaptor, so I open Serial.list()[0].

 // On Windows machines, this generally opens COM1.

 // Open whatever port is the one you’re using.

 String portName = Serial.list()[7];

 myPort = new Serial(this, portName, 9600);


void draw()



 x_pos_history[frameCount % 10] = mouseX;

 y_pos_history[frameCount % 10] = mouseY;

 if ( myPort.available() > 0) {  // If data is available,

   val =;   


   // read it and store it in val



 if (val == 1) {              // If the serial value is 0,

   float r = random(255);

   float g = random(255);

   float b = random(255);

   clr = color(r,g,b);


 for (int i=0; i < x_pos_history.length; i ++) {


   ellipse(x_pos_history[i], y_pos_history[i], 50, 50);




Here are some photos and videos from our documentation:


The first video shows the circle changing colors at random, before we were able to make it change to one random color and switch as the button was pressed. The second video shows it once we got it to work how we wanted!

Lab 2: Documentation

Documentation Notes

Lab: 2

Documented by: Anna Perez

Date: Sept 9th

Instructor: JH Moon

For Lab 2 I did the Traffic Light and the Temperature Alarm. For both, we began by copying the codes into Arduino that were linked to the lab instructions blog post. This was my second Lab experimenting with the Arduino Beginner Kit, and I feel like I became more comfortable with using the circuits through this lab. A handout was passed around that explained how to set up the traffic light circuit and my partner and I tried to mirror it exactly. The main problem that we faced when first setting up the circuit board and it not working was that we realized a few of the resistors we used were inserted in the wrong places in accordance with the LED lights. Once we fixed this, it worked perfectly!

For the Temperature Alarm, we couldn’t get the alarm to sound off at first because we had only connected the alarm buzzer to the ground, and not connected it to the power. Once we did this, everything worked. The lesson that I learned for both of these was that for these circuits to work, you have to be attentive to every detail and make sure everything is connected, because with just one pin off, everything could be out of circuit.

Here are some pictures:

thumb_img_1981_1024 This is us trying to use the handout as a guide in creating our circuit board. This photo is before we connected all of the wires, so you can see it better. thumb_img_1984_1024

This photo is after we added all of the wires.


Here is a picture of when the LEDs began to light up!


Here is a photo of us setting up the temperature alarm, and below is a video of it:


Lab 1 Documentation

Documentation Notes

Lab: 1

Documented by: Anna Perez

Date: Sept 2nd

Instructor: JH Moon

For Lab 1, my partner and I worked as partners to create all three of the circuit diagrams. We followed a help sheet that was given out with blueprints of each circuit setup. The first using a voltage regulator, buzzer, and a switch. We had some trouble at first because we’re both beginners in this class, and it was our first time creating a circuit on a breadboard. First we laid out the parts we needed, and started by inserting the black wire in the ground, and the red into the 5V power. For the first circuit, everything ran relatively smoothly due to the guidance and explanation we received from Nick when we were a bit lost. The second circuit used a voltage regulator, resistor, LED, and a switch. As for this circuit, one of the problems we had was that we inserted the LED wrong, not realizing the polarity of the bulb. The third circuit used a voltage regulator, resistor, potentiometer, LED, and a switch. We ran into trouble using the potentiometer, and had it positioned incorrectly. Nick also helped guide us through this one and explained the use of the potentiometer and how we could make it work, and we managed to get the circuit running where we were able to change the brightness of the bulb.

Here are some photos from the lab:


thumb_img_1763_1024 thumb_img_1764_1024 thumb_img_1768_1024 thumb_img_1773_1024 thumb_img_1778_1024 thumb_img_1782_1024 thumb_img_1786_1024 thumb_img_1787_1024 thumb_img_1789_1024

In the last three photos, you can see the difference in brightness in the LED.

Here is a video:

Response to The Work of Art in the Age of Mechanical Reproduction by Kefan Xu

In this reading, Benjamin’s mainly talked about how the mechanical reproduction brought the change to the history of art, and discussed about whether this mechanical reproduction is improving the art or destroying art.

This question is hard to answer, the improve of technology makes it easier for creating art work, but it also make the boundary between art and normal things become obscure. We may question that if one artist directly copy the image which is on a photo shot by him, can this art piece have the same value with the one that be painted completely according to one artist imagination? The most famous example of this is the argument with the painting Girl with a Pearl Earring which is famous for it’s brilliant use of the shadow and the light. People questioned about whether the artist of this painting used a darkroom method to get the real image, or photo, of this girl and then paint it according to the image. Since other artist at that time were still portray the light and shadow simply by their imagination and observation of life, people consider his way of painting as some kind of cheating and his paintings don’t not deserve the fame that they have. Though it’s hard to say which side is right or wrong, we can find that the mechanical reproduction actually didn’t have that much influence on art, for people will depreciate the value of an art work immediately when he know that it’s just a copy from a photo. We all know that the essence of a photo and a painting is different, whether it’s because a painting contains more effort of the artist in it or it requires a higher ability of using color. Once there is something unique in the something, it’s will become hard to mix them together and put them in an equal position. The taste between a wine which worth 100 dollars and a wine which worth 30 thousand dollars might just have 1% difference in it, but it’s 1% that most of the wine can’t give you that make the wine so expensive, and makes people pursue it that much. Though the mechanical reproduction changes so many things in the production of art, once the essence and the unique part can’t be change, a art work will still show it’s value to people.

Response to “The Work of Art in the Age of Mechanical Reproduction” by Gao Yang (Vasudevan)

The comedy and tragedy of the age of Mechanical Reproduction

In Walter Benjamin’s The Work of Art in the Age of Mechanical Reproduction, he wrote about the importance and impact of Mechanical Reproduction through the production and development of the film.

On the one hand, Mechanical Reproduction plays an important role in the history. Without it, the public cannot know many famous art products. No matter people use Mechanical Reproduction to fix them or spread them, the development of art cannot live independently. For example, Mechanical Reproduction fixed Da Vinci’s Mona Lisa, so that people can keep Mona Lisa for a long time. So Mechanical Reproduction also protects the immutability.

On the other hand, we may realize no matter how advanced Mechanical Reproduction is, it still cannot copy the unique existence and authenticity of a work. For an artwork, it is the authenticity of it that makes it unique. However, Mechanical Reproduction replaces the Man-made products somehow destroy its specialty and mystique.

Nowadays, the speed of the development is so fast that surprises us everyday and everyday. However, people still tend to chase art itself. For example, people tend to go to the theater to see the drama instead of watching movies; people tend to go to the cinema to see the movie instead of downloading it online. Maybe Mechanical Reproduction somehow destroys some part of the artwork, but the development of technology still bring some different color to the society.