As part of my final for Physical Computing, I’m setting up a system of ambient informatics and feedback which I’m calling The Destiny of Rooms. This idea started with an email sent to the notorious ITP student listserv by someone sitting in the Japanese Room, a room at ITP which is reserved for student use. The email, though public to everyone at ITP, was clearly addressed to the other people currently in the Japanese Room, asking them to be quiet, as the Japanese Room was supposed to be a quiet study room. The immediate effect, rather than to make the room quieter, due to the opt-in nature of receiving email, was to spark a debate with people outside the room as to what the actual “purpose” of the room was. Somewhere in that debate the notion that none of us, singly or as a group, had control over what the room would be floated to the top – it was a decision which was happening unconsciously in everyone who used the room. We might as well be saying that the room was deciding for itself.

So, I thought I would let it voice it’s decisions.

Over the ensuing weeks I built a system of sensors to gather ambient data about the current state of the room. I decided to choose three variables, which would give me a good picture of what was going on: volume (obviously), the number of people in the room, and whether the doors were opened or closed. For volume, I used an array of two condenser microphones mounted near the ceiling, which were mixed into one audio signal, giving an average volume for the entire room. The doors were monitored using simple magnetic switches, salvaged from home security systems. The people counting was more complex. I had originally thought that I would use laser break beams to count people going in and out of each door, but properly aiming the lasers was problematic. In the end, I used a more intrusive but reliable system – foot switches under doormats, placed on either side of both doors.

All of this was feeding back to an Arduino, which captured the numbers over serial and sent them via USB to a desktop computer. On a Mac, serial ports are treated as files, so I could just output the real-time data using the screen command in terminal, for debugging, or use cat and > to save it to a text file. Every two hours, an Automator script would save the current file to a folder and timestamp it, to keep the data manageable.

Over two days, this generated over 5GB of data about how students were using the room.

For the output, I decided that the room should play by the same rules that the students had set for it – it would send emails to the student list, attempting to influence what was going on through email. For the purposes of posterity, the emails would also be archived on a blog. The construction and sending of the emails was handled by Processing running on the desktop computer. Every fifteen minutes it would average the values for each of the sensors, and choose one of several pre-determined phrases deemed appropriate for each one, assemble them into an email, and send the mail to the student list. The Japanese Room spoke in the first person, and thus became an entity in it’s own right – despite the fact that my name was all over the project, all responses were addressed to JR (as he preferred to be called), and students quickly picked up on the rivalry between JR and the Lounge.

On December 12th – 14th, JR sent 15 automated messages, all of which are archived here, at a rate of about one every half hour. In addition, Adam sent 5 messages in character as JR to establish the situation and attempt to manage some of the response, for a total of 18 messages from the Japanese Room account. In response, there were a total of 23 messages about the emails or addressed to JR on the list, as well as 3 comments on the blog, for a total of 26 responses.

From the data, it doesn’t appear that anyone took the initiative to actually try to oblige the room in any way.

In response to some, “user feedback,” the emails were slowed to once every two hours after the 12th, and it was possible to have the room not email at all if he was happy. But the pendulum swung too far the other way, resulting in a day without JR emails, so on the evening of the 13th, emails every two hours were reinstated, no matter the state of the room.

Quotes from students responding the Japanese Room are available here, and all emails sent from the Japanese Room are available here.

For my midterm, I created a clock that identifies location rather than time. It’s a first-generation prototype for a system that uses ZigBee wireless devices to track location. Eventually, the tracking will occur automatically and allow two-way interaction between the observer and the observed, but for now I wanted to get my hands dirty working with un-Arduinoed ATMega8’s and XBee devices.

You can read more about it, and see photos and schematics, on the project page and in the photo gallery.

My Arduino and Daniel’s. They hate each other, and have refused to talk. It’s been 9 hours now…

Here’s a video of my serial input: two potentiometers running through the Arduino to control the x-position and y-position of a ball in Processing. I struggled for hours to get this working with Gozor, but I had tons of issues! I thought it was my code, but after much trial and error, it appears to be a combination of the Java rendering engine freaking out and running out of memory, and Processing not surrendering the USB port when that happened. I seriously thought my computer and/or my Arduino were fried on more than one occasion. After the break, I’ve posted the code for this ball example (courtesy of Tom Igoe and Todd Holoubek) and my non-functioning Gozor code. Anyone have an idea about why that code isn’t working? One serial input (a pot to control the xpos) worked just fine.

Here’s the Arduino code for the ball:

//declare the analog pin. Here we are using analog 0
int analog0 = 0;
int analog1 = 1;
//Declare a variable for the analog data
int val1 = 0;
int val2 = 0;

void setup() {
//initialize the serial
Serial.begin(9600);
}

void loop() {
//read the analog 0 pin
val1 = analogRead(analog0);
val2 = analogRead(analog1);
//divide the value by 4
val1 = val1/4;
val2 = val2/4;
//send the value to the external application. Notice how we are using
Serial.print(val1, BYTE);
Serial.print(val2, BYTE);
}

And here’s the Processing code for the ball:

import processing.serial.*;

//int bgcolor; // Background color
//int fgcolor; // Fill color
Serial port; // The serial port
int[] serialInArray = new int[2]; // Where we'll put what we receive
int serialCount = 0; // A count of how many bytes we receive
int xpos, ypos; // Starting position of the ball
boolean firstContact = false; // Whether we've heard from the

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()[2], 9600);
port.write(65); // Send a capital A to start the microcontroller
}

void draw() {
background(0);
//fill(fgcolor);
fill(255);
// Draw the shape
ellipse(xpos, ypos, 20, 20);

// If no serial data has beeen received, 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);
}
}

void serialEvent(Serial port) {
// if this is the first byte received,
// take note of that fact:
if (firstContact == false) {
firstContact = true;
}
// Add the latest byte from the serial port to array:
serialInArray[serialCount] = port.read();
serialCount++;

// If we have 3 bytes:
if (serialCount > 1 ) {
xpos = serialInArray[0];
ypos = serialInArray[1];
//fgcolor = serialInArray[2];

// print the values (for debugging purposes only):
//println(xpos + "\t" + ypos + "\t" + fgcolor);
println(xpos + "\t" + ypos);

// Send a capital A to request new sensor readings:
port.write(65);
// Reset serialCount:
serialCount = 0;
}
}

And here’s my crash-prone Arduino code for Gozor:

/* Analog in Serial Out to processing
* ----------------
*this takes a analog signal and returns a value
*
*
*/
//declare the analog pin. Here we are using analog 0
int analog0 = 0;
int digital2 = 2;
//Declare a variable for the analog data
int val1 = 0;
int val2 = 0;
int button = 0;

void setup() {
//initialize the serial
Serial.begin(9600);
pinMode(digital2, INPUT);
}

void loop() {
//read the analog 0 pin
val1 = analogRead(analog0);
val2 = digitalRead(digital2);
val1 = val1/4; //divide the value by 4 to cover width of screen
if (val2 == HIGH) {
button = 1;
}
else {
button = 0;
}
//send the value to the external application. Notice how we are using Serial.print instead of Serial.println
Serial.print(val1, BYTE);
Serial.print(button, BYTE);
}

And, finally, the crash-prone Processing code for Gozor:

import processing.serial.*;
Serial port;

Gozor[] gozors = new Gozor[1];
int pot = 0; //incoming pot values
int xpos; // x location of Gozor's center
int button; //is button pressed?
int[] serialInArray = new int[2];
int serialCount = 0;
boolean firstContact = false;

void setup() {
println(Serial.list());
port = new Serial(this, Serial.list()[2], 9600);
size(500,500);
smooth();
frameRate(15);
for (int i=0; i < gozors.length; i++) {
gozors[i] = new Gozor(height, -5, 0.1, color(random(0,255),random(0,255),random(0,255)));
}
}

void draw() {
background(0);
for (int i=0; i < gozors.length; i++) {
gozors[i].drawGozor();
gozors[i].dynamicMouth();
gozors[i].dynamicEyes();
gozors[i].jumpingGozor();
}
// If no serial data has beeen received, 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);
}

}

//function to move Gozor with a pot
void serialEvent(Serial port) {
serialInArray[serialCount] = port.read();
serialCount++;

if (serialCount > 1) {
pot = serialInArray[0];
xpos = pot;
button = serialInArray[1];
if (button == 1) {
jump();
}
println(xpos + "\t" + button);
port.write(65);
serialCount = 0;
}
}

void jump() {
for (int i=0; i < gozors.length; i++) {
gozors[i].startJump();
}
}

class Gozor {
int centerX; // x location of Gozor's center
float centerY; // y location of Gozor's center
float ypos; //current height of feet
float speed; //speed
float grav; // gravity
boolean jumping; //whether Gozor's jumping or not
color c;
int exp1 = 250;
int exp2 = 250;

Gozor(float ypos_, float speed_, float grav_, color c_) {
ypos = ypos_;
speed = speed_;
grav = grav_;
jumping = false;
c = c_;
}

//function to draw Gozor at the bottom of the screen
void drawGozor() {
centerX = xpos*2; //set Gozor's location to pot value
centerY = ypos - 201; //starts Gozor with his feet at the bottom of the screen

//feet
strokeWeight(1);
stroke(64,23,2);
fill(118,44,6);
triangle(centerX-37,centerY+155,centerX-14,centerY+200,centerX-60,centerY+200); //left
triangle(centerX+37,centerY+155,centerX+14,centerY+200,centerX+60,centerY+200); //right

//legs
stroke(23,121,29);
fill(c);
rect(centerX-50,centerY+140,26,40); //left
rect(centerX+24,centerY+140,26,40); //right

//tail
noFill();
stroke(c);
strokeWeight(7);
arc(centerX+100,centerY+135,150,20,PI,PI/4);
arc(centerX+175,centerY+143,50,20,PI/4,PI);

//body
noStroke();
fill(c);
triangle(centerX,centerY-25,centerX+100,centerY+150,centerX-100,centerY+150);

//simulate legs overlapping body
stroke(23,121,29);
strokeWeight(1);
line(centerX-51,centerY+150,centerX-51,centerY+125); //left
line(centerX-24,centerY+150,centerX-24,centerY+125);
line(centerX+23,centerY+150,centerX+23,centerY+125); //right
line(centerX+50,centerY+150,centerX+50,centerY+125);

//head
stroke(c);
strokeCap(ROUND);
strokeWeight(50);
line(centerX,centerY+50,centerX,centerY-25);

//chin
stroke(23,121,29);
strokeWeight(1);
arc(centerX,centerY+25,7,8,TWO_PI,PI);

//left eye stalk
fill(c);
noStroke();
triangle(centerX,centerY,centerX-25,centerY-110,centerX-50,centerY-100);
stroke(23,121,29);
strokeWeight(1);
ellipseMode(CENTER);
ellipse(centerX-38,centerY-105,30,30);

//right eye stalk
noStroke();
triangle(centerX,centerY,centerX+25,centerY-110,centerX+50,centerY-100);
stroke(23,121,29);
strokeWeight(1);
ellipse(centerX+37,centerY-105,30,30);
}

//function to draw Gozor's eyes & make them dynamic to mouse-y position
void dynamicEyes() {
//left eyeball
fill(255); //white
stroke(0);
strokeWeight(1);
ellipse(centerX-38,centerY-105,20,20);
fill(167,3,132); //iris
ellipse(centerX-38,centerY-105,20,10);
fill(0); //pupil
ellipse(centerX-38,centerY-105,2+(exp1/50.0),10);

//right eyeball
fill(255); //white
ellipse(centerX+37,centerY-105,20,20);
fill(167,3,132); //iris
ellipse(centerX+37,centerY-105,20,10);
fill(0); //pupil
ellipse(centerX+37,centerY-105,2+(exp1/50.0),10);
}

//function to draw Gozor's mouth & make it dynamic to mouse-x position
void dynamicMouth() {
noFill();
stroke(255,10,10);
strokeWeight(2);
arc(centerX,centerY,25,10,TWO_PI+(exp2/400.0),PI-(exp2/400.0));
}

//function to make Gozor blink
void blinkGozor() {
fill(23,121,29); // blink right eyelid
stroke(0);
ellipse(centerX+37,centerY-105,20,20);
line(centerX+27,centerY-105,centerX+47,centerY-105);
fill(23,121,29); // blink left eyelid
stroke(0);
ellipse(centerX-38,centerY-105,20,20);
line(centerX-28,centerY-105,centerX-47,centerY-105);
}

//funtion to make Gozor jump when the mouse is pressed
void jumpingGozor() {
float top = height - 175; //keeps Gozor on the screen when he jumps

//jumping actions
if (jumping) { //moves Gozor up
speed += grav;
ypos += speed;
}
// println("ypos: " + ypos + "; speed: " + speed); //debugging

if ((speed > -0.5) && (speed < 0.5)) { //blink
blinkGozor();
}

if (ypos > height) { //turns off jumping when Gozor lands & resets for more jumping!
ypos = height; // keep his feet on the ground
jumping = false; //stop jumping
speed = speed * -1; //reset for future jumps
}

}

void startJump() {
jumping = true;
}
void stopJump() {
jumping = false;
}

}