Reverie FieldFinal Project Update:

Progress on the final project has had its’ ups and downs so far. Jenny and I have made a good amount of progress with controlling the lights and getting them to dim and make patterns. Most recently we were able to connect all 15 of the bulbs together.

20181120_195557.jpg
20181124_135442.jpg

One of the larger problem areas we have been working with is getting the lights to change state properly using the FSR sensors.

20181127_125247.jpg

This week we are beginning the fabrication of the console and hanging apparatus. Final user testing will be done as well.

PCOMP Final: Reverie Field

The Idea:

The idea for the Physical Computation final project began with me thinking about memory and how people are able to, in some sense, manipulate their memories and really start to live in them like daydreams.

Out of this idea and collaboration with Jenny Lin, the Reverie Field was formed.

Thematic outline: The Reverie Field stores the memories of a user and transforms them in such a way so that the user must think about and dive deeper into the emotions that are connected with each particular memory. The emotions brought up in each person are byproducts of them really spending time focusing on those memories.  

At the end of the experience the lights drop down, surrounding the person. At this point the user feels an attachment to the lights and the thought that they are now surrounded by their memories.

Major Functional Elements:

The major functional elements of the piece are the console unit, the light array, light dropping mechanism, and the narrator.

A breakdown of how each element interacts with the others is as follows:

  1. The user approaches the console and see a glowing palm print on it.

  2. User puts hand on the glowing space and that activates the light array initially.

  3. the user is then prompted to put on the headphones.

  4. After listening to the prompt the user uploads their memory to the array.

  5. The array and user interact with each other (not completely sure on what happens yet)

  6. The user is prompted to walk under the array.

  7. The lights drop around the user and the interaction is complete.

Space needed: Around 6’’ from the console to the array space. the diameter of the hanging array will ideally be around 10’’

System Diagram:

This basic system diagram shows how the user interacts with the piece and then how the piece responds. At this point there is a feedback cycle between the light array and the user choosing the specific emotional state brought up by the memory. This allows the user to experience a wider variety of effects put on by the lights.

Initial Bill of Materials:

Screen Shot 2018-11-07 at 11.31.07 PM.png

Initial thoughts on the bill of materials are that we will need to do a lot of scavenging for parts to keep the cost down or find alternative methods of making portions of the project work. Mainly when it comes to motors, relays, powertails, and the gear box mechanisms.

Timeline:

Screen Shot 2018-11-07 at 11.33.20 PM.png

This timeline is meant to really front load the prototyping and fabrication to give us enough time to pivot in the project if we need to. It also allows us time to really focus on getting everything to work properly and make sure the meaning of the project comes across to the user.

Initial Final Project Ideas

Meaning vs. Technical Process

I have been thinking a lot about possible ideas for the final Physical Computing project. Creating something interesting to me that properly meets criteria for the class and is scalable to a possible Winter Show project has been difficult. Below are a few ideas for final projects. Each idea ranges in scope and sentiment behind. None of them are fully thought through and are still rough ideas at the least I think that there may be something in one or two of them that I can work with.

1.

For a while I have been thinking about taking my experience working in prison reform and what I have learned from that field and making a project that involves data about problems in the corrections world. My thoughts for this would either be a somewhat immersive interaction between the user and a manufactured space or a physical visualization of issues with the corrections world through a map and other visual cues.

2.

The second idea I’ve been thinking about involves googles location tracking services. More so that every month I receive an email from google that gives a full breakdown of places I have visited, Miles walked, and more. When I have looked through these emails I’ve noticed that seeing the places on the map linked in the email bring back memories of when I visited those places. Whether it be where I had a date or hung out with friends.

Thinking about this made me realize that my digital self, or the version of me that google remembers doesn’t carry those memories. But at the same time it could be distorting memories and feelings of the places it shows. So my idea would be to push forward with how our digital worlds affect our physical selves. This wouldn’t be in dystopian type way but more in how feelings and emotions are easily manipulated by shoing this data and information

3.

The final idea is more of a piece on introspection and how people really understand each other. I’m not totally sure which direction I would want to take this in but I will update when I am sure.

The Haunted Window

The Idea:

For the PCOMP Midterm Project Zhe Wang and I created a Horror themed window display. Requirements for the project stipulated that the project be interactive, have a halloween party theme, and utilize serial communication in some way. Recently I have been really interested in public works of art and just putting pieces in a space and seeing how random passerby’s interact with them. After iterating through a few ideas with public spaces in mind we first thought about using a door then after some time we settled on a window.

It was important for us to focus on drawing people into the interaction and try to have them feel immersed in experience when viewing it.

received_341071519799604 (1).jpeg

Functionality of the Piece:

  • Curtain that opens and closes when user gets within a certain distance of the installation.

  • Sounds that are dependent on the user’s distance.

  • Startling element inside of the display. (End result was a doll with a spinning head)

  • Interactive lighting effects

Trials and Error of Fabrication:

We knew that one of the most difficult parts of getting this project to be feasible was going to be getting the window so we made that a priority. Luckily we were able to find one on our first try at the big reuse in Brooklyn. After that we got the plywood from Home Depot and the doll from a halloween store and rest of the non technical supplies from the soft lab.

The fabrication portion of the project was one of the most labor intensive parts of the project. It included building the container for the window and materials, and building the “chair” for the doll to sit on, and the mount for the inner dc motor.

20181016_190516.jpg
20181020_151355.jpg

Prototyping:

Prototyping for the project included working with the two motors (One Stepper and one regular DC) to make sure that they functioned properly in the environment. It also included building out the lighting display. After all of the pieces were working separately one a breadboard I perf boarded out two separate circuits for the motors, lights and ultrasonic sensor.

20181024_015001.jpg
IMG_2307.jpg

Interactivity and the Workings of the Project:

The final piece had the following elements:

  • When the user walks within 100cm of the window from the front the lights change from white to red and the noise being output from the box changes to a disturbing tone.

  • Shortly after the curtain opens and the user is greeted by a terrifying doll. Within a few seconds the doll’s head begins to spin rapidly.

  • After a few seconds of this the dolls head stops and the curtain shuts.

  • The piece then resets and waits for the next user to approach

The main sensing component for the project was a standard ultrasonic sensor that would send bits of data to p5 from Arduino.

Final Piece:

Below you can watch a short video of the piece being interacted with.

Here is the code for the project:

p5 Code:

/*

Zhe Wang and Morgan Mueller

Physical Computation 2018 Midterm Project P5 code.

The main purpose for this p5 sketch was to communicate with the arduino

serially and play selected sounds when the data being sent in

meets a certain criteria

*/

//define noises

let noise;

let noise2;

let noise3;

let noise4;

let noise5;

let enticingNoises = []

//define serial variables

let serial;

let fromSerial;

let called = true;

let countdown = 0;

let delay = 2000;

let noiseBool;

//load sounds into the program

function preload() {

soundFormats('wav', 'mp3');

noise = loadSound('helpMe.mp3');

noise2 = loadSound('distortedVocals.mp3');

noise3 = loadSound('playWithMe.mp3');

noise4 = loadSound('imSoScared.mp3');

noise5 = loadSound('child_laugh.mp3');

enticingNoises = [noise, noise3, noise4, noise5];

}

function setup() {

createCanvas(500, 500);

// make a new instance of serialport library

serial = new p5.SerialPort();

// callback function for serialport list event

serial.on('list', printList);

// callback for new data coming in

serial.on('data', serialEvent);

// list the serial ports

serial.list();

// open a port

serial.open("/dev/cu.usbmodem1421");

noise.setVolume(0.5);

noise2.setVolume(0.5);

background(0, 0, 0);

}

// function playNoise() {

// if (fromSerial < 50) {

// print("hello");

// noise2.play();

// } else {

// noise.play();

// noise.loop();

// console.log(fromSerial);

// }

// }

function draw() {

}

function printList(portList) {

for (var i = 0; i < portList.length; i++) {

// Display the list the console:

print(i + " " + portList[i]);

}

}

function serialEvent() {

// this is called when data is recieved, data will then live in fromSerial

fromSerial = serial.read();

print(fromSerial);

//if the person is within 100 cm then play the defined sound

if (fromSerial < 100 && !called && millis() - countdown > delay) {

noise.pause();

noise2.amp(100);

noise2.play();

//noise2.pause();

//noise5.play();

countdown = millis();

print("called 1");

called = true;

}

//if there is no person being sensed then play the other sound

else if (fromSerial > 100 && called && millis() - countdown > delay) {

//for (let i = 0; i < enticingNoises.length; i++) {

noise2.pause();

// noise.amp(100);

// noise.play();

// noise.loop();

// noise.pause();

noise3.amp();

noise3.play();

noise3.loop(); t

// noise4.play();

// noise4.pause();

countdown = millis();

print("called 2")

called = false;

noiseBool = false;

}

}

Arduino code:

/*

Zhe Wang and Morgan Mueller PCOMP Midterm 2018

*/

#include <Stepper.h>

#include <Adafruit_NeoPixel.h>

#ifdef __AVR__

#include <avr/power.h>

#endif

#define PIN 6

//pin instantiation for distance sensor

const int trigPin = 2;

const int echoPin = 3;

//pin instantiation for dc motor

const int firstDCPin = 4;

const int secondDCPin = 7;

const int dcEnablePin = 5;

bool test = false;

//stepper revolutions

const int stepsPerRevolution = 1536; // change this to fit the number of steps per revolution

// for your motor

// initialize the stepper library on pins 8 through 11:

Stepper myStepper(stepsPerRevolution, 8, 9, 10, 11);

Adafruit_NeoPixel strip = Adafruit_NeoPixel(56, PIN, NEO_GRB + NEO_KHZ800);

long duration; //duration in microseconds

int distance; // distance in cm

void setup() {

Serial.begin(9600);

// set the speed at 180 rpm:

myStepper.setSpeed(20);

// initialize the serial port:

pinMode(trigPin, OUTPUT);

pinMode(echoPin, INPUT);

//LED Strip

strip.begin();

strip.show(); // Initialize all pixels to 'off'

strip.setBrightness(70);

//DC Motor pins

pinMode(firstDCPin, OUTPUT);

pinMode(secondDCPin, OUTPUT);

pinMode(dcEnablePin, OUTPUT);

//set enable pin high so motor can turn on

digitalWrite(dcEnablePin, HIGH);

}

void loop() {

//colorSwap(strip.Color(255, 255, 255));

// distance sensor functionailty

digitalWrite(trigPin, LOW);

delayMicroseconds(10);

digitalWrite(trigPin, HIGH);

delayMicroseconds(10);

digitalWrite(trigPin, LOW);

duration = pulseIn(echoPin, HIGH);

//calculate the object's/person's distance

distance = duration * (0.034 / 2);

Serial.write(distance);

//if the distance is less than 50cm or ~ 24 inches, then start the interaction

if (distance < 100 && test == true) {

//change the color of the led strip to red

delay(50);

colorSwap(strip.Color(255, 0, 0)); // Red

delay(10);

//pull the curtain back to the wall

myStepper.step(stepsPerRevolution);

delay(5000);

// delay(5000);

//some event needs to happen here in between the motors

//the stepper pulls the curtain back to open the curtain one more time

//myStepper.step(stepsPerRevolution);

digitalWrite(firstDCPin, LOW); // set leg 1 of the H-bridge low

// delay(10);

digitalWrite(secondDCPin, HIGH); // set leg 2 of the H-bridge high

//test = true;

delay(500);

digitalWrite(firstDCPin, LOW); // set leg 1 of the H-bridge low

// delay(100);

digitalWrite(secondDCPin, HIGH); // set leg 2 of the H-bridge high

delay(5000);

//test = true;

digitalWrite(firstDCPin, LOW); // set leg 1 of the H-bridge low

// delay(100);

digitalWrite(secondDCPin, LOW); // set leg 2 of the H-bridge Low

delay(500);

//the curtain goes back to the wall

myStepper.step(-stepsPerRevolution);

delay(5000);

test = false;

}

else if (test == false && distance > 100) {

colorSwap(strip.Color(255, 255, 255)); // White

// Serial.print("Distance: ");

// Serial.println(distance);

test = true;

}

}

//change color of the led strip

void colorSwap(uint32_t c) {

for (uint16_t i = 0; i < strip.numPixels(); i++) {

strip.setPixelColor(i, c);

strip.show();

}

}

Connecting P5 with Arduino

Assignment

This week in PCOMP we covered basic serial communication and how to connect p5.js with Arduino. The labs had us setting up the serial communication protocols and interfaces that we will be using throughout the rest of the semester. This meant downloading the serial controller app and using the github repository for porting the arduino code that was written by Shawn Van Every. the use of serial communication in this way creates a whole new range of possibilities for using both Arduino and Pt.

After the initial labs, the homework was to make a serial application that controls an animation project using analog inputs. I decided to control one of my more recent ICM homework assignments using a couple of potentiometers.

Here is a link to the original assignment.

I decided to have the potentiometers change different portions of the sinusoids, the opacity of the lines being drawn, and when in combination, the direction of the rotation.

Below are a few videos showing the animation with analog controls.

this assignment was a good introduction to the basics of serial communication between the two platforms.

Midterm Project Status

For our midterm project, Zhe and I are building a Haunted window interaction. the premise of the interaction will be that a user walks up to the window and sees a closed curtain. The curtain will then open, partially, and a light will turn on in the middle of the apparatus. Some more events that are not completely defined will come after. Below is a mockup of the window apparatus and sketch of display.

received_341071519799604.jpg

Hi, How Are You - Not Totally Functional (But It's Okay)

Recently, I have been going through my record collection and came across the album “Hi, How Are You” by Daniel Johnston. On the cover there is an interesting little frog creature; I wanted to make this weeks assignment based around this frog. I decided to try my hand at using the laser cutter to make the frog since I haven’t used it before. The process of creating the file and using the actual laser cutter was much easier than I had previously thought and quite enjoyable. The finished cut is shown below.

20181003_103525.jpg

I wanted to make it interactive so I decided to use a noise detection sensor as the input and have the frog react by making its eyes light a few different colors and having it pivot when a person spoke to it. these actions required:

1 - FC-04 Sound Sensor

1 - Servo

2 - RGB LEDs

6 330 ohm resistors

The schematic is shown below:

 Figure 1. Responsive album schematic

Figure 1. Responsive album schematic

(Fritzing did not have the exact noise sensor schematic piece so I substituted and left the NC of the chosen piece open)

20181004_114237.jpg

After creating the circuit I began to try and fine tune the noise sensor. Documentation I read online said that it’s internal potentiometer was very sensitive and if the voltage tigger point (VTP) was not in the exact right spot then the sensor’s voltage would get stuck at either HIGH or LOW and trigger the output immediately without any smooth transition. I was able to see this problem immediately when I began running and debugging my code.

It turned out that the sound sensor would continually cause me problems no matter what I had sent the potentiometer to. Retrospectively, I should have had a backup sensor that I knew would work but given that I didn’t give myself the time necessary to pivot and work the project in another direction. It is possible that there were other self-driven errors which caused the sensor to not function properly as well. Given the nature of the issue and the fact that I wasn’t able to fix it, I didn’t take the project as far as I wanted to in terms of functionality and casing but am going to keep playing with the sensor and seeking outside help to see if the error is an oversight on my part.

CODE:

#include <Servo.h>
int soundSensor = A0;
Servo servoMotor;
int servoPin = 3;
int LED1_red = 4;
int LED1_green = 5;
int LED1_blue = 6;
int LED2_red = 7;
int LED2_green = 8;
int LED2_blue = 9;
int sensorVal = 0;
void setup() {
  //set sound sensor to input
  pinMode(soundSensor, INPUT);
  //set rgb led pins to outputs
  pinMode(LED1_red, OUTPUT);
  pinMode(LED1_green, OUTPUT);
  pinMode(LED1_blue, OUTPUT);
  pinMode(LED2_red, OUTPUT);
  pinMode(LED2_green, OUTPUT);
  pinMode(LED2_blue, OUTPUT);
  servoMotor.attach(servoPin);
  Serial.begin(9600);
}
void loop() {
  // read the noise sensor and set it equal to sensorVal
  sensorVal = analogRead(soundSensor);
  Serial.println(sensorVal);
  //map sensor value to a smaller range
  int sensorRead = map(sensorVal, 0, 1023, 0, 179);
  //Serial.println(sensorRead);
  digitalWrite(LED1_green, HIGH);
  // digitalWrite(LED2_red, HIGH);
   //read the servopin
  int analogValue = analogRead(servoPin);
  //map the servo to an angle
  int servoAngle = map(analogValue, 0, 1023, 0, 179);
  if ( sensorRead > 500 ) {
    servoAngle ++;
  }
  else if (sensorVal < 500) {
    //    servoMotor.write(servoAngle -= 1);
    servoAngle --;
  }
  servoMotor.write(servoAngle);
  //write green LED high if the servo's angle is > 90
  if (servoAngle > 90) {
    delay(50);
    digitalWrite(LED1_green, HIGH);
    delay(50);
    digitalWrite(LED2_green, HIGH);
  }
  //set all leds low otherwise
  else {
    digitalWrite(LED1_green, LOW);
    digitalWrite(LED1_blue, LOW);
    digitalWrite(LED1_red, LOW);
    digitalWrite(LED2_green, LOW);
    digitalWrite(LED2_blue, LOW);
    digitalWrite(LED2_red, LOW);
  }
}

Cashless Metrocard Machine Observation

I decided to observe the use of a cashless metrocard machine for this last week’s Physical Computing assignment. I chose the metrocard machine on the Bogart St, Morgan Ave L train stop because it is a highly trafficked stop in my neighborhood. The purpose of these machines is to dispense new metrocards, refill existing cards, and to check the available balance on cards.

I observed people using the machine around rush hour, so it seemed that a majority of the people using it at that time lived in the area and were commuting to work. I watched 10 or so people use the machine and the part that held people up the most, from what I could tell, was swiping the card. There are no clear instructions on how to insert the card. Whether you should leave the card in or pull it out is not made clear and even if a person has used the machines before there are still issues with the swiping.

The touch screen interface was very quick and responsive for the people using the machine. Navigating the different pages seemed easy for people and not much backtracking needed to be done. I have to admit that if I had been doing this observation somewhere more tourist centered that may have yielded different results but being that these machines need to be streamlined and allow the everyday commuter to use quickly I think the observation was fair. Finally, The average time each person spent at the machines was around 15 seconds.

If there was a cash accepting machine next to the cashless one it would have been interesting to compare the accessibility of both.

20180927_091600.jpg

When looking for accessibility options on the machine I was able to see a few design elements. The first being braille and an audio jack next to the touch screen. After doing a bit of research online I was able to find that the braille gives instructions to visually impaired people to use the audio jack to give audio and personal keypad instructions to the machine instead of using the touch interface. The design of the machine is not trying to hide any of the accessibility features like the color coding or braille signage. Instead it takes the opposite approach and makes those features prominent and works the rest of the design around them.

flowing LEDs

Idea and Design

Homework 3 required students to create a circuit using using both analog and digital components. One type of circuit I have always enjoyed is the led chaser. This circuit is an array of LEDs turning on and off in a predetermined manner. I decided to use a potentiometer to control the speed of the LEDs turning on and off. Below you can see the schematic of the circuit.

 Figure 1. Potentiometer Driven LED Chaser Circuit

Figure 1. Potentiometer Driven LED Chaser Circuit

I decided to utilize all twelve digital out ports(pins 2-13) of the Arduino to drive 12 LEDS with the potentiometer’s wiper connected to the A0 port. After wiring, programming the Arduino, and some minor debugging of the code the circuit worked as expected.

 Figure 2. Photo of the fully wired circuit.

Figure 2. Photo of the fully wired circuit.

As shown above, when the potentiometer is twisted clockwise the speed at which the LED’s turn on and off begins to increase until the potentiometer is fully turned and the LEDs start to look like they are just flickering. It was enjoyable using the potentiometer to make this circuit and I began thinking of other analog inputs to control the LEDs, like a IR sensor or force sensor.

I decided to attempt to add more functionality to the circuit by adding a push button and having a state where if the button was pressed then the potentiometer’s location would dictate which led was on. After spending some time on this I wasn’t able to reach full functionality.

 Figure 3. Modified circuit with pushbutton added.

Figure 3. Modified circuit with pushbutton added.

This project got me thinking about different ways that these types of circuits could be used. Not just to drive LEDs but other larger more scalable projects.

Below you can see the code for the Chaser Circuit and additional, less functional circuit:

CODE

/*
 * Morgan Mueller 
 * PCOMP Homework 3
 * Basic LED chaser circuit
 * 
 */
int ledPin = 0;
int potPin = A0;
int btnSwitch = 2;
int chooseLED = 0;
int chooseLastLED = 0;

// set all LEDs and the button to their designated states
void setup() {
for (ledPin = 3; ledPin <14; ledPin++){
pinMode(ledPin, OUTPUT);
  }
  //push button for second part of code
  pinMode(btnSwitch, INPUT);
  pinMode(chooseLED, OUTPUT);
  pinMode(chooseLastLED, OUTPUT);
}

void loop() {
  //if the button is not pressed then run the led chaser circuit
  if(digitalRead(btnSwitch) == LOW){
    //write the value of the ledPin
    for (ledPin = 3; ledPin < 14; ledPin++){
      digitalWrite(ledPin,HIGH);
      //use a delay and mapping to read the value of the pot and map it to a time between 1000ms and 10ms
      delay(map(analogRead(potPin),0,1023,1000,10));
      //turn of the led
      digitalWrite(ledPin,LOW);
    }
  }

  else{
    //map the pot value to the current led position
    chooseLED = map(analogRead(potPin), 10, 1023, 3, 13);
      //check to see if the current state is = the last state 
      if(chooseLED != chooseLastLED){
    digitalWrite(chooseLastLED, LOW);
      }
    //write to the current led state  
    analogWrite(chooseLED,HIGH);

    //set the last led state to the current led state
    chooseLastLED = chooseLED;  
    }
  
}

Labs

Elvin Yu and I worked on the labs together, including the digital input and analog input portions. Below are photos from the basic analog and digital input assignments. You can find the Arduino code for the projects here:

The LED Fortune Teller

Design

Part of the Week 2 labs required students to make their own switching circuit with a switch of their creation. After thinking about the idea for a bit I saw a paper fan online and started thinking about those joke fortune tellers that everyone made as kids. I decided to make a circuit that would turn on an LED whenever a person’s “fortune” was told. I wanted to embed an LED in the fortune teller and have the person controlling the teller be make the switch connect whenever they wanted.

The circuit I designed was extremely simple and quick to prototype out on the breadboard.

 Schematic 1. Basic Switching Circuit to turn on LED

Schematic 1. Basic Switching Circuit to turn on LED

Creation

Using copper tape I was able to make a switch that could be hidden underneath the fortune teller while it was being used.The process of creating the circuit was quite simple. The biggest issue was making sure that the connections made by the copper under the fortune teller were strong enough to make the LED light up.

 photo of the circuit setup being created.

photo of the circuit setup being created.

The exercise and all labs were good refreshers on switches and basic circuit design/function.

 Top Down view of working circuit.

Top Down view of working circuit.

The Rest of the Labs

Along with the creative switching circuit, the labs required students to put three switches in parallel with an led at the end, then modify the circuit to put the three switches in series and seeing how the circuit acted after that. Once those were completed a circuit with a small DC motor and switch was created and tested out. Finally, an led was added to the switching dc motor circuit.

Below you can see photos of each circuit.

 Parallel Switching Circuit

Parallel Switching Circuit

 Series Switching Circuit

Series Switching Circuit

 DC Motor Switching Circuit.

DC Motor Switching Circuit.