Jiawei’s midterm project—Colorful umbrella

March 31, 2015April 7, 2015jl5656 Leave a comment

For the midterm, we are asked to create a piece of fabric that can sense something people couldn’t sense, or can convert an input to an output. My idea is to visualize the rain, because I really like the sound of rain dropping on the umbrella, thus I thought it would be great to also see it. My general idea is to use sensor to detect how strong the rain is and then to have interactive LEDs inside. I did many researches and found that there are many similar or related projects online. They are super cool. You can have a look if interested:

Visual effects

https://www.youtube.com/watch?v=pLBwa4QwMNM

https://www.youtube.com/watch?v=39MujY-vDbc

Sound effects

http://www.geek.com/geek-cetera/make-walking-in-the-rain-musical-with-the-8-bit-umbrella-1493543/

Practical use for sensor on an umbrella:

http://www.bbc.com/news/science-environment-27222282

Built on the common characters of these projects, first I want to make visual effects more dynamic and diverse. Second, I wanted to make this a removable decoration like the lights on Christmas tree, so that on one way you don’t need to worry about how to close the umbrella (thre are different kinds of umbrella; some of them fold many layers where closed and are not friendly to any internal circuits…), on the other hand, you can put it on different umbrellas according to your own preference. So at last after I made a twinkling and fading umbrella:

P.S. This has become my favorite selfie for now. I didn’t use any filter, but I guess the lens of an old Samsung cell phone is kind of a natural filter…

So there are mainly 2 phases of my project:

First I worked on the circuits with Arduino board to develop the effects I expected. Initially I wanted to directly do programming use Lilypad, considering it would be easier to put on an umbrella. But Antonius suggested to first making things actually work on a usual Arduino. I used vibration sensors. When the rain is not very heavy, common LEDs of different colors (red, blue, green, yellow and white) will blink with the rhythm of the rain, when the rain is heavy enough, which will lead to the aggressive blinking of LEDs, the common ones will die out and the fancy RGB LEDs out on the stage, They will fade between different mixed colors. Basically I built different part of the circuits and wrote the corresponding codes separately and put them together.

You can find my codes here: codes

The second phase is basically to transform the circuits from breadboard to umbrella, which was actually the real exhausting and difficult part. The first step is to soldering the real circuits. I’d never done this before. Vivian taught me when she helped my fix the broken wire on my sensor. In the beginning, of course, I was clumsy. I burned the plastic cover of irrelevant wires and nearly burnt my fingers one time. Gradually I get used to it and after many hours I managed to get a bunch of circuits in my hand. I didn’t choose conductive threads because the fabric on umbrella will have a lot of motions. Conductive threads in this case are easy to touch each other and cause short circuits.

Then I worked on fabrics, finally. I planned to fix the circuits to a piece of fabric which is exactly the shape of umbrella and then attach the fabric to the umbrella frames, so that I can both hide the tangling wires and make this decoration removable. I used Velcro to attach the fabric to the umbrella. I started with sewing machine but soon turn to hot glue, which wre faster, as there were piles of things to be fixed together and I really didn’t have much time first.

After that it was time to put circuits to the fabric. Similar with above, I tried couching first and only to find that it was time-consuming and not very stable. So I turn to 502 glue, which, as always, never disappointed me.

Now putting all these together after my great efforts (toil):

I am pretty satisfied with my project. But there are many places where needs improvement but I either don’t have time to do it or don’t know how to do it:

I’m still not over with Lilypad. You can see that scary stream of wires along the handle of my umbrella and that messy pile of wires down there. Also I haven’t attached the sensor to the top of umbrella, because I need to return it to lab and I. Another thing is the power, I definitely should use battery if I want to actually carry it into the rain. With Lilypad these can all be solved.
The fabric is not so well fixed to the umbrella cover. Maybe more velcro or buttons.
Initially I planned to made white tulle into small pocket in shape of water drop and wrap it around each LED inside the umbrella cover. It not only makes it more fun to see, but also soften the light of LED, making it incredibly beautiful, thanks to the magical texture of tulle (you can have a look at the video below to check what it likes). I have made some prototyped before and Antonious gave me great suggestion on how to fix two piece of tulle together. However, when I finished the major steps above and wanted to do this final refinement, I found that white tulle had run out… So, maybe next time.

I really enjoyed my project, not only the shiny umbrella itself, but also the process of building it. I really learned a lot and had great fun!

Lab 8: 象棋：Elephant Chess-Connie and Lily

March 31, 2015August 26, 2015Lily 1 Comment

In today’s lab, we finally tried the most exiting thing–3D modeling!! It is not that hard, but you need to be very very patient, especially when moving different shapes around to the accurate position you want. I was first impressed by a moveable elephant, which made me want to want to model a zoo based on it. But then a interesting idea come up in my mind: Placing an elephant on a chess board! I know it sounds a little bit weird, but it’s actually very cool, if you understand some Chinese. “Elephant” in Chinese is “象”，and “Chess” in Chinese is “象棋“. So basically Chinese call chess “象棋“ (literally translated into elephant chess), although there’s no relationship between elephants and chess at all. So I decided to “form” some relationship between these two objects. It’s also a combination of Chinese and western culture. And Connie couldn’t log in with her account, so she joined me with constructing this project. We aim at creating a juxtapose of “elephant” and “Chess”, making this language connection a real, physical connection.

When starting to work on this project, some difficulties came up. For example, because we don’t have color of black and white, we can’t differentiate colors of a chess board. But instead, we chose to use projection and depression to represent white and black. We also paid attention to the conjunction between elephant an board, between chessmen and board, depending on whether we want these two parts connected or separated.

Jiayi and Jamie’s lab 6

March 31, 2015August 26, 2015Jamie Zhang Leave a comment

===============================Jiayi=========================

in Lab 6, we built a circuit that allowed our mouse to control the buzzer and the color and location of a ball on the screen is determined by temperature through a sensor.

The basic structure of the circuit is based on example No.7.

QQ20150331-1

However, the description of the feets on the data sheet of LM35 is different from the actual one.

QQ20150331-2

(5V and ground is opposite with the one we have)

So at the beginning the sensor didn’t work at all and almost burnt itself up.

As for the code , I did the processing part

import processing.serial.*;

Serial myPort;

float serialVal;

void setup()

{

size(255, 255);

println(Serial.list());

myPort = new Serial(this, “/dev/tty.usbmodem1421”, 9600);

background(255);

stroke(0);

}

void draw() {

background(255);

if (myPort.available() > 0) {

serialVal = myPort.read();

println(serialVal);

fill(serialVal,225-serialVal,serialVal);

}

//rect(20, 20, width-40, height-40);

ellipse(width/2, serialVal, 30,30);

}

void mouseMoved() {

myPort.write(mouseY);

println(mouseY);

}

============================Jamie============================

The code on Arduino is as followed

int tempSensorVal;

int prevVal = 0;

int toneVal = 0;

void setup(){ ;

Serial.begin(9600);

pinMode(8, OUTPUT);

}

void loop(){

tempSensorVal = analogRead(0);

int val = (int)map(tempSensorVal, 52, 68, 0, 255);

/*Serial.print(tempSensorVal);

Serial.print(” “);

Serial.println(val);*/

if (val != prevVal){

Serial.write (val);

delay(100);

}

prevVal = val;

if (Serial.available() >0){

toneVal = Serial.read();

}

analogWrite(8,toneVal);

}

I searched online for the example in our arduino kit which combine the buzzer with the temperature sensor. Unfortunately, however, it wasn’t a simple work as merely copy and paste. We attempt to map the data from the temperature sensor to the range of screen’s y axis, and the y coordinate of the mouse to the buzzer’s input. In order to achieve a sensitive reaction, we have tested and adjusted the original temperature scale for several times.

IMG_0272

Cheryl’s Lab 8

March 31, 2015August 26, 2015sl4642 Leave a comment

So… This is my first work with purely Tinkercad. And as its name suggests, it is a poisoned duck. Because it’s color and its weird-shaped eyes. So what I did is basically used a lot of “egg”s and change its width/height and make it into different shapes and directions.

Then I downloaded a super cool mask from Thingiverse and combined it with the poisoned duck. And we got this demon duck! Because it looks kinda creepy and weird.

What I have made is quite easy, but through this, I saw how useful and creative it can be!

Young Wang Lab 8

March 31, 2015August 26, 2015xw786 Leave a comment

I made the hammer of Thor.

https://tinkercad.com/things/4jeTqqZMZiu

Interaction Lab 8 – Tristan A

March 31, 2015August 26, 2015Tristan Armitage Leave a comment

For this project I made a pen using Tinkercad, then added chain links which I found on Thingiverse. I decided on a pen because I usually take a while to come up with ideas, so I thought using a real object I had with me would speed up the process. This also allowed me to take real measurements so that my design was more realistic. Here is the pen by itself:

After I recreated the pen I wasn’t sure what to add, but I found a chain link from a project on Thingiverse which I downloaded and added to my own project. I had to modify the chain link to make it fit within the pen’s clip. Then I copied the new link and made a short chain. Here is the result:

This was a fun project that centered around learning the controls of Tinkercad, which certainly took some getting used to. It was frustrating that the camera always focused on the center of the grid, so when my object was off center it was difficult to manipulate. In the end, though, I am pleased with the outcome.

TF Midterm Project: Tapestry of Life — Naomi Y Losman

March 31, 2015March 31, 2015nyl232 Leave a comment

For the midterm I decided to continue working with my touch project by adding an additional electronic component to enhance the sensory experience. For the touch project I wove and dyed a series of patches varying in texture from very soft and plush to thin and course, then sewed them together to create a long gradient of fabric. This was meant to represent the coarsening at we all experience throughout life, both physically and mentally. You can read more about this initial process in my Touch Project post.

After some helpful suggestions from fellow classmates during my presentation of the initial project I decided to add sound to my project. To do so I had to work with both Arduino and processing, as well as more fabric in order to create buttons within the project. As you can see in the rough sketch above, I decided to make a sort of fabric sandwich by weaving and sewing a second piece of textured fabric to act as the project’s backing, then two thinner pieces of fabric to embed the electronics within the two woven pieces.

Spinning Thread

Prototype 1 Test

Soft Prototype Test

First I built a prototype of the circuit,both on the breadboard, then using felt and conductive tape, with the arduino to get a grasp of what I was doing, made sure everything worked, then moved on to making the actual buttons. I made these by taking a thin, long, narrow piece of muslin and stitching three pairs of X’s and Crosses across it using conductive thread, then I cushioned the buttons with felt. Later it was pointed out that the felt wasn’t thick enough to stop the buttons from connecting constantly, so I cushioned the connections further with some fluffy stuffing.

Next I connected the individual sections of conductive thread to wires, that I then couched into the muslin and soldered into place over the conductive thread to hold them still.

Soft Button Test

Next I connected the individual sections of conductive thread to wires, that I then couched into the muslin and soldered into place over the conductive thread to hold them still.

Once the wires were in place I adjusted my arduino prototype to use the fabric buttons instead of the ones on the breadboard, and turned my focus to coding. With some help from Antonius and Vivian I was able to successfully connect my Arduino to processing using the below code.

Arduino Code:

/* Basic Digital Read

* ——————

* turns on and off a light emitting diode(LED) connected to digital

* pin 13, when pressing a pushbutton attached to pin 7. It illustrates the

* concept of Active-Low, which consists in connecting buttons using a

* 1K to 10K pull-up resistor.

* Created 1 December 2005

* copyleft 2005 DojoDave <http://www.0j0.org>

* http://arduino.berlios.de

int ledPin = 13; // choose the pin for the LED

int inPin7 = 7;

int inPin8 = 8;

int inPin9 = 9; // choose the input pin (for a pushbutton)

int val7 = 0; // variable for reading the pin status

int val8 = 0; // variable for reading the pin status

int val9 = 0; // variable for reading the pin status

void setup() {

pinMode(ledPin, OUTPUT); // declare LED as output

pinMode(inPin7, INPUT); // declare pushbutton as input

pinMode(inPin8, INPUT);

pinMode(inPin9, INPUT);

}

void loop(){

val7 = digitalRead(inPin7); // read input value

val8 = digitalRead(inPin8); // read input value

val9 = digitalRead(inPin9); // read input value

if (val7 == HIGH || val8 == HIGH || val9 == HIGH) { // check if the input is HIGH (button released)

digitalWrite(ledPin, LOW); // turn LED OFF

}

else {

digitalWrite(ledPin, HIGH); // turn LED ON

}

Once this was accomplished I started looking for sounds to correlate to each button. I planned to place the buttons to accompany three specific periods of life – childhood, adulthood and old age. Using FreeSounds I was able to get three different sounds that could represent these stages of life well. Originally I had planned to only do one sound per button, but the coding was easier than I had expected, so I opted to make the buttons more interesting.

Screen Shot 2015-03-31 at 10.15.22 AM

Sounds:

Baby Talk

Bar Noise

Heart Beat

Heels on Marbel

Humming

Music Box

Old Man Laugh

Kids Play in Park

Whistling

Once my sounds were selected I transferred the .wav files, which could not be read in Processing, into .mp3 files using Adobe Audition. Then I focused on making the code for the buttons in Processing with Antonius’s help. It was a little tricky, but after a few attempts and tweaks, we managed to get the code working.

Processing Code:

import org.firmata.*;

import cc.arduino.*;

import processing.serial.*;

import cc.arduino.*;

Arduino arduino;

import ddf.minim.*;

Minim minim;

//Kid

AudioPlayer player1;

AudioPlayer player2;

AudioPlayer player3;

//Adult

AudioPlayer player4;

AudioPlayer player5;

AudioPlayer player6;

//Elder

AudioPlayer player7;

AudioPlayer player8;

AudioPlayer player9;

int counter1, counter2, counter3;

boolean soundPlaying = false;

void setup() {

size(470, 280);

arduino = new Arduino(this, “/dev/tty.usbmodem1411”, 57600);

// Set the Arduino digital pins as inputs.

for (int i = 0; i <= 13; i++)

arduino.pinMode(i, Arduino.INPUT);

minim = new Minim(this);

//Kid

player1 = minim.loadFile(“BabyTalk.mp3”);

player1.play();

player1.setGain(-80);

player2 = minim.loadFile(“MusicBox.mp3”);

player2.play();

player2.setGain(-80);

player3 = minim.loadFile(“playground.mp3”);

player3.play();

player3.setGain(-80);

//Adult

player4 = minim.loadFile(“Heels.mp3”);

player4.play();

player4.setGain(-80);

player5 = minim.loadFile(“humming.mp3”);

player5.play();

player5.setGain(-80);

player6 = minim.loadFile(“barsounds.mp3”);

player6.play();

player6.setGain(-80);

//Elder

player7 = minim.loadFile(“oldmanlaugh.mp3”);

player7.play();

player7.setGain(-80);

player8 = minim.loadFile(“whistling.mp3”);

player8.play();

player8.setGain(-80);

player9 = minim.loadFile(“heartbeat.mp3”);

player9.play();

player9.setGain(-80);

counter1 = 0;

counter2 = 0;

counter3 = 0;

// loops

player1.loop();

player2.loop();

player3.loop();

player4.loop();

player5.loop();

player6.loop();

player7.loop();

player8.loop();

player9.loop();

}

void draw() {

background(0);

fill(255);

if (arduino.digitalRead(7) == Arduino.HIGH) {

if (!soundPlaying) {

counter1++;

println(counter1%3);

}

if (counter1%3==0) {

player1.setGain(20);

} else if (counter1%3==1) {

player2.setGain(20);

} else if (counter1%3==2) {

player3.setGain(20);

}

} else {

player1.setGain(-80);

player2.setGain(-80);

player3.setGain(-80);

}

if (arduino.digitalRead(8) == Arduino.HIGH) {

if (!soundPlaying) {

counter2++;

println(counter2%3);

}

if (counter2%3==0) {

player4.setGain(20);

} else if (counter2%3==1) {

player5.setGain(20);

} else if (counter2%3==2) {

player6.setGain(20);

}

} else {

player4.setGain(-80);

player5.setGain(-80);

player6.setGain(-80);

}

if (arduino.digitalRead(9) == Arduino.HIGH) {

if (!soundPlaying) {

counter3++;

println(counter3%3);

}

if (counter3%3==0) {

player7.setGain(20);

} else if (counter3%3==1) {

player8.setGain(20);

} else if (counter3%3==2) {

player9.setGain(20);

}

} else {

player7.setGain(-80);

player8.setGain(-80);

player9.setGain(-80);

}

// if any of the buttons are being pressed, sound is being played.

if (arduino.digitalRead(7) == Arduino.HIGH || arduino.digitalRead(8) == Arduino.HIGH || arduino.digitalRead(9) == Arduino.HIGH) {

soundPlaying = true;

} else {

soundPlaying = false;

}

After I had the code down all I had to do was sew the top and bottom woven layers over the electron spine and voi la! my project was complete. I opted to sew it like this so I would still be able to access the inner electronics in case something went wrong.

Final Test

Unfortunately I found that, once I had some other people test it out, that it would have probably been a much more satisfying user experience to have more buttons, so that the sounds changed constantly as you run the length of fabric through your hands. Perhaps I will go back and explore more options to improve the project at another time.

Black and Yellow- By Tyler Rhorick (Talking Fabrics Midterm)

March 31, 2015Tyler Rhorick Leave a comment

For our midterm, we were assigned to make a fabric piece that would take an input (like sound, motion, or light) and produce an output. Having wanted to make clothing for awhile, I decided that this time around I would attempt to make a skirt that would take motion and produce it into light. As I started doing my research on this topic, I saw that similar things had been done before with accelerometers and fabric Arduinos on the market, but I couldn’t find any example of an Arduino Uno being used. I did not let this stop me though. After looking online for awhile, I realized that there was no pre-existing code for the Uno meaning I would have to make or modify my own. It was in this stage that I realized that Hunter Jarvis was also doing a similar project. She was using motion to light up a head piece, so we decided to work together. Working together, we were able to find a sample code for the accelerometer online that we were then able to modify to get an effect that we wanted. The code wasn’t perfect, since it seemed to require a lot of movement in one of the 3 axises to work, but it seemed good enough at the moment.

Then came the construction, which is always the hardest part. Wanting to make a skirt, I started looking up skirt tutorials online. As I was doing this, Antonius came over and suggested that I might make a circle skirt and showed me how I would block that out on fabric. Looking easy enough, I decided that this would be the best route of action.

Before I was able to block out the piece of fabric, I had to iron it. Which sounds easy enough, but when you are working with a large piece of fabric it can be a real pain in the …. you get the idea.

After ironing, it was time for blocking. To block I folded the large piece of fabric into quarters and then used the left bottom corner of the fold to draw my radius of my subject’s waist (Hunter). From this radius I made a circle quarter that when cut out would also cut through the other pieces of fabric. To do this drawing I attached a piece of string to a piece of chalk.

I did an outer quarter circle as well to be the length of the skirt. After this process, it was time to sew all of the pieces together. This process was made pretty easy because I used the machine. To give it cleaner sides I tried to fold the edges over so there would be no unfinished edges. The finished product was this:

To clasp the skirt, I decided to use velcro, since it would make taking the skirt on and off easier.

The next stage was the wiring. To do the wiring I decided to use yellow Chibitronic lights to match the color of lights that Hunter was using for her hat. To stitch this required making to relatively close circles one for positive and one for ground that could not touch in any way (if they touch it sparks!)

During this labor intensive process, I decided to take a few videos along the way.

IMG_0958

Theoretically- I could have stopped here and worked on something usefully like trying to attach the Arduino or sensor better, but I decided to work on aesthetics instead, which ended up being sort of a backwards step. I decided to cut a piece of black overlay to put on top of the skirt to hide some of the circuitry.

But in doing this—- I also sewed together the two distinct lines of electricity meaning that I was dealing with another potential fire hazard. After fiddling with this set up for awhile, I decided that it was better to cut the excess fabric and keep a working product. In the end this is what I got-

Final

Midterm Project: A Buzzing Black Thing

March 31, 2015August 26, 2015rkm290 Leave a comment

My midterm project has fallen from great heights, but luckily, I’ve learned a lot about integrating fabrics and electronics together. The original idea was to use some sort of sensor to make a bag that begins to glow as your hands approach it. I began by researching the different types of sensors that would be available to me. I wanted to try to use something that was simple and robust, so I stayed away from more advanced motion sensors or very constrained touch sensors. Eventually, I decided to go for a capacitive touch sensor because that would allow me to make the sensor as large as I wanted (because it could be made of a number of different materials) and it would let me make a sensor that didn’t have to be directly touched and could be hidden under fabric.

IMG_1233

At first things were going really well. I was very quickly able to get the capacitive touch sensor up and running and it worked very effectively–sometimes tracking my hand when it was 3-4 inches away from the surface. From there, however, things seemed to get more difficult. Try as I might I couldn’t find a good way to integrate the circuit into my bag or any bag that I might have been able to make. At first it was difficult to do prototypes because everything was on a arduino and a bread board which means it would usually disconnect when I put it into a bag. Therefore, I decided to solder the circuit that I was using onto little bits of board since it was a very simple circuit. This was fairly successful although there always seemed to be the occasional problem with the circuit not working properly. It sounds like it should have been fairly easy going from here but I simply couldn’t wrap my head around an effective way to integrate the circuit into the bag. At first I tried to make two bags, where I would wrap one in the other with a layer of tinfoil in between. Eventually, this layer of tin foil could be replaced with something like conductive fabric. Every time I tried this, though, something seemed to go wrong and I would have to take everything apart to see if the circuit was working.

Eventually, I decided to simplify things to establish the same kind of tech proof of concept but in a much more doable way. This involved using a little speaker instead of an LED, so that the entire circuit could be hidden away. What I ended up doing is making a little black pillow that beeps when you touch it, handle it or put your hands near it. It’s the same circuit that I originally used and it attaches to a piece of conductive fabric that is sewn in right under the black fabric that is on top. I also added some batting so that my project is fluffy and delicious. The noise that the speaker makes is really annoying so I think that conceptually the piece is interesting in as far as it is an object that in some ways resists interaction. It’s beeping makes it something that has an interactive element, but the interactive element is something that actually provides a negative incentive for interacting with it.