So after a little debate, we decided to use video footage instead of a light meter to record the lightness and darkness of NYC at night. We did a short test outside of ITP, where we walked down a block on Waverly Place (between Greene and Mercer) and took video footage of the street. Rune made up a quick sketch to analyze the brightness of the frames, and here is the quick and dirty result.
He made two visualizations. The first is more of a histogram and draws a line sequentially whose stroke is the average brightness of each frame. The other I believe draws a circle whose radius maps to the average brightness value of each frame, where the center shifts over one pixel to the right each draw. I think we’re going to move forward with the histogram based visualization, since it seems to map really well to the grid-based orientation of Manhattan.
For my final project in ICM I would like to try and make a darkness map, which would attempt to visualize dark areas in New York City. The concept for this project came out of my History of Sound and Light class, and the experiments one of my classmates, Scott Wayne Indiana, is doing with outdoor projection. He mentioned how difficult it was to actually find a dark surface in the city to project onto, and it got me thinking that that might be a really interesting thing to try and visualize. We are also planning on working with Rune Madsen.
We wanted to make a micro scale darkness map. Many people are probably familiar with the amazing satellite views of the earth at night, where you can see the lit areas of the world at night, mostly clustered in the first world. This is an amazing depiction of lightness and darkness on a macro scale, but we wanted to see if we could create a system to create a map or visualization of darkness on a more micro scale.
the earth lit up at night
The first step in this process is to go out and collect the data. We plan on using the GPS in our smart phones to keep track of our locations, and light meters to take readings of the light bouncing off various walls and surfaces.
A few things to consider in collecting this data:
- How far up do we measure? Specifically, since most of New York City is so well lit by street lights, do we decide to measure darkness above the area that the light hits the buildings?
- Phase of the moon. It’s obviously brighter when there is a full moon, as there is now. From now until early December the moon will be waning. There will be a new moon on December 5th, and by December 16th it will be about 3/4 full again.
- Do we take measurements on each side of the street? Do we restrict ourselves to man-made, flat surfaces, or do we include parks, bushes and trees?
A few things to consider in visualizing this data:
- What are the darkness and lightness thresholds? Namely, what value of darkness is dark enough for our purposes, and what values do we ignore. How much of the gray area or spectrum in between do we include? Do we have to include light areas in order for the dark areas to be visible?
- Do we visualize the darkness values for a whole street, or do we include values for each sidewalk?
- Is there any interactive functionality, like a rollover which might give you coordinates and an exact light meter reading?
- We would like to create a platform that allows the map to be filled in over time through some sort of crowd sourcing process. We’re probably going to use the Google Map API in some respect so that people can fill in gaps in the future.
- We think it is interesting to try and map New York City’s dark areas since they are actually pretty hard to find. We aim to try and cover as much of Lower Manhattan as we possibly can in the next few weeks. Ideally, this map would grow to include information about the 5 boroughs, and possibly go to other well-lit cities where darkness at night might be hard to come by.
A few sources of inspiration:
- Max Neuhaus made a sound map of Times Square in preparation for his sound installation there beneath the subway grates. It is in the form of an aural topographic map, which could be a nice way to do the darkness map.
- Donald Appleyard’s Livable Streets research and map, in which he compared three streets in San Francisco that were practically identical except for the amount of traffic on each. Both his method of research and findings are of interest.
Map of quality of life in relation to traffic, by Donald Appleyard
So this was the week to make it all happen. We finalized our design, and decided to lasercut instructions onto the wood we were using for our display. Emily is an Illustrator whiz, and whipped up a great layout. We had it in our heads that we would have an outline of a tape cassette on the wood, which people would then put a tape over. Luckily, we were able to find some vector art on the internet, so it wasn’t too hard to make the tape design. Next, we layed out text describing how people should insert the tape, thread the ribbon around bobbins and across the tapehead.
Test board, still need to tweak it a bit
Another missing piece in the puzzle is that we hadn’t finalized what speakers we were using until this week. We wanted ones that were about 2″ diameter, but still loud, and affordable. We ended up buying these from Amazon. We bought 2, thinking we could split a pair in two and have one left over, but when they arrived it turned out we couldn’t easily divide the power and stereo signal, so we decided to mount one in the front facing outward, and the other in back facing inward and amplifying the sound against the board.
front speaker mounted, the next ready to go
Also, here’s the code we ended up using. It’s pretty simple, just takes the voltage input, and divides by our maximum sensor reading, then multiplies the result by 255. There is a threshold in there so we could adjust for when the signal sends data even when no tape is being run over it.
/* Tape Translations, 2010
by Emily Webster, Genevieve Hoffman and Ju Yun Song
www.tapetranslations.com
*/
float brightness1 =0;
int potPin1 =0;// Analog input pin that the potentiometer is attached to
int inValue =0;// value read from the analog sensor
int outValue =0;// value after averaging
int absInVal =0;// absolute value of inValue - threshold
int threshold =8;// threshold - we ignore values below
float maxValue =200;// maximum value we read from sensor
int led1 =5;
void setup(){// initialize serial communications at 9600 bps:
Serial.begin(9600);// declare the led pin as an output:
pinMode(led1, OUTPUT);}
void loop(){
inValue = analogRead(potPin1);// read the pot value
outValue =((abs(inValue - threshold))/(maxValue - threshold))*255;//float outValue = map(outValue, 0, 30, 0, 255); //check boundsif( outValue >255) outValue =255;if( outValue <11) outValue =0;// don't know if this is the best way to do this
analogWrite(led1, outValue);
Serial.print("inValue = ");
Serial.print(inValue);
Serial.print('\t');
Serial.print("outValue = ");
Serial.println(outValue);
delay(20);// Serial.println();}
emily gluing boards - she's a pro
components all in, almost done!
here are the guts, pre arduino and perf board (goes on the left)
A little note on lightbulbs. We really wanted to incorporate the form of an incandescent light bulb in this project. Like the cassette tape, it has a really wonderful form that I have grown up with, have many memories and connotations of, but I know that people in the future will not necessarily share my sense of familiarity. These technologies are on the way out.
Anyway, we knew that we wanted our media controller to translate sound data into light. We tried to our hands on a 12V DC light bulb, and thought we found the perfect one, but turns out it only worked with AC power not DC. So, after weighing our options, we decided to hack an incandescent light bulb and insert LEDs inside of it in place of the filament.
So, I got to work cutting off the end of some light bulbs. One thing that helped was running the end of the lightbulb against a belt sander, which chipped away at the ceramic bottom. Next, I took a hammer and chisel and carefully picked away at the ceramic end, removing the pieces with a needle nosed pliers. After the end was removed, I inserted the chisel over the filament and gave a light tap, which broke the bulb. In order to get the bulb and filament out of the light bulb, I had to chisel away at an angle at the glass lip. After a while doing this carefully, it all came out. I used needle nose pliers to grind away at any sharp pieces left over.
Here is a very helpful tutorial that I consulted throughout this process.
So, it turns out that when you break open a nice soft white diffused light bulb, all the glass shards scrape away at this white coating on the inside, and all the diffusion turns into little bits of dust. In light of this fact (haha), we decided to use clear light bulbs, and then spray on fake snow to give it back diffusion. This turned out to be a little bit of a process, namely, because ITP doesn’t allow spray paint on the floor and there is no spray booth. So, we went out guerilla style to an alley and tried out our spray technique.
It looks pretty good but up close not so much
So we noticed that we weren’t getting a very even spray, and that there were a lot of drips happening. Apparently spray paint condenses in cold weather, who knew! Luckily, we were doing this nonsense right outside of NYU’s Scenic Design shop, and a nice man happened to see what we were up to and asked if we wanted to use their spray booth. We happily accepted, and the rest was pretty straightforward. Hold the can about 10-12 inches away, and do a bunch of coats. A warm environment makes for nice happy spray paint, and no drips!
As a side project, I’m helping to design some lighting for a window installation designed by Emily Ryan, another ITP student who won a contest sponsored by H&M to have her art installed in their 5th Avenue store for three months. She’s designed an interactive installation that visualizes tweets, texts and flickr photos and displays them across an outline of New York City. After seeing my Hot or Not project, she asked if I wanted to help out designing some lighting for the skyline.
Emily's winning design!
One of the main things she wanted was to light the Empire State Building in the skyline so that its lights matched the lighting of the real Empire State Building. I’m working with ITP alum Matt Richard, creator of Estrella, to make this happen. He told me about a site and rss feed that already displays what colors the lighting on the Empire State Building will be each day: www.whatcoloristheempirestatebuilding.com/. This will be easy to have either PHP or Processing parse the XML for the color data, then feed it to Arduino to program the lights.
Coincidentally, this in week in ICM we had to do a project that imported data into a processing sketch. I decided to take this opportunity to make a mockup of the lights in processing, where it would parse the XML and display the color data as a simple screen visualization. It looks fairly static and boring since the XML only updates once a day, but here is the sketch.
The code is still clunky (remind me to finally try and understand classes), but it works. Next steps are making it cleaner, as well as trying to do the same thing in PHP, which people have told me is a “better” way to interface with Arduino for this application.
When we started talking to people about this project, namely that we wanted to translate the voltage signal coming off cassette tape into light, the name Eric Rosenthal kept coming up as someone “we should talk to.” Eric Rosenthal is ITP’s resident electronics guru. Just as Tom Igoe is an expert in all things Arduino, Eric Rosenthal is the master at all things analog. He teaches a class (that I really want to take) called Basic Analog Circuits. He basically knows anything you’d want to know about electronics.
So, we went to him to try and figure out the best way to read the signal coming off the tapehead, and translate it into light. After hearing our concept, Eric proposed an analog method to achieve what we wanted. We were really excited about this, mostly since the concept behind the project is a sort of ode to analog technologies that have been (or will soon be) retired. However, after thinking about the project a bit more, we opted to use the Arduino since it will afford us more control in mapping the input signal we get from the tapehead.
In order to preserve the signal coming out of the hacked Walkman, Eric recommended we get an 1/8″ stereo jack, which splits the signal from the ground. He also helped us design a circuit to preserve the signal, which connects one of the stereo signals to a 104 capacitor and signal diode in parallel. I’m not completely sure what they do, but I think it maintains the signal strength without actually amplifying it with an op amp, which is what we thought we had to do originally.
signal input and light output circuit
We split the signal coming out of the Walkman line out jack with a Y-splitter. One 1/8″ cable goes directly to our speaker for the audio output, and the other 1/8″ cable goes to the stereo jack, then to the signal diode / capacitor circuit, then into the Arduino. Our Arduino program then maps the input to an LED connected to a PWM pin, so that it gets brighter and dimmer according to the voltage signal.
This week we also heard about the NIME conference, which had a call for projects for a museum exhibition that would coincide with the conference and performances. We decided to enter our Media Controller as an exhibit, which was due on Friday, November 5th. It was an interesting process trying to write about the project before we had completely finished making the conceptual and formal decisions, but it also made us put down on paper what we wanted it to do, and the significance behind it. Here’s crossing our fingers we get to go to Norway!
So the second serial lab was good practice since I actually haven’t made any projects yet that really require the Arduino to talk to Processing. Hopefully I can figure out something I can do for the final that incorporates both.
I am starting to understand the difference between BYTE, DEC and other serial values, but this chart is still immensely handy. The code for the lab that sent the sensor values in “many formats” was especially helpful to compare the different characters (and see how they’re related.)
Code:
int analogPin =0;
int analogValue =0;// integer to print
void setup(){// open serial communications at 9600 bps
Serial.begin(9600);}
void loop(){// read the analog input, divide by 4:
analogValue = analogRead(analogPin)/4;// print in many formats:
Serial.print(analogValue, BYTE);// Print the raw binary value analogValue
Serial.print('\t');// print a tab
Serial.print(analogValue, BIN);// print the ASCII encoded binary analogValue
Serial.print('\t');// print a tab
Serial.print(analogValue, DEC);// print the ASCII encoded decimal analogValue
Serial.print('\t');// print a tab
Serial.print(analogValue, HEX);// print the ASCII encoded hexadecimal analogValue
Serial.print('\t');// print a tab
Serial.print(analogValue, OCT);// print the ASCII encoded octal analogValue
Serial.println();// print a linefeed and carriage return
delay(10);}
Multiple Sensors communicate Serially
So I wired up my Arduino with multiple sensors: a potentiometer, an FSR, and a switch. In order for my switch value to appear in the first part of the Punctuation section, I had to declare it an analog input instead of a digital input, since the code was set up to go through three analog inputs and print all the values. It still gave me a digital reading of 1 or 0.
void loop(){for(int thisSensor =0; thisSensor <3; thisSensor++){
int sensorValue = analogRead(thisSensor);
Serial.print(sensorValue, DEC);// if this is the last sensor value, end the line.// otherwise, print a comma:if(thisSensor ==2){
Serial.println();}else{
Serial.print(",");}}}
Next came “Hand-shaking” or “Call and Response.” I can see the benefits of this method, as I don’t think they fill up the buffer as much as constantly sending serial data does. That said, I’m still at the “copy and paste” stage with this code, and don’t completely understand the logic behind it. But I did get it to work, so that’s something. One thing I had to do was map the sensor values to the width and height of the Processing screen, so that they’d be more visible. Other than that, this lab was pretty straightforward.
Next we wanted to see if we could “explode” the Walkman and still read the tape head. To do this, we unscrewed as many screws as we could find, then used shears to cut away at the plastic casing. A few times we accidentally snipped important cables, like the one connecting the tapehead to the amplifier, or the one powering the circuit board. Proceed slowly is probably the best advice I have.
By connecting a 3V power supply (the voltage recommended on the back of the Walkman) to the battery terminals, we were able to supply the playhead with power so that it read the tape. By connecting the line out jack on the walkman circuit board to a speaker we could hear that signal as sound.
Powering the hacked walkman -- it still works!
In order to get a better sense of the signal coming off the tape playhead we hooked it up to an oscilloscope. An oscilloscope allows you to visualize an analog signal. You can actually see the voltage signal visualized as waveforms on the oscilloscope screen. This helped us determine in a more exact way than using the multimeter what the changes in voltage we have to work with are (in order to turn the light on and off).
Here’s video of the oscilloscope graphing the tape playhead signal:
After getting confirmation that what we want to do is possible, we decided to focus on the interface that we want people to use to play the tape. We had a few directions we wanted to go in. One idea was to have the tape static and have the playhead move over it. This is similar to what Nam June Paik did in Random Access Music, as well as the Analog Tape Glove project.
We liked the idea of having the tape move across the playhead in a way that required the user / listener to control it by hand. One idea was to cut the cassette tape and pull it out of the case over the playhead, in a gesture that slightly mimics having to deal with tape that has gotten loose from its cassette. However, instead of being ruined, we wanted to show that there is still information on that tape that could be read, even if the quality is slightly degraded, and, that this information could be translated into a different form.
We also wanted to see if we could make some sort of hand crank system to play the tape back and forth over the playhead. This method is proving a bit more difficult since it’s pretty hard to maintain the tension of the cassette tape when it’s out of the cassette. We’ll see if we can come up with a system in the next few weeks that can turn the tape spokes. Stay tuned.
In order to experiment with some different techniques to route the tape over the playhead, we mocked up a quick study to see what parts and routes worked best. We used the tape-pulling interface to start, as it’s the most straightforward and easiest to put together.
Scrap wood, plastic casing, and lego parts come in handy
This layout seemed to provide the right amount of tension, but not too much so that the tape would crinkle or get stuck as we pulled. The further apart the pivot points are, the harder it is to pull the tape.
