Final Project:
Grid Mate By Veronika Dubrovskaya and Ryan Viglizzo
Veronkia and I developed a framework in Processing and Arduino that allows artists, educators, and musicians to attach visuals and sounds (music or voice) to any physical space via sensors. The core idea is simple–place a sensor on a physical space (wall, ground, desk, etc.); create a visual of your choice, upload that visual to processing, project the processing sketch canvas on that space and attach sounds to your sensors. As you press the sensors your visual moves to the sensor that you pressed as well as triggers a sound that can be looped or activated once. There are four aspects to this project: “sensors”, “visuals”, “sounds” and ‘space’. Anyone of these contexts can be modified. But here is how we presented it….
“Sensor”: We picked an FSR (pressure sensor) because of the accuracy of its reading.
“Visuals”: We decided to have a dissolving ball be our visual. So as it moves to the different locations on the canvas it begins to paint the canvas.
Beginning sketch: attachingballstosensors
new brush stroke sketch: Brush stroke visual with sound
“Sounds”: We mixed various samples to have them looped
Midi with sensors progress video
visuals working (but we need new music) video
Chopping up samples (sound design): In the sound design. I took samples from various bands from ‘Boarders of Canada’ to ‘the books’ and synced them so at any point the beat would be cyclical– meaning that any sample can engage at any point and sync with currently running sample. Here is a photo of the chops and the layouts in LogicPro.
“Spaces”: We decided to make a canvas our medium.
Mapping Sounds and Visuals Video
—We also incorporated a whiteout function that deleted the entire visual starting it over from scratch. —
In developing this code we realized how malleable it was. Anyone of these parameters can be interchanged. For instance, in the context of musicians you could put sensors on your performance backdrop wall behind you that triggered sounds and visuals to where they touched on the wall. Educators could use this system to attach sensors to a map of the USA where kids could press on states and trigger voice descriptions of the places. The possibilities are endless.
We made this project open source. Anyone can use this code (the sensors are up to you). Please feel free to contact either Veronika or Myself for questions or project ideas using this technology.
Schematics:
The circuit for the final project is really simple. We have 16 FSR sensors each of which takes 5V of power to a 10Kohm resistor back to ground. We used a Mega Arduino for the project because we need more Analog read pins.
Arduino Code: The Arduino code was a simple analog read of the sensors. We made this the most simplistic portion of the code in order to make the communication between processing and Arudino smooth.
void setup() {
Serial.begin(9600);
}
void loop() {
int x = analogRead (A0); // read the pot value
Serial.print(x); // print the value in the serial monitor as a binary value
Serial.print (“,”);// to delimit bytes
int x1 = analogRead (A1);
Serial.print(x1); // print the value in the serial monitor as a binary value
Serial.print (“,”);// to delimit bytes
int x2 = analogRead (A2);
Serial.print(x2); // print the value in the serial monitor as a binary value
Serial.print (“,”);// to delimit bytes
int x3 = analogRead (A3);
Serial.print(x3); // print the value in the serial monitor as a binary value
Serial.print (“,”);// to delimit bytes
int x4 = analogRead (A4);
Serial.print(x4); // print the value in the serial monitor as a binary value
Serial.print (“,”);// to delimit bytes
int x5 = analogRead (A5);
Serial.print(x5); // print the value in the serial monitor as a binary value
Serial.print (“,”);// to delimit bytes
int x6 = analogRead (A6);
Serial.print(x6); // print the value in the serial monitor as a binary value
Serial.print (“,”);// to delimit bytes
int x7 = analogRead (A7);
Serial.print(x7); // print the value in the serial monitor as a binary value
Serial.print (“,”);// to delimit bytes
int x8 = analogRead (A8);
Serial.print(x8); // print the value in the serial monitor as a binary value
Serial.print (“,”);// to delimit bytes
int x9 = analogRead (A9);
Serial.print(x9); // print the value in the serial monitor as a binary value
Serial.print (“,”);// to delimit bytes
int x10 = analogRead (A10);
Serial.print(x10); // print the value in the serial monitor as a binary value
Serial.print (“,”);// to delimit bytes
int x11 = analogRead (A11);
Serial.print(x11); // print the value in the serial monitor as a binary value
Serial.print (“,”);// to delimit bytes
int x12 = analogRead (A12);
Serial.print(x12); // print the value in the serial monitor as a binary value
Serial.print (“,”);// to delimit bytes
int x13 = analogRead (A13);
Serial.print(x13); // print the value in the serial monitor as a binary value
Serial.print (“,”);// to delimit bytes
int x14 = analogRead (A14);
Serial.print(x14); // print the value in the serial monitor as a binary value
Serial.print (“,”);// to delimit bytes
int x15 = analogRead (A15);
Serial.print(x15); // print the value in the serial monitor as a binary value
Serial.print (“,”);// to delimit bytes
Serial.print(‘\n’); // end of line
}
Processing Code: This is where the grid comes in…. We used the minim library in processing for the music.
import processing.serial.*; // import the Processing serial library
import ddf.minim.*;
int grid[][] = new int[16][2];
int sensor[][] = new int[16][2];
boolean isPlaying[] = new boolean[16];
int isToggleSensor[] = {1, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1};
boolean whiteOutPressed = false;
Minim minim;
AudioPlayer[] bobby;
Serial myPort;
int destination[] = {0, 0};
int currentPos[] = {0, 0};
int[] getNext(int[] c, int[] d)
{
int[] res = {0, 0};
res[0] = c[0];
res[1] = c[1];
if ((c[0] == d[0]) && (c[1] == d[1]))
return d;
float k = (float) (c[1] – d[1]) / (float) (c[0] – d[0]);
int b = d[1] – (int)(k * (float)d[0]);
if (abs(c[0] – d[0]) > abs(c[1] – d[1]))
{
res[0] -= ( (c[0] – d[0]) / abs(c[0] – d[0]) )/5 ;
res[1] = (int)((float)res[0] * k) + b;
}
else
{
res[1] -= ( (c[1] – d[1]) / abs(c[1] – d[1]) )/5 ;
res[0] = (int)(((float)(res[1] – b)) / k);
}
// println(“res = ” + res[0] + ” ” + res[1]);
return res;
}
void setup () {
size (600, 600);
// for (int i = 0; i < 4; i++)
// {
// for (int j = 0; j < 4; j++)
// {
// grid[(i+1)*j][0] = (900 / 4) * (j + 1);
// grid[(i+1)*j][1] = (900 / 4) * (i + 1);
// }
// }
grid[0][0] = 90;
grid[0][1] = 50;
grid[1][0] = 38;
grid[1][1] = 80;
grid[2][0] = 65;
grid[2][1] = 90;
grid[3][0] = 90;
grid[3][1] = 90;
grid[4][0] = 30;
grid[4][1] = 140;
grid[5][0] = 70;
grid[5][1] = 130;
grid[6][0] = 35;
grid[6][1] = 185;
grid[7][0] = 75;
grid[7][1] = 165;
grid[8][0] = 100;
grid[8][1] = 170;
grid[9][0] = 85;
grid[9][1] = 210;
grid[10][0] = 90;
grid[10][1] = 130;
grid[11][0] = 70;
grid[11][1] = 130;
grid[12][0] = 110;
grid[12][1] = 130;
grid[13][0] = 145;
grid[13][1] = 200;
grid[14][0] = 145;
grid[14][1] = 140;
grid[15][0] = 145;
grid[15][1] = 80;
smooth();
background(255);
colorMode(HSB);
minim = new Minim(this);
bobby = new AudioPlayer[16];
bobby[0] = minim.loadFile(“atmosphere.wav”, 1400);
bobby[1] = minim.loadFile(“clapwheel.wav”, 618);
bobby[2] = minim.loadFile(“anote.wav”, 1200);
bobby[3] = minim.loadFile(“bnote.wav”, 1200);
bobby[4] = minim.loadFile(“fastclick.wav”, 442);
bobby[5] = minim.loadFile(“d#.wav”, 975);
bobby[6] = minim.loadFile(“swishclick.wav”, 442);
bobby[7] = minim.loadFile(“g#.wav”, 975);
bobby[8] = minim.loadFile(“a4.wav”, 1200);
bobby[9] = minim.loadFile(“oceanbell.wav”, 180);
bobby[10] = minim.loadFile(“e.wav”, 1200);
bobby[11] = minim.loadFile(“f#.wav”, 975);
bobby[12] = minim.loadFile(“c#.wav”, 975);
bobby[13] = minim.loadFile(“mandolin.wav”, 709);
bobby[14] = minim.loadFile(“harmonic.wav”, 709);
bobby[15] = minim.loadFile(“underwaterclick.wav”, 618);
println(Serial.list());
String portName = Serial.list()[0];
myPort = new Serial(this, portName, 9600);
myPort.bufferUntil(‘\n’);
}
void draw()
{
// for (int i = 0; i < 16; i++)
// {
// fill(0);
// ellipse(grid[i][0], grid[i][1], 20, 20);
// }
//
if (whiteOutPressed)
{
background(255);
whiteOutPressed = false;
}
else
{
int[] next = getNext(currentPos, destination);
filter(DILATE);
filter(BLUR,6);
stroke(frameCount % 150, 200, 255);
strokeWeight(40);
line(currentPos[0], currentPos[1], next[0], next[1]);
currentPos[0] = next[0];
currentPos[1] = next[1];
}
}
void serialEvent (Serial myPort)
{
String input = myPort.readString().trim();
println(input);
if (input != null)
{
String [] parts = input.split(“,”);
if (parts.length != 16) //change to 8 when you put in the samples
{
return;
}
for (int i = 0; i < 16; i++)
{
if (parts[i] != null)
{
sensor[i][0] = sensor[i][1];
sensor[i][1] = int(map(int(parts[i]), 0, 300, 0, 1));
}
}
for (int i = 0; i < 16; i++)
{
if ( (sensor[i][0] == 0) && (sensor[i][1] == 1) )
{
if (isPlaying[i] && (isToggleSensor[i] == 1))
{
bobby[i].pause();
}
else
{
bobby[i].rewind();
if (isToggleSensor[i] == 1)
{
bobby[i].loop();
}
else
{
bobby[i].play();
}
}
isPlaying[i] = !isPlaying[i];
destination[0] = grid[i][0];
destination[1] = grid[i][1];
if (i == 9) // put the number of the whiteout sensor
{
currentPos[0] = destination[0] = 0;
currentPos[1] = destination[1] = 0;
whiteOutPressed = true;
}
}
}
}
}
Issues and Development: We are currently trying to develop the framework for MadMapper to project on smaller surfaces. We are also working to make a function for the visuals to be reactive to the music. Because different users of the framework will have different goals we want to make an external interface to allow the project to be more accessible to people who don’t do any coding or work in physical computing. We also hope to do an interactive educational instillation in the Brooklyn Children’s museum involving storytelling in a space.
This was our final project was developed for physical computing and Computational Media class; special thanks to Benedetta Piantella, Dan O’Sullivan, Heather Dewy Hagborg, Physical Computing Class, and ICM Class for helping us refine the interaction, coding, and concept.
Media Controller: pRoJecT zOrb
Mark, Rose, and I built a ball to control sound and video… The aim was to make a musical performance object that can shift video and sounds of various sample patches during a live performance. We built it as a wireless device so any performer or audience member can interact the ball to shift the sound and video…. We are extending the prototype to become more functional in a performance space.
The zOrb has three main compents: a mini arduino, bluetooth BlueSMiRF chip, and an accelerometer/gyroscope sensor. The sensors were hooked up in MAX to control video and music.. Here is a clip of the zOrb, enjoy…
MAX Patch:
Arudino code:
Final project proposal for Physical Computing and ICM
Title: //sound+pixels=Awesome
Proposal: What if you could paint with sounds? What if you could paint with your instrument? What would it look like? How can we communicate using the language of music to bridge the gap between the organic tonal world and digital pixilated world? The goal of this project is to connect digital imagery and tonal vibrations. This is a prototype to a larger idea that would allow musicians who play various stringed instruments to create and customize digital images in improvisation music. For this project, we will be investigating one instrument coupled with one style of digital visualization.
Our inspiration came from: http://www.youtube.com/watch?v=WWai4UZ0OqI and http://www.youtube.com/watch?v=gleC2MoUX8k
—This project is done in collaboration with Veronika Dubrovskaya and combines ICM and Physical Computing—
Our Journey: We initially built a prototype of a completely different instrument, which we designed with photocells as inputs. Here is the Arduino code and Processing Code for few of the analog outputs using photocells.
Arduino Code:
void setup() {
Serial.begin(9600);
}
void loop() {
int x = analogRead (A0); // read the pot value
Serial.print(x); // print the value in the serial monitor as a binary value
Serial.print (“,”);// to delimit bytes
int x1 = analogRead (A1);
Serial.print(x1); // print the value in the serial monitor as a binary value
Serial.print (“,”);// to delimit bytes
int x2 = analogRead (A2);
Serial.print(x2); // print the value in the serial monitor as a binary value
Serial.print (“,”);// to delimit bytes
//int x3 = analogRead (A3);
//Serial.print(x3); // print the value in the serial monitor as a binary value
//Serial.print (“,”);// to delimit bytes
//int x4 = analogRead (A4);
//Serial.print(x4); // print the value in the serial monitor as a binary value
// Serial.print (“,”);// to delimit bytes
Serial.print(‘\n’); // end of line
}
Processing Code:
import processing.serial.*; // import the Processing serial library
//import rwmidi.*;
int xpos,xpos1, xpos2;
//int notes [] = {0,2, 4,7, 12, 14,16, 19.21.24.26}
//int midiTonic = 60
//MIdiOutput output;
Serial myPort;
void setup () {
size (400, 400);
background (207, 86, 75);
println(Serial.list());
String portName = Serial.list()[0];
myPort = new Serial(this, portName, 9600);
myPort.bufferUntil(‘\n’);
// output = RWMidi.getOutputDevices()[0].createOutput();
}
void draw()
{
background (207, 86, 75);
fill (255, 255, 255);
ellipse (xpos, height/3, 40, 40);
ellipse (xpos1, 2*height/3, 40, 40);
ellipse (xpos2, height/2, 40, 40);
}
void serialEvent (Serial mmyPort)
{
String input = myPort.readString().trim();
println(input);
int x = xpos;
int x1 = xpos1;
int x2 = xpos2;
if (input != null)
{
String [] parts = input.split(“,”);
if (parts[0]!=null)
{
x = int (parts[0]);
}
if (parts[1]!=null)
{
x1 = int (parts[1]);
}
if (parts[2]!=null)
{
x2 = int (parts[2]);
}
xpos = int (map (x, 300, 1000, 0, width));
xpos1 = int (map (x1, 300, 1000, 0, width));
xpos2 = int (map (x2, 300, 1000, 0, width));
}
}
Although we got the photocells to work with the light calibration, we decided that we want to make a more realistic interaction rather than building a new instrument. In our search we stumbled upon the Chinese stringed instrument the guqin (ancient zither). The instrument was approachable to almost anyone because the strings are aligned in one key. It requires more skill to get more complex note patterns but anyone can start playing easily.
The sensors that we are going to use are still up for debate and refinement but we he had the idea of attaching two types of sensors to each of the 7 strings— mini microphone sensors and piezo sensors. The mini microphone sensors will pick up the range of notes and pies sensors to pick the vibration intensity. The vibration intensities and the note information coming from the instrument and will be sent Arduino which will then be sent processing. The singular notes and the multiple vibration intensities will be mapped to various color textures, intensities, and patterns that will be displayed in a processing sketch. The visual design developed in a processing sketch will be reminiscing of Chinese watercolor painting styles.
Road Map:
Phase 1: Picking instrument
We have chosen the guqin (ancient zither)— it’s playable, beautiful and nimble. A trip to china town should solve this. We decided to have the imagery mimic Chinese watercolors but in an abstract way.
Phase 2: Sensor Search
We are still in the process of this but we want to attach piezo and mini microphones to pick up the vibrations and note patters of the instrument.
Phase 3: Code/Calibration
This will be our coding phase. We have to map the range of the sensors based on the vibrations and notes to specific color textures, patterns, and styles in processing. We have already been messing around with code and textures. Here we will be testing the instrument with the sensors and sketch.
Phase 4: Final Construction/presentation
After the mapping of the sensors are correctly corresponding with the sketches we shall construct a cleaner version of the instrument by making the sensors non-visible on the instrument.
Second Serial Lab #7:
In this lab we coded an accelerometer in Arudino to communicate with a processing sketch. I completed it with Mimi and Bruna.
Video: Lab #7 -Second Serial Lab Video
Code and Images:
Observation Blog Post: MTA Kiosk
I picked the MTA Kiosk to observe for my interactive piece of technology in public. I chose this because it is both a familiar and foreign device for the public. The MTA Kiosk is self-explanatory; it is where you get your tickets for the train. The entire interaction can take anywhere between 30sec. to 3min. (that was the longest time I saw someone take). There were three types of users: regular users, new users, and specialized users.
The reaction of both the regular users and new users were obvious. The regular user moved through the menu flawlessly. They seemed to not even need labels on the keys. They mapped and memorized the interface. The new users struggled. They either had difficulty with the language or functionality asking their friends “what the does this mean?”, “how much money should we put on a card?”, “what does unlimited ride do?” and so on…
The third class of specialized user was revealed to me when my friend finally met me at the subway. She only buys month passes, but this time she wanted to buy a card for a fixed amount of money because she was leaving to home for a couple of weeks. When she went through the menu system she immediately began her normal routine and clicked on the unlimited ride. She then backtracked and told me “I don’t know how to buy a regular ticket?! What’s wrong with me today?!” She fumbled around the menus and eventually picked the right pathway to buy a single ticket.
The specialized user was interesting because they used the kiosk for one thing and never engaged with the other features. They were experts but also novices at the same time. The communication between the MTA Kiosk and the 3 types of users reflected the points mentioned in the first chapter in “Emotion and Design.”
This chapter discussed the implications of usability vs. aesthetic and how these elements are both intertwined and separated. Designs are emotional. The aesthetic of a design can override the functionality and visa versa. Norman gives the example of the color monitor something that added no extra functionality but only aesthetic quality. He describes how the aesthetic quality kept him engaged in his work and his product.
The MTA Kiosk was designed for usability. In thinking about this product and watching its users I see another quality of aesthetic not mentioned in Norman’s chapter—The fact that familiarity and functionality is an aesthetic its self. People enjoy things they can use easily. Norman suggests that “positive affect” makes people more tolerant, flexible and creative when interacting with a design. He was referring to a beautifully aesthetic design but I believe that functionality can fall into this category as well.
There is comfort in a product we use all the time. The user becomes emotionally attached to the form of the product. Even if the product is entirely designed around its usability, they learn to love the typeface, the layout, and the simple sight of the product. Familiarly brings beauty to a design.
Lab #6: Serial output
I completed this lab with Bruna and Mimi. We messed around with the shapes and the variability of their masses controlled by a potentiometer in a processing sketch that communicated with Arduino. Here is what we came up with…
First Code:
Video of first code:
Occupy Arduino Code:
Video of Occupy:
Stupid Pet Trick!
Concept: Light Activated Music box.
Description: I made a music box for my stupid pet trick. The concept was that I would first map 4 photo sensors to a note. I placed those photo sensors on 4 sides of the box. I would then have 4 LEDs placed around the box in front of the photo sensors that I could control from 4 switches. When I would activate the LEDs the photo sensors would read the light and give an output the note I mapped for it.
Pet trick (lights functioning)
Code:
#define NOTE_C4 262
#define NOTE_D4 294
#define NOTE_E4 330
#define NOTE_F4 349
int sum = 0;
int threshold1 = 0;
int threshold2 = 0;
int threshold3 = 0;
int threshold4 = 0;
void setup() {
Serial.begin(9600); // initialize serial communications
pinMode(13, OUTPUT); // speaker
for (int i = 0; i < 10; i++) {
sum += analogRead(A0);
}
threshold1 = sum / 10; //to take 10 waves of light and divide it by 10 for average
sum = 0;
for (int i = 0; i < 10; i++){
sum += analogRead(A1);
}
threshold2 = sum / 10;
sum = 0;
for (int i = 0; i < 10; i++){
sum += analogRead(A2);
}
threshold3 = sum / 10;
sum = 0;
for (int i = 0; i < 10; i++){
sum += analogRead(A3);
}
threshold4 = sum / 10;
pinMode(2, INPUT); // set the switch pin to be an input
pinMode(8, OUTPUT); // set the red LED pin to be an output
pinMode(3, INPUT);
pinMode(9, OUTPUT); // set the green LED pin to be an output
pinMode(4, INPUT);
pinMode(10, OUTPUT); // set the white LED pin to be an output
pinMode(5, INPUT);
pinMode(11, OUTPUT);// set the yellow LED pin to be an output
}
void loop() {
// read the switch input:
if (digitalRead(2) == HIGH) {
// if the switch is closed:
digitalWrite(8, HIGH); // turn on the red LED
}
else {
digitalWrite(8,LOW);
}
if (digitalRead(3) == HIGH) {
// if the switch is closed:
digitalWrite(9, HIGH); // turn on the red LED
}
else {
digitalWrite(9,LOW);
}
if (digitalRead(4) == HIGH) {
// if the switch is closed:
digitalWrite(10, HIGH); // turn on the red LED
}
else {
digitalWrite(10,LOW);
}
if (digitalRead(5) == HIGH) {
// if the switch is closed:
digitalWrite(11, HIGH); // turn on the red LED
}
else {
digitalWrite(11,LOW);
}
int analogValue1 = analogRead(A0); // read the analog input
int analogValue2 = analogRead(A1); // read the analog input
int analogValue3 = analogRead(A2); // read the analog input
int analogValue4 = analogRead(A3); // read the analog input
// Serial.println(analogValue); // print it
if (analogValue1<threshold1-50) {
tone(13, NOTE_C4, 10);
}
if (analogValue2<threshold2-50) {
tone(13, NOTE_D4, 10);
}
if (analogValue3<threshold3 – 50) {
tone(13, NOTE_E4, 10);
}
if (analogValue4 < threshold4 – 50) {
tone(13, NOTE_F4, 10);
}
}
// if the switch is open:
Code Image: 
Issues: I never was able to calibrate the light correctly. The ambient light kept throwing my calculations off. The photo sensor was to sensitive. I had to calibrate it in complete darkness which was impossible to find. Basically, my main issue was that I could not get the LEDs around the box to trigger the tones and the ambient light.
Positives: Although my concept did not work perfectly I learned a lot about calibrating light with photo sensors, outputting tones, coding and doing the math behind the calibration. I also learned a lot about how to wire my board properly. I think I will do a cleaner job next time, but everything worked perfectly in this respect…. I also learned a lot about coding in Arduino both in the mathematical sense and operational sense. Overall, gained a lot of skill and had a fun adventure from going from nothing to something with wires!
PComp Lab #5: Tone Output
For this lab I made a photo sensor change the pitch of a tone…..
PComp Lab #4 : Servo/analog out
– I made a halloween servo creation for my lab with a baby head I found in the junk bin. The lab was inspired by the exorcist.
Code: 
Fantasy Device: (I have a presentation that goes with it but I can’t up load it!)
I designed an application for the iPhone tracks your diet metrics via scanning your blood veins. You scan yourself daily and it provides a diet metric report suggesting different food you need to balance those metrics. It also suggests places you can get those foods, gives you coupons for having a healthy reading, and suggests recipies (still in beta). The image reveals the user pathways of the app.
PComp Lab #2
analog knob//make lights go analog via knob!
cconst int ledPin = 9; // pin that the LED is attached to
int analogValue = 0; // value read from the pot
int brightness = 0; // PWM pin that the LED is on.
void setup() {
// initialize serial communications at 9600 bps:
Serial.begin(9600);
// declare the led pin as an output:
pinMode(ledPin, OUTPUT);
}
void loop() {
analogValue = analogRead(A0); // read the pot value
brightness = analogValue /4; //divide by 4 to fit in a byte
analogWrite(ledPin, brightness); // PWM the LED with the brightness value
Serial.println(brightness); // print the brightness value back to the serial monitor
}
analog pressure//Make lights go analog on via pressure!
const int ledPin = 10; // pin that the LED is attached to
int analogValue = 0; // value read from the pot
int brightness = 0; // PWM pin that the LED is on.
void setup() {
// initialize serial communications at 9600 bps:
Serial.begin(9600);
// declare the led pin as an output:
pinMode(ledPin, OUTPUT);
}
void loop() {
analogValue = analogRead(A1); // read the pot value
brightness = analogValue /4; //divide by 4 to fit in a byte
analogWrite(ledPin, brightness); // PWM the LED with the brightness value
Serial.println(brightness); // print the brightness value back to the serial monitor
}
Blog Post #2: A world of sensors!- Tracking the sensors from Prospect Heights to ITP
photo walk from Prospect Park to ITP
- Camera outside APT.
- Light on street
- Cars on the street
- Metro Card Dispenser
- Card reader
- LED Subway display
- Emergency gate in subway
- Subway car
- LED in Subway car
- LED display for Stops
- Light for Train
- subway door
- Subway door close light
- Subway door open light
- Payphone
- Subway Camera
- Subway Exit
- Subway microphone
- Street light signals
- Fire alarm
- Sensor lights in ITP hallway
- Hand Sensor for ITP doorway
—- Reaction: Doing this project made me realized… ALRIGHT WE GET IT!~ Physical Computing is important! Everywhere we look—there are sensors!—Doors, locks, lights, light sensors, motors, etc. The sensor walk pushed me to become aware of the connections between the human and mechanical world. I realized, if you live in a city, how much one relies on sensors, machines, etc. to get us where we are going…. I realized that the road I was walking on was created by machines with sensors, everything I had in my bag– my computer, phone, pencil, even the bag use or were created using sensors of some kind. It made me feel mechanical if a very organic way. The world of sensors lays under our organic world helping it to function. It also gave me purpose to making a go light blink!
PComp Lab#1: Pcomp guitar!
blinking light// lights go blink
Source code:
//this is where we initialize
pinMode(13, OUTPUT);
pinMode(12, OUTPUT);
}
//we do things in loops
void loop(){
digitalWrite(13, HIGH);
delay(500);
//turn light low for 1 second
digitalWrite(13, LOW);
delay(500);
}
Cut me a switch//switch light on and off
Source Code:
void setup() {
pinMode(2, INPUT);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
}
void loop() {
// read the switch input:
if (digitalRead(2) == HIGH) {
// if the switch is closed:
digitalWrite(3, HIGH);
digitalWrite(4, LOW);
}
else {
// if the switch is open:
digitalWrite(3, LOW);
digitalWrite(4, HIGH);
}
Many lights go blink//Make More Lights go blink!
void setup() {
pinMode(2, INPUT); // set the switch pin to be an input
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
pinMode(7, OUTPUT);
}
void loop() {
// read the switch input:
if (digitalRead(2) == HIGH) {
// if the switch is closed:
digitalWrite(3, HIGH);
digitalWrite(5, HIGH);
digitalWrite(7, HIGH);
digitalWrite(4, LOW);
digitalWrite(6, LOW);
}
else {
// if the switch is open:
digitalWrite(3, LOW);
digitalWrite(5, LOW);
digitalWrite(7, LOW);
digitalWrite(4, HIGH);
digitalWrite(6, HIGH);
}
}
Blog Reaction: Interactivity.–Moma _ Readings
Interactively is hard to define because it depends on the lens you look through to define it. It seems interactivity in art, music, industrial design; new media and so on have their own special definitions. So I think it is important to define it in the broader sense:
Interactivity is the communication between two or more things or living things (people, objects, animals, etc.) each of which has an input and output to the discourse between them.
Understanding the definition: I struggled with the fact that sometimes the other side of interaction can be void of output. Ex. Lets say you poke a dead raccoon with a stick are you the only one interacting? The output of the animal is to be moved by the stick and the input is the stick hitting it. In contrast the animal does have the ability to give an output unless the human does something. Does interactivity mean that it takes two to have the power to input and output on to each other? Does the thing outputting need to be alive or can it be allowed to be contingent on the output of the other thing interacting with it to facilitate interactivity?
In the context of Crawford, he describes interaction as a “conversation—a cyclic process where two actors listen, think and speak.” He is defining interactivity from the lens of a designer and artist (which is a perfectly good definition). I think he sees “consciousness” as a necessity. There needs to be intention on both ends. Let’s take an example like: A huge rock falls and knocks over a tree. I would call that interactivity— it is an interaction in nature. Both objects are not conscience but they both have outputs and inputs:
Rock
Output: falling
Input: Colliding with the tree
Tree
Input: Rock colliding with it
Output: Falling
— this would not be a valid example of interactivity because neither of these objects have intention.—
In the context of the Moma exhibit there was a much broader definition of interaction. Some works were clearly interactive like the “talking Carl” where as others like the “taxi hand sign shape lingo for blind people” was merely a representation or a study of how people communicate or interact. The “taxi exhibit” did not allow you to interact with anything. I think this is what leads us into—The difference between a good and bad interaction.
The lens of expectation you put over it defines a good or bad interaction. In the context of the Moma, I was expecting to interact with all the pieces and have them give me output. The pieces that were representations of interactions were disappointing to me— but that was only in the context for how I was viewing the works. I had the expectation that I would be the force of interaction. The lens defines your expectation for the interactivity but it does not mean interaction is not happening in a different context.
Thanks so much for sharing your thoughts on the Moma exhibit! And thanks for posting great documentation on your Lab. I0′m happy to see that you took it a step further and made it your own!
B_