Maria and Albert's Laundry Pocket

Our initial design concept was a bit more complicated.  We wanted to leverage the power of the Arduino platform to dynamically and precisely change up to four outputs connected to our printed circuit board.  Nothing struck the imagination more than a music mash-up like the one below:

Greeting Card Music Mash-Up

Unfortunately, our electronics skills weren’t quite good enough to figure out how to connect and more importantly power-up our musical outputs and so we had to go back to the drawing board for something a bit simpler.

What we opted for instead was to a simple laundry pocket, powered by a PCB that flashed an LED red every 0.1 second when the circuit was closed — in this case, when the button was closed.  However, if there were enough quarters in the pocket and the connection was complete, that red LED would turn off and be replaced by a green LED that flashed every 0.1 second.

You can see a video demo of it here: Maria and Albert’s Laundry Pocket

The Arduino code is as follows:
const int buttonPin = 2;
int buttonState = 0;

void setup() {
pinMode(4, OUTPUT);
pinMode(3, OUTPUT);
pinMode(buttonPin, INPUT);

digitalWrite(buttonPin, HIGH);
}
void loop(){

buttonState = digitalRead(buttonPin);
if (buttonState == LOW) {

digitalWrite(4, HIGH);
delay(100);
digitalWrite(4, LOW);
delay(100);

digitalWrite(3, LOW);

} else {

digitalWrite(3, HIGH);
delay(100);
digitalWrite(3, LOW);
delay(100);

digitalWrite(4, LOW);

}
}

More pictures of our process are below — ENJOY!!!

Putting Together the Pocket

Inserting the PCB into the Pocket

Backside of the Pocket

Ironing on the Laser-Cut Laundry Prints

New Fashion Statement

Pocket Full of Quarters

Finished Pocket - Front View

Finished Pocket - Back View

Our concept is a hat which measures the wearer’s body temperature using a sensor held against their forehead and then displays the measurement with a color-changing antenna.

In Action

Construction

The brain behind the hat is a small microcontroller, the Atmel ATtiny85, mounted to a fabric PCB designed by Prof. Buechley and made by us in lab.

Temperature measurements are currently made by an integrated thermometer-on-a-chip (MCP9700A) which has been sewn in the forehead of the hat.

A tri-color LED is used as the output device and is mounted on an antenna made of clear plastic fiber.

Current Schematic

Future Schematic

Initial Circuit
An initial circuitry design featured the circuitry inside the puzzle pieces. This design had three lights and one puzzle piece that contained both an LED and a battery. Ideally, this puzzle piece would be placed first followed by the second or third whose LED would subsequently light up if attached correctly. The order of the 2nd and 3rd puzzle pieces did not matter. If all three pieces were correctly attached, all three lights would light up. There are flaws to this design however — for example, the pieces without the batteries might be placed first and despite being correctly positioned, they would not light up because the battery was contained in another puzzle piece. After speaking with Leah, we were advised to consider how we might integrate Arduino into our circuit. We also needed to consider a design that excluded the battery and micro-controller from the puzzle pieces.

Final Circuit
In considering Arduino, we thought that perhaps we could have a pin dedicated to each LED along with an input pushbutton that kept track of whether or not the puzzle piece was correctly attached. To do this circuit, however, we would’ve needed at least 8 pins which was more than the lilypad we made in class contained. So, we simplified our circuit design and integrated a sound feature.

The path for light is triggered: When the correct piece of the puzzle is placed in place, the light on the piece will fade in and out. When all the pieces placed correctly, the light emitted will be constant.

The path for the sound is triggered: When all the pieces are placed correctly, the “Celebration” song is played.

The code for the PCB is:

int brightness = 0;    // how bright the LED is
int fadeAmount = 5;    // how many points to fade the LED by
const int buttonPin = 1;
int buttonState = 0;

void setup()  {
//Initialize the PINS
pinMode(0, OUTPUT);     // ALL on , FADING each will start fading when put in the correct spot
pinMode(buttonPin, INPUT);    // Pushbutton, when all are assembled correctly, they complete a circuit which turns on the music
// When the music turns on/circuit is completed, the lights stay on, NO FADING.
digitalWrite(buttonPin, HIGH);
}

void loop()  {

buttonState = digitalRead(buttonPin);

// check if the pushbutton is pressed.
if (buttonState == LOW) {
analogWrite(0, 255);    // all turn on to brightness.

}
else {
analogWrite(0, brightness);    // all turn on to brightness.
brightness = brightness + fadeAmount;
if (brightness == 0 || brightness == 255) {
fadeAmount = -fadeAmount ;
}

// wait for 30 milliseconds to see the dimming effect
delay(30);

These are our videos

Learning Points:

1. Use similar LEDs for parallel circuits to ensure that all light up at the same time.

2. Use magnetic or conductive velcro attachments to complete circuits.

3. Measure the resistance of the circuits to ensure batteries are not overloaded.

4. Create another separate circuit for the sound so that it doesn’t go through the micro-controller.

At the start, we decided that we wanted to build a prototype that uses pressure sensors to trigger some reaction. With this in mind, we designed a cell phone case that would alert the user to a missed call or text with LEDs. When the phone vibrates, the felt case dampers the sound of the vibration and simultaneously triggers a blue LED to signal an incoming call/text. The program in the PCB turns on a fading yellow LED that keeps fading on and off until the case is opened, so that the user is constantly reminded of the missed call or new text message. This would allow the user to keep track of their cell phone even in a quiet environment like a library, as it converts auditory feedback into visual feedback.

Process and Technical Problems:

We both learned a lot in doing this project, from building  fabric PCBs and textile sensors to figuring out how to use them in an integrated textile circuit.  As part of the learning process, we made a phone case each, which was nice because our phones are not the same size.

We ran into problems early on in the project, with our AtTiny85 chip losing contact with the conductive fabric base several times . On one PCB, we resorted to burning a hole through the back of the fabric in order to solder the contact close. Programming was also tricky as we discovered that we were shorting out the PCB as our components were connected to the pins 1 and 2.

Inspired by Hannah’s sensor examples, we experimented with several crochet pressure sensors to pick up the vibrations of the phone. We went though many different sized sensors before settling on the one inside the case. The sensor is constructed of crocheted yarn in a patch the size of the phone. In the middle is a strip of conductive yarn mixed with wool yarn. There are positive and negative threads running though the sides of the sensor that are connected to the PCB to trigger the LEDs. Pressure on the conductive patch of the sensor would decrease the resistance of the path and hence make the signal at the PCB stronger. We used trial and error to “calibrate” the sensor. Before we resorted to trial and error, we made an attempt to draw data from the sensor. Quickly after starting we found that Println(); cannot be used with the AtTiny85 because it does not have the same hardware as the Arduino. Leah helped us with the software serial library in hope that it would allow for data to be read.  Unfortunately we could not make the speeds of the PCB and computer sync up and were not able to draw usable data.

Eventually, the sensor functioned in the way we intended and we started to map out the circuity and design the case. Once everything was sewed together we needed to re calibrate the sensor.  This is when things became tricky and the sensor finicky. Proof of concept has been achieved but currently the case is unreliable. We think that because the sensor is woven after some time the sensitivity changes because the fibers vibrate into a position that is not a sensitive and is more stretched out. Some of the unreliability may also be caused by the changes in voltage as the battery slowly loses it charge. However, the circuit still works when the case is squeezed.  In the future, we will consider using a sensor that is more suited to sensing vibrations, like a piezoelectric sensor, instead of a simple pressure sensor. However, we still think that the project was a success as we learned a lot from the process of making it.

Images:

To view us testing the sensors click here: http://www.youtube.com/watch?v=YtR3RHIZZE8

Here is a video of the case working before sewed together http://www.youtube.com/watch?v=_ZHjxvbGjWA

Here is the final working product:

Here is the final working differently than intended:

Code:

How did we make this project? The details are laid out below.

Firstly,  inspiration for all the pattern pieces were collected. The images were then traced  in Adobe Illustator as a means of producing templates for laser cutting.

Every piece of felt (except the black background and the tongue) was cut out using a laser cutter. The lilypads turned out especially nicely; We were able to use the laser cutter at very low power and a high speed setting to produce etched lines as a means of describing leaf veins.

We sewed the various pieces together – first, off the base mat and then onto the base mat. This is one of the flowers done. It is three layers of different colors and diminishing size that are sewn together in the middle. The flower was then folded in half and the middle sewed again and then folded in half the other way and sewed again for the 3D effect.

Then, the various pieces were sewn to the mat – a flower example is shown above.

We also sewed a stuff frog. The dots on its back are also etched on. We cut to identical frog shapes, sewed them right sides together, and then flipped him inside and stuffed him. Here we are sewing him to the mat.

Here is a close up of one of the dragonflies with and LED on it’s back. We used tiny LEDs that have the positive and negative leads soldered to little beads which are used to attached the LED to the fabric.

The lilypads were special. Each of them had heat sensitive glue on the back and they were each ironed onto the mat. The two lilypads that were going to be part of our buttons/sensors were embroidered along the veins with conductive thread. The tongue was also embroidered along the underside.

The finished product looks like so.

All of the circuitry is done on the underside of the mat.

Everything attaches to the microprocessor.

Arduino Code:

// constants won’t change. They’re used here to
// set pin numbers:
const int buttonPin_LilyPad1 = 1; // Lily Pad 1′s button goes to pin 1
const int buttonPin_LilyPad2 = 2; // Lily Pad 2′s button goes to pin 1
const int ledPin_LilyPad1 = 3; // Lily Pad 1′s led goes to pin 3
const int ledPin_LilyPad2 = 4; // Lily Pad 2′s led goes to pin 4

// variables will change:
int buttonState_LilyPad1 = 0; // variable for reading the pushbutton status
int buttonState_LilyPad2 = 0; // variable for reading the pushbutton status
int lastButtonState_LilyPad1 = 0; // previous state of the button
int lastButtonState_LilyPad2 = 0; // previous state of the button

void setup() {
// initialize the LED pin as an output:
pinMode(ledPin_LilyPad1, OUTPUT);
pinMode(ledPin_LilyPad2, OUTPUT);
// initialize the pushbutton pin as an input:
pinMode(buttonPin_LilyPad1, INPUT);
pinMode(buttonPin_LilyPad2, INPUT);

digitalWrite(buttonPin_LilyPad1, HIGH);
digitalWrite(buttonPin_LilyPad2, HIGH);
}

void loop(){
// read the state of the pushbutton value:
buttonState_LilyPad1 = digitalRead(buttonPin_LilyPad1);
buttonState_LilyPad2 = digitalRead(buttonPin_LilyPad2);

// compare the buttonState to its previous state
if (buttonState_LilyPad1 != lastButtonState_LilyPad1) {
// if the state has changed, change the lights
digitalWrite(ledPin_LilyPad1, LOW);
digitalWrite(ledPin_LilyPad2, HIGH);
}
else {
}
if (buttonState_LilyPad2 != lastButtonState_LilyPad2) {
// if the state has changed, change the lights
digitalWrite(ledPin_LilyPad1, HIGH);
digitalWrite(ledPin_LilyPad2, LOW);
}
else {
}

lastButtonState_LilyPad1 = buttonState_LilyPad1;
lastButtonState_LilyPad2 = buttonState_LilyPad2;
}

For this assignment you will work in pairs to create an artifact that includes a fabric PCB. The artifact should include an ATtiny85 microcontroller, at least two outputs and at least one digital (switch) input. Projects from last year’s class can be found here.

Teams for this assignment are listed below. With your team you should create a post that documents your project and add it to the Fabric PCB category. Your page should include pictures–including at least one close up of your PCB and one image that shows the entire project–a paragraph about your experience, and the Arduino code for your project. Also create a short video of your project in action. Post the video online (vimeo, youtube, etc.) and embed the video in your documentation page.

Bring your project to class on March 8 for demonstrations.

Extra Lab Help + Hours
My student David Mellis will be available from 3-6pm on Friday March 4 to help with Arduino programming. We’ll have extra lab hours from 12-6 on Saturday March 5th.

Teams
Albert Ching and Maria Anna Stangel
Ellann Cohen and Dena Molnar
Heidi Chen and Nicole Tariveridan
Judy (Zheng) Jia and Ilan Moyer
Sheralyn Woon and Crystal Ray