This assignment provided me with a precious opportunity to work on the DMX PAR lights which I previously thought that I could only see on the stage. During the working process, we brainstormed about the idea that we would like to address, learned how to install the lights, and gained practical knowledge of coding the lights. It was fun and meaningful to work in a group of six, and I learned how to cooperate with others throughout our communication and collaboration.

We started on Sunday afternoon when all of us gathered together at school to brainstorm ideas of the project. One of our group members suggested that we could use a wood stick to symbolize the sundial, whose history can be traced back to thousands of years ago. Her starting point was that as the lights could not move automatically in either direction or position, we needed to figure out a method to show the change in position of a certain object. However, as it was too troublesome to carry an object in person and move around the room, we could utilize the variation of the shadow in both colors and positions to make our project more intriguing. Therefore, we reached a consensus at this point that we were going to fix a wood stick on the ground and code the lights so that their colors and the rhythm of the whole composition could affect the shadow of the stick and hence make the light show more interesting.

Our interpretation of this project was that as the speed of color change goes from slow to fast, it could represent our school life which is relaxing at first but becomes more and more tense as time flows. At the end of the semester everyone is busy multitasking and we have little time left for ourselves. Meanwhile, the colors can also represent our hobbies and the happy moments in our daily life. As the position of the shadow shifts, our lives proceed at our own speeds as well.

 

After we had made our plan about the assignment, we started to work separately. I participated in the whole process as an assistant in our group. Firstly, another group member and I met together on Tuesday afternoon to complete the physical fabrication part. We first cut the bottom part of our installation under the help of the Fabrication Lab Manager. In this process, both of us were exposed to a new electric saw that we had never seen or used before. Then, we utilized both abrasive paper and the drill to levigate the bottom part of the stick so that it could fit into the hole we dug previously on the pedestal. 

After we had finished the physical fabrication, we started to work on the code, which was the most crucial part of this assignment. One member in our group finished the draft code earlier that day and we were revising that code in the evening. We utilized the example code, what we had learned in class and our existing knowledge to write the code. The biggest problem we encountered, to our surprise, was that the term “dimmer” in the code actually meant “brightness” rather than “to dim”. We recognized this when we were setting the value of the dimmer. We first set it to be 0, because in our expectation the light would become more and more dim as the number grows. However, after uploading the code, the light just wouldn’t turn on. After trying multiple times, we finally recognized that if we want the lights to light up we should set the value of the dimmer to 255. This is definitely a precious lesson that we learned from this experiment, and all of us cheered after seeing that the lights finally worked according to our initial plan.

Below is the video of the final version. I am very grateful for this precious opportunity for group work and access to DMX PAR lights!

 

Below is the final code:

/*
 * 3 DMX controlled LED Par Light example
 * 
 * In this example we're using 3 par lights model Chauvet DJ Eve P-130 RGB
 * Each light can have up to 9 DMX channels to control different
 * functionality of the light. For an overview of the channels
 * look at https://open-fixture-library.org/chauvet-dj/eve-p-130-rgb
 * 
 * For this example the lights should be set to 9 channel DMX mode
 * on the light itself. And, light1 should start at DMX channel 1,
 * light2 at DMX channel 11, and light3 at DMX channel 21.
 * 
 * Each channel can be a value between 0 - 255, which is exactly what
 * the 'byte' datatype can hold. Below, a variable of the byte datatype
 * is declared for each channel of each of the three lights.
 * 
 * Not all of the channels will be usefull in every use case, so don't 
 * worry about the ones that you're not going to use.
 * 
 */

// 9 variables for the DMX channels of light 1
byte light1Dimmer = 0;
byte light1Red = 0;
byte light1Green = 0;
byte light1Blue = 0;
byte light1ColorMacros = 0;
byte light1Strobe = 0;
byte light1AutoPrograms = 0;
byte light1ProgSpeedSoundSens = 0;
byte light1DimmerSpeedMode = 0;

// 9 variables for the DMX channels of light 2
byte light2Dimmer = 0;
byte light2Red = 0;
byte light2Green = 0;
byte light2Blue = 0;
byte light2ColorMacros = 0;
byte light2Strobe = 0;
byte light2AutoPrograms = 0;
byte light2ProgSpeedSoundSens = 0;
byte light2DimmerSpeedMode = 0;

// 9 variables for the DMX channels of light 3
byte light3Dimmer = 0;
byte light3Red = 0;
byte light3Green = 0;
byte light3Blue = 0;
byte light3ColorMacros = 0;
byte light3Strobe = 0;
byte light3AutoPrograms = 0;
byte light3ProgSpeedSoundSens = 0;
byte light3DimmerSpeedMode = 0;

bool stage3shown = false;



// include the DMX library
#include 

// set the maximum amount of channels we'll need
// each light will run 9 DMX channels so 27 is enough
#define DMX_MASTER_CHANNELS 27

// pin number to change read or write mode on the shield
#define RXEN_PIN 2

// configure a DMX master controller, the master controller
// will use the RXEN_PIN to control its write operation on the bus
DMX_Master dmx_master(DMX_MASTER_CHANNELS, RXEN_PIN);



void setup() {

  // Enable DMX master interface and start transmitting
  dmx_master.enable();

  // To be extra safe,
  // let's set channel 1 - 30 to off (0) to start with
  dmx_master.setChannelRange(1, 30, 0);
}

void loop() {
  // In loop we can modify the values of the variables
  // to make the lights do what we want

  //1st period: only one light would be turn on
  //first turn: red, blue, green
  // light1 - red

  //  if(!lightCleared){
  //  clearLight();
  //  }


  if (!stage3shown) {
    delay(2000);
    stage1Red();
    writeDMXdata();
    delay(5000);

    stage1Green();
    writeDMXdata();
    delay(2500);

    stage1Blue();
    writeDMXdata();
    delay(2500);

    stage1Yellow();
    writeDMXdata();
    delay(2500);

    stage1Purple();
    writeDMXdata();
    delay(2500);


    stage1GreenBlue();
    writeDMXdata();
    delay(2500);


    light1Red = 255;
    light1Green = 153;
    light1Blue = 18;

    light2Red = 173;
    light2Green = 255;
    light2Blue = 47;

    light1Dimmer = 255;
    light2Dimmer = 255;
    light3Dimmer = 0;
    writeDMXdata();
    delay(5000);

    light2Red = 216;
    light2Green = 191;
    light2Blue = 216;

    light3Red = 176;
    light3Green = 224;
    light3Blue = 230;

    light1Dimmer = 0;
    light2Dimmer = 255;
    light3Dimmer = 255;
    writeDMXdata();
    delay(5000);

    light3Red = 255;
    light3Green = 182;
    light3Blue = 193;
    light1Red = 0;
    light1Green = 245;
    light1Blue = 255;
    light3Dimmer = 255;
    light1Dimmer = 255;

    light1Dimmer = 255;
    light2Dimmer = 0;
    light3Dimmer = 255;
    writeDMXdata();
    delay(5000);
    stage3shown = true;
  } else {
    stage3();
  }
}

void stage3() {

  light1Red = random(0, 255);
  light1Green = random(0, 255);
  light1Blue = random(0, 255);

  light2Red = random(0, 255);
  light2Green = random(0, 255);
  light2Blue = random(0, 255);

  light3Red = random(0, 255);
  light3Green = random(0, 255);
  light3Blue = random(0, 255);

  light1Dimmer = 255;
  light2Dimmer = 255;
  light3Dimmer = 255;

  writeDMXdata();
  delay(400);
}



//2nd period: 2 lights are turned on together
//还没设颜色
//1+2

/*
 

  
  delay(500);

//.....这里copy and paste and change 上面一段就行，设计一下颜色？
//arrange 灯的位置，两个一起亮的时候是时间点，也可以讲讲concept和故事？颜色-故事-> any connections?


//3rd period: 3 lights are turned on together, random color, speed++

 


  light1Red = random(0,255);
  light1Green = random(0,255);
  light1Blue = random(0,255);

  light2Red = random(0,255);
  light2Green = random(0,255);
  light2Blue = random(0,255);

  light3Red = random(0,255);
  light3Green = random(0,255);
  light3Blue = random(0,255);
  
  light1Dimmer += 2;
  light2Dimmer += 2;
  light3Dimmer += 2;


  light1Red = random(0,255);
  light1Green = random(0,255);
  light1Blue = random(0,255);

  light2Red = random(0,255);
  light2Green = random(0,255);
  light2Blue = random(0,255);

  light3Red = random(0,255);
  light3Green = random(0,255);
  light3Blue = random(0,255);
  
  light1Dimmer += 3;
  light2Dimmer += 3;
  light3Dimmer += 3;








  // write the DMX data to the lights
  // see the function declaration below
  writeDMXdata();

  delay(50);
  */
//}



void stage1Red() {
  light1Red = 255;
  light1Green = 0;
  light1Blue = 0;
  light2Red = 0;
  light2Green = 0;
  light2Blue = 0;
  light3Red = 0;
  light3Green = 0;
  light3Blue = 0;
  light1Dimmer = 255;
}

void stage1Green() {
  light1Red = 0;
  light1Green = 0;
  light1Blue = 0;
  light2Red = 0;
  light2Green = 255;
  light2Blue = 0;
  light3Red = 0;
  light3Green = 0;
  light3Blue = 0;
  light2Dimmer = 255;
}

void stage1Blue() {
  light1Red = 0;
  light1Green = 0;
  light1Blue = 0;

  light2Red = 0;
  light2Green = 0;
  light2Blue = 0;
  light3Red = 0;
  light3Green = 0;
  light3Blue = 255;

  light3Dimmer = 255;
}

void stage1Yellow() {
  light1Red = 255;
  light1Green = 255;
  light1Blue = 0;

  light2Red = 0;
  light2Green = 0;
  light2Blue = 0;
  light3Red = 0;
  light3Green = 0;
  light3Blue = 0;

  light1Dimmer = 255;
}

void stage1Purple() {
  light1Red = 0;
  light1Green = 0;
  light1Blue = 0;

  light2Red = 255;
  light2Green = 0;
  light2Blue = 255;
  light3Red = 0;
  light3Green = 0;
  light3Blue = 0;

  light2Dimmer = 255;
}


void stage1GreenBlue() {
  light1Red = 0;
  light1Green = 0;
  light1Blue = 0;

  light2Red = 0;
  light2Green = 0;
  light2Blue = 0;
  light3Red = 0;
  light3Green = 255;
  light3Blue = 255;

  light3Dimmer = 255;
}




/*
 * This function writes all the values of the variables to
 * the DMX shield which then passes them on to the 
 * the apporpriate channels on the lights.
 * 
 * All the lights should be set to 9-channel DMX mode
 * Light1 has to start on DMX channel 1
 * Light2 has to start on DMX channel 11
 * Light3 has to start on DMX channel 21
 */
void writeDMXdata() {
  // write to channel 1-9 for light1
  dmx_master.setChannelValue(1, light1Dimmer);  // 亮度
  dmx_master.setChannelValue(2, light1Red);
  dmx_master.setChannelValue(3, light1Green);
  dmx_master.setChannelValue(4, light1Blue);
  dmx_master.setChannelValue(5, light1ColorMacros);  // 光宏
  dmx_master.setChannelValue(6, light1Strobe);       //频闪
  dmx_master.setChannelValue(7, light1AutoPrograms);
  dmx_master.setChannelValue(8, light1ProgSpeedSoundSens);
  dmx_master.setChannelValue(9, light1DimmerSpeedMode);

  // write to channel 11-19 for light2
  dmx_master.setChannelValue(11, light2Dimmer);
  dmx_master.setChannelValue(12, light2Red);
  dmx_master.setChannelValue(13, light2Green);
  dmx_master.setChannelValue(14, light2Blue);
  dmx_master.setChannelValue(15, light2ColorMacros);
  dmx_master.setChannelValue(16, light2Strobe);
  dmx_master.setChannelValue(17, light2AutoPrograms);
  dmx_master.setChannelValue(18, light2ProgSpeedSoundSens);
  dmx_master.setChannelValue(19, light2DimmerSpeedMode);

  // write to channel 21-29 for light3
  dmx_master.setChannelValue(21, light3Dimmer);
  dmx_master.setChannelValue(22, light3Red);
  dmx_master.setChannelValue(23, light3Green);
  dmx_master.setChannelValue(24, light3Blue);
  dmx_master.setChannelValue(25, light3ColorMacros);
  dmx_master.setChannelValue(26, light3Strobe);
  dmx_master.setChannelValue(27, light3AutoPrograms);
  dmx_master.setChannelValue(28, light3ProgSpeedSoundSens);
  dmx_master.setChannelValue(29, light3DimmerSpeedMode);
} 

Our idea for this project is to use the water to create water ripples on the wall in order to create an intriguing light effect. Our inspiration came from my partner when she sent me a video of her using the smartphone flashlight and a water bottle to create some light effects. After watching this video, we decided to work on this idea and use the casting of the water ripples on the walls to make the light fill the entire room.

 

At first, our proposal was to combine two bottles together, put the light installation within the inner bottle and fill the space between the two bottles with water. We spent some time building our bottle installation, and tried different methods such as the lighter and glue gun to fill the gap between the two bottles.

However, it kept leaking so we had to change our plan. Not only did we need a waterproof box for adding water to our project, but we also needed a bigger space for installing the light bulb and the RGB strip. Therefore, I suggested that we could use two separate semi-enclosed acrylic boxes created by laser cutting for our project. We can put one onto the other, fill water into the upper one and put our light installation in the lower one.

After we have cut the transparent boxes, we started to paste the RGB strip inside the box so that it could be fixed. At this point, my partner had come up with the idea that we could also introduce straws and water-soluble pigment into our project so that the ripples projected on the ceiling could be more colorful. And by adding pigment to water and using the straw to blow on the water, our classmates could have more interaction with our project and become more engaged during our presentation.

When choosing the lighting techniques, we first decided to only use the analog RGB strip and make its color blue. However, when testing its effect before class, we found out that its brightness was not enough to project the colorful water ripples onto the ceiling, which differed a lot from our original inspiration, since the effect created by a smartphone flashlight was even stronger than that of the RGB strip. Therefore, we made up our mind to introduce a halogen light bulb to provide more brightness. In the end, we used both the analog RGB strip and the halogen light bulb to create a mixed effect for our project. We simply set the color of the RGB strip blue and lit the light bulb up without any special lighting effects, because we wanted people to focus more on our installation and the interaction with water. 

During the in-class presentation, we displayed both our original idea, which is the (leaking) bottle, and our final installation. The two videos can be seen below.

 

In fact, we have encountered a lot of challenges and difficulties during our process of setting things up. Firstly, we used my analog RGB strip at first, but somehow it just didn’t work. Hence, we spent a lot of time checking and revising the code but nothing worked out. Therefore, we switched to my partner’s strip and it worked quite well. Our guess was that it was because she soldered the wires onto her strip while I used the clip, so maybe mine had a bad attachment. Secondly, we tried hard to prevent the laser-cut boxes from leaking, but in the end it was still not 100% waterproof. The physical installation part was also tiring because the boards were large and the hot glue dries really quickly, so I had trouble glueing two boards together. 

Though the building process was challenging, both of us gained a lot during this precious experience and we also enhanced our ability of tackling unexpected problems. Personally, I enjoy the working experience of this project a lot, and I was really amazed by the final effect when all the lights were off and the water ripples were shone by the light bulbs!

In this assignment which aims at creating a 2 minute composition in light and objects, we chose to utilize an LED Matrix to explore the technology covered in class. My partner got the idea when she was taking an airplane back to her hometown and witnessing the sunrise above the clouds. She suggested that just like a musical composition which has a beginning, middle and end, the color transition from dull red to light blue also forms a complete composition. Therefore, we decided to compose a gradual change of colors to represent different stages of the sunrise within 2 minutes. 

We started by referencing some example code. Below are some photos taken during this process. At this time we didn’t reach the exact effect that we wanted, but we learned a lot by keep making attempts to revise the code and compare them to each other.

When it came to the wiring part, we referred to the Class 03 Slides and built our circuit according to the diagram provided. One thing I noticed here was that when connecting the LED Matrix to the whole circuit, we should connect them by the “DIN” pin rather than the “DOUT” pin on the LED Matrix because we were sending signals to the Matrix and expecting it to give us responds.

When it came to the final code, we referenced this code online (https://gist.github.com/jasoncoon/d54216fc8ce2eb0ecee87f8002d421c5). We spent a lot of time revising the code to make it align with our needs, and I consider this as the most challenging part in our project because both of us are unfamiliar with the code that runs the LED Matrix. Subsequently, we ran the code, and everything seemed to be OK except for the timing part. It took the matrix about 5 minutes to finish the whole transition process, which was way beyond the time limit. Hence we tried to revise different lines of the code, and ultimately we found that the effective way to achieve this was to change the number behind the “sunriseLength * “. Meanwhile, though we didn’t know the reason behind it, it appeared to us that the number should keep one decimal place, otherwise the whole transition process would finish in about 5 seconds.

As we had finished the coding and wiring part, we began to generate ideas about the physical installation. I suggested that we could use laser cut to make a wooden box and add multiple layers of mountains into it. By doing this each wooden piece of mountain would be of different colors. Besides, the reason for us to choose wood instead of other materials was that wood is good at blocking the passage of light, limiting the color of the matrix in the wooden box instead of letting it extend outside the installation. My partner added a semi-transparent acrylic board in the rear of the box, making the light more gentle and the transition process more natural.

So far we have finished all the making processes of our Sunrise project. It was really fun to explore the potential of the LEDs, and we benefited a lot from this hands-on learning experience!

Below are some photos taken at different stages of the Sunrise:

 

Below is the code that we used for our final version:

#include "FastLED.h"

#define NUM_LEDS 64

#define DATA_PIN 3
#define CLOCK_PIN 13

CRGB leds[NUM_LEDS];

void setup() {
  // Uncomment/edit one of the following lines for your leds arrangement.
  //FastLED.addLeds<TM1803, DATA_PIN, RGB>(leds, NUM_LEDS);
  //FastLED.addLeds<TM1804, DATA_PIN, RGB>(leds, NUM_LEDS);
  //FastLED.addLeds<TM1809, DATA_PIN, RGB>(leds, NUM_LEDS);
  //FastLED.addLeds<WS2811, DATA_PIN, RGB>(leds, NUM_LEDS);
  //FastLED.addLeds<WS2812, DATA_PIN, RGB>(leds, NUM_LEDS);
  //FastLED.addLeds<WS2812B, DATA_PIN, RGB>(leds, NUM_LEDS);
  FastLED.addLeds<NEOPIXEL, DATA_PIN>(leds, NUM_LEDS);
  //FastLED.addLeds<APA104, DATA_PIN, RGB>(leds, NUM_LEDS);
  //FastLED.addLeds<UCS1903, DATA_PIN, RGB>(leds, NUM_LEDS);
  // FastLED.addLeds<UCS1903B, DATA_PIN, RGB>(leds, NUM_LEDS);
  // FastLED.addLeds<GW6205, DATA_PIN, RGB>(leds, NUM_LEDS);
  // FastLED.addLeds<GW6205_400, DATA_PIN, RGB>(leds, NUM_LEDS);

  FastLED.addLeds<WS2801, RGB>(leds, NUM_LEDS);
  FastLED.addLeds<SM16716, RGB>(leds, NUM_LEDS);
  // FastLED.addLeds<LPD8806, RGB>(leds, NUM_LEDS);
  // FastLED.addLeds<P9813, RGB>(leds, NUM_LEDS);
  // FastLED.addLeds<APA102, RGB>(leds, NUM_LEDS);
 FastLED.addLeds<DOTSTAR, RGB>(leds, NUM_LEDS);

  // FastLED.addLeds<WS2801, DATA_PIN, CLOCK_PIN, RGB>(leds, NUM_LEDS);
  // FastLED.addLeds<SM16716, DATA_PIN, CLOCK_PIN, RGB>(leds, NUM_LEDS);
  // FastLED.addLeds<LPD8806, DATA_PIN, CLOCK_PIN, RGB>(leds, NUM_LEDS);
  // FastLED.addLeds<P9813, DATA_PIN, CLOCK_PIN, RGB>(leds, NUM_LEDS);
  // FastLED.addLeds<APA102, DATA_PIN, CLOCK_PIN, RGB>(leds, NUM_LEDS);
  //FastLED.addLeds<DOTSTAR, DATA_PIN, CLOCK_PIN, RGB>(leds, NUM_LEDS);
}

void loop() {
  sunrise();

  FastLED.show();
}

void sunrise() {

  static const uint8_t sunriseLength = 30;

  static const float interval = ((sunriseLength * 6.0) / 270) * 1000;

  static uint8_t heatIndex = 0;

  CRGB color = ColorFromPalette(HeatColors_p, heatIndex);

  fill_solid(leds, NUM_LEDS, color);

  EVERY_N_MILLISECONDS(interval) {
    if (heatIndex < 255) {
      heatIndex++;
    }
  }
} 

Echo Helmet – Jingchen Gao – Eric Parren

I. Project Introduction & Description:

The Echo Helmet is a wearable device aimed to create the echo of one’s own sound within the helmet. By using materials like wood boards and disposable cups, one’s sound can form echoes when it encounters these materials, and they can be further amplified by traveling and reverberating through the space between these materials and therefore reach the effect of amplifying one’s own sound when the person is speaking and listening to his / her voice. Besides, the two transparent cups in front of the eyes can also distort the eyesight to some extent because of the uneven surface on the bottom of the cup.

My intention of making this device is to try to combine our two perceptions – seeing and hearing together and create a semi-enclosed space where we can temporarily isolate ourselves from the outside world and spend time focusing on ourselves and listen to our inner voices. Nowadays as social media is occupying every aspect of our lives and the term “social contact” has extended to both online and offline domains, we spend most of our time either chatting with others on our phones or talking with our friends face to face, and the time we spent alone reflecting on ourselves has been largely reduced. Therefore, by combining the ideas of distorting different modalities of our perception and creating a physically semi-closed space where we can be temporarily cut off from external information, I finally decided to choose this “Echo Helmet” instead of my other options.

II. Perspective & Context

This project is deeply related with our sensory functions and is aimed at combining creation, art and our daily sensory feelings together. Before starting to design this project, I first watched the videos about synesthesia (https://www.youtube.com/watch?v=s32v0rTkey4) and the theory of Merleau-Ponty (https://www.youtube.com/watch?v=JFj8kWm_N-Y). The contents of these videos, though largely differ from each other, were both related to our sensory feelings. In the first video, the speaker claimed that synesthesia happens when one can relate two (or more) sensory feelings together and utilize one to help the other. For example, he mentioned that some people can relate words or numbers with colors or relate different sounds with certain tastes. This special ability may be inborn or cultivated at a young age and usually accompanies the person for the entire life. In the second video which was a brief but insightful introduction to the most crucial theory of Merleau-Ponty, the speaker pointed out that in Merleau-Ponty’s point of view, our thoughts, perceptions and experiences are deeply related to our bodily experiences, which means that we cannot be totally separated from our bodies when forming the cognition of the world as if we are treating things in a totally objective way. Instead, we should focus on our bodily movements and experiences as well. He is against the traditional “dualism” between our minds and bodies and appeal that we should utilize our bodies to actively engage with the external world.

I also read Robert Irwin’s essay “The Process of Compounded Abstraction- Notes Toward a Model” (https://drive.google.com/file/d/10IffU7CT0TfDZ20RFZAqbBnHbLkMrVse/view). In his article, Irwin argues that instead of simply being a process of simplification and reduction, abstraction should involve deeper complexities. This requires our own understanding of the subject, therefore our concept and perception play an important role in the process of abstraction. His idea is somehow similar with the idea of Merleau-Ponty’s, because in my personal understanding both of them agree that our perception of one thing is deeply related to our direct engagement with it and that in-person interaction is very crucial when shaping our understanding and thoughts of an external object.

These ideas benefited me a lot. Firstly, the idea of synesthesia inspired me to connect two different sensory feelings – hearing and seeing – together, and to make a device that could distort both of them at the same time to provoke some connection between the feelings. I also got a new idea of how our bodily experiences may affect our perception, so that’s part of the reason why I created a wearable device to directly relate our bodies with our perceptions of the external world. However, when writing this documentation, I do feel that my project lacks the interaction that is highly emphasized in the second video and the reading, because my project does not include the person’s active and initiative engagement with the external world and other people, and therefore the distortion of our perception modalities may only be limited to a small range. I think that although I did try to combine our bodily experiences with our perception and created a connection like synesthesia, I can go further by involving more interactive process in the future since that is a crucial element when experiencing art too.

III. Development & Technical implementation

Before starting to do hands-on fabrications, I first tried to come up with some ideas that fulfilled the requirements. After being inspired by the “paper cup telephone” which I used to play with when I was a child, I decided to use two kinds of disposable cups and combine them together by creating a wearable wooden box. Above is my draft about this idea. During the drafting process I did not think of using the transparent cups in front of the eyes, but later I added them due to three reasons: the transparent cups were available at the cafeteria and broke my limited  previous perception that disposable cups were all paper-made; if I didn’t block the two openings I designed for seeing, the echo effect would be greatly reduced because the space was not enclosed any longer and it would be easy to exchange sound through the helmet; the two transparent cups could also fulfill the purpose of distorting one’s vision. Therefore, my final project includes two kinds of disposable cups attached to a wooden helmet.

Then it came to the fabrication process. In the beginning I thought of using cardboard to build the helmet, but after trying I gave up and turned to the 3mm wood boards. The cardboard was too hard to be cut into pieces of the exact same size, and if the pieces were not of the same size, then it would be difficult to glue them together and create a box without a lid. Meanwhile, the cardboard was softer than the plank and was not smooth and hard enough to generate echoes. As a result, I turned to wood and used laser cutting to create the wood boards. I first used the cardboard to formulate the size of each possible hole that needed to be cut, and then went to cuttle.xyz to generate the file for laser cutting. Below is a screenshot of this file.

After that, I went to the Fabrication Lab and cut the wood boards under the help of a professor. I glued them together and added the disposable cups.

As my inspiration came from the idea of paper cup telephones, I also used strings to connect the paper cup located in the mouth position with the other two paper cups located near the ears. My intention was to make the sound travel through the string and therefore generate a stronger vibration and create a bigger sound (although later I figured out that it actually didn’t work), so I used a needle to poke a hole at the bottom of the paper cups and connected the three cups by elastic strings.