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 .

1. I am able to connect my Wiflys to the internet, and it is able to get information from websites.

In my initial projet plan, I predicted that the setup of the Wifly will take the most time, and I was correct. The setup of the wifly has been the meat of the project thus far. It has been a source of headache for weeks, but I was finally able to configure it correctly and receive a positive behavior last week. The documentation of the wifly can be found on the Sparkfun website, scroll down and click on “Reference Guide (RN-131C)”. I always reference documentation whenever I work on a coding project. However, I found the Wifly documentation to be too technical and I didn’t understand a lot of the protocols it describes. Nonetheless, I was able to get my Wifly into AdHoc mode by following the steps described in section 15 of the reference guide. Even though getting into AdHoc mode is one step closer to what I want to be able to do, it is not sufficient. For example, having both wifly be in adhoc mode, I can sent and receive with both modules when they are within a certain distance, but not if one is across the country from the other. My ultimate goal is to get them both to connect to a wifi network.

Next, I went to Sparkfun and tried to go through the Wifly Talking Speaker Jet tutorial. Again, I ran into problems. It turns out that the code in the Wifly Serial Library is not optimized for the Arduino 1.0 software, the newest update. If you wish your code to compile on the newest Arduino software, please download this package, and put it in your Arduino library. In that package, you will find a version of the Wifly Serial Library that I edited to be compatible with the new Arduino 1.0 software. I found this guide from Cairo Hacker Space helpful in configuring the wifly. The code that he has on the website does not compile, but the setup instructions are correct.

I was still running into a lot of problems because I can not get my wifly to talk to the Arduino. This is because I am not able to configure the UART chip on the wifly. By this time,  I am nearing the end of the time I allotted to setup/configure the wifly on the initial timeline. So, I asked Leah for help. With her help, I am finally able to configure the UART and allow my Arduino to talk to the wifly. Here is the code that configures the UART chip. Next, I ran the  ”getWebClient” sketch in the Wifly Serial Package. See this video for the behavior.

This means the wifly works! It shows that it can get the html of the google home page. If you have a website, change “google.com” in line 14 to your site url and it will pull the html of the index page and display it in the serial monitor.

To make it easier to use, I’ve soldered headers onto the wifly so that it can be plugged into the arduino pins.

Here is a scan of my circuitry system as of now. It may get more complicated if I need to input more sensors.

2. I have finished knitting my two stuffed bunnies.  I ran into all the problems that a beginner knitter would run in to. Luckily, Emily is willing to offer her expert knitting tips. Right now, the bunnies are knitted, but I have not closed the top of the heads because I am still making sensors to embed into them.

3. Currently, I am working on creating an online database to manage signals from one bunny and send it to the next.

I created a scripts account from SIPB (hylinlin.scripts.mit.edu), and I am using phpMyAdmin co-currently. Right now, I am learning PHP at a rather sped-up pase from web3schools.com. The idea is shown in the below diagram.

There are still many things I need to do to make the project successful.

1. Make the sensors.

I will make pressure sensors (ears) , stroke sensors (head) , and a capacitance sensor (body) for each of the stuffed animals (inputs). The outputs will be sound (speakers) and light (LEDs) on the respective stuffed animals. Currently, I am also working on embedding a speaker into the stuffed animal. The media has to be down-graded  to a 8bit mono-sound. I am following a tutorial from the High-Low Tech group called Simple Arduino Audio Examples.

2. I need to calibrate the sensors so that they perform logically.

3. I need to test out the entire system once I have created the SQL database.

4. I need to come up with a way to store all the sensors and the arduino/wifly so that the stuffed animal is still a stuffed animal.

I started my design by visiting the Shapeways website to learn about the different materials and their properties. Most importantly, I need to find out the minimum thickness of the material that can be 3d printed, and the bed size of the 3d printers. The material properties, like flexibility and malleability, is also important, because it defines the wear-ablility of the jewelry. In the end, I chose to 3d print with the white, strong, and flexible in the color purple.

I started my design by creating simple modules that promise interesting, tessellation effects. For the module to become textile-like, it also needs to easily attach to itself. I experimented with several designs by first drawing lines, then rotating them in 3d space, and finally use the command “pipe” to give them thickness. The diameter of the module is 2 mm. It is unlikely that structures with alls <2mm in diameter can withstand the stress of wear and tear as jewelry, as explained to me in the tutorial section of the Shapeways website. Another important requirement is that the design must be a solid. This means that the structure must be fully closed on itself. A final piece of advice when creating 3d textiles is that each module can not intersect with one another in the structure. If they do, this will render the final product useless as a movable piece. It will be rigid where it intersects. I figured out a trick to speed things up in checking for intersections. Simply select the entire structure and type in the command “boolean union.” If meshes are created, that means there are intersecting modules. If not, then the design is good to go.

Originally, I designed a full necklace at a thickness of 0.9mm before I realized my mistake. If this structure survives the 3d printing and excavation, it will be “string-like”, and unwearable.

[rendering of first trial necklace]

I scrapped the original design, and started fresh, this time with the correct thickness for the walls. Below is a rendering of my favorite module.

During the design process, I didn’t really think about the cost. I had thought that the company would charge based on the amount of material in the final product, but it turns out that they charge based on the dimensions of an imaginary 3D box that can encase the design. Below is a render of my ideal 3D print necklace.

This structure would have costed me over $250 to print!

Of course, I don’t have this kind of money, so I had to downsize. Below is a smaller version of the necklace.

Still, this is too expensive. It would cost me $180.

I realize at this point that the amount of the necklace that I can print would be less than 1/4 of what I designed in Rhino.

This small section of my design cost me $90. 3D printing is extremely expensive, I learned. However, I look forward to receiving this little piece of art and wear it as a piece of my own design.

I have not received my order yet. It is scheduled to be delivered by the end of the day, May 1. If I’m lucky, it will get here before class! I will upload some pictures after I receive the product!

[UPDATE]

I finally received the 3D printed necklace! To make it wearable, I used strings of yellow leather strands to braid fishtail pattern on either side of the necklace.

]]> http://newtextiles.media.mit.edu/2012/?feed=rss2&p=2698 0 http://newtextiles.media.mit.edu/2012/?p=2623 http://newtextiles.media.mit.edu/2012/?p=2623#comments Wed, 11 Apr 2012 06:25:58 +0000 lefroyobunny http://newtextiles.media.mit.edu/2012/?p=2623 This week, I tried out some pattern knitting techniques on the knitting machine. I found that casting on is quite a challenge, depends a lot on the tension of the yarn, and also on the type of yarn. The thick, white yarn is especially hard to cast on, for example. However, after some practice, I was able to fix the initial cast on mistakes by observing how the cartridge layers the yarn and fix it with just the hook tool. Then, I can continue my knit without having to recast again.

My series of knit experiments began with the little “elf hat” structure described by this week’s lab instructions.

I also experimented knitting 4 such “elf hat” structures in a row to create a “mountainous terrain”-like structure.

I became very interested in creating 3D knit structures after this initial trial. I envision a large tapestry or carpet made up of entirely 3D knit structures which can be used as decoration or some sort of haptic feedback system. I wanted to explore the method of creating 3D geometry of knitting by putting the Reynold levers in position 1 and putting stitches on hold to create holes. I began to explore some pattern ideas with small sections of needles. By doing the initial “elf hat” knit pattern, I began to gain some intuition about how to create sinks and holes by putting certain needles on hold and others on knit. So I began, very simply, by putting everything on hold except 6 that are close to the carriage. Because those needles are the only ones in stitch, I decided to stitch over these needles several times to create extrusions in the structure.  I decided to repeat this kind of pattern across my 40 stitch cast on knit. I decided to switch which needs are in knit and takes some out as I move across horizontally. I decided to progress by 3 needles per knit. If I progressed by a lot of needles, it will degrade the quality of the texture (because the more folds I can make across, the more complex the geometry will be). If I progress by only a few needles, I found it was hard to see the pattern as I knit. In the end, this is the knit structure I produced.

While knitting, I can only see the back side of the knit, and I did not know how the front of the knit will be affected. Once I finished casting off, I turned the knit over and was very surprised to find I actually produced a sort of nice braiding pattern. I think if I finished a row and continued backwards in the same stitch pattern, I would be able to produce a fish braid 3D knit pattern! I didn’t have a chance to try this successfully yet (every time I’ve tried, I end up dropping stitches), but if I have time with the knitting machine, I will pursue that idea.

Here is the method I used to produce the above pattern:

1 – cast on 40 stiches

2 – knit 20 rows with pink yarn

3 – knit 10 rows with grey

4 – knit 10 rows pink

5 – knit 6 rows grey

6 – knit 2 rows pink

7 – switch Russel levers to position 1

8 – put all needles on hold except the 6 closest to carriage

9 – knit over 4 times, then put the next 3 needles into knit and the first 3 needles closest to carriage into hold (carriage should be on right), and knit another 4 times

10 – then put the next 3 needles into knit and then put the 3 needles closest to carriage into hold (carriage should be on right), and knit over 4 times

11 – continue the procedure described in steps 9 and 10 until you get to the end of the row

12 – switch Russel levers to position 2 and knit on all needles

13 – knit about 10 rows with alternating colors if you wish and then either begin the pattern again or cast off.

I will warn that it is very easy to drop stitches if there is not enough weight on the knit. I suggest moving the weights across the knit as you progress horizontally across with the pattern. Additionally, while the Russel levers are in position 1, it is very important that the needles not in knit are pushed completely forward in the D position. Else, the carriage will pull up the needle into B position and knit where you don’t wish it to knit.

The only precedent related to the concept of the idea is Pillowtalk. It is a concept to wirelessly connect two pillows so that they “talk” to each other. I don’t know whether or not the project is actually made, but their proposed communication technic requires the users to wear a belt while going to sleep, which is a component that I would rather leave out because it is unnatural.

The most difficult aspect of the project will be learning how to use the WiFly shield with the Arduino. I have never used it before, and I would need to read a lot of documentation. Testing will take a bit of time. However, once the wireless works, the boundaries of what I can do with communication factor between the two stuffed animals become almost limitless: this makes the project very attractive to me. The knitting will also take a while to complete, as I’ve never knitted before. However, I am learning fast. (Knitting is all I did over spring break!)

Sensors will be attached to the stuffed animals to sense the world around them and relay information to the Arduinos. The sensor wirings and setup will require some planning.

Here is a PDF version of my presentation : final project

During the exploration course, I found a voronoi shape that I became very found of. It is a simple flower shape with one spiral which branches out from the center. The geometry is very simple yet many astonishing moments which I have chosen to capture through photography.

I found the ‘rails’ of this voronoi simple yet beautiful.

This is an image taken of the back of a cut sheet using the metal + heavy paper which did not cut through.

The way that light travels through this voronoi creates and interesting halo.

The centers of this particular cutting is very delicate and I dare not pull the small pieces out.

Lastly, here is the processing code to generate this pattern.

 void setup() {
size(800,800,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

// =========GENERATE SPIRAL=============== //

int centerLimit = 500; // variable to control the maximum diameter of the spiral
float theta = .2; //like the diameter of your circle, but increases with every point in your spiral, producing the spiral effect.

//this will draw one spiral
for(int k=0;k        theta +=.7; //change to alter the tightness of your spiral
drawPoint(width/2,height/2,theta,theta);

}

drawVoronoi(); //renders your voronoi
endRaw(); //ends the recording

}

void drawPoint(float orgX, float orgY, float theta, float diameter) { //function that generates and adds circular points

float xPos = sin(theta)*diameter+orgX;
float yPos = cos(theta)*diameter+orgY;

 voronoi.addPoint(new Vec2D(xPos, yPos));

The first thing I made is a simple rectangular piece with an LED embedded inside. I used conductive tape for the two ends of the LED and cast it inside the silicone. Here, I used one drop of the purple dye to get a great violet for the silicone.

The results of this experiment works quite well.  The effect of the LED shining through the translucent  layer of purple silicone is very pretty. From this initial experiment, I learned that the silicone is very messy to work with, but it spreads evenly by itself quite well.

Then, I started to explore the possibility of integrating thermo chromatic paint into the silicone piece and see how it would behave. I found some dried thermo chromatic paint (aqua) in the lab and crushed it into chunks. I left it as chunks and mixed into part B of the silicone. I wanted to see the behavior of the color change of chunks vs specs of the thermo chromo paint.

I put conductive thread across different parts of the casting hoping to see the color change when I put current across the wires. The results turned out to be quite stunning. Silicone turns out to be a great insulator. It takes about 1.5amps to change the color dramatically. To see a quicker color change, I used a heat gun, and that’s the most dramatic change. I was specifically interested in the chunks vs specs and how they change color. The result was that the chunks changed colors faster than the specs. So, when I blow a heat gun across the cast, the chunks turn color faster than the other, less concentrated parts.

Next, I tried out the effects of fiber optics and its ability to direct light within double layered silicone casting. I found some fiber optic wires lying around and chopped them into small pieces with a wire cutter.

I had planned to lay them out so that they are orthogonal to the surface. However, this task was very difficult to do because it was very hard to place tiny pieces into a certain configuration, especially when the second layer of silicone was added to the mold on top of the tiny pieces.

Lastly, I put three drops of paint of  different colors onto the top of the silicone, and make swirl patterns. The intention of this is to be able to see the different colors as light is directed to the end of the fibers. It wasn’t a good idea to put dye on top of the silicone because after the silicone cures, the dye is not stable enough to maintain its form. Therefore, it rubs off on heated contact.

After the first few experiments, I gained enough experience with the silicone to begin doing more with it.  I am very interested in making stretch sensors with the silicone. My vision for such a device is one whose resistance decreases when stretched and lights up the an LED to make the visual signal of change in resistance.

For my first iteration, I use latex with carbon fiber and 4 LEDs. The latex cures more quickly than the silicone so I chose it as a “first try.” In order for this sensor to work, I realized that I need to use a lot of carbon fiber so that the fibers will touch even if the material is stretched.

This sensor works, but it doesn’t work very well. When it is not stretched, it has very little resistance (around 1k ohms) and when it is stretched, the numbers jump around the vicinity of 1M ohms. However, it seems that once the material is stretched, it doesn’t spring back to its original form. This makes the sensor unreliable and hard to work with.

The second iteration is using silicone with schoeller wool and LEDs. The appearance of the casting turns out to be much better than the one made with latex, mostly because silicone cures clear, not yellow. I layed out the schoeller wool across the silicone on either side of the LEDs.

I haven’t had the chance to test this iteration yet because I have not yet had time in the lab. I will report back with resistances and interesting things I learned once I have a chance to test it.

]]> http://newtextiles.media.mit.edu/2012/?feed=rss2&p=1887 0 http://newtextiles.media.mit.edu/2012/?p=1301 http://newtextiles.media.mit.edu/2012/?p=1301#comments Tue, 06 Mar 2012 20:20:29 +0000 lefroyobunny http://newtextiles.media.mit.edu/2012/?p=1301 A “wallflower” is someone who is shy, and who no one really knows. But that person can be some of the most interesting people we have ever met. This project is a tribute to those seemingly shy, yet extraordinarily interesting people.

The materials I used to make this installation include felt, 2-ply paper, heat-bound paper, about 8 in of flexinol wire, copper tape, fabric glue, conductive fabric, a lilypad arduino, and some wires.

The design of the flower began with a sketch.

The flower comes together in two layers, in alternating petals. There is a pressure sensor inside the step of the flower. When the flower senses someone approaching, it becomes shy and its petals close just a little. To close the petals, I used pre-trained flexinol (or nitinol) wire. I will be using a 3.7volt battery as the power source for this installation. The idea is as the current passes through the flexinol wire, the flexinol contracts due to heat and pulls the flower petals closer together.

The electrical connections is illustrated in this sketch.

The sensor goes to A5 and ground on the Arduino, and each of the petal layers connect via a MOSFET to a digital pin and ground on the Arduino. The other end of the flexinol wire connects to the positive (+) pin on the Arduino. Because flexinol is expensive, I have a limited supply. I decided to make the connections between each individual petal with the help of copper wires. Each individual petal is connected in series with each other on the same petal.

With all that in mind, I began the physical work.

step 1: Cut out the shape of each petal and a circular center piece to hold them together. After assembling the petals onto the center piece, I creased them at the edge of the center piece to aid in folding when they’re pulled by the flexinol.

step 2: I ironed some cloth onto the white paper using the heat-bond paper just to make the flowers look prettier, and I plan to cover the electrical wiring with felt.

step 3: Next, I cut the flexinol into 6 pieces, each about 2 inches. Then I poked two folds into each leave just above the bend crease and put the flexinol through. Because flexinol doesn’t solder, I pinched a crimp bead on each of the ends and saldered the flexinol onto the copper tape. Each piece of flexinol is connected in series with each other.

step 4: After all the soldering is done, I connected a MOSFET to one end of the wire going through the flexinol. The other end of the flexinol wire will be connected to the + on the arduino. Because I don’t want to risk burning the flexinol, I measured the resistance between the two ends. The top petals give a resistance of about 11 ohms and the bottom petals give a resistance of 14 ohms. This means the current passing through the wire using a 3.7 v power source is less than 0.41 mA, the maximum amount of current that can pass through the flexinol with out burning it. For the MOSFET to function correctly, I saldered a 1Mohm resistor in between the legs going to ground and the pin of the MOSFET.

Top petal > resistance: 11ohms ; calculated current: 0.33mA ; measured current: 0.30mA.

Bottom petal > resistance: 14ohms ; calculated current: 0.26mA ; measured current: 0.20mA.

step 5: For the pressure sensor, I made a simple “stem” for the flower using green felt. The sensor is calibrated with a non activated resistance of 11Mohms and an activated resistance of 1kohm.

step 6: Finally, I soldered all the connections to the conductive fabric with which the Arduino pins will be connected. I decided to use wires to connect the petals to the Arduino because the circuit would be too complex (with crossing wires and what not) if I had used copper tape or conductive wire. Pictured below is the side view of the product. The middle of the flower will be used to hold the electrical connections.

The final product of this project does not work as well as I had hoped. The main reason is because I did not have enough flexinol. With the amount of flexinol that I had, I was only able to make the petals move a tiny bit. However, if I had more flexinol to pull each petal, the united force would be stronger, and I would be able to achieve a greater folding action. Another reason is because my cardstock paper is a bit too heavy for the flexinol I have. If I had use just regular paper, the effects would be must more present. Even though, you can see the subtle yet present effect the flexinol has on the flower petals in this video. When the sensor is pressed, the petals fold in ward.

More improvements are being made to the current iteration. I will report back if there are noteworthy changes.

The materials I had access to were velostat, felt, conductive material, conductive thread, 5 LEDs, snaps, the sewing machine, and the Lilypad Arduino. The main idea I had is that I wanted the glove I am making to respond to touch, which can be achieved by making a resistive sensor that decreases its resistance if pressure is applied to it. I experimented with using velostat to make a resistive sensor. I searched online for previous work on these kind of resistive sensors and came across one on Instructables by Plusea. I read through the method and used it as sort of a guide in creating my own.

step 1: Cut four pieces of felt into small, button-like shapes. I cut four pieces even though two will achieve the goal because I want the button to have a rather thick texture so it feels nice.

step 2: Cut four pieces of velostat into circles. I know that I may not use all four, because if I put too much velostat in the sensor, that means it will have a higher resistance. The internal pull up resistor in the Lilypad is ~35k and I need the sensor to have resistance on the same magnitude as the internal resistor in its inactivated state for the pressure sensor to work nicely.

step 3: Next I double threaded the needle to sew a simple pattern onto one of the felt pieces. Notice I sewed a piece of conductive fabric to the end of the felt pieces. This is to make it so that I can connect other pieces of the circuit to the sensor easily. I double threaded the needle because it allows more current to travel through, which gave me a small control over the resistance of the thread. It also allows me to make the sensor more responsive to pressure. I did the same for the other side of the felt piece.

step 4:  The two felt pieces come together, sandwiching the conductive thread in between. I placed an extra felt piece on either side of the sensor to 1) hid the conductive thread and 2) create a nicer, thicker texture for the sensor.

step 5: Now is the time to play around with how much velostat to put into the sensor. As mentioned earlier, I wanted to create a sensor which has a resistance on the same magnitude as the internal pull-up resistor in deactivated state. As for my sensor, I still wasn’t sure how many pieces to put in at this point, so I just moved onto the next part for now.

step 6: Making the glove is very tricky. As I’ve never sewn before, I viewed this as a fun challenge. I traced a pattern around my hand and cut out the shape on felt. The first three iterations did not work well because, as a common mistake, I cut the pieces too small and neglected to account for the third dimension of my hand. However, the fourth iteration was successful and I sewed it up with the sewing machine.

step 7: In order to attach and detach the Arduino to my glove, I soldered buttons to the Lilypad and pressed buttons into a piece of felt so that I can button the Arduino on to the glove.

step 8: It takes a little effort in mapping out the exact route of the circuit on the glove so that 1) the wires don’t cross, 2) the glove looks aesthetically pleasing, and 3) the circuit functions correctly. This is the design I came up with for the back of the glove. The palm of the glove is simpler than the front: the A5 pin simply go to one side of the sensor and ground goes to the other side of the sensor. All the LEDs are connect to ground on the palm of the glove in a similar “whirlwind” pattern of the front of the glove. All the stitches are done with conductive thread, double threaded to decrease their resistance.

[palm  +  back of the glove]

The physical assembly is now almost complete with the exception of how much velostat to put in the sensor. I used the serial monitor on the Arduino to aid me in calibrating the sensor. After writing some simple code and turning on the serial monitor, I discovered that putting three pieces of velostat in between the felt allows me the best range in voltage drop over the sensor as a pressure sensor.

Resistance | Calculated Voltage across sensor |Measured Voltage Drop across sensor

400kΩ       |                       3.4V                                    |                          3.4V                                      |                  inactive

1kΩ             |                     0.12V                                   |                       0.2 V                                        |                active

Now that the physical assembly of the glove is finished, the software portion of the project begins. I wrote a couple of behaviors for the glove to make it interesting. These behaviors can be seen in this video.

behavior 1:  When the glove is not squeezed, the LEDs on the thumb, middle and pinky fingers light up. When it is squeezed, the LEDs on the forefinger and the ring finger lights up instead.

behavior 2: This is a visualization of how hard the glove is being squeezed. The LEDs turn off in a linear relationship with how hard you are squeezing or pressing the glove.

behavior 3: This pattern can be used in a game of roulette or a game of “red light/green light.” (Except the title will be modified to “light on/light off” of course.)

The first step is to estimate the amount of current that will go through the circuit. I laid out an estimated amount of conductive thread needed for the pattern and determined its resistance with the multimeter. The estimated resistance was 17 ohms. Using Ohm’s Law, the current is determined to be 218 mA.

To make sure that the circuit has at least 100mA and to account for practical errors, I double threaded the needle to sew the pattern. Below is the finished stitch work.

Here are some measurements and calculations I took of this project:

battery ~ 3.72v

resistance ~ 11 Ω

calculated I ~ 338 mA

measured I ~ 180 mA

It is interesting that the measured current is so much less than the calculated current. I think one reason could be because the contact points (the button and the power switch)  are sewn on too loosely, making it hard for the current to pass through the circuit.

Here is a link to the video of the textile changing color. The color change is quite faint and subtle, but if you look for it, you can see the blue region becoming more red, first in the middle then the sides.

Because I had some extra time, I decided to make this pattern wearable. I took two pieces of the canvas and put a piece of felt in the center to act as an insulator between the body and the color-changing canvas. then, I sewed some buttons to one side and some yarn on the other, and voilà it becomes a sleeve.

This is the final product.