WEEK 1 - Observation
For our first P-Comp project, we were asked to start by observing and documenting the ways that people use a specific tool of our choosing. We did some talking and decided that the bicycle pump was a good, simple physical tool that most people know how to use, despite it's design flaws and the fact that it is not typically condusive to good, ergonomic useability. We shot some video of the pump in action:
From a usability standpoint, we discovered that the pump was deeply flawed. The main problem is that the user has to bend over in a way that puts a lot of strain on her back and thighs. The pump is flimsy, not at all stable, and the footpads are too small, all of which mean the user has to tense her legs, back and arms in order to hold it in position. Also, it is very easy for the user to pinch her hand between the base of the pump and the piston when pumping quickly. We were also really bothered by the fact that the pump is called a "hand pump" but requires use of the entire body. As you can see in the video demo, one of our test users decided to use the pump in his hands instead of on the floor, which was not entirely effective but did resolve some of the ergonomic issues.
WEEK 2 - Prototype design
Keywords: interactive video installation, bicycle pump controller, effort and reward, narrative
Possible names: Pop!
After spending much time with the bicycle pump, we came to realize two things: 1. that it is a perfectly fine tool for doing what it is supposed to, and 2. that it is incredibly awkward to use. In this vein, we were most interested in the up and down pumping mechnaism that serves to compress the air in the cylinder and then push it out through the nozzle. We decided to focus on this motion alone, using it as a switch to create some other physical change. Wishing to take advantage of the bent-over position that the user must be in to properly control the bike pump, we thought that having the physical change take place in a position that only the user could see would be more rewarding and somehow make the position slightly less awkward. We decided a small video screen, either shielded or somehow goggle or eyehole equipped, when placed at about three to four feet from the ground and slightly tilted, would make this a more pirvate experience for the person who is doing the work of pumping.
The question now was, what to change? We discussed several conceptual ideas but found ourselves constantly hampered by what the content of the video would be and how it could possibly relate to the act of using a bicycle pump. In the end, we decided that the pump should control a video of a balloon being blown up at a rate similar to the rate of pumping. Should the user stop pumping for long enough, the balloon will deflate, but should he or she keep pumping, eventually the balloon will pop. We will be incorporating sound into the installation as well, including some sort of strecthing/inflating and deflating noise, just loud enough for the user to hear, and, of course, a popping noise, loud enough for others to hear.
Mechanically, the device is fairly simple. The pump acts as a switch. Each time the switch connects, the video advances slightly and a sound effect is triggered. If the pump is left in either the on or off position for long enough, the video of the balloon deflating will run, until another user comes along and changes the state of the pump.
What interests us most about this project is the fact that we are using a rather laborious and awkward physical task to bring about a change that, in itself, is not physical, but is analogous to the type of work one would be doing with this tool in the real world. It is definitely a commentary on the theme of effort and reward, and we hope to discover how people feel about these themes when they are dissociated in this way (i.e. the effort takes place in the physical world, but the reward does not). Also, we have agreed that there is a certain compelling or provocative quality to it, relating it to Danish artist Marco Evaristti's "goldfish in a blender" exhibit in which a series of blenders with goldfish were displayed, confronting the audience with the choice of powering on the blender, and thereby liquifying, the goldfish. The user knows what would happen to a "real" balloon were they to keep blowing air into it, and, although the result is not necessarily surprising, it is nonetheless startling and somehow hard to resist. The user's foreknowledge of the outcome serves to drive, rather than detract from, the action. The tension that the action creates and the climax that follows allows for a certain narrative to take place through this action.
As an example of saying "to pump someone for details" or of balloon-shaped dialogue boxes in cartoons, pumping or ballooning itself can be a metaphor for expression. One fascinating thing on this project is that we are transforming a physical expression of pumping into a virtual one of ballooning. Contents do not have to be specific. What matters is to express something by bodily movements and to have it sent into a different space. Whatever explanation useres would seek from pumping, ballooning, and popping, they experiment multi-spatial communication.
WEEK 2 - Feedback
Michael likes the idea, but seems most interested in the concept of object and subject within the installation and making sure that the different kinds of components are appropriate. One idea is to use directional sound, aiming one speaker at the user(s) and another for the viewer. I have some home made sound domes from last semester that would help us facilitate this. I think it would add another dimension to the project if the viewer could hear the sound effects but couldn’t see the video. This goes back to Sai’s original idea of having the installation produce a sound that would peak the interest of the viewer and make them want to participate to find out what the corresponding video could be. Especially considering that the sound effects will reflect the amount of work that the user is doing, this could make watching the user especially interesting.
Another idea Michael brought up was making the installation into a kind of contest, where several users are competing at once to see who can pop the balloon, or reach the climax of the pumping action first. For now, we are going to focus on a single prototype and discuss how the groupp dynamic would affect the installation, wether we would want to have different content for different users or possibly implement Rocio’s idea of having one of the videos be a “trick” video, where the balloon either won’t deflate, pops too soon or simply flies away. If we do something like this, it might also be interesting to have the content change from screen to screen for each “round” of the game.
In addition to building our prototype this week, which involves building the kiosk and determining the position for all of the installation’s components, we also need to examine our code and set the rules for the way the switch will work. We want the pump action and the way the switch mechanism responds to be as realistic as possibile. Down the line, if this becomes our final project for the class, this may involve using the actual pressure and amount of air that comes from the pump to activate a motor or some pressure-sensitive switch that controls the video, but, for now, it seems like our best bet would be to create either a single switch that connects when the piston reaches the bottom of the pump, or a double switch that connects at the bottom and is reset about halfway up the pump. Another approach proposed by Xiaochang would be to use a proximity sensor which reads the rate of movement of the piston within the pump. Once our rules are determined, code is written and prototype is built we will start some user testing.
Sooo…here is our to-do list for this week:
1. buy new bike pump 2. turn pump into switch 3. write code- determine rules (2 switch system? proximity sensor?) 4. build installation- kiosk and monitor setup (materials?) 5. start user testing 6. content discussion- group (contest- different types of content?) / single-user 7. compile useable video and audio 8. get sound domes and speakers from Min
WEEK 3 - More Prototyping
This week, we managed to accomplish most of our goals. We built a prototype of the kiosk using cardboard and a pair of goggles. Some user testing helped us figure out exactly where to place the goggles in relation to the pump and that we needed to cut a hole in the cardboard under the goggles for the nose. Eventually, the speakers will be set up with two in the kiosk and one directional overhead.
Modifying our pump wasn’t quite so easy. We thought that, to start, we would place a button at the bottom of the pump which the internal piston would press each time the user concluded a full pump. The problem was that the bottom of the pump was welded on, and dropping the button into the cylinder from the top of the pump was problematic at best.
Xaiochang bought a new and imporved pump- one that detached from the bottom- and we were good to go. Won built a place for the botton to rest inside the cylinder out of clay and a plastic tube.
Sai and Xiaochang got some processing code working that will take a simple digital signal, controlled by whether the botton is pressed or released and draw an ellipse that will increase in size with every push. Christin added a couple of lines and a data file to the code that will also play a balloon sound every time the botton is pressed. At this time, there is no deflating or popping action or sound. We thought it best to keep the drawing code simple until we add our video component.
This is a simple prototype meant to demonstrate some of the physical actions in our project. The actual workings and visual/audio output of the device as it is now isn’t quite as comparable to the real physical action we are hoping to demonstrate as we would like. We’ve already discussed some ideas as to how to make it more “life-like” and hopefully the class will offer some good input as well. One possibility would be a proximity sensor at the bottom of the pump, as, with a working bike pump, the air begins being pushed at the top of the pump and continues through the bottom. Another idea is a two-switch system, one in the middle of the cylinder and another at the bottom, that will ensure the user will use a full pump. Perhaps the bottom switch could cause a slight change in the video fram advance while a two-switch pump causes a greater change, imitating the difference in the amount of air that the user would be puching into a real balloon.
As it is now, the sound is playing out of the computer. Hooking up the audio output of computer to the speakers using a breadboard and audio amplifier is simple enough, but we will need to find a way to control two different channels of audio. This may not be possible using processing, but there are some other methods, such as MAX/MSP that we can look into.
PIC Basic Code >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DEFINE OSC 4 switchedOnVar var byte switchcheck Var bit input portd.0 pause 500 ‘ start program with a half-second delay switchcheck = 0 switchedOnVar = 0 main: if portd.0 = 1 then
if switchcheck = 0 then switchedOnVar = 1 else switchedonvar = 0 endif
switchcheck = 1
else switchcheck = 0 switchedonVar = 0 endif
serout2 portc.6, 16468, [DEC switchedOnVar, 13,10] switchedOnVar = 0 goto main
Processing Code >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
import processing.serial.*;
int bgcolor = 255; // background color
int fgcolor = 0; // fill color
Serial port; // the serial port
//int[] serialInArray = new int[3]; // where we'll put what we receive
//int serialCount = 0; // a count of how many bytes we receive
float xsize, ysize, xpos, ypos; // Starting position of the ball
boolean firstContact = false; // whether we've heard from the microcontroller
void setup() {
size(256, 256); // stage size noStroke(); // no border on the next thing drawn // Set the starting position of the ball (middle of the stage) xpos = width/2; ypos = height/2; // print a list of the serial ports, for debugging purposes: println(Serial.list()); /* I know that the first port in the serial list on my mac is always my Keyspan adaptor, so I open Serial.list()[0]. On Windows machines, this generally opens COM1?. Open whatever port is the one you're using. */ port = new Serial(this, Serial.list()[0], 9600); port.write(65); // send a capital A to start the microcontroller sending
}
void draw() {
background(bgcolor);
fill(fgcolor);
// Draw the shape
ellipse(xpos, ypos, xsize, ysize);
// get any new serial data:
while (port.available() > 0) {
serialEvent();
// note that we heard from the microntroller:
firstContact = true;
}
// if there's no serial data,
// send again until we get some.
// (in case you tend to start Processing
// before you start your external device):
if (firstContact == false) {
delay(300);
port.write(65);
print ("not working");
}
}
void serialEvent() {
print ((char)port.read());
if (port.read() == '1') {
xsize = xsize + 10;
ysize = ysize + 10;
}
}
goto main code for processing: import processing.serial.*; int bgcolor = 255; // background color int fgcolor = 0; // fill color int xpos = 10; float xpos, ypos Serial port; // the serial port boolean firstContact = false; // whether we’ve heard from the microcontroller void setup() { size(320, 240); // stage size noStroke(); // no border on the next thing drawn
// print a list of the serial ports, for debugging purposes: println(Serial.list());
/* I know that the first port in the serial list on my mac is always my Keyspan adaptor, so I open Serial.list()[0]. On Windows machines, this generally opens COM1??. Open whatever port is the one you’re using.
- /
port = new Serial(this, Serial.list()[0], 9600); } void draw() { background(bgcolor); fill(fgcolor); //Draw the shape ellipse (xpos, ypos, 50, 50)
while (port.available() > 0) { serialEvent(); // note that we heard from the microntroller: firstContact = true; }
// if there’s no serial data, // send again until we get some. // (in case you tend to start Processing // before you start your external device): if (firstContact == false) { delay(300); print(”not working”); } } void serialEvent() { print((char)port.read()); if (port.read() == ‘1?){ xpos = xpos + 20; } }
Processing Code with Sound >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
import processing.serial.*;
int bgcolor = 255; // background color int fgcolor = 0; // fill color int xpos = 10; float xpos, ypos Serial port; // the serial port boolean firstContact = false; // whether we’ve heard from the microcontroller
void setup() { size(320, 240); // stage size noStroke(); // no border on the next thing drawn
// print a list of the serial ports, for debugging purposes: println(Serial.list());
/* I know that the first port in the serial list on my mac is always my Keyspan adaptor, so I open Serial.list()[0]. On Windows machines, this generally opens COM1??. Open whatever port is the one you’re using.
- /
port = new Serial(this, Serial.list()[0], 9600);
sound = loadSound (”pumpsound.wav”); }
} void draw() { background(bgcolor); fill(fgcolor); //Draw the shape ellipse (xpos, ypos, 50, 50)
while (port.available() > 0) { serialEvent(); // note that we heard from the microntroller: firstContact = true; }
// if there’s no serial data, // send again until we get some. // (in case you tend to start Processing // before you start your external device): if (firstContact == false) { delay(300); print(”not working”); } } void serialEvent() { print((char)port.read()); if (port.read() == ‘1?){ xpos = xpos + 20; }
if (port.read() == ‘1?) { pumpsound.play(); /*else{ sound.stop(); }*/ } }
Week 4 - Final Prototype
pic code
'**************************************************************** '* Name : UNTITLED.BAS * '* Author : dct * '* Notice : Copyright (c) 2006 [select VIEW...EDITOR OPTIONS] * '* : All Rights Reserved * '* Date : 3/6/2006 * '* Version : 1.0 * '* Notes : * '* : * '**************************************************************** DEFINE OSC 4
switchCheck Var bit blink var byte switchVal var bit
blinkOut VAR portd.2 switchIn var portd.0 dataOut var portc.6
input switchin
serout2 dataout, 16468, [dec 1000, 13, 10]
blinky:
for blink = 0 to 3
HIGH blinkout
pause 200
low blinkout
pause 300
NEXT
switchcheck = 0
main:
switchval = switchin
if switchval != switchcheck then
serout2 dataout, 16468, [dec switchval, 13, 10]
endif
switchcheck = switchval
goto main
Processing Code: Circle>>>>>>>>>>>>>>>>>>>>>>>>>>
import processing.serial.*;
int bgcolor = 255; // background color
int fgcolor = 0; // fill color
Serial port; // the serial port
//int[] serialInArray = new int[3]; // where we'll put what we receive
//int serialCount = 0; // a count of how many bytes we receive
float xpos, ypos; // Starting position of the ball int xsize = 5; int ysize = 5;
boolean firstContact = false; // whether we've heard from the microcontroller
void setup() {
size(500, 500); // stage size noStroke(); // no border on the next thing drawn // Set the starting position of the ball (middle of the stage) xpos = width/2; ypos = height/2; // print a list of the serial ports, for debugging purposes: println(Serial.list()); /* I know that the first port in the serial list on my mac is always my Keyspan adaptor, so I open Serial.list()[0]. On Windows machines, this generally opens COM1??. Open whatever port is the one you're using. */ port = new Serial(this, Serial.list()[0], 9600); port.write(65); // send a capital A to start the microcontroller sending
}
void draw() {
background(bgcolor);
fill(fgcolor);
// Draw the shape
ellipse(xpos, ypos, xsize, ysize);
// get any new serial data:
while (port.available() > 0) {
serialEvent();
// note that we heard from the microntroller:
firstContact = true;
}
// if there's no serial data,
// send again until we get some.
// (in case you tend to start Processing
// before you start your external device):
if (firstContact == false) {
print ("not working");
}
}
void serialEvent() {
//print ((char)port.read());
if (port.read() == '1') {
xsize = xsize + 10;
ysize = ysize + 10;
}
}
Processing Code: Video>>>>>>>>>>>>>>>>>>>>>>>>>
import processing.serial.*; import processing.video.*;
int bgcolor = 255; // background color
int fgcolor = 0; // fill color
Movie ourMovie; boolean forward = false; boolean paused = false; int movieCounter = 150;
Serial port; // the serial port
//int[] serialInArray = new int[3]; // where we'll put what we receive
float xpos, ypos; // Starting position of the ball int xsize = 5; int ysize = 5;
void setup() {
size(320, 240); // stage size framerate(30); noStroke(); // no border on the next thing drawn // Set the starting position of the ball (middle of the stage) xpos = width/2; ypos = height/2; // print a list of the serial ports, for debugging purposes: println(Serial.list()); /* I know that the first port in the serial list on my mac is always my Keyspan adaptor, so I open Serial.list()[0]. On Windows machines, this generally opens COM1??. Open whatever port is the one you're using. */ port = new Serial(this, Serial.list()[0], 9600); //port.write(65); // send a capital A to start the microcontroller sending ourMovie = new Movie(this, "demo.mp4"); ourMovie.framerate(30); ourMovie.pause();
}
void draw() {
//background(bgcolor);
//fill(fgcolor);
// Draw the shape
//ellipse(xpos, ypos, xsize, ysize);
// get any new serial data:
if (movieCounter < 60) {
if (paused == true) {
ourMovie.play();
//println("play");
paused = false;
}
movieCounter++;
} else if (paused == false) {
ourMovie.pause();
//println("pause");
paused = true;
}
image(ourMovie, 0, 0);
while (port.available() > 0) {
serialEvent();
// note that we heard from the microntroller:
//firstContact = true;
}
}
/* void mousePressed() {
movieCounter = 0;
}
- /
void serialEvent() {
//print ((char)port.read());
if (port.read() == '1') {
//xsize = xsize + 10;
//ysize = ysize + 10;
movieCounter = 0;
}
}
void movieEvent(Movie m) {
m.read();
}
ELEVATOR PITCH
Keywords: interactive video installation, bicycle pump controller, effort and reward, narrative suspense, pop
Possible names: Pop!
Description: By using a tool intended for work as a video controller, our installation seeks to exagerate the differences between the physical and digital world, as well as to explore the concepts of effort and reward.
Background Physical Computing is a discipline that seeks to explore the interactions between the physical and the virtual world. Our installation demonstrates the flexibility of using a real world tool to control a digital environment while commenting on the futility of exerting a physical effort to acheive a virtual reward. The reward itself is, in a sense, a guilty pleasure, or, at least, a direct result of curiosity and a human desire to bring situations to a climax. The content of the installation creates tension, if not physically, then mentally in the mind of the user.
Audience: The height of the viewing podium will be somewhat adjustable, but, do to the physical impllications of making the video unviewable to anyone besides the user, this installation may not be useable for individuals under a certain height. The content of the video is non-offensive and the amount of work needed to operate the bicycle pump is minimal.
User Scenario: The potential user approaches the viewing podium, having heard the loud "pop" sound come from it before, but not knowing what it means or what the installation does. This is because the video content is visable to no one but the current user, and only when that person is in place. The user sees the bicycle pump and should intuitively know how to use it, though foot prints will be in place to reiterate where he or she should stnd to operate the pump. The user then assumes the bicycle pumping position, causing him or her to lean forward, which is when their face is close enough to the podium to be able to see inside. An eyepiece shaped hole in the top of the podium will also exaggerate where the user's face and eyes should be. Now that the user is in place, they will see an image of a deflated balloon. At this point, it may not be clear wether the balloon is real, an actual image or an animation. The user bgins pumping and notices the balloon negin to inflate. After a while, they may realize that the rate at which they pump affects the rate at which the balloon inflates. Soon, the balloon becomes so big that it's entire image is not contained on the display screen. At this point it becomes obvious that the user is controlling a digital video. They may wonder wether this digital balloon follows the same laws of physics as a rel balloon. Knowing that a real balloon, if filled with enough air, will eventually pop, this will entice the user to keep pumping. Eventually, of course, the balloon does pop and the loud nois that it makes can be heard throughout the room.
Implementation: This project uses serial input to talk to Processing, which then controls the duration and rate at which the video is played. A sensor or button placed at the bottom of the pump alerts processing as to how quickly the user is using the pump. The viewing podium is constructed out of wood and has a 17" flat screen display placed 3/4 of the way down.
Reference, Research, Literature:
Conclusions: We hope that the installation and the content therein will create a narrative in the mind of the user, a narrative which entices him or her to use it to some ends, despite the fact that the means requires physical work. Ideally, the reward, though virtual, will still be satisfying enough for the user to want to try it again.