An analysis of the interactivity design of Brain Drain project

The interactivity design of Brain Drain project

– A sound and visual interactive installation

 

What is interactivity? In the 1980s, Rafaeli declared that interactivity is

“an expression of the extent that in a given series of communication exchanges, any third (or later) transmission (or message) is related to the degree to which previous exchanges referred to even earlier transmissions. “(1988: 111)

So, Interactivity can be generally concerned as human to human communication and human to artifact communication (Kiousis, 2002). The Brain Drain project mainly achieved a good interactivity towards interaction design.

tu1

Figure 1: interactivity definitions (Kiousis, 2002)

Introduction

Brain Drain is an interactive art installation presented to the public. It has both visuals and sounds interact with the audience based on using an EEG headset to perceive the data gained due to performer’s brain activities. And its generate the data into different emotions: Excitement, Frustration, Engagement, Meditation and Boredom and they are presented in different shapes, movements, speeds and colors through using a programming software, processing. Also there are 10 different kinds of interactive sound object for audiences to play with. This project is aiming to present people’s brain activities in a visually designed way and allow audience to play sounds to change and interact with the visualization based on the performer’s emotion changes.

Human to Artifact Communication

In this brain drain project, from the view of the audience, the first type of thing attracted their attentions are the sound objects. For the light sensor sound object, people press the button to start and move their hands up and down to make the melody. However, through running several experiments, we got feedbacks from people that they are not sure how to play with it, due to the messy cables and unfamiliar arduino board. We also get similar feedbacks on some other sound objects, which cooperate with arudino. People were afraid of touching them because they think they might unplug some cables or press the button they are not supposed to. This situation did reduce a lot of interactivity of the project. So we designed boxes for arduinos and only put the buttons and sensors outside of the box on the surfaces. Also, we used bigger buttons and switches instead of the small ones for people to use them more comfortably. In order to solve the issue that people were not sure how to play with the buttons and switches, we also designed interfaces on the arduino boxes showing the instructions of how to interact with the specific sound object.

step_on_for_sound instructions_for_arduinoBoxes

Since the mid-trimester, we planed to explore different kinds of interactions. So we used motion sensor, which does not require people to touch anything but still triggering the sound object to play. When people pass through the certain area, they have already been part of the whole interaction progress of the project.

On the performer’s side, the EEG headset has 14 sensors locate on specific points of people’s head to gain the data. The performer interact with every person who came to the presentation, due to the sounds performer can hear are not only generated from the sound objects but also audience’s movements and conversations. For the performer, the interactivity might not felt as strong as the audiences. However, the performer is the heart of the whole interaction and the bridge between people and the visualization that was projected on the wall.

Also, using the innovative real-time technologies is the most important method for designers to attract a greater audience and bring the interactivity. (Freyer et al. 2008) In our project, there is a sound object we built up a pressure sensor using two pieces of blades with nonconductor in between around its edges. When people stand on it, their weight made the two pieces of blade connected so that the electricity could go through. And it will trigger the toy motor start to spin. And it is concluded that technology is not the only thing that brings interactivity to a project but also the things that are very simple and people are familiar with. (Bullivant, 2007) This is also the reason why we use the old record player in the project, the feature of simple and people are familiar with it creates the interactivity here.

Human to Human Communication

Play is the basic drive behind interactivity – it’s the big ‘what if?’ aspect that keeps a good interactive experience humming along.” (We make money not art, 2006). To encourage people become physically engaged with a design, and to explore it more through interaction, art forms designed for ‘fun and play’ must make direct connections between people; they can even be a vehicle for other people to gain new insights. This was commented on by a visitor of ‘The Sonic Hedgehog’s Guide to Art’, in Museums News. (Bullivant, 2006)

In the Brain Drain project, there is a tube, which people can talk from one side to another side, which is directly next to the performer. Because of the length of the tube, it makes people’s voice sounds like a robot that attracted people to improvise and interact with the performer.

During the presentation of the project, audiences talk to each other and cooperate with each other through playing the sound objects.

Conclusion

Throughout this project, we used programming softwares, high technology equipments, varies of interfaces and sensors, things that people are adequately familiar with, visualizations and sounds improved the interactivity of it. There are a lot more different and interesting ways for an interactive installation to create more fun and interactivities such as place things at more interesting places and more different kind of sensors. Also, because the signal of the headset is not stable, so that the performer can only sit on the chair next to the laptop instead of moving in space so that audience can also see performer’s reaction through his movements.

Bibliography

Bullivant, L. (2006). Responsive Environments: Architecture, Art and Design

London: V&A Publication.

Bullivant, L. (2007). Playing with Art. 4dsocial: Interactive Design Environments, 77(4), pp. .

Kiousis, S. (2002). Interactivity: a concept explication. new media and society, vol4(3):355-383.

Rafaeli, S. (1988) ‘Interactivity: From New Media to Communication’, in R.P. Hawkins, J.M. Wieman and S. Pingree (eds) Advancing Communication Science: Merging Mass and Interpersonal Processes, pp. 110–34. Newbury Park, CA: Sage.

Freyer, C., Noel, S., and Rucki, E. (2008). DIGITAL BY DESIGN. London: Thames & Hudson Ltd.

We make money not art (2006). Interview of Andy Cameron. Available at:

we-make-money-not-art.com/archives/2006/09/interview-of-an.php#.UNHp7Tk8PKq [accessed at: 10th December 2012]

B28 in ECA main building

Image

We went to B28, the sound studio in the ECA main building this afternoon and got those photos to help ourselves to discuss the relationship between the space and our project designs. Also would be convenient for us to get started with designing the interfaces.

DSC_0102 DSC_0108 DSC_0121 sound equipment potential wall for projection DSC_0131_gDSC_0124

button controls servo_windChime

// Sweep
// by BARRAGAN <barraganstudio.com&gt;
// This example code is in the public domain.
#include <Servo.h>

const int buttonPin = 2;
const int servoPin = 9;

int buttonState = 0;
int lastButtonState = 0;
int count =0;
boolean state=0;

Servo myservo; // create servo object to control a servo
// a maximum of eight servo objects can be created

int pos = 0; // variable to store the servo position

void setup()
{
myservo.attach(9); // attaches the servo on pin 9 to the servo object
pinMode(buttonPin, INPUT);
pinMode(servoPin, OUTPUT);
Serial.begin(9600);

}

void loop()
{

buttonState = digitalRead(buttonPin);
if(buttonState!=lastButtonState){count++;}
if(count%2==1){state=1;}
else if(count%2==0){state=0;}
if(state==1){
for(pos = 0; pos < 180; pos += 7) // goes from 0 degrees to 180 degrees
{ // in steps of 1 degree
myservo.write(pos); // tell servo to go to position in variable ‘pos’
delay(15); // waits 15ms for the servo to reach the position
}
for(pos = 180; pos>=1; pos-=1) // goes from 180 degrees to 0 degrees
{
myservo.write(pos); // tell servo to go to position in variable ‘pos’
delay(15); // waits 15ms for the servo to reach the position
}
}
else if(state==0){myservo.write(0);}
lastButtonState=buttonState;
Serial.print(0,0);
}

code for button control toy motor_woodenFish

#include <Button.h>

const int motorPin = 9; // define the pin the motor is connected to
// (if you use pin 9,10,11 or 3you can also control speed)
const int buttonPin = 2;

//Button button = Button(2,PULLUP);
int buttonState = 0;
int lastButtonState = 0;
int count = 0;
boolean state = 0;
/*
* setup() – this function runs once when you turn your Arduino on
* We set the motors pin to be an output (turning the pin high (+5v) or low (ground) (-))
* rather than an input (checking whether a pin is high or low)
*/
void setup()
{
pinMode(motorPin, OUTPUT);
pinMode(buttonPin, INPUT);
}
/*
* loop() – this function will start after setup finishes and then repeat
* we call a function called motorOnThenOff()
*/

void loop() // run over and over again
{
motorOnThenOff();

void motorOnThenOff(){
int onTime = 2500; //the number of milliseconds for the motor to turn on for
int offTime = 1000; //the number of milliseconds for the motor to turn off for

buttonState = digitalRead(buttonPin);

if(button.isPressed()){
digitalWrite(buttonPin, HIGH);
}else{
digitalWrite(buttonPin, LOW);
}

if(buttonState == HIGH){
// state = 1;
digitalWrite(motorPin, LOW); // turns the motor On
//delay(onTime); // waits for onTime milliseconds
//digitalWrite(motorPin, LOW); // turns the motor Off
//delay(offTime); // waits for offTime milliseconds
}
else{
//state = 0;
digitalWrite(motorPin, HIGH); // turns the motor On
}

}
}
}

code for light sensor controlled by button

/*
Pitch follower

Plays a pitch that changes based on a changing analog input

circuit:
* 8-ohm speaker on digital pin 9
* photoresistor on analog 0 to 5V
* 4.7K resistor on analog 0 to ground

created 21 Jan 2010
modified 31 May 2012
by Tom Igoe, with suggestion from Michael Flynn

This example code is in the public domain.

arduino.cc/en/Tutorial/Tone2

*/
int inPin = 2;
int outPin = 9;
int state = HIGH;
int reading;
int previous = LOW;
long time = 0; // the last time the output pin was toggled
long debounce = 200;
void setup() {
// initialize serial communications (for debugging only):
Serial.begin(9600);
pinMode(inPin, INPUT);
pinMode(outPin, OUTPUT);
// read the sensor:
}

void loop() {
reading = digitalRead(inPin);
if(reading == HIGH && previous == LOW && millis() – time > debounce){
if (state == HIGH)
state = LOW;
else
state = HIGH;

time = millis();

}

digitalWrite(outPin, state);
previous = reading;

if(state == LOW){

int sensorReading = analogRead(A0);
Serial.println(sensorReading);
// map the analog input range (in this case, 400 – 1000 from the photoresistor)
// to the output pitch range (120 – 1500Hz)
// change the minimum and maximum input numbers below
// depending on the range your sensor’s giving:
int thisPitch = map(sensorReading, 10, 300, 90, 2500);

// play the pitch:
tone(9, thisPitch, 3.9);
delay(4); // delay in between reads for stability
}

if(state == HIGH){
//noTone(9);
int sensorReading = analogRead(A0);
Serial.println(sensorReading);
// map the analog input range (in this case, 400 – 1000 from the photoresistor)
// to the output pitch range (120 – 1500Hz)
// change the minimum and maximum input numbers below
// depending on the range your sensor’s giving:
int thisPitch = map(sensorReading, 10, 300, 0, 0);

}

}

code for pot on arduino working with the piano string

// Controlling a servo position using a potentiometer (variable resistor)
// by Michal Rinott <people.interaction-ivrea.it/m.rinott&gt;

#include <Servo.h>

Servo myservo; // create servo object to control a servo

int potpin = 2; // analog pin used to connect the potentiometer
int val; // variable to read the value from the analog pin

void setup()
{
//Serial.begin(9600);
myservo.attach(9); // attaches the servo on pin 9 to the servo object
}

void loop()
{
val = analogRead(potpin); // reads the value of the potentiometer (value between 0 and 1023)
val = map(val, 0, 1023, 0, 179); // scale it to use it with the servo (value between 0 and 180)
//if (val>10){
myservo.write(val); // sets the servo position according to the scaled value

// }
delay(100);
Serial.println(val);
//Serial.print(0,0);
// waits for the servo to get there
}