New Textiles 2012

Clipping Mask Removal

2012-05-25T04:00:51Z

Once you execute your code, it will save a pdf of your design to the corresponding sketch folder in your Processing directory. At this point, you will need to modify your design a bit in adobe illustrator to prep it for the laser cutter.

These steps are as follows:

1. Open the pdf in illustrator

2. Right click on your diagram and select “Release Clipping Mask” and delete the box around the border that results.

3. Select all of the remaining objects in the file and go to Object->Expand. Select “stroke” and hit ok.

4. Lastly, Select the whole diagram, go back to your pathfinder window and select “Unite”. This will merge all of your paths into one. (You only need to do these last two steps for the pattern.pdf file. Everything else just needs to have the clipping mask removed.) Save your file as a pdf and you’re ready to cut!

Animated Paper

2012-05-22T18:01:13Z

My final project explores the idea of creating live physical and tangible animation that can be programmed and interactive. Robots do that in a way but they are massive, loud, and very technical in their look and feel. I am using paper and Ni-chrome wire that give a quite, unexpected and biological like motion and movement. Paper was selected for this project because it’s flexibility and springiness (especially thick paper like the one I am using) that is great for working with the Flexinol.
My focus in this project was on design. Usually the electronics of objects are hidden and messy, here the paths of the circuit board are being used as a decorative element that support the shape and concept of the objects. The electronic components and the Lilipad are also designed as “part of the story” and integrate in the overall look of the objects. The objects are minimal and simple in order to emphasis the motion and interactivity experience.

I cut the outline of the shape on the laser cutter, in addition the I used the laser cutter to mark where the electronic traces should be. The copper tape was cut using the vinyl cutter.
The project is made out of 100lb. (270gr) Brisol paper, 0.006in Flexinal wire, and copper tape.
The project consists of three objects: a turtle, a snail and an interactive sheet.

Turtle
Turtles are slow it fits with the slow actuation of the Ni-Chrome wire. Here, the wire are actuation the legs but also creating the 3D shapes from the flat piece of paper

Interactive Snail
The snail has one capacitor sensor and one Ni-Chrome wire. When it’s antenna is touched it bend a little bit, something that reminds interaction with a real snail.

Interactive sheet
The sheet of paper has 4 Ni-Chrome wires and 4 capacitor sensors. When you put your hand over one of it’s four corners, the corner rises in a surprising way. Here the control is done from another small sheet of paper to keep the simple look of a blank sheet of paper.

Here is a link to the presentation:
presentation_small

Omni_Rocker

2012-05-22T03:25:53Z

A Dress that Breathes

2012-05-22T00:37:35Z

As a continuation of my project from the moving textile assignment, I made a dress with fabric origami panels that are actuated by nitinol shape memory wire. The repetitive contracting and expanding motion of the panels is reminiscent of breathing. The panels are made in a pair to mimic anatomical lungs.

I created a pattern for a dress with a straight skirt and a princess-seamed bodice and sewed the dress out of polyester satin. To make the origami panels, I laser cut the fold pattern on a piece of cotton/poly blend fabric. Then, I folded the fabric along the fold lines and stitched the folds in place. To stiffen the fabric, I made my own starch (by dissolving 2 tbsp. of cornstarch in 1/4 c. of water, then whisking in 2 c. of boiling water) and dipped the fabric in it, then set the starch by ironing the fabric when just barely damp.

To make the nitinol springs, I wrapped wire around a screw and held it in place with nuts. I put them in a furnace at 500 degrees Celsius for 10 minutes to set the shape.

The Voronoi lace pattern of the peplum is inspired by the Voronoi patterns present in alveoli, which are structures in lungs that are responsible for gas exchange.

: sciencephoto.com

I laser cut the peplum pattern that I designed using Processing and a random Voronoi generator code.

A Lilypad Arduino is used to control the nitinol actuated panels. The panels are programmed so that the current switches on and off, causing the wire to expand and contract to create a repetitive motion that is reminiscent of breathing.

Here are videos of the dress in action:

The motion is quite subtle, but I think that is ideal for mimicking respiration since breathing is subtle as well. I would have liked to have had the panels be attached so that they contour the body of the dress. However, when I tried this, the panels were too constrained to produce the desired motion. I was pleased with how the fabrication of the fabric origami worked out. I think it would be interesting to use this technique to make other origami structures out of fabric.

Final presentation slides

Felted Musical Landscape

2012-05-21T22:37:25Z

Felted Musical Landscape is a textural interactive felted 3D textile project. The tips of individual bumps are capacitive touch sensors that responds to touch and plays piano notes via Processing. This interactive piece is soft to touch and fun to interact with, as one wouldn’t expect these bumps to make sounds when squeezed or touched!

Inspiration

During spring break I traveled to Reykjavik, Iceland and was inspired by the low planes of bumpy moss landscape. Right when I came back from Iceland we worked on using the knitting machine at the lab, and I was excited about knitting 3D bumpy structures. I also had some Icelandic Lopi Wool that I brought back from Iceland. Perfect. This is the project I’m going to work on. Large size installation scale (initially planning on making a 30″ x 36″ large wall textile), interactive, fun!

Below are examples of felted topology projects done by Xandy Peters. I was also inspired by the large scale installation by Pia Mannikko.

I wanted to make the textile piece devoid of any wires to the computer, so I tested using the Arduino Fio with Xbee. Fio is much easier to work with if you’re doing a point to point simple sensor network. There is a easy configuration tool, and the Fio board has the Xbee shield and power integrated with the board. However I managed to break the board when I was soldering multiple resistors (without headers…), so I decided to work with Lilypad Arduino and Lilypad Xbee since it’ll be easier to sew on to the textile later on.

I used Image Based Circle Packing Script in Rhino to generate a packing pattern that I’d use as a base for the bump knit pattern. I layered a grid on top of the packing pattern and mapped out a preliminary circuit path from the Lilypad Arduino.

To follow this pattern, knit all grid boxes, and start the hold-knit-hold pattern at darker lines (circle diameter lines indicated with stitch numbers) to make bumps. Add conductive thread to the wool strand at the dotted tip areas of each bumps to create conductive surface. (hold-knit-hold: knit one row until last stitch, hold last stitch. Turn and purl until last stitch, hold last stitch. Repeat this pattern until two stitches are left. Then work your way backwards).

I was planning to use the mid-gauge knitting machine at the lab, but unfortunately the machine broke. I had to choose between:
-hand knitting
-use fine-gauge knitting machine
-mill bump surface with foam as formwork and make wet-felted landscape.
I decided to go with #1: hand knit.

Test #1 was using wool yarn (from the lab, and it seemed like 100% wool), but I translated my pattern inaccurately (didn’t knit enough rows to allow enough expandable surface for knitted bumps. I kept knitting the hold-pattern after another). Also the yarn didn’t felt well. Change of yarns.

Test #2

I used 200 grams of Iceland Lopi Wool from Istex Mill , and this time read the pattern correctly. Knit knit knit.

After many hours of relaxed but shoulder-intensive knitting, I felted the piece using washing machine (2 cycles). Below is a picture of the felted piece when it’s still fuzzy. While it’s damp (never put it in the dryer), make sure to shape the textile to your desired form. Let it air dry.

Here’s a little intro on capacitive sensor: http://www.arduino.cc/playground/Main/CapSense

To maximize the number of sensor pins on the arduino, I designated three send pins, and used those pins to connect 10 mega ohms resistors to each of the sensor pins. I had to debug the the arduino pin connections by testing each pin with simple capsense code. Most of the times it was my amateur soldering technique that caused the problem. After everything is connected, I sewed the Lilypad on the textile and connected each sensor pins to the conductive tip of the bumps.

This time, I made sure to lay out the entire circuitry before starting any sewing. The bottom pin is the Lilypad and top one is the Xbee Shield. LEDs were difficult to see through the thick felt, so I took them out later. There are a total of 12 notes – a full octave with flat/sharp notes. Now it’s time to put everything together. Piano frequency can be found here, and the Processing Piano code sketch can be found in our class notes here.

Next step is connecting with the Xbee modules. I want this interactive piece to be a stand-alone piece, and with the xBee it’s possible to send sensor data over radio/wireless network. I used simple Series 1 Xbees.
You need: 2 xBees, 1 xBee explorer (for your computer), lilypad xbee shield, power connector for xBee/lilypad, usb cable

I used X-CTU program to configure the xBees, and followed the steps described in this online post except few things: I didn’t change the baud rate to 19200, and also didn’t set the D2 pin as data pin in the sensor-xBee module. Plug in the xBee, and if two xBees are communicating, green light turns on. Yes! it’s communicating. I opened up the Arduino serial port, I’m reading 13 sensor readings. Great. However, when I went to the Processing sketch, nothing would happen. WHY?? Do I need to import the xBee library? I tried multiple things but all didn’t seem to work. More research is needed (frustration! why isn’t this working?)

So finally, here’s a demo video of the felted musical landscape (wired for now)

Magnetically Controlled Silicone

2012-05-21T18:43:48Z

PROPOSAL

As a continued exploration of my studies in embedding magnets in silicone along with the experiment of casting silicone into a folded structure, I propose a screening device that is either manually controlled through physical interaction with the embedded magnets or electronically controlled through a sensor-based interaction.

The actuation I hope to achieve is one that controls the opening of the slits created by the depth (and angle) of the original valley of the folded mold and the amount of silicone on the crease of the ridge. I can experiment with both the type of fold for the mold and the extent to which the structure is folded or unfolded when I cast into it. The main application I envision for this screening device would be an alternative to traditional curtains and blinds. This system would allow for diffuse light through the silicone and more precise control of the open and closed states through the individual or group control of the apertures. Beyond an application on windows, the system could also be envisioned as a freestanding piece that functions as a variable screen between spaces that also has the ability to precisely control its apertures and allow diffuse light through.
PRESENTATION SLIDES

PROCESS
MOLD:

EMBEDDING IRON:

CASTING SILICONE:

MAGNET RODS:

FRAME CONSTRUCTION:

FINAL SILICONE PIECE:

FINAL CONSTRUCTION

IN ACTION!

Lissajous & Prolate Code

2012-05-21T17:26:43Z

/*This example draws voronoi diagram generated by a random set of points.*/

void setup() {

size(1200,600,P3D); //size of your intended pattern

noLoop(); // don’t need to use the draw loop

/*unique name for your file. if left unchanged,

will simply save file with current milisecond*/

String fileName= “voronoi”+millis()+”.pdf”;

beginRaw(PDF, fileName); //enables you to save your design to a pdf

setupVoronoi(); // create your voronoi generator

int a = 3;

int b=4;

int numPoints=200; //must be multiple of n

float x=0;

float y=0;

float delta =0;

float t=0;

delta=(b-1)/b*3.14159265/2;

for (int k=1;k

t= k*2*3.14159265/numPoints;

x=200*sin(t*a+delta)+600;

y=150*sin(b*t)+300;

voronoi.addPoint(new Vec2D(x,y));

}

int c = 3;

int d=4;

int numPoints2=200; //must be multiple of n

float theta =0;

for (int k=1;k

y=5*(c*theta-d*sin(theta));

x=5*(c-d*cos(theta))+20;

theta= theta+23*3.14159/numPoints2;

voronoi.addPoint(new Vec2D(x,y));

voronoi.addPoint(new Vec2D(1200-x,y));

}

drawVoronoi(); //renders your voronoi

endRaw(); //ends the recording

}

/*This example draws voronoi diagram generated by a random set of points.*/
void setup() { size(1200,600,P3D); //size of your intended pattern noLoop(); // don’t need to use the draw loop /*unique name for your file. if left unchanged, will simply save file with current milisecond*/ String fileName= “voronoi”+millis()+”.pdf”; beginRaw(PDF, fileName); //enables you to save your design to a pdf setupVoronoi(); // create your voronoi generator int a = 3; int b=4; int numPoints=200; //must be multiple of n float x=0; float y=0; float delta =0; float t=0;
delta=(b-1)/b*3.14159265/2; for (int k=1;k }

Elephant

2012-05-21T13:18:49Z

elephant

http://nt.media.mit.edu/wp-content/uploads/sites/12/2013/05/elephant.pdf

//talkingbunnies

2012-05-22T02:56:57Z

My final project for the New Textiles class was inspired by the idea of telepresence, a word coined by the great Malvin Minsky. According to him, technologies are evolving to perfect the idea of telepresence, making it fit naturally in daily life. The premise for my project is simple, my loved one is moving away, across the nation, and I would still like to have a close relationship with him, not only through words but also through small actions. An easy way for someone to know you love of them is through a simple touch. Combining that idea with the fact that stuffed animals are naturally used by children to show care and love, I wanted to create a pair of stuffed animals that can communicate across the nation, using wifi.

The materials I used for the project are the following :

soft things

yarn, circular knitting needles, double pointed needles, tapestry needles, buttons, stuffing

electronics

2 WiFly shields, 2 Arduino Unos (R2), 2 A-B usb cables, regular wires, square LEDs, hot glue gun

I will continue the story from the previous update post about the final project.

The sensors I made for the bunnies are pressure sensors for the body and the ears, and a stroke sensor for the head. I did not run into many problems with making the sensor. However, they took a while to make.

body-sensor

testing sensor

stroke sensor

The part that turned out to be harder than I expected is the assembling process. I do not want to solder directly onto the wifly or the arduino because they are expensive, and I want to be able to use them again for different projects. It took several tries to come up with the correct solution. Leah suggested that I solder female headers perpendicular to the top of the wifly. This turned out to be a wonderful idea! I can remove the wires from the wifly and plug them for testing in to the arduino freely.

wifly module with female headers

Next, I soldered wires to all of the sensors and pulled them through the bottom hole of the stuffed animals. Because the inside is virtually a space that can be used to hide everything, it was easy to fit the sensors inside the bunnies. The only sensor that I did not solder wires to is the stroke sensor. For that, I used conductive wire and weaved that to the bottom of the bunny, being careful not to make any accidental shorts in the circuit. For added security, I used the hot glue gun to put glue on parts of the wirings that may have a chance to short out the circuit. This helped save a lot of headaches, but it is not very pretty.

sensors stuffed inside bunny

All the wires come out of the center hole

The bigest monster of the project is the wifly. The coding of the interaction itself is not difficult. For example, if one bunny is hugged, then the body of the other bunny will light up with the LED. The other bunny must be hugged to shut off the LED. Now, if this bunny is hugged only once, his LED will simply shut off, but if hugged twice, he will “return the hug.” There is also a simple need for keeping time in the system, otherwise the wifly will be commanded to check webpages several times a second. In my code I’ve written to check for new signals every 10 seconds and to not send the same signal again until after 2 seconds has passed.

It was hard getting the wifly configured, and it is also hard to get it to pull webpages at a set interval and then parse them.

1. The connection that the wifly makes is very inconsistant. Sometimes, it will connect and sometimes it doesn’t. This also changes with the network that it is trying to connect to. For example, it is harder for the wifly to connect to a open MIT network than a protected WPA1 or WPA2 network. The wifly also does not like to connect to webpages that are hosted by scripts.mit.edu. For some reason that I have not investigated, it sometimes takes the wifly over 20 tries to connect once. Because of this, I had to get my own server (using Amazon’s virtual machine) and host my .php files there. (The setup for the server is not trivial, and I had to ask a friend who had experience to help me.)

2. Parsing the output of the wifly is a daunting task. In the following video, you will see what I mean. It shows what happens on my computer as I simulate a “conversation” between the two stuffed animals.

Not only do I have to find the words that I want, I have to find a way to disregard all of the symbols that are printed out by the WiFly. I don’t really understand why the print outs look like so, but I came up with a semi-workable way to go around the problem. Instead of using the web stuff (http) I decided to use the more low-level TCP protocol to retrieve “pushes” from either bunny. Here, I assign each “action” to a number. So instead of reading a whole slew of letters, it only needs to recognize and parse 1 char.

Here is a short video of the bunnies communicating! (After the scare over the weekend because it stopped working, I took it to a friend’s house and tested using their network. After some small tweaks, everything was fine.)

I will be presenting this to my loved one who is moving away in the next couple of days!

Here is a PDF of my in-class presentation .

Interactive Hanging LED Lamp

2012-05-21T13:59:38Z

For my final project, I designed and built an interactive hanging lamp that changes behavior based on one’s proximity to the lamp. The design consists of a spherical base structure made of plywood, LED lights, flower-shaped cutouts made of mylar, a proximity sensor, and an Arduino board. The lights are programmed so that when someone stands close to the lamp, the lights turn on and remain steady, when one moves a slight distance away, the lights flash in an alternating pattern, and when one is much further away, the lights turn off.

The base structure was inspired by and built using Jennifer Jacob’s Codeable Objects library in Processing. The structure is approximately 20 inches in height, and about 12 inches at its maximum diameter. This went beyond the parameters which the codeable objects library allows you to use, but with some tweaks I was able to achieve the my desired size. Here is an image of the resulting 3D design as well as the 2D parts that were laser cut:

The base structure took quite a bit of trial and error to laser cut. At first, the design was too large to fit in the laser cutter. Also, the notches on the top and bottom pieces were too deep but after some adjustments and experimentation, I was able to laser cut the pieces correctly.

The 36 white LED lights were attached and wired to the lamp through the use of solder and copper tape lining the ribs of the base structure . The proximity sensor was also wired using copper tape as well as some insulated wire. Both the sensor and LEDs were wired to the LilyPad Arduino board using copper tape and solder.

Initial test of the lights after the Arduino was attached:

Attaching the laser cut flower shapes:

The finished product!

Link to Presentation: https://www.dropbox.com/sh/034kcsgpomeje1d/yZrIpkNK13/FinalPresentation.pdf

Link to the Arduino code: