Midterm Proposal — Bottled Boat

My midterm project was inspired while we were talking about having water on our projects and exploding.

I want to make a boat that has an Arduino attached to it. The boat will be made of plastic material so that it doesn’t sink (maybe inside a water bottle?) and will be enclosed so wires are not expose to the water.

For the sensor, I would be using an ultrasonic sensor for distance sensing, so that the boat knows to not go any further if it is near the surrounding wall of the box. I will attach two servo motors that is attached to some propeller looking object (I’d probably make the propeller myself from plastic). These two servo motors will control the direction the boat will move in.

  1. Moving forward — left moves counter clockwise, right moves clockwise
  2. Moving backwards — left moves clockwise, right moves counterclockwise
  3. Moving left — left motor rotates
  4. Moving right — right motor rotates

Users will press different buttons to move whichever motor. For example, if you want to go left, you would press a button for the left motor and another button for the direction of the motor.

Response: A Brief Rant on the Future of Interaction Design #2

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.

 

Response: A Brief Rant on the Future of Interaction Design

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.

 

 

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!

https://youtu.be/G1A2rHHSoMI

// 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);

}

 

Stage Design Midterm Idea

Since my primary passion in life is bringing technology into theater, I am interested in making a small model of a stage. In this model, I would have some set design that is attached to servos and leds/string lights to light the space. I would then be able to change the set and lighting design from a board on the outside of the model.

Features would include:

1) Lighting changes

2) Set changes

3) Curtains pulled back at start

4) All controlled from breadboard using sensors and buttons

I will be focused less on the entertainment side of IM and more on the functionality of it and its application into theater.

Enclosure References

Box designer: http://boxdesigner.connectionlab.org/

Hollow project enclosure: http://makezine.com/projects/hollow-2×4-project-enclosure/

Examples from Aaron:

Makezine examples: http://makezine.com/slideshow/15-fantastic-project-enclosures/

A Body of Music by Tori and Kyle

“What if you were the instrument?” A young, curly haired girl said to her best friend one rainy afternoon. Of course, it wasn’t actually rainy. It was Abu Dhabi.

And so, with that idea, Kyle and Tori set off on an adventure that woud use six sensors, four buzzers, one servo, and two solinoids, one fish bowl, one miscellaneous metal piece, and many wires to change the world.

This was a process and a half and took way too much time. Basically, we made an instrument in three different parts: percussion, piano, and maraca.

Percussion: consists of two solinoids attached to different materials, one a glass bowl and one a metal goblet type piece. It is attached to a muscle sensor. When Kyle flexes his muscle, a programmed beat begins.

Piano: consists of four pressure sensors attached to four buzzers. Each pressure sensor corresponds to two notes in the C major scale. At a low force, it plays one note and at a higher force it switches to another note.

Maraca: consists of one servo and one photoresistor attached to a tongue depressor. When the photoresistor changes its light reading, the servo moves and the maraca is shaken. We used a battery to balance the weights.

Here is our code. Kyle’s code is responsible for the percussion while my code is responsible for the maraca and piano. This is mainly because of issues with delay and balancing between the two boards.

Kyle’s Code:

int solenoidPin3 = 3;
int solenoidPin2 = 2;
const int analogInPin = A0;
int sensorValue = 0;        // value read from the pot
int outputValue = 0; 

void setup() {
  // put your setup code here, to run once:
pinMode(solenoidPin3, OUTPUT);
pinMode(solenoidPin2, OUTPUT);

Serial.begin(9600);
}

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

sensorValue = analogRead(analogInPin);
  // map it to the range of the analog out:
  outputValue = map(sensorValue, 30, 700, 0, 100);

    Serial.print("sensor = ");
  Serial.print(sensorValue);
  Serial.print("\t output = ");
  Serial.println(outputValue);

  //get help figuring out the delay
  if (outputValue > 30) {
digitalWrite(solenoidPin2, HIGH);
delay(50);
digitalWrite(solenoidPin2, LOW);
delay(100);
digitalWrite(solenoidPin2, HIGH);
delay(50);
digitalWrite(solenoidPin2, LOW);
delay(100);
digitalWrite(solenoidPin2, HIGH);
delay(50);
digitalWrite(solenoidPin2, LOW);
delay(100);


digitalWrite(solenoidPin3, HIGH);
delay(100);
digitalWrite(solenoidPin3, LOW);
delay(200);
digitalWrite(solenoidPin3, HIGH);
delay(100);
digitalWrite(solenoidPin3, LOW);
delay(200);  

}
else if (outputValue < 30){
  digitalWrite(solenoidPin2, LOW);
  digitalWrite(solenoidPin3, LOW);}
}

Tori’s Code:

#include <Servo.h>

Servo servo;

unsigned long pressure1 = A0; //with C4
unsigned long pressure2 = A1; //with Am4
unsigned long pressure3 = A2; //with G4
unsigned long pressure4 = A3; //with F4
unsigned long fsrReading1;
unsigned long fsrReading2;
unsigned long fsrReading3;
unsigned long fsrReading4;

const int buzzbuzz1 = 2;  //with C4 and F4 
const int buzzbuzz2 = 3;  //with Am4 and 
const int buzzbuzz3 = 4;  //with G4
const int buzzbuzz4 = 5;  //with F4

void setup() {

    servo.attach(9);
    
  Serial.begin(9600);
  pinMode(buzzbuzz1, OUTPUT);
  pinMode(buzzbuzz2, OUTPUT);
  pinMode(buzzbuzz3, OUTPUT);
  pinMode(buzzbuzz4, OUTPUT);
}

void loop() {

  int lightRead = analogRead(A4);

  int angle = map(lightRead, 0, 1023, 0, 180);
  
  fsrReading1 = analogRead(pressure1);
  fsrReading2 = analogRead(pressure2);
  fsrReading3 = analogRead(pressure3);
  fsrReading4 = analogRead(pressure4);

  Serial.println(fsrReading1);


  if (fsrReading1 > 50 && fsrReading1 < 900){
    tone(buzzbuzz1, 261.63, 100);
  } else if (fsrReading1 > 900){
    tone(buzzbuzz1, 523.25,100);
  } else if (fsrReading1 < 50){
    noTone; 
  }

    if (fsrReading2 > 50 && fsrReading2 < 900){
    tone(buzzbuzz2, 293.66, 100);
    
    } else if(fsrReading2 > 900){
  tone(buzzbuzz2, 329.63,50);
    
  } else if (fsrReading2 < 100){
    noTone; 
  }

    if (fsrReading3 > 50 && fsrReading3 < 900){
    tone(buzzbuzz3, 349.23, 100);
  } else if (fsrReading3 > 900){
    tone(buzzbuzz3, 392.00,100);
  
  
  } else if (fsrReading3 < 50){
    noTone; 
  }

  if (fsrReading4 > 50 && fsrReading4 < 900){
    tone(buzzbuzz4, 440, 100);
  } else if (fsrReading4 > 900){
    tone(buzzbuzz4, 493.88, 100);
    
  } else if (fsrReading4 < 50){
    noTone; 
  }
servo.write(angle);
}

Videos:

Rotating Piano

In exploring not only code but also how to create interesting sounds, Jana and I designed a small instrument that turns and creates noise as you play a note.

 

Our reading has been about converting what we can do into what we want to do. I find this a compelling idea, especially in the context of affordance and signifiers from the previous readings.

Within the context of their abilities, humans have innately, design, technology, and interaction become choices in the human world. We are able to decide how we translate what we can do into what we want. I find screens an interesting example in the text, as the screen is a flat surface. But in many modern phone applications, we find a reflection of physical affordances within the 2D frame. Sliding/swiping, turning, vibrating are forms of feedback that can be ways of mimicking less screen-based interaction. As technology becomes more and more a part of human life and experiences, what type of interaction and feedback become inherent characteristics of a world that we have regularly chosen to create.

A common trope in media is children in our generation not understanding the meaning of the save button on Microsoft programs. In a generation of humans that have never experienced floppy disks, the save button becomes the point of reference. What does the world look like when a simple analogue interaction is not the reference for new technology, but a screen-based gesture becomes the reference?

In the context of the capabilities of people, how do we design our world and translate these ideas, when newer generations don’t have access to older technologies that are viewed as outdated.