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
}
}

}

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;
}

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.

Make a piece of flexible nonwoven fabric with some noteworthy characteristic. (An unusual blend of materials, interesting structural characteristics, embedded circuitry, special electrical properties, …?) Create a post that documents your project and add it to the Nonwoven category. Your page should include a photo of the finished nonwoven and a short description of the fabric and how it was built. Since you are also working on your final projects I am not expecting you to spend as much time as usual on this assignment or its documentation, but I wanted you to get a chance to play with some of these materials and techniques. A single photo and a few sentences is fine.

See designs from last year’s class here.

Bring your fabric to class on the 3rd for demos!

For this assignment you will create a computationally generated textile pattern. You’ll write a program that generates a pattern and use the embroidery machine, laser cutter, knitting machine (or another CNC device, ie: a CNC loom or a 3D printer) to automatically produce the pattern.

Create a post that documents your project and add it to the Computational Design category. Your page should include pictures of your finished textile, the code you wrote to generate the pattern, a few photographs of the construction process, and a paragraph about your experience.

Something to think about…You have three weeks to finish this assignment. This would give you time to order fabric from a service like Spoonflower (custom fabric prints) or Shapeways (3D printed fabrics). A 3D printed fabric:

Tutorials, including sample code are available in the Machine Tutorial category of the HLT wiki.

Bring your projects to class on April 19 for demonstrations.

For your final project, you’ll explore a specific set of materials, techniques, or applications in depth. You are very welcome (in fact encouraged) to work in groups. The project could take many different forms, including but not limited to:

• A finished garment with unique functionality, design, or material composition.
• A finished textile with unique functionality or material composition.
• A prototype for a new tool that could help others work with textiles and technology.
• A series of documented material or technique explorations.

The final project proposals will consist of short (10 minute) formal presentations that you will present in class and short online descriptions. Your presentation should include:

• A concise description of your project.
• A preliminary survey of previous work in the area.
• If you are planning a project whose outcome is a specific artifact (ie: a garment), preliminary sketches of the artifact.
• A time line/plan of work.

Create a post on the site for your proposal and add it to the Final Project Proposal Category. Your page should contain a short description and a downloadable version of your presentation. You can see proposals from last year’s class here.

For this assignment you will create a soft, flexible, textile-based sensor and a simple screen-based interface that displays information from the sensor.

Part 1. Felt, knit, sew, fuse, or crochet a soft sensor. Document your construction process with pictures. Write a paragraph that describes your sensor and a scenario for its use. If your sensor is a resistive sensor, use the multimeter to measure its resting and activated resistances and include this information in your paragraph.

Part 2. Connect your sensor to an Arduino (you will be loaned an Arduino for the duration of this assignment). Write a simple Arduino program that takes readings from your sensor and sends them to the computer. Write a simple Processing program that uses the data from the Arduino to create an interactive program–a small game–that can be controlled with your sensor. Take a video of your sensor controlling your program. Include your video and your Arduino and Processing code in your write-up. This tutorial will be useful. Note: don’t permanently attach your sensor to the Arduino. You will return the Arduino on March 29.

Create a post that documents your project as described above and add it to the Textile Sensor category.

Bring your projects to class on March 29 for demonstrations.

For this assignment you will create two knit pieces, one by following an existing pattern and one by developing your own pattern. This assignment will focus on different knit structures. A later assignment will focus on color and pattern.

Part 1. Create a knit swatch from the following pattern:
Cast on 20 needles. Knit 10 rows. Carriage should be on right side. Make sure carriage is in the proper mode (Russel levers should be in position I). Bring needle closest to carriage into hold position. Knit one row (carriage should be on left side). Bring needle closest to carriage into hold position. Knit one row (carriage should be on right side). Continue bringing one needle into hold position on the carriage side until you have 2 needles in knit position in the center of your pattern. Carriage should be on right side.

Begin taking needles out of hold position. Push the needle closest to the knitting on the opposite side of the carriage (the left side) into B (knit) position. Knit one row (carriage should be on right side). Push the needle closest to the knitting on the opposite side of the carriage (the right side) into B (knit) position. Knit one row (carriage should be on left side). Continue bringing one needle out of hold position opposite the carriage side until all needles are back in knit position. Knit 10 rows. Cast off.

Part 2. Create and document your own pattern
Create a knit swatch that is at least 6″ x 6″ large that has a noteworthy topography or topology. Write out the pattern for your swatch.

Create a post that documents your projects and add it to the Knitting category. Your page should include pictures of both of your finished pieces, the pattern for the Part 2 assignment, and a paragraph about your experience–including an explanation of why your Part 2 pattern is interesting or novel.

Bring your projects to class on March 15 for demonstrations. Note: you’ll turn these assignments in for closer inspection.