Bret Victor’s post about the future of interaction design was very compelling to me because it made me question what the future looks like. I’ve always thought “What else can we make when everything’s already been invented?” I think the reason why developers are creating more and more apps through a screen is because there’s so much more you can create on phones, tablets, etc. Even within his own post, Victor does not mention any technology that’s not Pictures Under Glass, but I acknowledge the fact that he is writing this post to inspire younger generations to think of something more revolutionary than what is currently thought of as the future of interaction design.
I believe the future is the screen because outside of that, what can you really create? I agree with Victor’s point about how these screen technologies leads us to lose connection with the task that we are performing. Isn’t that somewhat the purpose of technology though? It’s suppose to make your life easier; what if you’re too lazy to use your hands? Some people want things done with a swipe of the finger.
I respect what Victor has to say about the future of interaction design, but I really don’t know what else to expect than a screen that can do so much more than what we humans are capable of.
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 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.
Don Norman sure does have a unique tone. His semi-sarcastic style of writing this piece, “The Design of Everyday Things” was informative, yet also entertaining and it provided a good amount of insight into the design of things we interact with everyday.
One of the things I could relate to was his quote, “We have to accept human behavior the way it is, not the way we wish it to be.” I really struggle with realizing that how humans act usually does not correlate with how they should act. I have never considered this from the design standpoint, but I can imagine it would be particularly problematic to design something that only an ideal society could benefit from.
Another section that stuck with me was his thoughts on a human-centered design. I agreed wholeheartedly with his idea that the design should be based around humans and their needs. However, like we discussed in class today, I disagree that good designs produce pleasurable experiences. I think that the design should go unnoticed. I believe this because of how fast-paced the world has become. In my experience, I don’t have time to really admire or enjoy the design of an object because I am too busy thinking about four other things or focusing on getting the function of the design completed. We don’t have time to admire how the design works, we just need it to work. Unfortunately, that means the designer is a life that can often go unpraised.
From reading this, I will definitely pay more attention to making my designs human centric and focused on mapping. Incorporating things like feedback and conceptual models will be an interesting thing to develop into my own work, as I figure out my design style and how to best make a functional device.
I designed the danger box to be misleading on multiple levels, starting with the name. Like the Masochist’s coffee pot we read about in this reading, this device is specifically designed to do what the user did not intend to do. Most of the device’s wiring is hidden within the box, so any user who comes by without knowing what it does can receive no clues from it.
I used mapping as a diversion by using the yellow LED light as a moving piece instead of a light, as it was intended to. this had the affect of surprising the user.
Another diversion I used was the copper tape on the top of the box that looks like it must be connected to make something in the box work.
The cumulation of all these things is an experience in which a user expects to press on a button or light sensor, expecting something to happen like the light turning on, but something completely contrary to that happens.
int solenoidPin3 = 3;
int solenoidPin4 = 4;
// Solenoid Pins
void setup() {
// put your setup code here, to run once:
pinMode(solenoidPin3, OUTPUT);
pinMode(solenoidPin4, OUTPUT);
//makes solenoids output
Serial.begin(9600);
}
void loop() {
// put your main code here, to run repeatedly:
int knobValue = analogRead (A0);
// grabs data from light sensor reading
Serial.println(knobValue);
// shows light sensor reading
if (knobValue > 650) {
digitalWrite(solenoidPin3, HIGH);
digitalWrite(solenoidPin4, LOW);
}
if (knobValue < 650) {
digitalWrite(solenoidPin3, LOW);
digitalWrite(solenoidPin4, HIGH);
}
// this section tells the solenoids to move depending on the light that the light emitter is receiving
}
THE READING:
The reading reminded me of the podcast 99 Percent Invisible (which I listen to religiously). It is a podcast about design and our place as humans within the world of design. There were two things that particularly stood out to me in the text.
Everything in our human world is designed, but not all design is good. This is why it is necessary for designers to act as an intermediary between engineers and the rest of the world.
I want to reiterate just how much I loved the Masochist’s Coffeepot. It is a beautiful art piece because it flips design on its head, taking something well designed and reverse designing it so it no longer works.
This week’s prompt was to have something unexpected in our project, to have an element of surprise. But since we were specifically asked for a surprise, anything we make will not be a surprise, as it would be expected! This was such a dilemma for me. Therefore I decided to tweak and change the use of my previous project, since my audience already knew how it worked, to create an unexpected surprise.
Valentine’s day is over. Now, even though my project might look the same, it is no longer a tool showing a person’s love to you, but has transformed into a heart rate monitor. The heart beats go faster and faster with pressing the button, but when a hand is held over the light sensor, the heart stops beating and creates the beeping sound of a heart rate monitor when a heart stops. Many love stories, such as Romeo and Juliet, end with death, this is one of them.
For this project (like love story part 1), I used 10 LED lights, and put them into a piece of poster board in the shape of heart. I used different circuits for each LED as well as the button. At first I tried to solder the LEDs to the wires before poking them into the surface, but then found that this made the LEDs not stand up straight and move around due to the large hole. Therefore I decided to solder the LEDs after having put them into the board. I soldered the power and ground side of each LED separately, therefore using a total of 20 wires for the soldering. I considered having the button on the board too but decided that I want it to be eventually framed and still be able to use the button, so it would be better to have it separate. In order to make them fixed on the board, I glue gunned the LEDs from the back on to the board.
For this project I adjusted the code, and wiring, in order to add a light sensor and buzzer and have the light sensor turn off the lights and turn on the buzzer.
int ledPin1 = 3;
int ledPin2 = 6;
int buttonPin = 2;
int index = 0;
int prevButtonState = LOW;
int lowDelay[4] = {0, 200, 100, 30};
unsigned long toggleTime = 0;
int triggerInterval = 500;
int buzz = 13;
// Blink
// Turns an LED on for one second, then off for one second, repeatedly.
//
// Most Arduinos have an on-board LED you can control. On the UNO, MEGA and ZERO
// it is attached to digital pin 13, on MKR1000 on pin 6. LED_BUILTIN is set to
// the correct LED pin independent of which board is used.
// If you want to know what pin the on-board LED is connected to on your Arduino
// model, check the Technical Specs of your board at:
// https://www.arduino.cc/en/Main/Products
//
// modified 8 May 2014
// by Scott Fitzgerald
// modified 2 Sep 2016
// by Arturo Guadalupi
// modified 8 Sep 2016
// by Colby Newman
//
// This example code is in the public domain.
//
// http://www.arduino.cc/en/Tutorial/Blink
//*/
// the setup function runs once when you press reset or power the board
void setup() {
// initialize digital pin LED_BUILTIN as an output.
for (int i=3; i<=12;i++){
pinMode(i,OUTPUT);
}
pinMode (buttonPin, INPUT);
Serial.begin(9600);
}
// the loop function runs over and over again forever
void loop() {
int currentButtonState = digitalRead(buttonPin);
int knobValue = analogRead(A0);
Serial.println(knobValue);
if (knobValue <50) {
index = 0;
}
if (currentButtonState == HIGH && prevButtonState == LOW) {
index = index + 1;
if(index >= 4){
index = 0;
}
// Serial.println(index);
}
if(index != 0){
for (int i = 3;i<=12;i=i+1){
digitalWrite(i, HIGH);
}
delay(100);
for (int i = 3;i<=12;i+=1){
digitalWrite(i, LOW);
}
delay(lowDelay[index]);
for (int i = 3;i<=12;i++){
digitalWrite(i, HIGH);
}
delay(100);
for (int i = 3;i<=12;i++){
digitalWrite(i, HIGH);
}
delay(1000);
for (int i = 3;i<=12;i++){
digitalWrite(i, LOW);
}
delay(lowDelay[index]);
for (int i = 3;i<=12;i++){
digitalWrite(i, HIGH);
}
delay(100);
for (int i = 3;i<=12;i++){
digitalWrite(i, HIGH);
}
} else {
for (int i = 3;i<=12;i++){
digitalWrite(i, LOW);
}
}
prevButtonState = currentButtonState;
// for (int i = 3;i<=12;i++){
// if (knobValue == 0)
// {
// digitalWrite(i,LOW);
// }
// }
int LIGHT = analogRead(13);
if (LIGHT < 100){
tone(buzz, 3000, 50);
}
}
Light of the Lotus was my idea for project 3. The idea was to have a temperature sensor inside of a glass lotus and when water of a certain temperature was poured into that lotus an LED would Light up from underneath. Initially, I wanted to have the sensor in the lotus, but then I realized this would create a short circuit. So I just manually carefully put the sensor in.
float tempPin = A0;
float maxTemp = 50
;
int led = 2;
float temp, cel;
void setup() {
Serial.begin(9600);
pinMode(tempPin, INPUT); //the input recieved is the water's temp
pinMode(led, OUTPUT); //the output is the LED, so wether it is low high
}
void loop() {
int c = analogRead(tempPin);
float voltage = c * 5.0;
voltage /= 1024.0;
c = (voltage - 0.5) * 100 ; //converting from 10 mv per degree wit 500 mV offset
if(c > maxTemp) { // if temp is higher than tempMax
digitalWrite(led, HIGH); // turn on led
}
else { // else turn of led
digitalWrite(led, LOW); // turn on led
}
Serial.print("TEMP: ");
Serial.print(c); // display the temperature
Serial.print("C");
Serial.println();
}
float readTemp() { // get the temperature and convert it to celsius
temp = analogRead(tempPin);
return temp * 0.48828125;
}
#refrenced, will add urls later tonight
For my third project, I decided to play around with the photo-resistor. The goal was to use analog inputs to manipulate LEDs, so what I did was set my LED to first turn on if there was a certain amount of light.
After, I built a small lamp-like device that covered or shadowed my photo-resistor. That way, the LED would remain turned off. Inside my lamp box, there is a small green LED. I programmed so that the switch I had next to it would turn on the green LED, which would provide artificial light to my photo-resistor. Once it detected light, the photo-resistor would provoke my original red LED to start blinking, indicating that my green LED inside was working since the box is so small and it is arduous to look inside.
const int PR = A0;
const int checklight = 3;
const int rlight = 2;
int value;
const int button = 4;
int PBS = LOW;
int checklightstate = LOW;
unsigned long pm = 0;
const long interval = 1000;
int rlightstate = LOW;
void setup() {
// put your setup code here, to run once:
pinMode(checklight,OUTPUT);
pinMode(rlight,OUTPUT);
pinMode(PR,INPUT);
pinMode(button,INPUT);
}
void loop() {
// put your main code here, to run repeatedly:
value = analogRead(PR);
int CBS = digitalRead(button);
unsigned long cm = millis();
if(value>500){
if(cm - pm >= interval){
pm = cm;
if(rlightstate == LOW){
rlightstate = HIGH;
} else{
rlightstate = LOW;
}
digitalWrite(rlight,rlightstate);
}
}
else{
rlightstate = LOW;
digitalWrite(rlight,rlightstate);
}
if(CBS == HIGH && PBS == LOW){
if(checklightstate ==HIGH){
checklightstate = LOW;
}
else if (checklightstate ==LOW){
checklightstate = HIGH;
}
}
digitalWrite(checklight,checklightstate);
PBS = CBS;
}
After finishing my “star constellation” embroidery piece, I was very disappointed that the supposedly metallic thread almost did not show at all- so the intended contrast between white and metallic thread was completely lost. This was sort of an inspiration to make it a little more interesting with a slightly different medium. I took couple of white LEDs and tried to incorporate them into the piece to achieve the promise that metallic thread did not meet. The idea was to make them blink in a consequent line, increasing the speed if the pressure on the sensor increases.
Since my coding game is very weak, with some help of Youtubers and code forums, I managed to make it work, but it was really lacking the “unexpected element” crucial for this assignment. I had an idea of including another pressure sensor which would reverse the order the LEDs light up in, but struggled to code it. With the incredible help of Jack (thank you again!) who patiently worked with me, I learned my lesson why the “for (LEDpin = 2; LEDpin < 10; LEDpin++)” did not work, if a condition including the second pressure sensor was included. Instead, the whole code was rewritten, leaving out the “for” command, while increasing/decreasing the LEDpin number in the end of each condition.
And in case you’re wondering- the two pressure sensors are in the two ends of the metallic thread, to demonstrate the very very deep meaning of power dynamics of the two figures.
And here is the code:
int LEDpin = 0;
int pressurePinA = A0;
int pressurePinB = A1;
void setup() {
for (LEDpin = 2; LEDpin < 10; LEDpin++)
pinMode(LEDpin, OUTPUT);
LEDpin = 2;
}
void loop() {
//telling arduino to check the pressure of both pins A and B and if A is bigger then lights go from left to right
//the bigger the pressure, the higher the speed
if ( analogRead(pressurePinA) > analogRead(pressurePinB) ) {
digitalWrite(LEDpin, HIGH);
delay(map(analogRead(pressurePinA), 0, 1023, 1000, 10));
digitalWrite(LEDpin, LOW);
//telling it to move to the next pin in next loop
LEDpin = LEDpin + 1;
if (LEDpin > 9) {
LEDpin = 2;
}
//if pressure in B is bigger, the lights go from right to left
} else {
digitalWrite(LEDpin, HIGH);
delay(map(analogRead(pressurePinB), 0, 1023, 1000, 10));
digitalWrite(LEDpin, LOW);
//telling it to move to the previous pin in next loop
LEDpin = LEDpin - 1;
if (LEDpin < 2) {
LEDpin = 9;
}
}
}
Over the past week, I figured out how to make lights fade on and using sensors. So naturally, I went a completely different direction. I created a little game that generates a random value between 0-255 and lights up an LED with that value (0 being LOW and 255 being HIGH). The user must then control a photoreceptor so that it falls within a range of the generated value. If they are too high, a red light will come on (HOT) and if they are too low, a blue light will come on (COLD). If they fall within the range, they will be rewarded with a yellow light.
In this game’s production, I fell into some interesting problems and came up with solutions for a few of them. One was that the loop would go so fast that it would constantly be generating new values, thus rendering the game useless. However, I think this would make a great EXTREME MODE for the truly daring player. I fixed this by adding a button. The loop would only generate a new number if the button was pressed.
Here are my video and code 😀
const int ledPinR = 2;
const int ledPinG = 3;
const int ledPinB = 4;
const int ledPinWIN = 6;
int ledRState = LOW;
int ledGState = 0;
int ledBState = LOW;
int ledWINState = LOW;
int button = 7;
int buttonState = 0;
int randNumber = random(1,255);
void setup() {
pinMode(ledPinR, OUTPUT);
pinMode(ledPinG, OUTPUT);
pinMode(ledPinB, OUTPUT);
pinMode(ledPinWIN, OUTPUT);
pinMode(button, INPUT);
Serial.begin(9600);
randomSeed(analogRead(0));
}
void loop() {
if (buttonState == HIGH){
randNumber = random(1,255);
}
Serial.println(randNumber);
ledGState = randNumber;
int lightValue = analogRead(A0);
if (lightValue < ledGState + 250){
ledBState = !ledBState;
ledRState = LOW;
ledWINState = LOW;
}
if (lightValue > ledGState + 400){
ledRState = !ledRState;
ledBState = LOW;
ledWINState = LOW;
}
if (lightValue >= (ledGState + 250) && lightValue <= (ledGState + 400)){
ledWINState = HIGH;
// if in x range, start a timer, once timer is 3 seconds, do whatever
}
digitalWrite(ledPinR, ledRState);
analogWrite(ledPinG, ledGState);
digitalWrite(ledPinB, ledBState);
digitalWrite(ledPinWIN, ledWINState);
buttonState = digitalRead(button);
}
