The author, coming back to answer questions on his rant, addresses a few more important details. His point about technology such as iPads not being bad but good for now is critical as the world engages in more research towards more interactive technologies.
I think his emphasis is on creating technology that allows humans to deal with tactile interfaces and not deplete our existence to immobility is important. However, I do not agree with his argument, using the neuroscientist’s words, that “while a blind person may simply not be able to find this or that object, the finger-blind cannot understand its inner meaning and value.” This seems a little exaggerated as humans are not only limited to their fingers to find meanings or value in things, we have four other very reliable senses that exist to help do this too. Therefore, I don’t think “finger-blindness” is the end-all and be-all of all things in future technology if we don’t achieve the tactile immersive technology the author is seeking.
With an entire body at your command, do you seriously think the Future Of Interaction should be a single finger?
The author rants about how the future of interaction forgets to include a critical component: the human capability of using our hands. The many levels of manipulation we can achieve with our hands is probably only limited to these limbs specifically and yet they are not given that much thought in the ‘future’ of interactive design.
I agree with the author because reading his rant reminded me of the the VR headsets that the world went crazy for a couple of years ago (and still does in a few places). Although they provide a new way for consumers to immerse themselves in an alien environment, they do not offer much more than just moving our heads left and right. Most forms of VR headsets do not allow for movement within the environment or any real acknowledgment of depth. In most, you can’t even see your hands and use them to manipulate the environment. So they make me question, how futuristic are they really?
Although the author does not offer any real solution, personally, I believe haptics are they way forward to provide the future of interaction with more ability to manipulate and actually make use of our bodies.
I had heard that piano was a popular choice in previous years so this week, Suman and I decided to make drums. We used two different rhythms, one for a buzzer and one for the drums, and had them playing at several times as though to be responding to each other, sort of like a drum solo. while the buzzer rhythm is the same one and loops. There is two rhythms for the drums and with each round of the buzzer one of the rhythms plays, alternating. And the servo stands act like hands, playing the drums.
materials:
-2 servos
-1 buzzer
-some wood
-foam board
-tape
Our source for the drums: https://www.instructables.com/id/Simple-Arduino-Drum-Robot/
#define NOTE_B0 31
#define NOTE_C1 33
#define NOTE_CS1 35
#define NOTE_D1 37
#define NOTE_DS1 39
#define NOTE_E1 41
#define NOTE_F1 44
#define NOTE_FS1 46
#define NOTE_G1 49
#define NOTE_GS1 52
#define NOTE_A1 55
#define NOTE_AS1 58
#define NOTE_B1 62
#define NOTE_C2 65
#define NOTE_CS2 69
#define NOTE_D2 73
#define NOTE_DS2 78
#define NOTE_E2 82
#define NOTE_F2 87
#define NOTE_FS2 93
#define NOTE_G2 98
#define NOTE_GS2 104
#define NOTE_A2 110
#define NOTE_AS2 117
#define NOTE_B2 123
#define NOTE_C3 131
#define NOTE_CS3 139
#define NOTE_D3 147
#define NOTE_DS3 156
#define NOTE_E3 165
#define NOTE_F3 175
#define NOTE_FS3 185
#define NOTE_G3 196
#define NOTE_GS3 208
#define NOTE_A3 220
#define NOTE_AS3 233
#define NOTE_B3 247
#define NOTE_C4 262
#define NOTE_CS4 277
#define NOTE_D4 294
#define NOTE_DS4 311
#define NOTE_E4 330
#define NOTE_F4 349
#define NOTE_FS4 370
#define NOTE_G4 392
#define NOTE_GS4 415
#define NOTE_A4 440
#define NOTE_AS4 466
#define NOTE_B4 494
#define NOTE_C5 523
#define NOTE_CS5 554
#define NOTE_D5 587
#define NOTE_DS5 622
#define NOTE_E5 659
#define NOTE_F5 698
#define NOTE_FS5 740
#define NOTE_G5 784
#define NOTE_GS5 831
#define NOTE_A5 880
#define NOTE_AS5 932
#define NOTE_B5 988
#define NOTE_C6 1047
#define NOTE_CS6 1109
#define NOTE_D6 1175
#define NOTE_DS6 1245
#define NOTE_E6 1319
#define NOTE_F6 1397
#define NOTE_FS6 1480
#define NOTE_G6 1568
#define NOTE_GS6 1661
#define NOTE_A6 1760
#define NOTE_AS6 1865
#define NOTE_B6 1976
#define NOTE_C7 2093
#define NOTE_CS7 2217
#define NOTE_D7 2349
#define NOTE_DS7 2489
#define NOTE_E7 2637
#define NOTE_F7 2794
#define NOTE_FS7 2960
#define NOTE_G7 3136
#define NOTE_GS7 3322
#define NOTE_A7 3520
#define NOTE_AS7 3729
#define NOTE_B7 3951
#define NOTE_C8 4186
#define NOTE_CS8 4435
#define NOTE_D8 4699
#define NOTE_DS8 4978
#include <Servo.h>
#include "pitches.h"
// notes in the melody:
int melody[] = {
NOTE_C4, NOTE_G3, NOTE_G3, NOTE_A3, NOTE_G3, 0, NOTE_B3, NOTE_C4
};
// note durations: 4 = quarter note, 8 = eighth note, etc.:
int noteDurations[] = {
4, 8, 8, 4, 4, 4, 4, 4
};
Servo servoL;
Servo servoR;
int BUZZER = 8;
//hardware and pins
int srvoR = 5; //assign digital pwm pin for Left servo
int srvoL = 6; //assign digital pwm pin for Right servo
//musical things
int bpm = 90; //beats per minute
int timeSig = 4; //regular time signature (beats per measure)
int Tbeat = 60000/bpm; //time per beat in milliseconds is one minute divided by beats per minute
int beat = 1; //start the fist measure with the first beat
int measure = 1; //start with the first measure
//servo control
int travel = 17; //in degrees, how far does the servo need to turn
int Tservo = 130; //time allowed for servo to reach position before further instruction in milliseconds
void setup() {
Serial.begin(9600); // opens serial port, sets data rate to 9600 bps
//setup code here, to run once:
//establish each pin mode
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
//setup the servos at set at zero
servoL.attach(srvoL);
servoR.attach(srvoR);
servoL.write(0);
servoR.write(0);
}
void beatTEST(){
servoR.write(travel);
servoL.write(travel);
delay(60000/bpm);
servoR.write(0);
servoL.write(0);
delay(60000/bpm);
}
void quarterBeatL(){
servoL.write(travel);
delay(Tservo);
servoL.write(0);
delay((60000/bpm)-Tservo);
}
void quarterBeatR(){
servoR.write(travel);
delay(Tservo);
servoR.write(0);
delay((60000/bpm)-Tservo);
}
void eighthBeatL(){
servoL.write(travel);
delay(Tservo);
servoL.write(0);
delay((30000/bpm)-Tservo);
}
void eighthBeatR(){
servoR.write(travel);
delay(Tservo);
servoR.write(0);
delay((30000/bpm)-Tservo);
}
void loop() {
for (int thisNote = 0; thisNote < 8; thisNote++) {
// to calculate the note duration, take one second divided by the note type.
//e.g. quarter note = 1000 / 4, eighth note = 1000/8, etc.
int noteDuration = 1000 / noteDurations[thisNote];
tone(8, melody[thisNote], noteDuration);
// to distinguish the notes, set a minimum time between them.
// the note's duration + 30% seems to work well:
int pauseBetweenNotes = noteDuration * 1.30;
delay(pauseBetweenNotes);
// stop the tone playing:
noTone(8);
}
delay(50);
if(measure == 1){ //a set of four quarter notes.
quarterBeatR();
quarterBeatL();
quarterBeatR();
quarterBeatL();
measure = 2;
}
for (int thisNote = 0; thisNote < 8; thisNote++) {
// to calculate the note duration, take one second divided by the note type.
//e.g. quarter note = 1000 / 4, eighth note = 1000/8, etc.
int noteDuration = 1000 / noteDurations[thisNote];
tone(8, melody[thisNote], noteDuration);
// to distinguish the notes, set a minimum time between them.
// the note's duration + 30% seems to work well:
int pauseBetweenNotes = noteDuration * 1.30;
delay(pauseBetweenNotes);
// stop the tone playing:
noTone(8);
}
delay(50);
if(measure == 2){ //a set of 8 eighth notes. not perfectly in time because the motors are slow
eighthBeatR();
eighthBeatL();
eighthBeatR();
eighthBeatL();
eighthBeatR();
eighthBeatL();
eighthBeatR();
eighthBeatL();
measure = 1;
}
}
I really liked Norman’s method of breaking down design in terms of terminology used and the many different conceptions that are integrated within it.
Bad design is definitely a hassle that almost everyone has faced at one point in their life or another. However, while reading his work at first, I felt as if Norman was being a little bit exaggerated about how important design and signifiers are in daily life and objects but then I remembered being in London a few weeks ago and struggling to work the tap for a good ten minutes before asking for help (my roommates did not know either). The situation we faced was pretty disruptive and frustrating and a set of clearer indications on the tap could have definitely averted this problem; thus, I conceded that Norman is correct in identifying how crucial design is for objects – especially those that should not require too much thinking in the first place.
“The same technology that simplifies life by providing more functions in each device also complicates life by making the device harder to learn, harder to use. This is the paradox of technology and the challenge for the designer.”
Moreover, Norman’s statements about the future of design really resonated with me as well. Watching my grandmother or even my mom interact with a new phone is painful at best as they attempt to understand how each flick of their finger or movement of their face will cause a change on the screen. Even myself, having access to iPhones, Macs etc. am unable to remember sometimes how different movements can result in different results without having to look them up. Even as I write this, having become used to using a Windows computer in my class and changing back to a Mac for personal work, I continue to mistake the commands on the keyboard between the two. This makes me question, what does this mean for the future of design as electronics get more and more complicated in terms of functionality?
When I thought of the word “unexpected”, the first cliche that popped into my head (no pun intended) was the ‘Jack in the Box’ toy every little kid knows. At first, I wanted to use a flex sensor to turn the LED on and off once the box was opened/closed but I realized that a photoresistor would do the same job. I really enjoyed creating this box from scratch, soldering the sensor and LED for the first time and then seeing it work; hence, the smile :).
int Pr = 0; // will be used for analog 0.
int PrValue = 0; // value of output
int Pr_Input = 700; // value of when light is on
void setup() {
Serial.begin(9600);
pinMode(13, OUTPUT); // pin 13 as output
}
void loop() {
PrValue = analogRead(Pr);
Serial.println(PrValue);
delay(100);
if (PrValue < Pr_Input)
{ digitalWrite(13, HIGH); } else { digitalWrite(13, LOW);}
}
For our second assignment, we were asked to use code within our switch to do something creative with the LED lights. I decided to create a car game of sorts (however, having run of time, it was reduced to a lesser parody).
I coded 3 different LED lights to turn on as a traffic light would. This took a lot of help and I ended up learning new methods I hadn’t used before. I also wanted to attach a button pin to turn the traffic lights on and off which proved to be very difficult.
Lastly, I also wanted lights to turn on once the car touched the finish line – I did this using a simple circuit using foil and without any code.
If I had more time, I would have liked to build a proper traffic light and circuit and also two cars that could actually race.
int red = 2;
int yellow = 3;
int green = 4;
int buttonPin = 5;
// boolean variable to keep track of whether our sequence is on or off
bool start = false;
// variable to keep track of our prevous button state
int prevButtonState = LOW;
// a very large container of memory used as a variable for numbers that continually increase (Like time)
unsigned long triggerTime = 0;
// the interval between light changes
int interval = 2000;
// which light are we currently activating
int whichLight = 0;
void setup() {
pinMode(red, OUTPUT);
pinMode(yellow, OUTPUT);
pinMode(green, OUTPUT);
pinMode(buttonPin, INPUT);
Serial.begin(9600);
}
void loop() {
// read our button (switch)
int currentButtonState = digitalRead(buttonPin);
// if the button is currently being pressed and during the last frame it was not pressed then continue
if (currentButtonState == HIGH && prevButtonState == LOW) {
// flip start on or off
start = !start;
// reset our trigger time to the current time so we can trigger immediately
triggerTime = millis();
// reset our light sequence to the beginning
whichLight = 0;
}
// if sequence is activated then call changeLights()
if (start == true) {
changeLights();
} else { // otherwise turn everything off
digitalWrite(yellow, LOW);
digitalWrite(red, LOW);
digitalWrite(green, LOW);
}
// remember the current button state so we can have a previous button state the next time through loop
prevButtonState = currentButtonState;
}
// the actual sequence of light changes
void changeLights() {
// boolean to trigger the next light or not, start off by not triggering
bool triggerLight = false;
// get our current time
unsigned long currentMillis = millis();
// if the current time is greater than the time when we should trigger, THEN LET'S TRIGGER!
if (currentMillis >= triggerTime) {
triggerLight = true; // LET's TRIGGER
triggerTime = currentMillis + interval; // reset the trigger time for 2 seconds later
}
// if we're triggering the next light
if (triggerLight == true) {
// which light are we on
if (whichLight == 0) { // red
digitalWrite(red, HIGH);
} else if (whichLight == 1) { // yellow
digitalWrite(yellow, HIGH);
} else if (whichLight == 2) { // green
digitalWrite(yellow, LOW);
digitalWrite(red, LOW);
digitalWrite(green, HIGH);
} else if (whichLight == 3) { // then turn everything off
start = false;
}
// increase the sequence to the next light, only to be triggered after the triggerTime == currentTime
whichLight = whichLight + 1;
}
}
Crawford begins his work by exploring the overuse of the word ‘interactivity’, a word that is thrown around to describe almost every product in the market. He, thus, attempts to define it himself. Crawford metaphorically uses the actions of “listening”, “thinking” and “speaking” as the foundations of interaction. He states that interactivity requires two active participants and exists on a continuum rather than an either/or situation or (as its most often confused as) an intensified emotion or even simply an act of participation. Instead, it is almost a conversation wherein the three aforementioned actions are optimised.
Crawford also describes the role of interactivity designers as ones who have to consider both the form and function in creating their design. They work by maximising the strengths of their computer in the aforementioned actions (listening, thinking and speaking) and minimising their weaknesses. He urges that interactive designers, although should be learning from the past, must not cling firm to their foundations in “graphic design” but more importantly, incorporate “form with function”.
For our first assignment, we were asked to design a switch that turned on an LED without using hands. For my project, I wanted to incorporate a book and a book mark that would align to light up the LED.
To do so, I created a bookmark out of foil and copper tape and added a foil lining to a page in a book (ideally, this would exist on every page). Both the page and the bookmark were connected by wires to the breadboard to complete the circuit where an LED would light up once they were in place.
I also, just for fun, decided to attach wires to magnetic salt and pepper shakers to complete the circuit.
