I have always been interested in the intersection between visual arts and technology, and Interactive Media acts as the perfect middle ground for those interests. For my midterm project, I am considering creating a small art installation or performance; which will combine the use of a certain medium (paint, graphite, ink, etc.) with different sensors and motors to facilitate the process of producing a work of art. The installation will be interactive in the sense that the user can decide which movements or brushstrokes will be undertaken by the motors, through operating the different sensors.
Author: Tala Asiri
The Midnight Band
For this week’s project, Nick and I decided to create a cover for one of our favourite songs, “Shooting Stars” by the prominent Disco/Tech group Bag Raiders. Our project was divided into two parts, the beat (using Servos) and the melody (using Tone).
In total, we had three percussion-like instruments. The first, being a cork attached to a wooden stick, banging on a piece of wood, functioned as the underlying drum that would provide the 1/4 beat. Next, we had two metal rods attached to two different Servos hit glass cups to create clinking sounds that would harmonise with the Tone produced by the buzzers.
Our Tone had 4 buttons, namely four sounds (E-flat, E,B,A-flat). Each button would make the sound designated for 300 milliseconds, and with code we just had to make sure that we were using F-sharp, for example, the different name of A-flat since those weren’t registered in the library.
So below is the result of what we have created, since midnight yesterday when we first joined forces. Hence the name “Midnight Band”. Enjoy!
// Include the Servo library
#include <Servo.h>
Servo myServo1;
Servo myServo2;
Servo myServo3;
int pos1 = 0; //variable for number of degrees for servo1
int pos2 = 0; //variable for number of degrees for servo2
int pos3 = 0; //variable for number of degrees for servo3
int buttonPin = 2; //activating pin 2 for Push Button
int buttonPin2 = 4; // activating pin 4
int buttonPin3 = 7;
int buttonState = 0; //variable for Push Button
int buttonState2 = 0;
int buttonState3 = 0;
int angle = 0;
void loop() {
buttonState = digitalRead(buttonPin); //reading buttonPin and storing it as buttonState.
buttonState2 = digitalRead(buttonPin2);
buttonState3 = digitalRead(buttonPin3);
//Serial.println(buttonState, buttonState2,buttonState3); //telling computer to print buttonState.
if (buttonState == LOW){ //if button is pressed...
myServo2.write(180); //setting servo2 to 180 degrees
delay(500); //wait one second
//setting servo1 to 180 degrees
myServo2.write(20); //setting servo2 to 20 degrees
delay(500); //wait one second
}
if (buttonState2 == LOW){
myServo3.write(20);
delay(500);
myServo3.write(180);
delay(500);
}
if(buttonState3 == LOW){
for(angle = 0; angle<180;angle+=6){
myServo1.write(angle);
delay(15);//setting servo1 to 20 degrees
}
}
}
void setup() {
// attach the servo to pin number 9
Serial.begin(9600); //activating Serial Monitor
myServo1.attach(9); //activating pin 9 for servo1
myServo2.attach(11); //activating pin 11 for servo2
myServo3.attach(10); //
pinMode(buttonPin , INPUT); //setting Push Button as an input
pinMode(buttonPin2 , INPUT);
}
Fortune Cookie(?)
The title of this blogpost may be a little misleading, but the process behind bringing my idea to life might give you some clarity regarding the naming. So when I was thinking “unexpected”, I immediately thought of magic eight balls and fortune cookies, with their random phrases and words of wisdom that I never seem to anticipate. I saw the box displayed in the image below, when I was walking around the lab; and it was as if the idea was calling to me.
Initially, I had considered using a temperature sensor, and have the different members of the audience touch it; which would then detect their body temperature and display a random statement (similar to the ones we find in fortune cookies). However, there were several flaws in that logic, since most people have similar body temperatures, and the changes in the temperature sensor were too minuscule to alternate between statements. I then decided to change to a different analog sensor; the photoresistor. the photoresistor was easier to operate, since it encompasses a wider range of values when exposing it to light or darkness. But, I wasn’t able to devise a way to adapt the fortune cookie scenario to the function of the photoresistor, and instead opted for a different narrative. I will hopefully be able to implement and develop this idea further with more knowledge of code.
// include the library code:
#include <LiquidCrystal.h>
// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(12, 11, 5, 4, 3, 2); //defining lcd pins
int sensorValue = 0; // variable to store the value coming from the sensor
int sensorPin = A0; // select the input pin for LDR
void setup()
{
pinMode(3,INPUT); //setting arduino pin3 as input
Serial.begin(9600); // opens serial port, sets data rate to 9600 bps
lcd.begin(16,2); // set up the LCD's number of columns and rows
}
void loop()
{
sensorValue = analogRead(sensorPin); // read the value from the sensor
Serial.println(sensorValue); //prints the values coming from the sensor on the screen
//display text on lcd
if (sensorValue < 50) {
lcd.clear();
lcd.print("Never leave me");
} else {
lcd.clear();
lcd.print("This is why I");
lcd.setCursor(0,2);
lcd.print("have trust issues");
}
// Turn off the display:
lcd.noDisplay();
delay(100);
// Turn on the display:
lcd.display();
delay(1000);
}
The Psychopathology of Everyday Things – Reading Response
The Psychopathology of Everyday Things is a book written by Donald Norman, about the importance of design in facilitating the communication between users and the object or service. Seeing as how the book was written by a cognitive scientist, it was interesting to see how different theories and concepts of psychology determine what “good” or “bad” design is. What I got from reading the first chapter, is that Norman is attempting to discuss the numerous design principles that come into focus when a certain design malfunctions.
Norman employs the terms affordances and signifiers, and assigns them great value as essential concepts in the creating a design experience tailored for the user. Norman’s in-depth explanation of these concepts, made me consider how every object we interact with on a daily basis, has a perceived or unperceived affordance, and I immediately thought back to all the times I fought with doors; not intuitively knowing whether to pull or push it on the first try. This brings Norman to his next essential concept of the inclusion of adequate signifiers, which are meant to help facilitate the user experience and make it easier. The author elaborates on the perceived shortcomings some signifiers have, and how they can often be misleading to users. Norman also emphasises the importance of having signifiers, and how they help construct a “good” design or user experience. This is due to the fact that good design predominantly requires the presence of clear communication of purpose and structure to the user.
Another vital challenge to the formation of a cohesive user experience is the mapping and feedback inherent to a specific object or design. Mapping tackles the connection and correspondence between the different elements and controls within a certain design – which ultimately makes it easier to navigate the use of a product. Similarly, feedback refers to designing a system that communicates the result of an action to the user. Adequate and vivid feedback facilitates the user experience, while poor feedback can be misleading and disconcerting to the user.
All in all, it was evident in the reading that Norman is attempting to create an analysis of all the design concepts and elements that are crucial for establishing a cohesive and productive user-based experience. Norman also discusses the importance of considering behavioral psychology, ergonomics and several design principles, even when designing the most basic objects.
Week 2 Assignment – Tilt Sensor
For this assignment, I had to combine a switch that doesn’t require the use of hands as well as produce multiple inputs and/or outputs. The main challenge for me was actually settling on a concept for the project. I went over several iterations of the project before deciding on building a scale-like structure that acts as an indicator for the water level. The circuit included a tilt center, which acts as a switch or trigger for the code to run. The code then alternates between blinking red and blue lights, depending on which side is tilted. The first iteration of the model included a simple wooden structure with the breadboard attached to one side. There was a certain flaw in the balance of the structure, however, as the side with the breadboard kept leaning to the side. The only solution at the time was to place random objects on the opposite end of the wooden panel, and that didn’t seems like a very efficient solution.
The final iteration of the project included a plastic cup attached to the side opposing the breadboard with hot glue. Pouring water into that cup would allow the wooden piece to lean to the other side, so the effect of the tilt sensor can be observed in its full glory.
int tilt = 2;
int redled = 6;
int blueled = 7;
void setup() {
// initialize serial communication at 9600 bits per second:
Serial.begin(9600);
// make the pushbutton's pin an input:
pinMode(tilt, INPUT);
pinMode(redled,OUTPUT);
pinMode(blueled,OUTPUT);
}
// the loop routine runs over and over again forever:
void loop() {
// read the input pin:
int buttonState = digitalRead(tilt);
if (buttonState){
digitalWrite(redled,HIGH);
digitalWrite(blueled,LOW);
} else {
digitalWrite(redled,LOW);
digitalWrite(blueled,HIGH);
}
if(buttonState){
digitalWrite(redled,HIGH);
delay(500);
digitalWrite(redled, LOW);
delay(500);
} else {
digitalWrite(blueled,HIGH);
delay(500);
digitalWrite(blueled, LOW);
delay(500);
}
// print out the state of the button:
Serial.println(buttonState);
delay(1); // delay in between reads for stability
}
What is Interactivity?
The Art of Interactive Design by Chris Crawford, acts as a guide for explaining the nuances of using the term interactivity, and describing which experiences can be deemed interactive. Crawford clarifies that the term interactivity is often contested and misunderstood, as people attribute it to user experiences that do not necessarily interact with the user, but rather simply provide a reaction or a response. It was interesting to see how Crawford compares interactivity to a conversation, where two or more entities engage in active dialogue; having to carefully listen and think in order to produce an adequate response (or speak).
Moreover, establishing that successful conversation through “listening, thinking, and speaking”, is metaphorical in the sense that it does not have to exclusively occur between two humans; since these are processes associated with the human senses. Crawford illustrates that such conversations can occur between different types of system – both digital and analog. I felt like the reading acted as only the tip of the iceberg for the discussion on interactivity