Author: Nisala Saheed

Me and Nisala started very ambitiously in our brainstorming session, but learned really fast that executing the theoretical ideas is a completely different thing. Instead of having a clear vision and linearly making it happen step by step, we experimented a lot with different sensors, materials and code. The process was very enjoyable, playful and although we ended up not using many of the elements we tried, we learned a bunch of new things (and how not to use them).

One of the major problems that got us stuck in the beginning was that the Tone and Servo library did not work together in one code – we solved it by creating a little bit more of tedious work for us and declared the notes and frequencies manually.

The beauty that was born eventually is a rotating music instrument that has a lot of paper clips inside. The main part of the instrument is a cardboard box, which is rotated by a servo, consequently making a lot of … music? (who said the music needs to be beautiful, right). Then we have a set of 8 buttons that together with a buzzer serve as a C major scale and that also control the servo. The degree to which the servo turn is determined by which button is pressed (the higher the note, the smaller the angle).

Here is a demonstration:

The breadboard: 

And lastly the code:

#include <Servo.h>


#define NOTE_C4 261
#define NOTE_D4 294
#define NOTE_E4 330
#define NOTE_F4 349
#define NOTE_G4 392
#define NOTE_A4 440
#define NOTE_B4 494
#define NOTE_C5 523

int duration = 500;

const int button1 = 4;
const int button2 = 5;
const int button3 = 6;
const int button4 = 7;
const int button5 = 8;
const int button6 = 9;
const int button7 = 10;
const int button8 = 12;

Servo servo;


const int buzzer = 3;


bool servoState = false;
int toggleTime = 0;
int triggerInterval = 500;
int angle = 0;

void setup() {
  // put your setup code here, to run once:

  pinMode (button1, INPUT);
  pinMode (button2, INPUT);
  pinMode (button3, INPUT);
  pinMode (button4, INPUT);
  pinMode (button5, INPUT);
  pinMode (button6, INPUT);
  pinMode (button7, INPUT);
  pinMode (button8, INPUT);

  servo.attach(11);

}

void loop() {
  // put your main code here, to run repeatedly:

  int buttonState1 = digitalRead(button1);
  int buttonState2 = digitalRead(button2);
  int buttonState3 = digitalRead(button3);
  int buttonState4 = digitalRead(button4);
  int buttonState5 = digitalRead(button5);
  int buttonState6 = digitalRead(button6);
  int buttonState7 = digitalRead(button7);
  int buttonState8 = digitalRead(button8);





  if (buttonState1 == HIGH) {
    tone(3, NOTE_C4);
    servo.write(180);

  }


  else if (buttonState2 == HIGH) {
    tone(3, NOTE_D4);
    servo.write(160);
  }



  else if (buttonState3 == HIGH) {
    tone(3, NOTE_E4);
    servo.write(140);
  }


  else if (buttonState4 == HIGH) {
    tone(3, NOTE_F4);
    servo.write(120);
  }



  else if (buttonState5 == HIGH) {
    tone(3, NOTE_G4);
    servo.write(100);
  }


  else if (buttonState6 == HIGH) {
    tone(3, NOTE_A4);
    servo.write(80);
  }



  else if (buttonState7 == HIGH) {
    tone(3, NOTE_B4);
    servo.write(60);
  }



  else if (buttonState8 == HIGH) {
    tone(3, NOTE_C5);
    servo.write(40);
  }


  else {
    noTone(3);
    servo.write(0);
  }

}

 

My mother will hate me for this, but I have to say it: I come from a loud house. So it only makes sense to let myself know how loud since I would be drowning in noise anyway. I used the following code to connect a sound sensor to a series of LEDs that light up in sequence the louder the sound. In started with three, and then distributed the hertz across 9 LEDs after I solidified my logic.

int soundSensor = A0;    // select the input pin for the soundSensor

const int ledPinR3 = 13;      // select the pin for the LED
const int ledPinR2 = 12;
const int ledPinR1 = 11;

const int ledPinY3 = 10;
const int ledPinY2 = 9;
const int ledPinY1 = 8;

const int ledPinG3 = 7;
const int ledPinG2 = 6;
const int ledPinG1 = 5;

void setup() {
  // put your setup code here, to run once:
  //declare the sounSensor as INPUT
  pinMode(soundSensor, INPUT);
  pinMode(ledPinR1, OUTPUT);
  pinMode(ledPinR2, OUTPUT);
  pinMode(ledPinR3, OUTPUT);


  pinMode(ledPinY1, OUTPUT);
  pinMode(ledPinY2, OUTPUT);
  pinMode(ledPinY3, OUTPUT);


  pinMode(ledPinG1, OUTPUT);
  pinMode(ledPinG2, OUTPUT);
  pinMode(ledPinG3, OUTPUT);


  Serial.begin (9600);


}

void loop() {
  // put your main code here, to run repeatedly:

  //create an integer to sense the data from the sensor. it is an analog one, so you have to analogRead.
  int soundValue = analogRead (soundSensor);

  Serial.println(soundValue);


  if (soundValue >= 21)
  {
    digitalWrite (ledPinG1, HIGH);
  } else {
    digitalWrite (ledPinG1, LOW);
  }



  if (soundValue >= 70)
  {
    digitalWrite (ledPinG2, HIGH);
  } else {
    digitalWrite (ledPinG2, LOW);
  }


  if (soundValue >= 150)
  {
    digitalWrite (ledPinG3, HIGH);
  } else {
    digitalWrite (ledPinG3, LOW);
  }


  if (soundValue >= 170)
  {
    digitalWrite (ledPinY1, HIGH);
  } else {
    digitalWrite (ledPinY1, LOW);
  }

  if (soundValue >= 210)
  {
    digitalWrite (ledPinY2, HIGH);
  } else {
    digitalWrite (ledPinY2, LOW);
  }


  if (soundValue >= 250)
  {
    digitalWrite (ledPinY3, HIGH);
  } else {
    digitalWrite (ledPinY3, LOW);
  }


  if (soundValue >= 280)
  {
    digitalWrite (ledPinR1, HIGH);
  } else {
    digitalWrite (ledPinR1, LOW);
  }

if (soundValue >= 310)
  {
    digitalWrite (ledPinR2, HIGH);
  } else {
    digitalWrite (ledPinR2, LOW);
  }


if (soundValue >= 350)
  {
    digitalWrite (ledPinR3, HIGH);
  } else {
    digitalWrite (ledPinR3, LOW);
  }


}

 

 

We also read some foundational texts regarding design.

Reading Don Norman’s work on affordances and human centered design ironically made me worry about the future of the field. As someone deeply in love with design, Norman’s exceptional ideas about how to design our world expressed, at first, an end to the practice. An exhibit in London described a compelling idea along these lines: that humans are regularly creating a world that no longer requires humans. In the same way, are designers creating a world that no longer requires designers?

 

Although the thought sparked some initial anxiety, a few ideas in Norman’s text provided some comfort. He expresses that technology and people are constantly evolving and changing. As technology improves, as human behavior changes, the nature of affordances change. What we need as a society change. He also describes, when discussing mapping, that culture can define certain design ideas, and that although some concepts should be universal, others work best for particular societies.

 

Here, we reach the notion of the zeitgeist, and how we impact it as designers. If culture is constantly shifting and created by us, then maybe the norms of how we view chairs and what they are used for will also change. Changed by our own will. As someone who hopes to enter this design world, I can both be comforted in not only that design will exist and be necessary for as long as I am alive, but also that it will exist and be necessary for as long as humans are alive.

 

The police are coming!! But don’t fear they shall calm down with the push of a button.

Chris Crawford’s paper on defining interactivity aligns closely with my own understanding of design within this class. As I conceptualized and experimented with my code, I began to consider the contextual interaction or use of what I am creating. Crawford establishes a useful distinction in interaction, that passive or “non-conversational” designs cannot be classified in the same light as those that are a product of a conversation between a product and user. I do think that this allows us, as a society, to distinguish overused ideas of interaction from those that are truly interactive. I do, however, believe it is important to acknowledge that our conception of interaction and interactivity has come from complex and specific forms of human and technological development. Fridges, and their lights, upon their inception, would be revolutionary forms of interaction.

In today’s world, where interaction becomes more complex, and human behaviour becomes more closely intertwined with technology, the type of interaction we desire becomes that of the conversation. Fridge lights have become quite ubiquitous, and so have books, but our value of interactivity should not be hierarchical, rather an acknowledgement of the range of interaction. Much of Crawford’s argument lies in a conversation that exists within programming and processing. This is the context of our class and interactive media is useful, however, should not overshadow existing technology like doors, or create normative ideas about making all technology the same. What would doors or fridge lights look like if there were regular conversations between them and users? How much would that cost? Is that worth it?

I believe that we should let non-conversational interactions exist in our paradigm, and undergo a process of determining what type of interaction we desire from products.

 

What’s better than getting a warm hug from a good friend, and also illuminating your home! Or maybe just lightly illuminating a 3 cm radius.

Yes, the hug may have been awkwardly long, but it can be useful in exploring human contact as a way of powering facilities. Some technologies exist that use human work, like biking, to create energy. However, what does our world look like when we can harness simple human interactions to power what we use?