The project concept is a simple cozy covered in LEDs. Every 30 mins, the LEDs will start blinking. When the user picks up the bottle and slightly squeezes it to take a drink, the LEDs turn off and the timer restarts. The LEDs begin blinking again in 30 mins and the cycle repeats. The sensor is simply two pieces of conducting fabric that are connected by the users hand.

I started by laying out how I wanted the project to look. I decided to go with a zig zag pattern for the conductive fabric and horizontal stripes so that a hand would definitely connect two side by side stripes. The zig zag pattern was first printed on a piece of paper. One stripe was cut out and traced multiple times onto the conductive fabric and then cut out with an exacto knife.

I initially started with the LEDs on black triangles but this prevented good contact with the conductive fabric and was not used in the end.

Note that the LilyPad is in direct contact with the conductive fabric. This is not good because the back of the LilyPad is also conductive at points.

Thus, I made an extra insulating circle to go between the LilyPad and the cozy.

I also made a pocket to hide and to hold the battery.

After sewing on the pocket, ironing on the conductive fabric zig zags (it had heat sensitive glue on the back), and sticking on some velcro the cozy looked like this.

I then sewed on the LEDs and connected everything appropriately to the LilyPad Arduino.

The LEDs are very small and were soldered to little metal beads to make a sewable component.

The 11 pin on the LilyPad connects to the LEDs. The A5 pin connects to 1st, 3rd, and 5th stripes from the top. The – pin connects to the 2nd, 4th, and 6th stripes as well as the negative ends of the LEDs.

The finished circuit from the back looks like this.

Finished product.

This video shows the finished product working with a 10 second interval.




There are a few areas where this project could be improved. First, the LilyPad Arduino is not curved or flexible in any way. This means that it cannot sit flat against the side of the bottle. A different design may have not had an issue with this. To get around the curvature issue, only the pins that are parallel to the axis of the bottle were used. This means it can roll if necessary. Second, the cozy is not extremely durable. The LEDs have broken on several occasions. This could be due to the curvature of the bottle or due to the fact that the cozy is wrapped around the bottle quite tightly, which puts stress on the LEDs. The cozy must be wrapped tightly to prevent the bottle from slipping out the bottom when lifted. Third, it would be nicer if the cozy did not have to wrapped so tightly. This might be fixed with something like rubber placed between the bottle and the cozy.

Arduino Code:

// This code was modified from the Stopwatch code by Paul Badger in 2008
// http://www.arduino.cc/playground/Code/Stopwatch

// these constants don’t change:
const int ledPin = 11; // LED connected to digital pin 13
const int fabricButton = A5; // fabric button input to pin A0
const int threshold = 900; // threshold value to decide when fabric button connected
const int timerInterval = 10000; // interval to wait for next blinking: sec*1000

// these variables will change:
int value = LOW; // previous value of the LED
int blinking; // condition for blinking – timer is not timing
long interval = 100; // blink interval – change to suit
long previousMillis = 0; // variable to store last time LED was updated
long startTime ; // start time for timer
long elapsedTime ; // elapsed time for time

int sensorReading = 0; // variable to store the value read from the sensor pin
int ledState = LOW; // variable used to store the last LED status, to toggle the light

void setup()
{
pinMode(ledPin, OUTPUT); // sets the digital pin as output
pinMode(fabricButton, INPUT); // sets the analong pin to input
digitalWrite(fabricButton, HIGH); // turn on pullup resistors. Wire button so that press shorts pin to ground.
Serial.begin(9600); // use the serial port
}

void loop()
{
// read the sensor and store it in the variable sensorReading:
sensorReading = analogRead(fabricButton);

// this is to check the value of the sensor reading in the Serial Monitor
Serial.println(analogRead(fabricButton));
delay(10);

// check for button press while blinking
if (sensorReading <= threshold && blinking == true) {
// if true, restart the timer and turn off the blinking
startTime = millis(); // store the start time
blinking = false; // turn off blinking while timing
delay(5); // short delay to debounce switch
}
else{
elapsedTime = millis() - startTime; // calculate the elapsed time
}

// check if the timer has reached the desired time length
if (elapsedTime > timerInterval) {
// if ture, turn on blinking
blinking = true;
}

// blink routine – blink the LED while not timing
// check to see if it’s time to blink the LED; that is, the difference
// between the current time and last time we blinked the LED is larger than
// the interval at which we want to blink the LED.

if ( (millis() – previousMillis > interval) ) {

if (blinking == true){
previousMillis = millis(); // remember the last time we blinked the LED

// if the LED is off turn it on and vice-versa.
if (value == LOW)
value = HIGH;
else
value = LOW;
digitalWrite(ledPin, value);
}
else{
digitalWrite(ledPin, LOW); // turn off LED when not blinking
}
}

}

We are intrigued by the interaction between human and music. This project suggests a combination of body postures and generated acoustic effects.

For this final project, we created a blanket of matrix of 16 pressure sensors, each sensor consists of two pieces of conductive fabrics, with one piece of velostat and two layers of light net fabrics.

To connect the sensors, we used two set of parallel and perpendicular conductive threads, and using one diode  for each of the sensor. As a result, we used only 4 analogue input to read the numbers of the whole matrix. The design of the blanket is inspired from traditional Chinese paper-cut of zodiac and Polish woodcut. To construct cover layer, we used the white canvas as the base. We glued them first with iron and sewed them around with sewing machine. For those patterns, we laser cut the red cotton fabric and glued them on top of the white canvas.

For the processing, many improvements could be done. For this version, we tried sound and to create different pitches with the sensor. We used Promide library to process the data from the sensors and transform it into different set of sound track with different wavelength( pitch).We used a midi machine connected to computer and created sound of various musical instruments and electric effects.  To visualize it, we created several circles based on the position of the sensor, its diameter is based on the data from the sensor, that means the higher pressure it receives, the strong the signal it produces, the bigger it is.

Video: http://www.youtube.com/watch?v=HReYU7DG5MY

Code 1:

import processing.serial.*;
import promidi.*;
Sequencer sequencer;
Serial myPort;        // The serial port

//variables for collecting and storing information
int ARRAYX = 4;
int ARRAYY = 4;
int [][] sensorArray = new int[ARRAYX][ARRAYY];
//variables for drawing information on the screen
int [][] volArray = new int[ARRAYX][ARRAYY];
int spacing = 100;
PFont font;

Track track;
MidiIO midiIO;
MidiOut test;

void setup () {
//set the window size:
size(400, 400);
//initialize the font variables
//background(255);
// font = loadFont(“Interstate-Bold-12.vlw”);
//textFont(font);

// list all the available serial ports
println(Serial.list());
// open the appropriate port
myPort = new Serial(this, Serial.list()[2], 9600);
// don’t generate a serialEvent() until you get an exclamation mark character
myPort.bufferUntil(‘!’);
// set inital background:
sequencer = new Sequencer();
//MidiIO
midiIO = MidiIO.getInstance();
midiIO.printDevices();
midiIO.closeOutput(1);
//MidiOut
test = midiIO.getMidiOut(1,3);

test.sendProgramChange(new ProgramChange(20));
//Track
track = new Track(“one”, test);
track.setQuantization(Q._1_32);
}

void draw () {

background(255);
//loop through the array
for (int i=0;i<ARRAYX;i++)
{
for (int j=0;j<ARRAYY;j++)
{
//calculate the position for each entry so that print out is approximately centered onscreen
int xPosition = width/2-((ARRAYX-1)*spacing/2)+j*spacing;
int yPosition = height/2-((ARRAYY-1)*spacing/2)+i*spacing;
//draw the array entries on the screen
//  text(sensorArray[i][j], xPosition, yPosition);

//    noFill();
smooth();
stroke(255,55);
ellipse(xPosition,yPosition, sensorArray[i][j]/20, sensorArray[i][j]/20);

}
}
drawCircles();
}

void serialEvent (Serial myPort) {
//store a batch of data into variable “inString”
//batches are separated by exclamation mark characters
String inString = myPort.readStringUntil(‘!’);
//split the data into rows (rows separated by new line characters)
String[] incomingArrayRows = splitTokens(inString, “\n”);
//loop through all of the rows
for (int i=0;i<ARRAYX;i++)
{
//split each row into entries (entries separated by tab characters)
String[] incomingArrayEntries = splitTokens(incomingArrayRows[i], “\t”);
//loop through all of these entries
for (int j=0;j<ARRAYY;j++)
{
//store entries in the “sensorArray” variable
sensorArray[i][j]=int(incomingArrayEntries[j]);
//print the entries to the terminal, separated by tab characters
print(sensorArray[i][j]);
print(‘\t’);
}
//print a new line after each row
println();
}
//print a new line after each batch of data
println();
makesound();

}

void drawCircles()
{

for(int i=0;i<ARRAYX;i++)
{
for(int j=0;j<ARRAYY;j++)
{
//
if (sensorArray[i][j]>500)
{
//calculate the position for each entry so that print out is approximately centered onscreen
int xPosition = width/2-((ARRAYX-1)*spacing/2)+j*spacing;
int yPosition = height/2-((ARRAYY-1)*spacing/2)+i*spacing;

delay(20);
noStroke();
smooth();
fill(#AF0000, 50);
ellipse(xPosition,yPosition, sensorArray[i][j]/5, sensorArray[i][j]/5);
}
}
}
}
void mousePressed(){
if(mouseButton == LEFT) {
makesound();
sequencer.start();
}
else sequencer.stop();

}

boolean flag = false;

void makesound()
{
for(int i=0;i<ARRAYX;i++)
{
for(int j=0;j<ARRAYY;j++)
{
if (sensorArray[i][j]>300)
{
//volArray[i][j] = int (sensorArray[i][j]/1024*127);
volArray[i][j] = 127;
}
else
volArray[i][j] = 0;
}}

track.addEvent(new Note(60, volArray[0][0],40), 0);
track.addEvent(new Note(60, 0,40), 1);
track.addEvent(new Note(62, volArray[0][1],40), 2);
track.addEvent(new Note(62, 0,40), 3);
track.addEvent(new Note(64, volArray[0][2],40), 4);
track.addEvent(new Note(64, 0,40), 5);
track.addEvent(new Note(65, volArray[0][3],40), 6);
track.addEvent(new Note(65, 0,40), 7);
track.addEvent(new Note(67, volArray[1][0],40), 8);
track.addEvent(new Note(67, 0,40), 9);
track.addEvent(new Note(69, volArray[1][1],40), 10);
track.addEvent(new Note(69, 0,40), 11);
track.addEvent(new Note(71, volArray[1][2],40), 12);
track.addEvent(new Note(71, 0,40), 13);
track.addEvent(new Note(72, volArray[1][3],40), 14);
track.addEvent(new Note(72, 0,40), 15);
track.addEvent(new Note(74, volArray[2][0],40), 16);
track.addEvent(new Note(74, 0,40), 17);
track.addEvent(new Note(76, volArray[2][1],40), 18);
track.addEvent(new Note(76, 0,40), 19);
track.addEvent(new Note(77, volArray[2][2],40), 20);
track.addEvent(new Note(77, 0,40), 21);
track.addEvent(new Note(79, volArray[2][3],40), 22);
track.addEvent(new Note(79, 0,40), 23);
track.addEvent(new Note(81, volArray[3][0],40), 24);
track.addEvent(new Note(81, 0,40), 25);
track.addEvent(new Note(83, volArray[3][1],40), 26);
track.addEvent(new Note(83, 0,40), 27);
track.addEvent(new Note(84, volArray[3][2],40), 28);
track.addEvent(new Note(84, 0,40), 29);
track.addEvent(new Note(86, volArray[3][3],40), 30);
track.addEvent(new Note(86, 0,40), 31);

Song song = new Song(“test”, 100);
song.addTrack(track);
sequencer.setSong(song);
sequencer.setLoopStartPoint(0);
sequencer.setLoopEndPoint(512);
sequencer.setLoopCount(-1);

if(!flag){
sequencer.start();
flag = true;
}

}

Code 2:

import processing.serial.*;
import promidi.*;
Sequencer sequencer;
Serial myPort;        // The serial port

//variables for collecting and storing information
int ARRAYX = 4;
int ARRAYY = 4;
int [][] sensorArray = new int[ARRAYX][ARRAYY];
//variables for drawing information on the screen
int [][] volArray = new int[ARRAYX][ARRAYY];
int spacing = 100;
PFont font;

Track track;
MidiIO midiIO;
MidiOut test;

void setup () {
//set the window size:
size(400, 400);
//initialize the font variables
//background(255);
// font = loadFont(“Interstate-Bold-12.vlw”);
//textFont(font);

// list all the available serial ports
println(Serial.list());
// open the appropriate port
myPort = new Serial(this, Serial.list()[2], 9600);
// don’t generate a serialEvent() until you get an exclamation mark character
myPort.bufferUntil(‘!’);
// set inital background:
sequencer = new Sequencer();
//MidiIO
midiIO = MidiIO.getInstance();
midiIO.printDevices();
midiIO.closeOutput(1);
//MidiOut
test = midiIO.getMidiOut(1,3);

test.sendProgramChange(new ProgramChange(20));
//Track
track = new Track(“one”, test);
track.setQuantization(Q._1_32);
}

void draw () {

background(255);
//loop through the array
for (int i=0;i<ARRAYX;i++)
{
for (int j=0;j<ARRAYY;j++)
{
//calculate the position for each entry so that print out is approximately centered onscreen
int xPosition = width/2-((ARRAYX-1)*spacing/2)+j*spacing;
int yPosition = height/2-((ARRAYY-1)*spacing/2)+i*spacing;
//draw the array entries on the screen
//  text(sensorArray[i][j], xPosition, yPosition);

//    noFill();
smooth();
stroke(255,55);
ellipse(xPosition,yPosition, sensorArray[i][j]/20, sensorArray[i][j]/20);

}
}
drawCircles();
}

void serialEvent (Serial myPort) {
//store a batch of data into variable “inString”
//batches are separated by exclamation mark characters
String inString = myPort.readStringUntil(‘!’);
//split the data into rows (rows separated by new line characters)
String[] incomingArrayRows = splitTokens(inString, “\n”);
//loop through all of the rows
for (int i=0;i<ARRAYX;i++)
{
//split each row into entries (entries separated by tab characters)
String[] incomingArrayEntries = splitTokens(incomingArrayRows[i], “\t”);
//loop through all of these entries
for (int j=0;j<ARRAYY;j++)
{
//store entries in the “sensorArray” variable
sensorArray[i][j]=int(incomingArrayEntries[j]);
//print the entries to the terminal, separated by tab characters
print(sensorArray[i][j]);
print(‘\t’);
}
//print a new line after each row
println();
}
//print a new line after each batch of data
println();
makesound();

}

void drawCircles()
{

for(int i=0;i<ARRAYX;i++)
{
for(int j=0;j<ARRAYY;j++)
{
//
if (sensorArray[i][j]>500)
{
//calculate the position for each entry so that print out is approximately centered onscreen
int xPosition = width/2-((ARRAYX-1)*spacing/2)+j*spacing;
int yPosition = height/2-((ARRAYY-1)*spacing/2)+i*spacing;

delay(20);
noStroke();
smooth();
fill(#AF0000, 50);
ellipse(xPosition,yPosition, sensorArray[i][j]/5, sensorArray[i][j]/5);
}
}
}
}
void mousePressed(){
if(mouseButton == LEFT) {
makesound();
sequencer.start();
}
else sequencer.stop();

}

boolean flag = false;

void makesound()
{
//test.sendProgramChange(new ProgramChange(20));

for(int i=0;i<ARRAYX;i++)
{
for(int j=0;j<ARRAYY;j++)
{
if (sensorArray[i][j]>300)
{
//volArray[i][j] = int (sensorArray[i][j]/1024*127);
if(volArray[i][j] == 0){
volArray[i][j] = 127;
test.sendNote(new Note(i*4+j+60, 127, 1000));
}
}
else{
volArray[i][j] = 0;
test.sendNote(new Note(i*4+j+60, 0, 0));
}
}
}

Ladies, have you ever left the house without your cell phone? Locked yourself out without your keys? Paused mid step to hurriedly search your bag for items you thought you may have forgotten?

Deja Vu is here to help. The newly developed intelligent bag boasts an RFID system that helps you to remember to take important items like your wallet, keys, and cell phone with you. Just attach our custom RFID tags to your things, turn on the bag, and you’re all set. The bag will automatically scan items as they enter and leave, keeping track of what’s in the bag.  A simple squeeze of the soft button and the LED display will light up to show which items are accounted for, so that you never have to frantically search the bag to check if your items are there.  The bag can take up to 5 tags for important items.

Process:

Roll over each picture for more details.

Download the presentation slides here:
NewTextilesFinalProjectPresentation-DejaVu
It contains more details about the project, including: inspirations, process, circuitry, challenges encountered and future improvements.

Many thanks to:
http://bildr.org/2011/02/rfid-arduino/ – for the RFID- Arduino interfacing and code
http://machenmachen.files.wordpress.com/2007/08/machen-machen-wasp-bag.pdf – for the bag pattern

Arduino Code:

]]> http://newtextiles.media.mit.edu/?feed=rss2&p=3049 0 http://newtextiles.media.mit.edu/?p=3223 http://newtextiles.media.mit.edu/?p=3223#comments Thu, 12 May 2011 01:22:15 +0000 denamolnar http://newtextiles.media.mit.edu/?p=3223

The repeated elements of textile designs not only create a sense of rythm, but they can be quite mesmerizing. While they are capable of creating a sense of movement, in reality they are of often static. As a textile designer,  I have always been interested in the idea of a textile that is capable of shifting in terms of pattern and or color. My final project attempts this goal.

To begin, I developed a test on paper. I painted a series of test pieces with thermo chromic paint that represented what would be stripes in the final design. I then sewed conductive thread through each piece. Using an Arduino and  a motion sensor, I wrote a code that allowed for the stripes to be heated up and  in turn change color sequentially when motion was detected.

Above is detail of the first stripe shifting in color.

Once I had the system worked out, I used a shear textile with a striped weft as the surface of the screen. I painted a layer of transparent gesso to make the surface slightly more rigid and suitable for painting on.

I experimented with different ways of applying a patterned layer of thermo chromic pigment, including making a template from a piece of the textile. For the template, I simply gessoed a piece of the shear material to a piece of card stock. Once it was dry, I cut out the striped shapes with an exacto knife. While I used the template, I also found it just as easy to paint directly onto the textile.

After I painted in some areas of the textile, I sewed conductive thread over the black striped weft and added the mosfets and conductive tape which would connect to a 12V AC adaptor, ground and output to the Arduino.

After some initial trial and error (and a failed attempt to get the prototype working during the final presentation)..success!

Arduino Code

/*  AnalogReadSerial Reads an analog input on pin 0, prints the result to the serial monitor   This example code is in the public domain. */
int sensorold, sensornew;int sensordif = 3;boolean trigger;
void setup() {  pinMode(2, OUTPUT);  pinMode (6, OUTPUT);   pinMode (7, OUTPUT);  pinMode (13, OUTPUT);    digitalWrite(2, LOW);  digitalWrite(6, LOW);  digitalWrite(7, LOW);  digitalWrite(13, LOW);  sensorold = analogRead(A0);  sensornew = sensorold;  trigger = false;  Serial.begin(9600);}
void loop() {  sensornew = analogRead(A0);  if (abs(sensornew – sensorold) > sensordif)  {    Serial.println(“trigger 2″);    digitalWrite(2, HIGH);    digitalWrite (13, HIGH);// set the LED on    delay(1000);    // wait for a second    digitalWrite(2, LOW);    digitalWrite (13, LOW);  // set the LED off    Serial.println(“off 2″);    delay(10000);    Serial.println(“trigger 6″);    digitalWrite (6, HIGH);    delay(1000);    Serial.println(“off 6″);    digitalWrite (6, LOW);    delay(10000);    Serial.println(“trigger 7″);    digitalWrite (7, HIGH);    delay(1000);    digitalWrite (7, LOW);    Serial.println(“off 7″);    delay(10000);  }   // Serial.println(sensorValue, DEC);}

These days, with a little thing called an Android phone, a powerful little circuitboard called Lilypad Arduino, and an amazing toolkit called Amarino developed by Bonifaz Kaufmann, you can talk to your jacket — and even better, you can talk to someone else’s!

User Testing the Kung-Fu Jacket

The Amarino-Powered Kung-Fu Jacket that I developed started with an understanding of how an Android phone could talk to an Arduino board.  The connection is based on two necessary but ubiquitous components — a bluetooth modem for the Arduino and the free and open toolkit called Amarino that Kaufmann developed back in 2009.

Lilypad Arduino and Bluetooth modem

Amarino on the Android

The first test was to see if these items could talk to each other.  After some initial testing, success.

From there, I wanted to incorporate this technology into existing garments — not just because my sewing skills are quite rough but as much because I wanted to find a way to augment any garment that I had with smart technology.  The challenge was to design it in a way that allowed the garment to be resilient to washing.  The solution was simple in retrospect — soldered-on snaps! The snaps made it easy to remove the Lilypad board, the bluetooth and the battery when either the technology or the garment needed maintenance.

Snaps soldered onto a Lilypad board The next

Next, it was important to know where to put the output device — in this case, the vibrator to have maximum effect for the user.  After a bit of user-
testing including changing the conductive threat to a thicker one that provided more current and thus a stronger and more tangible vibration, I determined that the most sensitive part of my upper-quadrant (where the Arduino board was located) was the small area smack between my shoulders.  Since I wanted the vibrator to be felt by the user, I ended up sewing a place for snaps there.  (A few users have told me that the vibrator is so strong that if it was a bit stronger, it would give them a good shoulder massage).

Vibrator

With the platform in place, my final step was to program the Arduino board to sync with the multiple sensors on the Android phone in a unique way.  I started with the amazing accelerometer on an Android, a sensor that sends different data based on the orientation of the phone through 3 axes – x, y and z.  While it took a little learning to utilize that data for something that could then be translated into an output on the jacket, I got it to work in a basic and I think fun way!

Kung-Fu-ing with My Jacket Take 1

Kung-Fu-ing with My Jacket Take 2

The interesting part of the coding was whether or not to precisely to map the accelerometer movements with the outputs of the jacket — in other words to make it clear what orientations of the phone – up, down, horizontal – would respond to what outputs e.g. LED lighting up or a vibrator vibrating.  The looser the constraints e.g. LED lights up when phone is middle down to middle up made it more fun for the user to exaggerate their motions and to discover what actions was triggering what event.

You can see the code I used in the end below:

Since the phone also had a number of other sensors, I also tested out using the receive SMS sensor in Amarino.  It was simple to set-up and
my intention was to have the LED change based on the message that was received from a user.  Unfortunately, I couldn’t get the coding correctly so I only got a single LED event but imagine that it would not be too difficult to figure out how to adjust the code below to figure this out.

/*

Turns on LED when phone receives an SMS.

Author: Albert Ching – May 2011

*/

#include <MeetAndroid.h>

// declare MeetAndroid so that you can call functions with it

MeetAndroid meetAndroid;

// starting with 1 LED

int LED = 11;

void setup()

{

// use the baud rate your bluetooth module is configured to

// not all baud rates are working well, i.e. ATMEGA168 works best with 57600

Serial.begin(57600);

// register callback functions, which will be called when an associated event occurs.

meetAndroid.registerFunction(LEDon, ‘A’);

pinMode(LED, OUTPUT);

digitalWrite(LED, LOW);

}

void loop()

{

meetAndroid.receive(); // you need to keep this in your loop() to receive events

}

void LEDon (byte flag, byte numOfValues)

{

int values[]={0};

meetAndroid.getIntValues(values);

// xxx

int X=values[1];

if (X = ‘hey’) {

digitalWrite(LED, HIGH); // set the LED on

delay(1000);              // wait for a second

digitalWrite(LED, LOW);    // set the LED off

} else if (X = ‘aloha’) {

digitalWrite(LED, HIGH); // set the LED on

delay(1000);              // wait for a second

digitalWrite(LED, LOW);    // set the LED off

delay(1000);              // wait for a second

digitalWrite(LED, HIGH); // set the LED on

delay(1000);              // wait for a second

digitalWrite(LED, LOW);    // set the LED off

delay(1000);              // wait for a second

digitalWrite(LED, HIGH); // set the LED on

delay(1000);              // wait for a second

digitalWrite(LED, LOW);    // set the LED off

delay(1000);              // wait for a second

digitalWrite(LED, HIGH); // set the LED on

} else if (X = ‘aloha baby’) {

digitalWrite(LED, HIGH); // set the LED on

delay(200);              // wait for a second

digitalWrite(LED, LOW);    // set the LED off

delay(200);              // wait for a second

digitalWrite(LED, HIGH); // set the LED on

delay(200);              // wait for a second

digitalWrite(LED, LOW);    // set the LED off

delay(200);              // wait for a second

digitalWrite(LED, HIGH); // set the LED on

delay(200);              // wait for a second

digitalWrite(LED, LOW);    // set the LED off

delay(200);              // wait for a second

digitalWrite(LED, HIGH); // set the LED on

delay(200);              // wait for a second

digitalWrite(LED, LOW);    // set the LED off

} else

{

digitalWrite(LED, LOW);

}

}

The great thing with this project (for me at least) is that my jacket is now a platform for expressing anything that my Android phone can do.  With the significant range of the Bluetooth (100 meters), it can even be controlled by someone far away.  After showing the jacket to many of my classmates, I’ve heard of use cases from a long-distance massage, a way to find someone subtly in a crowd, to give real-time feedback to a presenter or a teacher, to receive text message notifications without being close to our sometimes too clingy  mobile phones.

I can’t wait to continue the experimentation and am extremely grateful to Leah and the other members of the High-Low Tech lab for introducing this whole new world to me — and to Bonifaz for creating this very easy to use toolkit.  Mahalo nui loa!

Skirt Design

To simplify things a bit (and after noticing that skirt patterns weren’t quite available in my size at a local fabric store), I decided to extract a skirt pattern from one of my favorite skirts. I’m not quite  familiar with sewing clothes, however, with some previous quilting experience, I improvised extracting the pattern and sewing the pieces together. From the previous assignment with the embroidery machine, I chose to use a thick fabric to lessen the chances of the bobbin thread bunching and knotting.

One of my favorite skirts.

Cutting the pattern out.

Processing Code

For my original computation assignment, I began working on code  that evaluated the RGB value of a given pixel of an image and then visualized the pixel’s RGB value with another shape — such as  a circle. I worked on this code a little more for this project so that I could change the number of pixels that were evaluated in the x and y directions in addition to filtering the image’s colors into 5 colors.

Embroidery

The embroidery took about ~4 hours. As the embroidery progressed, I cut the needle thread. After the embroidery finished, I cut off the loose needle thread. Here’s a YouTube Video of the embroidery process.

Problems

The most problems I had were with the embroidery machine.  There was inconsistency from the color layout as depicted in Processing code to the 29 threads that the embroidery software detected (which I filtered down to five in processing). In the embroidery software, I filtered back down to 5 threads again, but 29 threads still showed up while embroidering.

Further Work

As part of my thesis, I’ve continued studying Archigram’s works through 3D modeling and rendering of  one of their other projects: Plug-in City. I’m interested in continuing modeling their work after I graduate from MIT. As I’ve worked on the project for this class, I began to consider my skirt being similar to a Girl Scout’s sash ( i.e., as they complete projects/requirements, they receive a badge as a indication of their work and progress which is sewn onto the sash). For this project, I chose to embroider Walking City because it’s something I’ve worked on and completed. And, similar to a Girl Scout’s badge, I’ve considered adding embroidery of other Archigram projects on the skirt as I complete modeling and rendering other Archigram Projects. I may be including an embroidery of Plug-in City very soon.

In my proposal, I also considered adding light and this is something I may do after finals.

Files

Final Presentation

Pattern

Code

int x=0;
int y=0;
int a=50;
int b=0;
int e=0;
int f=50;
int img_y = 0;
int img_x = 0;
PImage img;

void setup()
{
size (1200,700);
img = loadImage(“test2.jpg”);
smooth();
background(255);

//image size
int img_width = img.width;
int img_height = img.height;

int stepsize = 10;
int width_density = round(512/stepsize)-1;
int height_density = round(281/stepsize)-1;

for (int i=0;i< width_density;i++) //X
{

for (int j=0;j< height_density ;j++) //Y
{
//Pick a point
//Archigram Image 512 px by 281 px
img_x = x+i*stepsize ;
img_y = y+j*stepsize ;
int loc = img_x + img_y*img.width;

// Look up the RGB color in the source image
loadPixels();
float r = red(img.pixels[loc]);
float g = green(img.pixels[loc]);
float b = blue(img.pixels[loc]);

//Test to check that shades of gray are when r==g==b
/*if(r==g && g==b) {

}*/
noStroke();

//Limit fill to 5 shades of gray
//keep dark spots dark
//Values of RGB determined per http://www.w3schools.com/html/html_colors.asp
//Shade 1 — Black
int shade1 = 32;
int shade2 = 88; // between 25 and 72
int shade3 = 120;
int shade4 = 180;
int shade5 = 220;
int shade6 = 255;

if(r <= shade1 && g <= shade1 && b <= shade1) {
r = 0;
g = 0;
b = 0;
}

else if ((r<=shade2 && r>shade1) || (g<=shade2 && g>shade1) || (b<=shade2 && b>shade1))  {
/*r = 48;
g = 48;
b = 48; */

r = 255;
g = 0;
b = 0;  //ReD

}

else if ((r<=shade3 && r>shade2) || (g<=shade3 && g>shade2) || (b<=shade3 && b>shade2))   {
/*r = 96;
g = 96;
b = 96; */

r = 128;
g = 0;
b = 128; //Magenta
}

else if (r<=shade4 && r>shade3)  {
/*r = 136;
g = 136;
b = 136; */

r = 255;
g = 255;
b = 0; //Yellow

}

else if (r<=shade5 && r>shade4)  {
r = 255;
g = 128;
b = 0;  //Orange
//print(“test: “);
}

else  {
r = 255;
g = 255;
b = 255; //White
}

fill(r, g, b);

int radius = round(random(8,15)); //width
int radius2 = round(random(3,8)); //height
int tester = width_density-5;
if(j==tester) {
radius = 5;
radius2 = 8;
print(“j: ” + j);
}

ellipse(x+i*10, y+j*10, radius, radius2);

}
}

}

The embroidery process and writing code in Processing was challenging.  The various pieces had to fit properly. When pieces were sewn separately, the sizes of the items were not of the same scale. To fit everything, all items were put into a hoop at the same time and sewed together at one time. (This took over 4 hrs). When testing the pieces, the snaps and velcro sometimes don’t snap together properly, giving strange readings. The velcro readings evened out after a while of repeated attachment and removal. Writing the code was also difficult for a first-timer.

I want to keep working on the coding for processing to add a timer and allow 2 players to play simultaneously.

Code:

import processing.serial.*;
Serial myPort;        // The serial port

//variables for collecting and storing information
int ARRAYX = 2;
int ARRAYY = 3;
int [][] sensorArray = new int[ARRAYX][ARRAYY];

int flag = 0;
boolean inGame = false;
boolean prompt = false;
int characterPrompt = 0;
boolean instructions = true;
boolean wonGame = false;
boolean endGame = false;

//variables for drawing information on the screen
int spacing = 100;
PFont font;
PFont fontA;

void setup () {
//set the window size:
size(600, 400);
//initialize the font variables
font = loadFont(“SansSerif-20.vlw”);
textFont(font);

fontA = loadFont(“SansSerif-48.vlw”);

// list all the available serial ports
println(Serial.list());
// open the appropriate port
myPort = new Serial(this, Serial.list()[0], 9600);
// don’t generate a serialEvent() until you get an exclamation mark character
myPort.bufferUntil(‘!’);
// set inital background:
background(0);
}

void draw () {
background(0);
//draw buttonNEXT
fill (255);
rect(520, 350, 50, 30);
text(“NEXT”, 520, 350);
//draw buttonEXIT
fill (255);
rect(450, 350, 50,30);
text(“EXIT” , 450, 350);

if (inGame==false)
{
if (instructions==true)
{
//draw instructions
text(“Stick the right clothes onto the right character.”, 75, 100);
}

else if (prompt==true)
{
// draw prompt
if (characterPrompt == 0)
{
text(“Mary Tepe”, width/2, height/2);
}
else if (characterPrompt == 1)
{
text(“Jenny Wade”, width/2, height/2);
}
else if (characterPrompt == 2)
{
text(“General Lee”, width/2, height/2);
}
else if (characterPrompt == 3)
{
text(“General Meade”, width/2, height/2);
}
}
else if (wonGame==true)
{
text(“You’re right!”, width/2, height/2);
}
}
else if (inGame==true & wonGame == false)
{
if (characterPrompt == 0)
{
if (testIfMary() == true)
{
text(“You’re right!”, width/2, height/2);
wonGame=true;
inGame = false;
}
else
text(“That’s not Mary, keep trying.”, 200, height/2);
}

if (characterPrompt == 1)
{
if (testIfJenny() == true)
{
text(“You’re right!”, width/2, height/2);
wonGame=true;
inGame = false;
}
else
text(“That’s not Jenny, keep trying.”, 200, height/2);
}

if (characterPrompt == 2)
{
if (testIfGeneralL() == true)
{
text(“You’re right!”, width/2, height/2);
wonGame=true;
inGame = false;
}
else
text(“That’s not Gen. Lee, keep trying.”, 200, height/2);
}

if (characterPrompt == 3)
{
if (testIfGeneralM() == true)
{
text(“You’re right!”, width/2, height/2);
wonGame=true;
inGame = false;
}
else
text(“That’s not Gen Meade, keep trying.”, 200, height/2);
}
}
}

void mousePressed() {
//test if over area
if (( mouseX> 519 & mouseX< 571) & (mouseY>349 & mouseY<381))
{
if (instructions==true)
{
instructions = false;
inGame=false;
prompt=true;
characterPrompt = int(random(4));
//characterPrompt = 0;
}
else if (prompt== true)
{
prompt = false;
inGame= true;
}
else if (wonGame== true)
{
wonGame= false;
prompt=true;
characterPrompt = int(random(4));
}

}

else if (( mouseX> 449 & mouseX< 501 ) & (mouseY>349  & mouseY<381))
{
println(“clicked exit”);
exit();
}
}

void serialEvent (Serial myPort) {
//store a batch of data into variable “inString”
//batches are separated by exclamation mark characters
String inString = myPort.readStringUntil(‘!’);
//split the data into rows (rows separated by new line characters)
String[] incomingArrayRows = splitTokens(inString, “\n”);
//loop through all of the rows
for (int i=0;i<ARRAYX;i++)
{
//split each row into entries (entries separated by tab characters)
String[] incomingArrayEntries = splitTokens(incomingArrayRows[i], “\t”);
//loop through all of these entries
for (int j=0;j<ARRAYY;j++)
{
//store entries in the “sensorArray” variable
sensorArray[i][j]=int(incomingArrayEntries[j]);
//print the entries to the terminal, separated by tab characters
print(sensorArray[i][j]);
print(‘\t’);
}
//print a new line after each row
println();
}
//print a new line after each batch of data
println();
}

void printArray()
{
for (int i=0;i<ARRAYX;i++)
{
for (int j=0;j<ARRAYY;j++)
{
print(sensorArray[i][j]);
print(‘\t’);
}
//print a new line after each row
println();
}
println();
}

boolean testIfMary()
{
int hat = sensorArray[0][1];
int clothes = sensorArray[0][0];
int other = sensorArray[0][2];

if ((hat>10 & hat <29) & (clothes>10 & clothes<29)  & (other>10 & other<29))
{
return true;
}
else
return false;
}

boolean testIfJenny()
{
int hat = sensorArray[0][1];
int clothes = sensorArray[0][0];
int other = sensorArray[0][2];

if ((hat>30 & hat <60) & (clothes>30 & clothes<60)  & (other>30 & other<60))
{
return true;
}
else
return false;
}

boolean testIfGeneralM()
{
int hat = sensorArray[1][2];
int clothes = sensorArray[1][0];
int other = sensorArray[1][1];

if ((hat>10 & hat<60) & (clothes>10 & clothes<60)  & (other>10 & other<60))
{
return true;
}
else
return false;
}

boolean testIfGeneralL()
{
int hat = sensorArray[1][2];
int clothes = sensorArray[1][0];
int other = sensorArray[1][1];

if ((hat>200 & hat<300) & (clothes>200 & clothes<300)  & (other>200 & other<300))
{
return true;
}
else
return false;
}

For this experiment I used the agenlina fibres to cast the shape of the daily objects. For the first one, I used a water bottle with hot water inside as a mold. Then I put a latex glove over the surface and filled the fibers in between the latex and the bottle. I put the whole thing into boiling water. Unfortunately the latex began to melt during boing. But basically the result is good. Some parts are lack of fibers since I did not distribute them homogeneously. I used the iron to “roll” the bottle to get more fibers on.

Then I put the fibers in between two paper bowls and drop the whole thing into boiling water. The paper became soft, but the casting seemed fast. I took it out before the paper turned to shapeless.

After Leah showed us all of the interesting techniques last week for making non-woven it made me start to think about what processes I could use. I was specifically interested in the compound, possible constructed by two fabrics dipped in a rubber or resin. It has an interesting texture and look. I started to think about what I could used to mimic it. I decided to experiment with acrylic glossing medium and a light weight shiny fabric.  I brushed the gloss medium on to a single pieces and let it dry. It produced a compound that feels similarly to vinyl. It has a little bit of stretch to it and changes flexibility with the heat of your hands. Next I used the same fabric and layered two pieces brushed with the medium. It has a slightly different appearance and feel.

Your final project assignment has 3 pieces: the project itself, a short presentation about the project, and a web page documenting the project. Information about presentations and documentation is below.

Presentations
Prepare a short formal presentation to present to the class. It should include:

* A short survey of previous work in the area.
* A demonstration of the project in action (the core of your presentation)
* A short discussion of your construction process including challenges and learning experiences.
* A short discussion of what you would do to improve the project if you were to keep working on it.

Documentation
Create a post that documents your project and add it to the Final Projects category. Your page should include a description of your project, a pdf copy of your presentation slides, a few work-in-progress photos, photos of your final piece, and a video of your final piece. Documentation is due by the end of the day on Wednesday May 11.

For this nonwoven, I decided to experiment with acrylic paints to see if they could be incorporated into a fabric. During the class, I was inspired by the silicone material, but thought the molding process was limiting and time consuming for textile applications. Making a mold takes time, and it is hard to control the topography of the finished product from the mold. Hence, I played around with some glue, acrylic paints and felt.

Unfortunately, the glue (Elmer’s) dried hard, and did not make an amazing fabric as it was very brittle. The acrylic however, dried into a splendidly soft and flexible material. Varying the paint colors and the way the paint was applied gave the top surface an interesting texture and surface aesthetic that I found very appealing. Next, I tried mixing felt and paint. Instead of painting on top of the felt (too similar to fabric paint), I decided to put the felt on top of the paint. This version has a combination of surface textures – the smooth back of the acrylic paint, the rough bumpy top surface of the paint, and the soft fuzziness of the felt. The felt also stuck pretty well to the paint.

I would like to further experiment with felt and acrylic paint. I think that putting the two together in a fashion that is similar to woven structures (maybe a grid of sorts?) will be quite fascinating. The fact that the acrylic can just be painted on gives rise to a large design space where one can paint whatever fabric structure one desires, and I think that property can be exploited for further use.

]]> http://newtextiles.media.mit.edu/?feed=rss2&p=2968 0 http://newtextiles.media.mit.edu/?p=2824 http://newtextiles.media.mit.edu/?p=2824#comments Tue, 03 May 2011 10:43:37 +0000 KristyKat http://newtextiles.media.mit.edu/?p=2824 I’ve recently become interested in the diagrid pattern and its variations. For this project, I laser cut a mold from masonite and plexiglass.

1st Diagrid Mold

I created the first mold from masonite  (1/8″) and used Smooth-On to cast the mold. The Smooth-On mold was very messy and runny. I wrapped it in three layers of wax paper and taped it to prevent leakage and let it sit for three days. After three days, however, the mold was not fully set. Despite this mold being very greasy — a feature intended to aid in the extraction process — I had a great deal of difficulty getting the mold out of the cast.

Smooth-On mold

Masonite

Smooth-On in masonite

2nd Diagrid Mold

I created the second mold from plexiglass (1/16″) and used another mold for casting. This mold was extremely viscous (but not as messy). I wasn’t quick enough pouring the mold into the cast and it became more viscous (hardened) as I worked my way across the mold (right to left) and air pockets formed on the left side of the mold. Additionally, I applied the final layer of the mold (smallest diagrids) on top too late — when I pulled it off the mold, it created an uneven surface across the already setting mold.

Plexiglass cast

plexiglass cast

Final Rubber Mold