L2: Sensor Cymbals!

Group Name: VARPEX

Group Number: 9

Group Members: Abbi Ward, Dillon Reisman, Prerna Ramachandra, Sam Payne

Prototype 1 (The Dog Toy Instrument):

For our first prototype, we use a force sensitive resistor to build a toy that a dog can bite at various places and create music. The force of the bite determines the tone of the music.

Prototype 2 (The Roll-Instrument)

For our second prototype, we use an accelerometer continuously maps the y-coordinate to a unique frequency of the tone that to create music when we roll the instrument.

Prototype 3 (The Clapper)

For our third prototype, we built a clapper that uses a light sensor to adjust the speed of beats based on the amount of light that reaches it through the plates, hence creating music.

We decided to refine our clapper to build a more playable, intuitive instrument.

Project Description:

Our musical instrument uses light to control the tempo of notes that have a pitch set by a user’s sliding finger. In our prototype of the light mechanism we found that the use of light gave the player a surprising amount of control over the sound produced, and could perform interesting, simple beats without even controlling pitch. This mechanism worked by placing a light sensor in a ‘clamshell’ that could be opened or closed- more light to the sensor created a faster beat, while a closed clamshell resulted in a slower beat. For our refined model, we have two black acrylic panels- one with the light mechanism attached, and another with the slider sensor for pitch-control. The player holds each piece in a hand and can pivot, rotate, pull away, or cover up the light sensor on one piece using the other piece. We chose this design because it gave the player two dimensions of sound to control in a very fluid, three dimensional way. In a future revision of this design we might want to give the user more control over the beat, such as the ability to have no beat (right now, the beat is, when the light sensor is completely covered, very slow, but not off).

Schematic

schematic

Project Demo

List of Parts

A list of parts used in your final system

  • Arduino
  • 1k-Ohm resistor
  • 10k-Ohm resistor
  • slider sensor
  • photocell
  • buzzer (speaker)
  • dead battery (This keeps the acrylic pieces from crushing the photocell and provides a pivot point for the pieces to rotate)
  • 2 pieces of acrylic
  • electrical tape to attach the battery to the acrylic

Instructions to Recreate System

Build the given schematic using alligator clips to attach the sensors. Tape the dead battery to one of the acrylic pieces — cover up the terminals. Carefully bend the leads of the photocell and rest it on top of the battery, parallel to the acrylic. Tape the slider sensor to one side of the other piece of acrylic. Load the Arduino code. Use the piece of acrylic with the slider sensor to cover the photocell and change the beat. Change the position of your finger on the slider sensor to change the tone.

Source Code

/*
Names: Dillon R, Prerna R, Sam P, Abbi W (Group 9)
Date: 3/2/13
Class: COS 436 - L2
For a musical instrument using the photocell and slider sensor. 
Light makes a faster beat and the slider corresponds to a scale
*/
// Pins
int sliderPin = A0;
int lightPin = A1; 
int speakerPin = 9;
int sliderValue;
int lightValue;
int tempo = 330;
int beat;
// sensor value ranges
int lightRangeLow = -1*200;
int lightRangeHigh = -1*950;
int sliderRangeLow = 100;
int sliderRangeHigh = 550;
void setup(){
 pinMode(speakerPin, OUTPUT);
 Serial.begin(9600);
}
void loop() {
 sliderValue = analogRead(sliderPin);
 lightValue = analogRead(lightPin);
 Serial.println(lightValue);
 //char note = setNotefromSlider(sliderValue); 
 setBeat(-1 * lightValue);
 playNote(setNote(sliderValue),tempo); 
 delay(tempo/2); 
}
// varies the tempo
void setBeat(int sensorValueA) {
 // for reading light sensor
 tempo = map(sensorValueA, lightRangeHigh, lightRangeLow, 5, 800); 
}
// sets a note c to C based on the slider position
char setNote(int sensorValue) {
 /* sensor value is 100 to 550 */
 int readVal = map(sensorValue, sliderRangeLow, sliderRangeHigh, 0, 830);
 int cmax = 180;
 int dmax = cmax+100;
 int emax = dmax+100;
 int fmax = emax+100;
 int gmax = fmax+100;
 int amax = gmax+100;
 int bmax = 780;
 if (sensorValue < cmax) {
 return 'c';
 }
 if (sensorValue < dmax) {
 return 'd';
 }
 if (sensorValue < emax) {
 return 'e';
 }
 if (sensorValue < fmax) {
 return 'f'; 
 }
 if (sensorValue < gmax) {
 return 'g'; 
 }
 if (sensorValue < amax) {
 return 'a'; 
 }
 if (sensorValue < bmax) {
 return 'b'; 
 }
 return 'C'; 
}
// method from Arduino tutorial
void playTone(int tone, int duration) {
 for (long i = 0; i < duration * 1000L; i += tone * 2) {
 digitalWrite(speakerPin, HIGH);
 delayMicroseconds(tone);
 digitalWrite(speakerPin, LOW);
 delayMicroseconds(tone);
 }
}
// method from Arduino tutorial
void playNote(char note, int duration) {
 char names[] = { 'c', 'd', 'e', 'f', 'g', 'a', 'b', 'C' };
 int tones[] = { 1915, 1700, 1519, 1432, 1275, 1136, 1014, 956 };
// play the tone corresponding to the note name
 for (int i = 0; i < 8; i++) {
 if (names[i] == note) {
 playTone(tones[i], duration);
 }
 }
}

 

L2: Coin Chime

Group Name: %eiip

Group members: Mario Alvarez (mmcgil@), Bonnie Eisenman (bmeisenm@), Erica Portnoy (eportnoy@), Valya Barboy (vbarboy@)

What we built: We built a “coin chime” — a small, windchime-like instrument using a bunch of quarters and alligator clips. Some of the quarters act as proximity sensors; when they come near the other quarters (or even better, touch), they send a signal to the Arduino, which in turn causes the buzzer to make noise based on this input. We built this because we thought that windchimes are cool, and somewhat unconventional in terms of “musical instruments.” We really like our result; it’s fun to play with, even though it’s difficult to intentionally produce “music.” If we were to improve upon our design we would probably add more proximity-sensing coins (currently there are only two), and we would probably refine the code that determines what sounds are played to make it more closely mimic a set of chimes. We also would like to experiment with the proximity sensors; using the code provided, if the delay between readings is too short the sensors don’t function correctly.

Erica using the coin chime. Above, you can see the setup, including the Arduino and buzzer.

The final setup: a bunch of quarters hanging from alligator clips, an Arduino, and a buzzer. The coin pouch keeps the quarters in place. Two of the quarters are proximity sensors.

Prototype 1: Gong with Piezo.

Building the prototype of our “gong,” using the Piezo and a paper plate.

Our first prototype is a “gong”-style instrument using a Piezo. The Piezo detects vibration, and then based on the level of vibration, a short program instructs the buzzer to sound.

Prototype 2: 

We call our second prototype the “Shakey.” It creates noise using a buzzer depending on how much you shake it (which is measured using the accelerometer). The noise is pseudorandom.

Prototype 3:

This is an early version of our coin chime. The first coin is a proximity sensor; we were testing what threshold was necessary for it to sense the second coin somewhat reliably. When the proximity sensor’s output passes a certain level, the buzzer sounds.

List of Parts:

  • ~12 Quarters
  • 1 Arduino
  • 2 10 Megaohm Resistors
  •  Wires
  • Alligator clips
  • 1 Buzzer
  • 1 USB cable
  • 1 Breadboard

Instruction for Recreation:

Circuit diagram for Coin Chime

Using the above diagram, recreate the circuit; the resistors pictured should be 10 megaohm resistors, and the two circles connected to them are quarters. The quarters should be connected using alligator clips or something similar, so that they can be dangled off of a ledge. Then, attach a bunch of other quarters to alligator clips and dangle them together with the two proximity-sensing quarters. (The extra quarters needn’t be connected to the circuit.) Finally, load up the code below, and start playing with your coin chime! Optional modifications include adding extra proximity-sensing quarters.

Source code:


#include 
int speakerPin = 9;

CapacitiveSensor   cs_4_2 = CapacitiveSensor(4,2);       
CapacitiveSensor cs_13_12 = CapacitiveSensor(13,12); 

int tempo = 300;

void playTone(int tone, int duration) {
  for (long i = 0; i < duration * 1000L; i += tone * 2) {
    digitalWrite(speakerPin, HIGH);
    delayMicroseconds(tone);
    digitalWrite(speakerPin, LOW);
    delayMicroseconds(tone);
  }
}

void playNote(char note, int duration) {
  char names[] = { 'c', 'd', 'e', 'f', 'g', 'a', 'b', 'C' };
  int tones[] = { 1915, 1700, 1519, 1432, 1275, 1136, 1014, 956 };

  // play the tone corresponding to the note name
  for (int i = 0; i = thresh && total2 >= thresh) {
    playNote('b',tempo);
  }
  else if (total1 >= 900) {
    playNote('C',tempo);
  }
  else if(total2 >=900) {
    playNote('a',tempo);
  }
  // Make the delay too short, and the proximity
  // sensors won't work. :(
  delay(50);
}


 

Resistance is futile

People

  • Keunwoo Peter Yu
  • Dylan Bowman
  • Green Choi
  • Taejune Ham

Group Number
8
What we built
We’ve built a lighting system that reacts to the background light and pressure. We wanted to build a lighting system that automatically dims itself to save energy when there’s enough background light, and only turns on if necessary e.g. when a person is standing in front of the door thereby applying pressure to the sensor. Our system only turns on the LED lights when there’s pressure and low background light as intended. We picked arbitrary thresholds for background light and pressure, but in the future, we’d like to select these values after a more systematic analysis.
Sketches

Our idea applied to a closet

Our idea applied to a closet. Depending on the background light, the light bulb adjusts its brightness accordingly. Also, it only turns on when a person is standing in front of the closet looking for something, thereby saving energy.

Toilet

Our idea applied to the toilet. Depending on the background light, the brightness of the room is adjusted. Also, the light turns on only when you’re sitting in the toilet.

Entrance of a House

Our idea applied to the entrance of a residential house. Only when someone is standing at the entrance does the light turn on. Also, it adjusts its brightness based on the background light.

Storyboard
IMG_1190
Pictures and Video

This slideshow requires JavaScript.



List of parts

  • 2 10K Ohm resistors
  • 2 LED Lights
  • 1 Force-sensing Resistor
  • 1 Photo Sensor

Instructions
Complete the circuit as shown in the picture below.
20130303_013414

Code

// pin numbers for LED
const int greenLED = 11;
const int yellowLED = 10;
const int lightSensor = 0;
const int forceSensor = 1;
const int LIGHT_MAX = 255;
const int FORCE_THRESHOLD = 400;
const int LIGHT_THRESHOLD = 100;

// variables
int light = 0;
int force = 0;

void setup() {
  pinMode(greenLED, OUTPUT);
  pinMode(yellowLED, OUTPUT);
}

void changeLight(int light) {
  analogWrite(greenLED, light);
  analogWrite(yellowLED, light);
}

void loop() {
  changeLight(0);
  light = analogRead(lightSensor);
  force = analogRead(forceSensor);
  if (light < LIGHT_THRESHOLD && force > FORCE_THRESHOLD) {
    changeLight(LIGHT_MAX);
  }
}

Lab1 – Weather Detector

COS436 – Lab 1 Blog

COS436 – Human computer Interface

Lab 1 – Resistance is Not Futile Blog

Kevin Lee, Saswathi Natta, Andrew S. Boik, Brian W. Huang

Group Number 16

Description:

We built a weather detector using various sensors to detect different weather conditions. We use a flex sensor for detecting wind as it blows on it, an FSR for detecting hail as it hits it, a photocell for detecting sunlight, a Variable You-sistor for detecting rain when electricity is conducted between the two bare ends of the jumper wires through water on the ground, and a thermistor for detecting temperature. The temperature is printed to the screen, while the other sensors have LEDs that correspond to them. The LED will turn on if the corresponding sensor reads a value that exceeds a threshold, in which case, the appropriate weather condition has been detected. We selected this project because we believe each sensor naturally has a corresponding component of weather that it is suited for detecting, and being able to detect weather conditions is a very useful, practical application of the tools provided in this lab.  In our opinion, the project was largely a success. We liked how our light sensor, flex sensor, photocell, and themistor all detect their weather components accurately. We however think that our FSR is not well suited as a hail sensor. This is because it seems to require a fair bit of weight to be on top of it to register any significant readings, so it is uncertain whether ice will be detected on top of it.. Realistically, the FSR would also probably break if hail were to fall directly on top of it. Had we had time, we also would have designed a container for our device so that the device doesn’t become damaged under intense weather conditions.

Sketches of Early Ideas

A weather detector that detects various weather conditions.

A weather detector that detects various weather conditions.

A primitive instrument with continuously changing pitch and volume.

A primitive instrument with continuously changing pitch and volume.

A version of the bop-it game.

A version of the bop-it game.

Storyboard for Weather Detector:

Storyboard for weather detector.

Storyboard for weather detector.

Final System – Weather Detector:

Our weather detector with design sketch in view.

Our weather detector with design sketch in view.

Close up view of our weather detector.

Close up view of our weather detector.

Photo of our weather detector with sail for wind detection in view.

Photo of our weather detector with sail for wind detection in view.

List of parts:

– Arduino

– 4 LEDs

– 9 10k Resistors

– FSR

– Flex Sensor

– Thermistor

– Photocell

– Cardboard and paper

– Jumper wires

Instructions:

1. Setup LEDs and sensors

-Place the long end of each of the 4 LEDs to the chosen Arduino digital output pin and the shorter end to ground through 10k resistor

-Setup FSR, Flex sensor, Thermistor, Photocell, and Variable You-sistor (two jumper wires). All sensors are wired with a voltage divider, using 10k resistor to ground, between one pin connected to 5V power and the other pin connected to an Arduino analog input pin to detect the resistance. Each sensor gets its own analog input. Tape cardboard to the base of the flex sensor for flexibility and a paper sail to the top of it to make it sensitive to wind.

2. Test baseline for sensors and adjust thresholds as necessary

-Once the sensors are connected, with the proper (~10K) voltage divider connected to power on one pin and the other pin connected to the Arduino, the Arduino software will display it’s reading of the input. For each sensor, test it with appropriate weather conditions to see how the readings change to determine appropriate thresholds.

-FSR, Flex sensor, Photocell, and Variable You-sistor all have corresponding LEDs that will turn on when threshold is passed. FSR LED signifies hail, flex sensor LED signifies wind, photocell LED signifies sunlight, and Variable You-sistor LED signifies rain.

Code:

/* Weather sensor for L2
 * Lab Group 16 (old 21):
 * Andrew Boik (aboik@)
 * Brian Huang (bwhuang@)
 * Kevin Lee (kevinlee@)
 * Saswathi Natta (snatta@)
 */

// pin inputs
int thermistor_pin = A0;
int flex_pin = A1;
int photo_pin = A2;
int fsr_pin = A3;
int wet_pin = A4;

// led outputs
int wind_led = 13;
int sunny_led = 12;
int hail_led = 11;
int rain_led = 10;

// thresholds for led light-up
int wind_thresh = 300;
int sunny_thresh = 800;
int hail_thresh = 10;
int rain_thresh = 10;

// led max brightness
int led_max_val = 255;
// led min brightness
int led_min_val = 0;
// delay time
int delay_time = 500;

// timeouts for hail/rain and time since last event
unsigned long hail_timeout = 5000;
unsigned long rain_timeout = 5000;
unsigned long time_since_last_rain;
unsigned long time_since_last_hail;

void setup(void) {

 time_since_last_rain = rain_timeout;
 time_since_last_hail = hail_timeout;

 Serial.begin(9600); 
 pinMode(wind_led, OUTPUT);
 pinMode(sunny_led, OUTPUT);
 pinMode(hail_led, OUTPUT);
 pinMode(rain_led, OUTPUT);
}

void loop(void) {

  // get readings
 int temperature = analogRead(thermistor_pin);
 double true_temp = (temperature - 345.684) / 5.878;
 int wind = analogRead(flex_pin);
 int sunny = analogRead(photo_pin);
 int hail = analogRead(fsr_pin);
 int rain = analogRead(wet_pin);

// print out vals from sensors
 Serial.print("Temperature = ");
 Serial.println(true_temp);
 Serial.print("Wind = ");
 Serial.println(wind);
 Serial.print("Sunny = ");
 Serial.println(sunny);
 Serial.print("Hail reading = ");
 Serial.println(hail);
 Serial.print("Rain reading = ");
 Serial.println(rain);
 Serial.println();

 // led light-up
 if (wind > wind_thresh)
   digitalWrite(wind_led, led_max_val);
 else
   digitalWrite(wind_led, led_min_val);
 if (sunny > sunny_thresh)
   digitalWrite(sunny_led, led_max_val);
 else
   digitalWrite(sunny_led, led_min_val);
 if (hail > hail_thresh) {
   time_since_last_hail = 0;
   analogWrite(hail_led, 255);
 }
 else if (time_since_last_hail < hail_timeout) {    Serial.print("time_since_last_hail = ");    Serial.println(time_since_last_hail);    time_since_last_hail += delay_time;    analogWrite(hail_led, 255);  }  else {    time_since_last_hail += delay_time;    analogWrite(hail_led, 0);  }  if (rain > rain_thresh) {
   time_since_last_rain = 0;
   analogWrite(rain_led, 255);
 }
 else if (time_since_last_rain < rain_timeout) {
   Serial.print("time_since_last_rain = ");
   Serial.println(time_since_last_rain);
   Serial.println();
   time_since_last_rain += delay_time;
   analogWrite(rain_led, 255);
 }
 else {
   time_since_last_rain += delay_time;
   analogWrite(rain_led, 0);
 }

 delay(delay_time);
}

Assignment 2: Princeton Pathfinder

ELE 469/ COS 436 – Assignment 2 : Individual Design Exercise

1)      I watched the IDEO video:  My favorite parts were the examples of how you do something first and then ask for forgiveness later, such as the bike hanging. I also liked the system of combining prototypes.

2)      Observing: I sat in the Friend center in between classes and observed students going in and out of class. What I found:

  • Some students arrive early,
    • They are already at the library, studying  and come down to class
    • Some print homework and rush around the library getting paper and stapling problem sets before rushing to class
    • Some just happen to come in and stand around outside the class room or go in early, not doing much except texting or checking their phones and computers
  • Many students arrive on time or a minute late and go straight into the lecture room
    • This is 5 minutes right before class that the halls are the most crowded
    • People meet their friends, form small groups just outside a big lecture hall and go in
    • Some people say hi in passing to friends
  • Then there are some students that arrive late
    • Some rush in, at a semi-running pace, jogging through the hallway and then quietly opening the lecture room door to not disturb the lecture
    • Some, even when late, just walk at a steady pace and walk into class
  • Some students, at the end of the class, walk out and back in if they forgot something
  • Many times students walk out in pairs or groups talking with friends
  • Sometimes, classes ended late, and if it was particularly late, some students would rush out trying to make it to their next class on time
  • When I chose specific students to observe as they waited for class:
    • One student was talking to friends outside of the classroom before they went to their respective classes
    • Another student tried to walk into the class room, but there was a lecture inside that had run over time, so they just waited outside. He looked at his phone and sat down by the window until students came out of the room
    • A third student as she was waiting for class sat down and crossed her arms and closed her eyes for a few minutes, just listening to her headphones before getting up to go into class. She took off her headphones as she walked into class and put them in her pocket.
    • A fourth girl walked toward her class room, then stopped midway to check her phone, respond to a text or maybe an email or facebook message. People swerved around her as she stood there texting. Then she looked up and put her phone away and walked into the classroom.

3)      Brainstorm:

  • 1)      More efficient way to print : Additional printers and printing stations
  • 2)      A printer outside the library with  “all clusters” access
  • 3)      App to find optimal path to get from point A to point B : Shortest path or fastest  path
  • 4)      App Record exact time that it will take to get form point A to point B on campus:  Uses student’s average walking pace to calculate time
  • 5)      An indicator light to tell students outside if a lecture is going on in a classroo
  • 6)      An indicator light to tell when an optimal time to enter class room unnoticed
  • 7)      An application in a phone or a separate device that will alert a person if they are blocking the path for others, such as when they stop to text with their head bent
  • 8)      A button to press so that doors will open without needing to grasp the handle
  • 9)     A way to share music that different students are listening to before class
  • 10)   A booth for quick naps with built in alarm for sited students between class
  • 11)   Icebreaker gam app for students to make friends in class: Students can collaborate later for projects
  • 12)   An app for students to find walking buddies before or after class:
  • 13)   An app to show where the nearest free food source is for a between class snack

4)      Two favorite Ideas:

  • 1)      Indicator Light for optimal time to walk in when class is already in session: This would be very useful, especially for late students wanting to walk in unnoticed
  • 2)      App to find optimal path to get from point A to point B : Shortest path or fastest path: This is what I would find most useful because I find that me and my friends constantly wonder which the shortest path is or the fastest path is as we walk to and from class.

5)  Paper Prototypes:

  • 1)      Paper Prototype I did not test: The indicator light prototype ended up being two lights drawn onto a postcard that would go outside the lecture room door. I could also make a paper prototype of the detector of the in-class noise that would send a signal for when there is enough noise that a student can enter unnoticed, but that would not be part of the usual user interface
  • 2)      The paper prototype that I did test: Princeton Pathfinder, a set of index cards representing an app that will take into account a user’s walking pace and suggest the fastest or shortest or most scenic path. I also included a bike path option

Paper Prototype windows

6)      User feedback:

Brian’s Suggestions :

  • Brian found that the difference between shortest path and fastest path were confusing so I may need to remove those two choices, or insert a short description about their differences that can be seen if the options are clicked on
  • He did find that the app would be very useful for him but also noted that a standard map would not include all the shortcuts
  • He suggested that the option to add in short cuts and paved or unpaved paths to the app would be a great way to make it more accurate

Brian

Victoria’s suggestions:

  • She found that the “calibrate” button being at the bottom was confusing, so moving it to a more visible location, or making a whole separate screen right after the welcome screen is the best way to have users calibrate their walking pace before selecting locations
  • She also found it un-intuitive to have a “next” button that needed to be pressed before the map was displayed. Just pressing enter should work.

Victoria

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Jingwen’s suggestions:

  • She found that there was too much writing for the user
  • She also commented that the app could also have a “very fast” option, that would draw a path cutting across grass and areas that are not walkways if a student needs to get to a place as fast as they physically can.

General insights:

– I found that users were a bit confused as to how to move from one window to the next

– I observed that they did not like to read text to follow directions, so the app may need to be more intuitive, with the buttons speaking for themselves

– I also observed that users were confused with needing to click the “next” button

– I should add in a feature that allows users to fund the fastest possible way and input their own shortcuts

 

Lab 1 — Theremax

Team Deep Thought (Group 25):
Vivian Qu
Neil Chatterjee
Alan Thorne
Harvest Zhang

We built a device that mimics a theremin, controlled using a light sensor and touch sensitive slider (softpot). The goal of the device is to be a fun, interactive way to play music using the sensors. This device also could conceivably be used to teach young students about the physics of sound waves, since our visualizer shows the actual wave form changing in proportion to the user’s actions! One issue we had is that we needed to keep a finger on the softpot at all times or else there were spikes in the sound because the readings need to stabilize. This would be an aspect we would want to fix to streamline the experience. Future improvements could include adding buttons to change the tone of the sound and figure out how to control two different wave forms simultaneously. Otherwise, the device successfully works and allows the user to control the graphic sine wave to create different sounds.

I. Photos & Videos:

Pulse Monitor — Uses a light sensor to detect the changes in light filtered through the skin, detecting the heartbeat. Emits sound from the buzzer to match the heartbeat.

Precise Clicker — The device uses a flex sensor as a discreet clicker for presentations.

Bop-It — A fun interactive game based on the “Bop-It” games, where LED lights signal which sensor (Flex/FSR/Potentiometer) to manipulate.

Theremax — Uses the softpot and light sensor to control the frequency and amplitude of the sound wave.

We chose to implement the Theremax idea, coming up with the following storyboard for why a user would want to interact with the device.

 

 

 

 

 

Here’s a video of our device at work:

The touch sensitive slider (softpot) controls the frequency and the light sensor controls the amplitude. Sliding down on the slider increases the frequency, and covering the light sensor (less light input) reduces the frequency.

II. Parts Used

  • Arduino Uno x1
  • Photocell x1
  • Softpot x1
  • 330 ohm resistors x2
  • Breadboard
  • Wires

III. Setup

Connect the middle lead of the softpot to analog input (we used A0) and the leftmost lead to 5V and the third through a 330 ohm resistor to ground. Connect the left leg of the photocell to 5V and the other leg is connected to both analog input (we used A1) and through a resistor to ground. Download the source code, using Arduino and Processing. Upload the code to the Arduino and voila!

IV. Source Code

ARDUINO CODE

// Lab 1: Theremax
// Arduino code to read user input from softpot and thermoresistor.

// Frequency
int freq;
// Amplitude
int ampl;
// Receiving input from analog ports 0 and 1.
int thermo = 0;
int softpot = 1;

void setup(void) {
// Send input data to Processing via the Serial monitor.
Serial.begin(9600);
}

void loop(void) {
  // Read from input.
  ampl = analogRead(thermo);
  freq = analogRead(softpot);

  ampl = map(ampl, 0, 260, 0, 100); 
  freq = map(freq, 0, 500, 0, 100);

  // Send data to Processing.
  Serial.write(ampl);
  Serial.write(freq);

  delay(500);
}

ARDUINO CODE

// Lab 1: Theremax
// Processing code to output sound and graphically show the oscillator.

import ddf.minim.*;
import ddf.minim.signals.*;
import processing.serial.*; 
Serial port;
Minim minim;
AudioOutput out;
SineWave sine;
int volume;
int slider;

void setup()
{
  size(512, 200, P3D);
  port = new Serial(this, Serial.list()[0], 9600);
  minim = new Minim(this);
  // Get a line out from Minim, default bufferSize is 1024, default sample rate is 44100, bit depth is 16
  out = minim.getLineOut(Minim.STEREO);
  // Create a sine wave Oscillator, set to 440 Hz, at 0.5 amplitude, sample rate from line out
  sine = new SineWave(440, 0.9, out.sampleRate());
  // Set the portamento speed on the oscillator to 200 milliseconds
  sine.portamento(200);
  // Add the oscillator to the line out
  out.addSignal(sine);
  volume = 0;
  slider = 0;
}

void draw()
{
  // Compensate for variable readings at the extremes.
  if (port.available() > 0 )
  {
    volume = port.read();
    int temp = port.read();
    if (temp >= 0 )
    slider = temp;
  }
  float freq = map(slider, 0, 100, 60, 1500);
  // Change the frequency of the wave.
  sine.setFreq(freq);
  float volout = map(volume, 0, 100, 0, 1);
  // Change the amplitude of the wave.
  sine.setAmp(volout);
  background(0);
  stroke(255);
  // Draw the waveforms
  for(int i = 0; i < out.bufferSize() - 1; i++)
  {
    float x1 = map(i, 0, out.bufferSize(), 0, width);
    float x2 = map(i+1, 0, out.bufferSize(), 0, width);
    line(x1, 50 + out.left.get(i)*50, x2, 50 + out.left.get(i+1)*50);
    line(x1, 150 + out.right.get(i)*50, x2, 150 + out.right.get(i+1)*50);
  }
}

The Processing code relies on the Minim library and is based on the Sine Wave Signal code found here.

A2: Individual Design Exercise

                                                                                         Assignment 2

-Joseph Turchiano

 Observations: (Transcribed from notebook)

1. Preceptor for CS/Math course.

–          Arrives approximately 5-10 minutes early for precept.

–          Places books on table. These books are never opened.

–          Stands around awkwardly doing nothing waiting for students to arrive.

–          Side note: students do more or less the same thing.

–          When precept starts, seems somewhat unprepared to actually teach the lesson.

2. Late friend.

–          Shows up approximately 5 minutes late for lecture, sits down next to me.

–          Spends the next 2 minutes picking up what he had missed so far.

–          Explains that he lost track of time doing other work.

–          Apparently spent the 10 minutes prior to lecture running to lecture.

3. Student in large lecture hall.

–          Has 2 subsequent lectures in the same room.

–          Does not leave after first class ends.

–          Instead continues to surf web with laptop, already open from previous class.

–          Continues to view facebook until about 5 minutes into next class.

–          This is just one student. 10 more are doing more or less the same thing

Brainstorm Ideas:

 

  1. Laptop computer app that sends you a reminder when a class starts.
  2. Phone app with quick notes; supports mathematical notation
  3. Phone-to-Phone/Laptop video streaming app (watch lecture without being there)
  4. Laptop quiz app that uses automatically-inserted note documents
  5. Local multiplayer phone app – enter as many words in the following category as possible
  6. Checklist app – make sure you have everything ready before class – resets
  7. Laptop app that pulls up a random problem from entered list of problem sets
  8. Phone app to automatically lower the volume on your headphones at a set time
  9. Web/mobile app – daily list of events on campus
  10. Mobile app – order coffee from Frist on the go to have it ready for your next class
  11. Phone app – calendar schedule/daily event planner linked with contact info
  12. Phone app – 10:00 min countdown – write as many things about next class as possible
  13. Web app – “Course Memes” – make memetic mutations specific to your course!
  14. Phone app – tell jokes over local wi-fi.
  15. Phone app that gives you a quick summary of events from all registered social media.

 

 Chosen Ideas:

 

1. I decided on the mobile app to order coffee – called P-Café On the Go – since it seemed to be both relatively straightforward to prototype and also useful to a large number of people – anybody who drinks coffee.

2. I decided on the “Course Memes” app because I thought it was a genuinely fun and funny idea, which people would want to take part in voluntarily.

Prototype Photos:

IMG_0048

 

4 of the 8 slides from the P-Cafe Prototype. On the upper left is the opening screen, which leads directly to the upper right – choose a location. Also visible are the exit screen (lower left) and the selection of pastries (lower right).

IMG_0049

On the flip side are the rest of the P-Cafe screens. After choosing a location, the user chooses a category of items (upper left) and then a specific item from a category (upper right). This leads into a loop where the user can select another item (lower right) or enter a netid to place the order (lower left).

IMG_0050

The Course Memes website prototype. The top page is the first screen – log in with netid and course number. This screen takes you to the overview – where you can view other people’s memes or make your own. Underneath that is the Meme Creation page – with buttons for text and image upload, as well as a preview image.

IMG_0052

 

The other option is to view memes instead of making them, and this takes the user to a page with thumbnails of memes. Upon clicking on one, it brings the user to a page with a larger image, where it can be rated or commented.

Prototypes in Action:

IMG_0055

 

After viewing a Course meme image, a user (my roommate) decides to make an image of his own.

IMG_0056

 

When the user uploads his image, a preview with the text overlayed fills the square.

IMG_0053

 

A user decides to add a croissant to her order after choosing to order tea.

IMG_0058

 

A user notices that there’s no bar to enter his password after his netid.

Insights:

–          One brilliant user quickly pointed out that it would be a good idea to require a password as well as a net id before P-Café could be ordered.

–          Another suggested sending email confirmations of orders to users, which I definitely think is a natural expansion of the system.

–          Also necessary was a “Back” button for the inner selection menus of the P-Café app, in case the user changed his/her mind – and perhaps even a “Start Over” button if the user messed up.

–          During the Course Meme prototype, one user suggested an anonymous mode for creating memes as well as the normal login method.

Assignment 2 — Jae Young Lee

Observations:

I observed a bunch of random people and purposely did not get their names or tell them I was observing them.

2:20 to 2:30, McCosh 50, before ECO 100 lecture on Thursday, 2/21 (about 300-400 students)

  • The professor, Harvey Rosen, was there before 2:20, and he spent his 10+ minutes drawing graphs and figures that he would need for lecture on the blackboard, as well as setting up his PowerPoint slides. 
  • A large number of students (I would approximate about 200) were doing nothing other than chatting with friends or sitting in silence.
  • Lots of students would walk into the giant lecture hall and spend some time just looking for their friends or walking around to find someone they knew. This caused a decent amount of traffic in such a large class.
  • One student was coding on his laptop during the 10 minutes.
  • One student mentioned: “I wish I could be doing my math homework right now, but my textbook is back in my room.”
  • Lots of students pulled out their phone to catch up on texts, emails, and Facebook.
  • A surprisingly small amount of people (I could only count about 20 on the main floor of McCosh 50) pulled out their laptops. I would guess that laptops are not allowed during lecture, or at least not ideal for taking notes because of the large quantities of graphs in that class.
  • I left immediately when the lecture started.

1:22 to 1:30, Woolworth 105, before MUS 103 precept on Tuesday, 2/26 (about 15 students)

  • The preceptor had a class in the same room beforehand, so there were some students who stayed behind to ask questions, which took up about 5 minutes of the preceptor’s time. 
  • The preceptor spent his remaining time writing a few things on the blackboard that he would need later on in class.
  • One student walked in, thinking he was in the right precept. He looked around and quickly realized he was an hour early for his actual precept, and he scurried out, looking slightly embarrassed.
  • The preceptor started taking attendance at 1:31. He does it the old-fashioned style by just calling out names (since there are only about 15 people). However, there were 4 students that walked in while he was taking attendance, so whenever one of them walked in, he had to check if he had marked them as absent and then fix it if he had. It seemed highly inefficient.
  • A good amount of students pulled out their phone during the waiting time.

2:54 to 3:00 in CS 104, before HCI lecture on Tuesday, 2/26 (about 60 students)

  • Dr. Vertesi (guest lecturer) spent pretty much all of those 6 minutes fiddling with the projector, the lights, and other technology in the room. A student helped her and seemed to get it working, and the lecture didn’t start until 3:03 because of technical difficulties. 
  • A good amount of students were eating/drinking things. I observed a lot of coffee/tea, a banana, a churro, and a granola bar.
  • The auditorium is terrible for seating: people seem to naturally like sitting towards the edges of each row, which makes it really difficult for people to get to open seats because of how narrow the rows are. I observed about a half-dozen students even climbing over seats just so they wouldn’t have to squeeze through a bunch of people. This problem is made worse by the fact that students want to sit next to their friends.

Brainstorming:

I collaborated with Gabriel Chen.

  1. Hand warmer mats on desks, activated when they sense force.
  2. Attendance (done quickly and automatically, perhaps by proxing in) at entrance of lecture hall/precepts for classes that take attendance.
  3. Attendance (done quickly and automatically, perhaps by proxing out) at exit of lecture hall/precepts to discourage people from leaving early.
  4. An app that automates taking attendance by using GPS: you “check-in” at the beginning of class and “check-out” at the end of class so that the professor knows that you were both on-time and stayed for the entire lecture.
  5. Sensor on every seat that connects to an app that tells you where your friends are and whether the seats are occupied.
  6. An app that has a general map of the classroom that you can use to “reserve” seats for friends; this is useful because it can be awkward telling other students that seats are “taken” when they aren’t actually “taken”.
  7. An app that shows you the outlet locations in lecture halls and whether they’re currently being used or not.
  8. An app that lets bikers press the crosswalk button automatically (so that they don’t have to get off the bike) by using proximity detection techniques.
  9. An app that electrocutes you (really gently…) when you start dozing off in lecture or even before the lecture starts: detects “nodding off” by using an accelerometer on your head.
  10. A live chat with OIT that is accessible on all computers built into lecture halls (for example, in CS 104, both Professor Fiebrink and Dr. Vertesi have had issues with the technology in that room even though they are obviously very capable with technology).
  11. An app that releases Febreze or some other subtle odor cancelling substance when it detects that you are farting or burping in a lecture hall.
  12. A device or system that lets professors see what they’re writing on the board from the back of the room perspective, so they can determine how large to write on a blackboard.
  13. A portable device that can project things clearly onto a blackboard: some professors spend the 10 minutes before class writing material or drawing graphs that they will use later on during the lecture, and they need to use the blackboard because they have lecture slides to show on the projector screen.
  14. A device built into the top of a blackboard that releases a torrent of water so that professors can erase the board from a previous class with a gesture or touch of a button; there is also a drain at the bottom, and a dryer for the board.
  15. A system that allows for delivery from restaurants directly to your lecture hall so that they’ll be there with your food by the time you get there.
  16. A device that automatically scrolls your phone if your eyes are at the top or bottom of the screen; students are often carrying lots of things and don’t have a free hand to actually use their phone.
  17. Phone keyboards that sense where your hand is positioned so that when you want to type with one hand, the keyboard is condensed onto one side of the screen; this is another problem for students who are carrying a lot of things to class.

Ideas chosen for prototyping:

  1. An app that automates taking attendance by using GPS: you “check-in” at the beginning of class and “check-out” at the end of class so that the professor knows that you were both on-time and stayed for the entire lecture. For classes that take attendance, I have never seen a good system for doing so. Some classes pass around a sheet, which often takes a really long time and inevitably skips over some people because students decide to pass the sheet in whatever direction is most convenient for them. Some students also come just to sign-in, and then leave. This app would automate the attendance process and also help discourage students from leaving lecture.
    GosmsPhoto1362192081290
    A typical iPhone screen. Attendance Made Easy is the name of my app.GosmsPhoto1362193410743
    Users need to sign in with their Princeton NetID and password to verify their identity. They can stay signed in to make it easier to use day-to-day.GosmsPhoto1362192108740
    The home screen for the app itself. There is easy-access to turn GPS services on/off since GPS is required for the app to work properly. There are three main buttons for signing in, signing out, and leaving a comment for the professor.GosmsPhoto1362193507637
    The sign-in screen. Based on GPS, it tells you what building you’re located in so that you know you’re signing into the right class. There’s an option to recalibrate if the GPS reading is wrong.

    JaeLee1
    The sign-out screen. Based on GPS, it tells you what building you’re located in so that you know you’re signing out of the right class. There’s an option to recalibrate if the GPS reading is wrong.

    GosmsPhoto1362193483824
    The comment screen. It tells you what class you’re in and the professor that will be receiving your comment. Basically, I envisioned using this option for any extenuating circumstances if a student was late or needed to leave early but had a legitimate excuse.

    GosmsPhoto1362193316321
    The waiting screen if you click recalibrate. Basically the GPS would just refresh your location.

    GosmsPhoto1362193384476
    The screen you see after successfully signing in. There’s just a single button to exit the app.

    GosmsPhoto1362193364192
    The screen you see after successfully signing out. There’s just a single button to exit the app.

  2. Phone keyboards that sense where your hand is positioned so that when you want to type with one hand, the keyboard is condensed onto one side of the screen; this is another problem for students who are carrying a lot of things to class.This seems like a feature on phones that should already be implemented. As phones have been getting bigger and bigger, it’s become increasingly harder to type with just one hand (especially for people like myself with small hands).GosmsPhoto1362192192024
    This is what the normal phone keyboard looks like when it senses two hands using the phone (the default keyboard, no different from a phone in its normal state).GosmsPhoto1362192162797
    When it senses that you take your left hand off, the keyboard becomes condensed on the right side so that all keys are easy to reach with just your right hand. For users who have big hands and have no need for this feature, they can press a button to revert back to the default keyboard.
    GosmsPhoto1362192138577
    When it senses that you take your right hand off, the keyboard becomes condensed on the left side so that all keys are easy to reach with just your left hand. For users who have big hands and have no need for this feature, they can press a button to revert back to the default keyboard.

User Testing:

Osman Khwaja, a junior in the COS department, tested the attendance app.
2013030195203936

  • He said there was too much text. For the sign-in and sign-out screens, he didn’t want to bother reading all of that. Just have a couple words that list the location, time, etc.
  • He never used the comment button. He didn’t really know what it was for, and wasn’t really sure it was necessary even when I explained what I envisioned it being used for (a student with an excuse for being late or leaving early).
  • He said that the app would be useful overall and make things easier.

Ross Smith, a sophomore in the ECO department, tested the attendance app.
GosmsPhoto1362197780091

  • He said he would never use the comment button because there are already easy ways to interact and communicate with professors. Afterwards, I told him I envisioned it being used for students who had an excuse for being late or leaving early, and he said that made more sense. He suggested just renaming it to an “Excuse” button.
  • He said it’s obviously not a viable system unless everybody has a smartphone.
  • He didn’t really understand how it worked when he was first going through the home screen and sign-in screen. When I explained that it knew what classroom you were in through GPS, he immediately understood the entire app a lot better.
  • Overall, he thought it would be a very streamlined way for professors to take attendance and make sure that students stay for the entire class.

Stephen Wang, a junior in the ORF department, tested the attendance app.
GosmsPhoto1362197752885

  • He actually knew what the comment button was for. He said he would use it to explain to the professor why he was late. He said it would obviously not help for telling the professor why you’re absent since you can only use it if you’re in the right classroom.
  • He also mentioned that it requires all students to have a smartphone.
  • He said that it would motivate him to go to class more often, which is a great side effect.
  • He said it was easy-to-use and a really good idea.

Insights:

  • Each button needs to have a clear function and a simple yet descriptive name. I created the comment button thinking students would want to leave comments to professors if they had any relevant issues with their attendance that day. However, when users saw the word “comment,” many of them just assumed it meant general feedback for the professor about the course, and they were confused about the functionality or just didn’t bother using it. I should rename the button to say, “Leave the professor an excuse.”
  • People are lazy. They don’t want to read a lot of text. The app should be as streamlined as possible since it’s something that students would potentially use multiple times a day.
  • It’s unrealistic to implement this for actual attendance since it requires all students to have a smartphone. I kind of realized this from the beginning, but still wanted to prototype it and get feedback.
  • There’s potential. My testers all said it would be useful, and that there’s really no good way for professors to take attendance right now without being inefficient or annoying in some way.

Assignment 2

How I conducted my Observations

On Tuesday February 19, I watched another student in HCI, sitting behind them, as they came into the lecture hall until class started.  My second observation was during a COS 448 class in the COS 104 classroom on Wednesday February 20 . This time I watched a student sitting behind me as they came into class and then spoke to a student behind them.

The third observation is actually a set of many. I took notes in Frist Gallery and outside Sherrard Hall on Wednesday February 20(typing on my phone to look like I was texting – I didn’t want to weird people out and change their behavior) and took notes on people as they went to class. Because most of the time in between class is spent walking to and from class, I thought this would be a useful place to observe. Most people were in a rush, so I was not able to stop and talk to them, but could observe trends in the crowd.

Lastly, I spoke to a student on Wednesday February 20 who had been late to a 10am COS 461 class earlier in the day, and took notes on the interview, as well as some notes on their entrance into the class

Observation Notes

Obs 1

  • getting a seat – everyone is on the edge and want a seat in the middle
  • check email – as a side note, many other people in the room are checking their email as well
  • looking over slides for this class
  • needs to move in repeatedly for other students coming in later
  • facebook
  • seems to be clicking through tabs as thinks of them, no real agenda

Obs2

  • talking to another student
  • turned around in seat
  • kind of awkwardly looking at the other student
  • the person they are talking to is leaning over their computer

Obs 3

-this last category is a large collection of small observations from many people.

  • Frist
  • diagonally on stairs
  • up one side of the stairs over at the gap in between the rails and up the other side
  • talking to friends
  • multiple steps at a time
  • walking quickly
  • heavy bags
  • average pace of passerby increases with the proximity of the next class time
  • so does the number of people in the area
    • creates traffic
    • dodging around people
    • stuck behind slower walkers
    • almost a collision!
      • one person walking with food from gallery, another with a backpack about to run up stairs
      • the one walking with food was distracted looking for a table
      • the one with backpack was only looking at the top of the stairs – their destination
  • In front of Sherrard
    • down Prospect Street
    • some come from over grass in front of Robertson
    • some walk behind Sherrard
    • in front of woody wu
    • sprinting
    • hold their head down to keep the wind out
    • fast walk
      • hand pumping at sides
      • head straight forward toward destination
      • legs reaching out as far as possible
      • swinging backpack – problem for moving quickly?
      • bulky jackets, tight jeans, bad shoes – “
      • walk across grass
      • quick nod to friends
        • what if they think it is rude – way to say hey later?
        • fighting the wind
        • bikes and people running close together – almost accident

Late student

  • Observations:
    • Rushes in, but tries not to make noise
    • looks for a free  iClicker (used for answering questions during lecture)
    • takes a middle row seat, walking past two people who have to get up and lift their desks
    • takes off all their jacket and scarf
    • opens laptop
    • opens notes
    • searches online for the slides and pulls them up
  • are you often late?
    • yes
  • why do you think this happens?
    • the last professor runs late
    • long distance to travel
    • run into a friend in between (I talk a lot)
    • getting up late
    • take too long at lunch
  • what made you late today?
    • got up late
  • what made you late at the last class you were late to?
    • the last professor had run overtime
  • what could improve your time in between classes?
    • printing reading, hws
    • sometimes i have to print out reading, slides, lectures
    • context of lecture
    • having notifications of what the class topic will be about  – based off of syllabus
    • more time
    • guest lecture – look him up

General Insights from Observations

When I was watching people in between class, I noticed overall that everyone seemed to have their own route, even if they were going to the same place. This makes sense for those taking different modes of transportation – bikes or skateboards. But it doesn’t make sense that there should be so many ways to get to one place. There was also a lot of efficiency lost with people and bikers swerving in and out trying to avoid each other or figure out how to not run into each other at junctions in the sidewalk.  Even indoors people ran into these problems, like in Frist where two students actually almost ran into each other.

Much of the problems of getting to and from class seemed to do with hurried people trying to navigate the physical world around them– from bikes, to stairs, to other people, to seating.

Once they were sitting down, students seemed to do mostly one or more of the following: settle in, check email/facebook/course sites, talk to their neighbor. The specific people I chose to observe mostly did these things, and I noticed that many around them seemed to be as well. It is hard to tell whether these activities are helping with productivity or relaxing between class or whether they are simply filling the time in which they would otherwise be bored.

I boiled my observations down to a set of problems that I thought would be interesting to address and focused my brainstorm around them.

Brainstorm

– organized by problems addressed

Avoiding Collisions

  • A device that beeps when you are too close to a person/object
  • Control traffic with lanes and lights installed in the sidewalk
  • Each person gets a signal in headphones telling them how to avoid congestion
  • Chairs that can move themselves in Frist so that there is a better arrangement for the flow of traffic
  • Sky-lifts for students going to class
  • Beeping sound from bike that tells you you’re going to run into something.

Late to class

  • Sensor to tell you how much faster you need to quicken your pace to get to class on time
  • Google glass app that tells you how to get to class efficiently
  • Extra loud/ annoying alarm clock to wake up in time for class
  • Variable time alarm clock to keep you guessing about what time it actually is
  • Google glass app that shows you slides and summaries of readings for today’s lecture
  • Alarm shoes that make noise and start walking away until you have put your feet inside them.

Boredom While Waiting

  • Smart desks in every classroom preloaded with games and quizzes on the material
  • Random dance party or flashmob event in between classes, coordinated by a computer

Seating

  • Smart seating that tells the best places for many students to sit

Looking through Email

  • A 3D filesystem for email.

 

Prototypes

1. Lecture Prep App

Why : I chose to do prototype an app that summarizes the class you are walking to with slides and summaries of readings for the day because it is a new way to prep for class in only a few minutes, a useful activity as you are running late to class and will probably not get a chance to orient yourself when you sit down.

Description :

This app will be displayed on google glass for mobility, combined with a source for taking video and processing the images of the user’s hands make simple interactions with the space around them, including swipes, grabs, and reaching to certain locations.

The app itself gives the user the option of viewing the syllabus, slides, readings and summaries drawn from Blackboard, Sparknotes, and course sites, all while walking to class.

The app also alerts the user to how much time is left until class begins. The UI is meant to be used easily with simple swipe (to move slides) and grab (to select) gestures.

page-0 page-1 page-2 page-3 page-4

page-5

page-6

 

2. Efficient Class Navigation

Why : I chose to make prototype for a Google glass app that efficiently get you to class(a Google glass app again, because of the superiority of the interface for mobility)because it seemed to be the biggest problem with getting to class on time –how to do it efficiently—and there is no existing definitive answer for it.

Description:

2013-03-01 23.46.02

The app has a very minimal UI in order to give the user maximal visibility of where they are going.

2013-03-01 23.38.54

Footsteps on the ground show the user exactly where to step (whether it is cutting across a lawn or going at an angle on the stairs).

The footsteps adjust for both the user’s pace and the minimal pace for the user to arrive at their destination on time.

2013-03-01 23.48.07

If the user is going too slow, the app alerts them and the footsteps adjust to help the user quicken their pace appropriately.

 

User Testing – Lecture Prep App

User 1

What they did while using app

  • just looked at the screen and wondered what it was for — > I need a welcome screen
  • swipe for ppt slides not intuitive, down makes more sense
  • “swipe to remove text” not clear what to do
  • no way to get text back

User comments/suggestions

  • There’s no annotation!
    • If I’m reading I want to be taking notes, highlighting
    • I would like it linked to my notes
    • It would be useful for quick review before precept etc
    • Syllabus would be helpful – I would use that feature
      • link calendar- put in assignments, meetings –> from syllabus
      • Pop out words while the app is reading them out loud
      • Use Wikipedia instead of Sparknotes
      • Could go to syllabus, “grab” a word and wiki it

2013-03-01 23.55.11

User 1 tries to change slides by swiping down instead of the intended swipe to the left.

 

User 2

What they did while using the app

  • tried to  move slides with one finger right to left
  • did not use autoplay feature on slides (probably did not notice it)
  • did not reach as far as expected to “grab” their selection
  • clicked through tabs in order then went back to home
  • surprised/confused that he had to “grab” to select

User comments/suggestions

  • full readings are not necessary
  • Syllabus is unnecessary – I only need to know the section for today
  • I would like the first thing I see to be the paragraph from the syllabus that is related to today – not just the topic
  • I would expect grab to make the object go away, not to select it
  • grab is very vague, maybe pinch instead

2013-03-01 23.53.00

User 2 is confused by the “grab” to select gesture.

2013-03-01 23.53.30

User 2 tries to change swipe slides with one finger instead of the intended whole hand.

 

User 3

What they did while using the app

  • also tried to move the slides down
  • looked for a scroll bar with the text
  • thought the button to turn the speaking feature off would just mute it, wanted a way to pause it -> I should differentiate between the two

User comments/suggestions

  • I mostly look at my calendar on the way to class, you should integrate that
  • I wouldn’t use the full readings, they wouldn’t fit in the 10 minutes in between class
  • I would be afraid of bumping into things, can you make it more transparent
  • maybe make it more transparent as I get closer to running into an object

 

Insights From Feedback

The user feedback was extremely helpful. If I were to go forward with this design I would first look at the interactions that I have created for the user. It was not clear to them exactly how to use the app.  This may be partly because it is a new form of display but also because there are many conventions for the tasks the user may try to accomplish (such as flipping through slides). There is not any standard way to do these actions, which are usually done on  a desktop or mobile, in a 3D space, and what I thought was intuitive – sliding the hand from left to right to change slides—was not for one user who thought that they should be pushed down. (It is important to note that the exact mechanism for taking user input from gestures is not determined yet, as this would likely affect the final gestures available for interaction.)

I would also spend more time testing the way that users actually use the features. It is possible, as several of them suggested that showing any text would only distract from walking. Or that certain features would be useless, such as full readings, and others would be helpful, such as the ability to search online about a given topic.

I liked the “grab and search” idea that one user mentioned. I might want to convert the project into a way to search easily using only hand gestures and a head mounted display and camera. For example, I would like to test a system that allows users to reach out to “grab” a word from given text and pull it in a certain direction indicating that they would like to search for the word on wikipedia or google it. This would make common internet searches very simple in an interface without any clear easy way to type words explicitly. This could even involve being able process text in front of them in the physical world and allowing a user to search for a word in the text recognized. This could allow users an easy way to interact with text around them without having to use inconvenient mobile UIs for internet searches.

 

 

Horia Radoi – Assignment A2

Observations:

 Most observations were done in my day to day activities, by identifying issues I confronted myself with while at Princeton. Some came up during discussion with my friends in Colonial Club, and others during my daily activities or my past experiences.

I have observed both people rushing to class, both in golf carts (injured athletes or students) and on bikes (who had to slalom between studeents wearing headphones or just not paying attention to their surroundings).

In my PHI 203 lecture, I see a lot of people come into class, and just spending the full 10 minutes on Reddit or on Facebook. I overheard some people discussing the readings, but in the context of one of the students not having read the materials for class.

I remember some heated discussions in German class, in which people were debating how a word should sound like. I went into East Pyne and asked some students if they have such problems, and they said it is usually hard to say who is right because everybody is a beginner (Perhaps some professor input might help – similar to an audio version of Piazza).

My friend does not like squirrels and is completely terrified of them!

It is a pain to be in a new building (think engineer in McCosh or English major in the EQuad) and not know where the bathrooms are. Or worse, to know only about one bathroom and that to be full.

 

Brainstorming:

Some ideas were discussed with John O’Neill. Most of them came up during dinner discussions in Colonial (various members).

1. Autonomous Golf Carts – A self-driven golf cart that can pick you up from class and drop you off at your next one. This way the golf cart is no longer bound to one person, and more people can be serviced during a break time.
2. History of my seat – Since a lot of people use PFML, leave a trace of your thoughts as you enter the class and sit on your seat. Can be seat-specific or class-wide messages.
3. Class finder – for when you go in a new building for the first time and you don’t know where that class is supposed to be.
4. Classroom anonymous chat – Class-wide anonymous chat to enable interaction between classmates (have them open up rather than isolate themselves in facebook or reddit)
5. Assassins game – Game that computes all paths to class and gives you a target you might encounter. Your goal is to assasinate that target on your way to class (by taking a picture of them – with consent of course!)
6. Group doodle – a bit of collaborative and artistic fun (displayed on the projector). to be used ONLY before class.
7. Calorie counter for walks – provide basic information about your height and weight, plus your schedule, and if time allows it, this app suggests a route that will increase your walking time while not making you late (to gain that extra bit of exercise)
8. Map of closest restrooms, step by step directions and estimated waiting time. Could include some information about “quality of air” as well.
9. iDidNotReadThatTextCanYouSumItUpForMe (iDNR) – discuss and sum-up readings before class – anonymous and open to anyone. Collaborative reading notes.
10. What happened in the last hour? Twitter application that looks up the latest tweets of your friends and major information sources (CNN, BBC, Princeton, TigerAthletics etc.) that provides you a sum-up of the news that happened in the last hour – this way you will not miss anything important happening while you are in class.
11. Sounds Like This – Text questions and audio answers, with a voting system to choose the best/closest spelling of a word or phrase.
12. Squirrel tracker – for people who just want to avoid these critters (or admire themon your way to class). Help a young John Nash determine their day-to-day routines, so he can develop a Theory of Games (or did that already happen?)
13. Walk With Me – an app that computes a path that you and your friends can take together to maximize the time spent together (big problem in groups of friends who don’t live in the same res college)
14. Vote on playlist – choose song to be played on speakers next. People suggest youtube clips (songs), and the class votes on them. Whichever gains the most votes in splayed next. The professor can veto at any time, and the scoreboard resets at the beginning of every class.
15. Massive TRON game on the projector – lightcycles controlled by smartphone or laptop.
16. Weighted bike map – suggests a route that avoids choke points or heavily populated areas.

Motivation:

1. Golf Cart
Golf carts are most of the time parked, waiting for the person they were issued to or for their friend to use. Sometimes, the users may forget to charge the golf carts, or might be reckless with them. This prototype would be able to charge itself in designated areas, accommodate and serve more people and selectively distribute the fleet to cover the whole campus, while being aware of students and bikes on campus. Useful for increased efficiency and safety of students.

This process is necessary because of the current limitations in the number of people it can service and the restrictions of who can operate a medical golf cart (it is forbidden for people to use the golf cart if their right leg is broken, or they have back problems, or hand problems). Also, most of the time the golf carts are parked, or are sometimes operated in hazardous or irresponsible ways by friends of the injured “owners”.

Prototype available at: https://docs.google.com/a/princeton.edu/file/d/0B4WrajEYbtdnTEliYjdhdVdjUzA/edit?usp=sharing

2. Calorie counter
We are all busy students, and sometimes we can’t find the time to exercise. Since walking is one of the healthiest and most natural means of exercise, this app suggests a route that will maximize your walking time in order to keep you fit and healthy.

Prototype available at: https://docs.google.com/a/princeton.edu/file/d/0B4WrajEYbtdnTWkxUmhROUg3cG8/edit?usp=sharing

 

Usage:

1. Golf Cart service:

The user logs in with his Princeton ID. After the authentication, his identity is checked against a list of people who are cleared by the health center to use the application, and his position is identified (either GPS or LAN access point).

One connection has been made, the user will be notified of the availability of golf carts, their proximity and time until available again. He is then presented with a number of default choices (Next Class, McCosh – in case complications have arised, Athletic Training facilities, back to room or eating club) or prompted to enter his own location.

After he has made his choice, the user is provided updated information about the Golf Cart locations and eta until its arrival. He is also recommended to wait in a designated waiting area, and be prepared to board the vehicle as fast as he can. He will also be notified of the additional stops of the Golf Cart and identity of the future passengers.

Upon the arrival of the Golf Cart, the user has to scan his proxmity card once he is boarded in order to confirm his departure.

The Golf carts will continue to roam around campus, using short range sensors (stereo vision image processing and radars incorporated) to navigate through students. It will use a GPS service to position itself on campus and filter its position using vision processing to better identify its location. On an average run, the golf cart can fit two people, with the possibility of servicing more people the shorter and more efficient the runs are. After every session, the golf carts will return to a base station, where they will charge and wait for the next instructions.

 

2. Calorie counter

Simple user-interaction program that identifies your current location and accesses information about your future classes. It then recommends a fastest route to your next class, with an eta based on your average computed speed, and suggests alternate routes that would fit in the remaining time until your class begins, based on your average computed speed.

Once you have chosen your route, it will run in the background (maybe integrate with a music player), and notify you if you are running behind or are ahead of your schedule. It will provide the option of tracking you through GPS or provide you a status bar of where you are supposed to be right now on your chosen route.

 

User testing:

Both products are designated for minimalistic use on the Client-side, with most of the processing being done by the server side.

1. My “injured” friend Kevin trying out the Golf cart service:

https://docs.google.com/a/princeton.edu/file/d/0B4WrajEYbtdnV2ljemw4ZUVRZ28/edit?usp=sharing

https://docs.google.com/a/princeton.edu/file/d/0B4WrajEYbtdndk84TzFaTG1iUEk/edit?usp=sharing

https://docs.google.com/a/princeton.edu/file/d/0B4WrajEYbtdnUElVT2dzYlhjM0E/edit?usp=sharing

https://docs.google.com/a/princeton.edu/file/d/0B4WrajEYbtdnelhKUlZEclFxNFU/edit?usp=sharing

https://docs.google.com/a/princeton.edu/file/d/0B4WrajEYbtdnbEtWNGZneFBvVU0/edit?usp=sharing

https://docs.google.com/a/princeton.edu/file/d/0B4WrajEYbtdnUFpvbTMtRGpyalU/edit?usp=sharing

 

Observations

During the prototyping process, a couple issues have been raised about the Golf cart service:

1. How safe will ti be for pedestrians, and what will one do if the golf cart “misbehaves”

2. Can the passengers still drive the cart? Why/Why not?

3. How will the students be made aware of the golf carts?

4. Will there be different “grades” of severity – ie. broken leg having priority over broken arm?

5. Can I introduce any address? What if I want to pick up my friend in Bloomberg and head together to the Street?

To address them, I have asked some of my friends, as well as people in some of my classes what they would think. These are the conclusions:

1. The golf cart will be equipped with an emergency stop button (or several), that will be easily reachable and will cause the golf cart to fully stop. An authorized programmer/public safety officer can deal with the problem.

2. no. While it is fun to drive such a golf cart through campus, its manual control could interfere with the server program. Besides, the vehicle will be autonomous anyway. Steering controls will not be removed from the golf cart in order for authorized mechanics to be able to manually pilot them, in case of a malfunciton.

3. Just as the current golf carts, they will be equipped with yellow warning lights and loud horns. While this could get the autonomous golf carts confused with normal ones, a paint change, or specific stickers could be mounted on the car. Of course, in addition to the sensors and cameras present on the car.

4. In the future there might be a distinction between different grades of severity. Of course people with locomotory disfunctions should have priority over people who can still walk.

5. The golf carts will have their hours of operation only during school hours. In addition to that, golf carts are restricted to a certain path on campus, even though some of the drivers choose to ignore the specified routes. This being said, at night, alternative means of transportation will be provided for injured athletes who wish to go party, or to return from a party.