Documentation assignment 5

 

For our group project, we went through a process of narrowing down the main idea, as well as a rather lengthy execution.

First, we were contemplating different projects, some of which aimed at amplifying a sense, and others aimed at depriving of and substituting a sense of the wearer. After discussing several options, we all agreed that it would be interesting to build a project in which someone would have to rely on a third person to move around a space.

When we settled for using vibration motors to guide a blindfolded user, we thought of first using sound as a way to direct the vibration, but then we realized that it made more sense to use light. That is how we ended up coming up with this project: a combination of LDR’s, Vibration motors and an Arduino (lilypad).

In terms of execution, we followed different steps:

  • Testing the circuit in the Arduino
  • Moving the circuit to a piece of fabric
  • Couching the components onto the shirt
  • Final tests

For the first step, we started building a simple circuit with a breadboard and an Arduino. We took the components (2 motors, 2 LDR’s, 2 resistors and a few wires) and built a prototype. Once we got it working, we moved on to the second phase.

For the second part of the execution, we split and I went to do the soldering work while Dania, Phylis and Lea were working on placing the lilypad and the supporting components onto some fabric.

The soldering took a while because of a few things. First, the wires of the motors were very small, so we had to use a lot of solder melted into blobs to seal the connections. Furthermore, the stranded core wires had to be twisted to make the connections and then, after Antonius suggested it, we added hot glue to seal the soldering job. Here are some pictures of the process.

Below, once we got the first parts of the circuit to work, we moved on to the tests to ensure that the motors and LDRs were working. We tried the motors with the code below:

const int motorPin = 9;

void setup(){

pinMode(motorPin, OUTPUT);

}

void loop(){

digitalWrite(motorPin, HIGH);

delay(1000);

digitalWrite(motorPin, LOW);

delay(59000);

}

There is a picture of the LDR readings on the console that shows them working. We used this code to test them:

int sensorPin = A0; // select the input pin for LDR

int sensorValue = 0; // variable to store the value coming from the sensor

void setup() {

Serial.begin(9600); //sets serial port for communication

}

void loop() {

sensorValue = analogRead(sensorPin); // read the value from the sensor

Serial.println(sensorValue); //prints the values coming from the sensor on the screen

delay(100);

}

 

While this was going on, Leah and I moved on to start couching the motors onto the t-shirt. We had a little change of design while executing this part, because originally we thought of putting them on the sleeve, then realized that it might be loose so it would not do its job.

We restructured the circuit, giving it a symmetric shape for the motors and sensors so that it would look neat and be under the user’s shoulder, thus giving him or her the feeling that someone is tapping on their shoulder.

For the last part of the process, once everything was built together, we combined the previously used programs into a very straightforward code that declared the LDRs as an input, the motors as an output and gave them a working range.

On Friday, I was travelling to Shenzhen and the rest of the team finished couching the components and ran our final tests. As you saw in the video we showed in class, everything was pretty much working perfectly until the presentation, which was a shame.

I really enjoyed this project because instead of only focusing on the coding part, I ended up taking part in the execution and it was very fun to work with the group. I really liked the project because it has an important human component – trust – embedded in the core of the idea, and turning this project into fabric and circuitry was very satisfying.

Certainly, there is room for improvement. Antonius suggested that next time we used male to female ends on the connections so that they can be easily changed. That is something that should be implemented in next projects, as it ensures that a broken component does not ruin the project.

All in all, I enjoyed working on this project, and I am very happy with the team, and I think this has prepared me for my final project as it has given me clarity in terms of what sense I want to amplify and through which means.

Lastly, the pictures that I have uploaded so far are very low quality and only 1/3 of all the documentation has been uploaded because my internet is really bad. I will update them from school tomorrow.

Assignment 5: Tilt Remote Sensor Makes a Sound

In this group project, Angelina, Sarah, Arizona, and I made a tilt remote sensor with the Arduino that can play a sound corresponding to tone 640 when you pressed the remote and tilted your wrist. We attached both the Arduino and the remote to separate wristbands. The Arduino wristband was quite long, spanning with 3 wristbands because it included a condensed breadboard and a portable battery.

 

This is the code for the Arduino. From what I know, you could get a regular remote without the tilt sensor and press volume – and volume + to get different sounds. But, for the conventions of our tilt sensor wristband, we can only play one sound, which came from the volume – button.

In our breadboard, besides wires, we used a buzzer, a sensor, and although in the photo it shows the LED light and resistor, we later realized we did not need it and replaced it with wires. This was because we didn’t need any component of our Arduino to light up, it only needed to receive the tilt sensor from the remote and make the sound. The communication was an audio response to the sensor, and not a visual one.

 

We learned how to correspond the red wires to power and positive and the black wire to ground and negative. This differentiation helped us in the long run in knowing how the breadboard and Arduino worked. The sensor also had a red wire for power, a black wire for ground, and a yellow wire for the Infrared receiver. The buzzer was connected to digital pin 10, and the sensor was connected to digital pin 8. I realize that we didn’t need to connect anything to digital pin 11 after all, because we removed the LED light, but we still just added wires where the resistor and the LED light would be so that it would close and continue the circuit.

For a future project, we should use our time to make more sound with the Arduino, and also make it more compact. We tried transferring it to the lilypad this time, but somewhere along the lines, it didn’t seem to comply, so we reverted back to the Arduino. In the end, I think this was a successful group project, and I got much enjoyment out of working with my group.

Arduino Project

For our Arduino project, my teammate and I based our idea off of holding hands. We placed sensors on the palm of our gloves to turn on a light when our hands attached together. Our long black gloves went down to our elbows with the intention of concealing our wires to give a more wearable look. However, the arduinos and the wires were bulkier than we expected and did not fit inside of the glove. Therefore, our gloves looked like items that belonged in a lab on a factory line. We used the arduino to program the sensors to turn on lights when they connect. This ideally. We connected the wires coming from the arduino to the sensors with conductive thread.  

We used the following codes to program the arduino:

int inValue = 0;

int outValue = 0;

void setup() {

 // put your setup code here, to run once:

 Serial.begin(9600); // this talks to my computer

 pinMode(9,OUTPUT);

 

}

 

void loop() {

 // put your main code here, to run repeatedly:

 inValue=analogRead(0);

 Serial.print(“input Value: “);

 Serial.print(inValue);

 outValue= inValue/8;

 analogWrite(9,outValue);

 Serial.print(” output Value: “);

 Serial.print(outValue);

 Serial.println();

 delay(10);

 

int redPin = 11;

int greenPin = 10;

int bluePin = 9;

//uncomment this line if using a Common Anode LED

//#define COMMON_ANODE

void setup()

{

 pinMode(redPin, OUTPUT);

 pinMode(greenPin, OUTPUT);

 pinMode(bluePin, OUTPUT);  

}

void loop()

{

 setColor(255, 0, 0);  // red

 delay(1000);

 setColor(0, 255, 0);  // green

 delay(1000);

 setColor(0, 0, 255);  // blue

 delay(1000);

 setColor(255, 255, 0);  // yellow

 delay(1000);  

 setColor(100, 120, 80);  // purple

 delay(1000);

 setColor(0, 255, 255);  // aqua

 delay(1000);

 setColor(123,50,48);

 delay(1000);

}

void setColor(int red, int green, int blue)

{

 #ifdef COMMON_ANODE

   red = 255 – red;

   green = 255 – green;

   blue = 255 – blue;

 #endif

 analogWrite(redPin, red);

 analogWrite(greenPin, green);

 analogWrite(bluePin, blue);  

TF: Electronic Fabrics Project

For this project, my partner and I almost immediately came up with the idea to have a t-shirt which activates when hugged by someone else. Using what we learned in class, we built a circuit which involved the following components: Arduino, breadboard, connecting wires, alligator clips, a resistor an LED and a push button. The method for connecting this circuit are as follows:

  1. Make a connection from digital pin 9 on the Arduino to a spot on the breadboard.
  2. In the same row, place one leg of the LED. The other leg can be placed in another row above/below.
  3. One leg of the resistor was placed in the same row as the second leg of the LED.
  4. Finally, a connection was made from that same row (with the resistor) to GRD on the Arduino.
  5. The button was placed onto the breadboard and one wire connection was made from the button to a resistor, then from the resistor to ground on  the breadboard. Finally, from there a connection was made to ground on the Arduino.
  6. On the other side of the button, a connection was made to digital pin 2 on the Arduino
  7. The Arduino was then connected to a computer.

 

 

From this circuit, we detached the wires closing the circuit around the button switch and attached alligator clips to them. We prototyped our idea using two mannequins. We placed two slightly separated, vertical strips of conductive fabric on one of them and connected one alligator clip to each of the two pieces of tape. The rest of the alligator clip was attached to the wires connection which we detached earlier. Next, we placed another piece of conductive tape on the other body horizontally. Once both bodies came together, the horizontal strip closed the circuit and allowed the LED to turn on.

.

 

Since this worked, we decided to use a similar concept on the final. For the design, we decided that we would have a pair of t-shits and each of them would have a heart design printed on them. One heart would have a plug and the other would contain the socket.

The designs were created in Illustrator. First I obtained an image of a heart on thenounproject.com. I also found the plug and socket designs on the same website. I used image trace to convert to a simple vector image and pathfinder to merge the plug to its heart. I deleted any other distracting lines that were not part of the outline which we wished to cut. Moreover, to achieve the same effect that we used in our prototype, we created a circular gap within the socket heart which, once closed by the fully solid cut of plug heart, would close the circuit allowing the LED to turn on.

.

We could have used the laser cutter or the vinyl cutter to print the design. However, we decided to go with the vinyl cutter as we didn’t have much experience with it. Moreover, with the vinyl cutter we could utilize the stickiness of the conductive tape to attach it to the shirt and remove it once we were done with the project. The laser cutter design would require us to use a fusible between the conductive fabric and the shirt, which could possibly leave a residue once removed (even if we used a fusible which would detach upon washing).

We ran into some problems while trying to use the vinyl cutter at IMA since the adhesive mat which is meant to keep the fabric in place while cutting was not sticky enough. After a few futile tries, I met with Antonius in office hours where he taught me how to use his vinyl cutter and the accompanying silhouette program. This process was successful.

Since the socket heart had a gap in the middle, and it would be difficult to tear the independent circle out in the middle then replace it onto the shirt in the exact place it as designed to be in(on Illustrator), we utilized transfer paper. The sticky part of the transfer paper was placed onto the design, the paper attached to theback of the conductive fabric was removed revealing the adhesive part and this was stuck onto the shirt. Next, the transfer paper was carefully removed from the front of the design. The same procedure was repeated for the plug heart which was placed on the other shirt.

 

We decided to use a strip of RGB LEDs(as opposed to single LEDs) for increased visibility around the neck of one of the shirts. We connected this strip to the circuit by soldering one wire to the 12V section of the strip and one to blue section of the strip (these spots are labelled on the strip), then attaching one side to the Arduino (5V) and the other to one to ground. We  used a portable battery to power thecircuit inplace of a laptop. TO make everything a little neater, we placed the circuitry into a Fannie pack.

Once this was done, we simply needed to use alligator clips(stemming from the circuit) to attach the circuit to the independent parts of the socket heart(outer heart and inner circle).  This was done in the same manner as the prototype.

 

Talking Fabrics | Social Switch | Hug Light

Project Name: Hug Light

Partner: Dania

Material: LED strip, Arduino kit, battery, T-shirts

Main Concept:

We want to make sweet T-shirts which will light up when people hug each other. And in order to indicate the idea more clearly, we also decorate the T-shorts with heart-shape plug and socket, therefore when the plug meets the socket, the LED strip light up and warm the huggers. For the T-shirts as the base, we used my T-shirt from NYU Shanghai and NYU Florence. Therefore we think it can also be functioned as NYU Alumni T-shirt when NYU students meet after graduation (Sadly I am now a Senior).

Process:

  1. Prototype our idea on a plain model, we use the conductive tape to achieve the effect that hugging activates lights by creating some gap between the tape on one T-shirt. And when the two T-shirt touches, the circuit connects and works, and the lights are turned on.

2. T-shirts ready

3. Pattern design

 

4. Solder the LED strip and connect it to the Arduino

DEMO of attaching the circuit on two T-shirts:

DEMO of attaching the circuit on one T-shirts and use the conductive tape to connect:

 

 

 

Talking Fabrics: Assignment 5 : Arduino (Leah)

Project: Arduino based gloves
Partner: Arizona Semones
Material: Gloves, two Arduinos, mini breadboards, Arduino attaches, wires
Process:
 Brainstorming:
 This assignment requires to contains a social switch, which means we have to have interactions with each other to trigger the switch of the circuit. So we came up the idea that we can attach our circuit to a pair of gloves. So when people clapping hands or holding their hands, the circuit will become accessible. So we bought gloves from Taobao and start to design.
Design and drafts.
Our original idea is to have two gloves with two conductive tapes as the switch, so we will have four different circuits in total.  So when people clapping different hands, the different circuits will be access
Here are our drafts of design
 
Circuit:
I started to design the circuit. I found that it is hard to active four circuits together. So I decided to just to do two circuits instead. I have one circuit with RGB LED and another circuit with twit switch and another led. I first test the circuit on the breadboard with conductive thread to test whether the circuit will work.
My basic idea is that one of the ground wire of the RGB LED circuit will to the ground of twit switch circuit. The twit switch circuit’s ground wire will go to RGB LED circuit’s ground.
For the coding part. The RGB led needs to import RGB values.
The twit switch needs to be controlled by if statements. The code is like this
 
Attaching the Arduino to the glove.
Then the next part is the most different part for me. It is to figure out a way that can attach the whole circuit into the gloves. The components are small and easy to sew into the glove, but the Arduino itself is way too big. And since our project is a pair of gloves, it is hard to carry the Arduino. Antonius suggested me to sew a little pocket on the back of hand part and have our Arduino into the pocket. Also, he suggested me to use the attachment of Arduino and have the circuit on the mini breadboard instead of separate them in the gloves.
Sewing
 It was still hard to sew the pocket, not the glove. The glove has two layers and I had to sew fabrics to only one side. I tried to roll up the gloves and make the needle through. But it didn’t work.
Finally, I figured out a way of sewing
It is like this.
Since the attachment and the Arduino itself has a gap in between, so I used fabrics went across the gap and sewed the fabric to the glove. The Arduino is attached to the glove in this way without hiding the circuit.
I also cut off shorter wires to make the circuit cleaner.
So here is what it looks like finally
int redPin = 11;
int greenPin = 10;
int bluePin = 9;
 
//uncomment this line if using a Common Anode LED
//#define COMMON_ANODE
 
void setup()
{
  pinMode(redPin, OUTPUT);
  pinMode(greenPin, OUTPUT);
  pinMode(bluePin, OUTPUT);  
}
 
void loop()
{
  setColor(255, 0, 0);  // red
  delay(1000);
  setColor(0, 255, 0);  // green
  delay(1000);
  setColor(0, 0, 255);  // blue
  delay(1000);
  setColor(255, 255, 0);  // yellow
  delay(1000);  
  setColor(100, 120, 80);  // purple
  delay(1000);
  setColor(0, 255, 255);  // aqua
  delay(1000);
  setColor(123,50,48);
  delay(1000);
}
 
void setColor(int red, int green, int blue)
{
  #ifdef COMMON_ANODE
    red = 255 - red;
    green = 255 - green;
    blue = 255 - blue;
  #endif
  analogWrite(redPin, red);
  analogWrite(greenPin, green);
  analogWrite(bluePin, blue);  
}

// RGB LED

int led = 13;
int buttonPin = 7;
boolean switchState = false;
int buttonState = 0;

void setup() {
  // put your setup code here, to run once:
  pinMode(led, OUTPUT);
  pinMode(buttonPin, INPUT);
  digitalWrite(buttonState, HIGH);
}

void loop() {
  // put your main code here, to run repeatedly:

  buttonState = digitalRead(buttonPin);

  if (buttonState == HIGH) {
    if (switchState == false) {
      switchState = true;
    }
    else {
      switchState = false;
    }

    if (switchState == true) {
      digitalWrite(led, HIGH);

    } else {
      digitalWrite(led, LOW);
    }

    delay(1000);

  }

}

//twit switch

Social Interaction– Huggable Heart

Diego and I were working together on the social interaction project, and we decided to create a heart that would light up when a person was hugged with the lights getting brighter the harder you hugged it. We planned on doing this with the microcontroller and the PWM pins to create a pressure sensor for the LEDs. After looking in the fabric scrap room, we decided on using blue felt to give the LEDs a sturdy backing. We also used some red ribbon to define the shape of the heart, as we were only using six LEDs to define the shape of the heart. We ended up using the Lilypad sewable LEDs. Luckily these LEDs have resistors built into them, which made the overall circuitry much easier.

First I sewed the red ribbon onto the blue felt in the shape of the heart, and then sewed the LEDs onto that so Diego could wire them. When we first prototyped the ground connections in class, it would only allow a few of the LEDs to light up at the same time, so Antonius suggested we wire them individually, which worked much better in the long run. Diego then used female to male wire connections to add these individual ground wires to the prototyping shield. We also used this same kind of connection for the positive wiring. Unfortunately after creating a mostly working prototype, we realized the connections to the LEDs were too flimsy, so we needed to solder them in place. This resulted in almost completely redoing the entire circuit from the beginning. Once this was done it worked much better, although it was still a little touchy in some spots.

While Diego worked on this wiring, I worked on creating a pocket on the back of the shirt for the microcontroller and the battery pack to sit in. After Antonius’s suggestion, I put a line of stitches in the center to make the components more stable and secure in the pocket. However, as Antonius pointed out during the presentation, it might have been more stable and more visually appealing to create an actual pocket for the components to sit in, rather than sewing a piece of fabric onto the shirt to create a basic sort of pocket.

We then began to work on the pressure sensor that Antonius showed us how to use in class. The conductive fabric was connected to the prototype shield using conductive thread, some alligator clips, and a few wires. We had one major problem with this however. We noticed that if the conductive thread touched anywhere on the board that had exposed parts that it would start to smoke and burn. In order to prevent a fire, we added wires with loops on the end that connected to the board to move the conductive threads away from the board. It ended up looking somewhat like an insect antenna. The initial code that Diego created for a blink function worked to light up the LEDs. Once we moved to creating code for a pressure sensitive switch, the LEDs, however, would not change in intensity, even after some code modifications.

After getting the main part of the circuitry working and in place, we decided to add a t-shirt over the top to hide the main portion of the wiring and to dim the LEDs since our pressure sensor wasn’t working. It was possible to see some of the color through the top t-shirt. As Antonius suggested though, it might have been more visually appealing to play with using different fabrics on top of the circuitry.

 

 

 

Assignment 5: Getting Acquainted with the Arduino (Phyllis)

Date: March 30th

Documented by: Phyllis

Role: Design, Circuit building, Coding, Soldering, Sewing the entire Arduino onto the yellow fabrics, Final decoration

Partner: Kai

Material: Arduino*1, LED*1, analog sound sensor*1, 220 ohms resistor*1, wires, power bank

Tool: Heat sealer, scissors

Inspiration: We consider “social switch” the most important keyword of this assignment. Therefore, we thought about many ways of socializing between people such as hugging, shaking hands and even bumping shoulders. However, many of them are about physical interaction. I asked myself if there are other forms of socializing rather than physical contact. Then, I realized that talking to people weighs so much in socializing. So we agree on the idea of using “sounds” as a social switch.

Process

Stage 1: Circuit Building & Coding

To detect sounds, I borrowed an analog sound sensor from the Equipment Room and connected it to the circuit. (Since we have practiced using a pressure sensor as well as conductive fabrics in class, I found that the way the analog sound sensor [see the left picture] works is pretty similar to that of the pressure sensor [see the right picture].)

Since we originally thought about having a design of a fabric cake and using the LED as the “candle,” so I tried to simulate the effect of blowing a candle. Therefore, the LED should be on when there’s no sound/noise, and should be turned off when someone is “blowing” it. So I figured out the relative coding in “loop” of turning off the LED when there is sound around it.

However, since we changed our design later, I deleted this part of coding in the end. Instead, as is shown in the video below, when you make some noise or say something close to the sensor, the LED will be turned on.

However, since the sound received by the sensor is not quite continuous, the LED is not able to stay on the same brightness, instead, it keeps blinking.

Stage 2: Design

At first, Kai came up with an idea of having the circuit in a fabric cake. We thought about using the LED as the “candle,” simulating a birthday celebration as a social activity. However, as Antonius asked us about “why fabrics,” we realized that it does not really make sense to have a circuit in a birthday cake as some sort of decoration on clothes. Although Kai already sewed the Arduino on fabrics (as is shown below), we decided to rethink about the design.

Then I asked my friend for advice, she suggested thinking about something that can blink. I then got another idea of making a star as a container of the circuit, Kai agreed. The star design look like this (after sewing on the arduino and cutting the shape)—

Stage 3: Soldering

Since we were no longer using breadboard in this assignment, I soldered the circuit first, so that we could directly sew the circuits on fabrics.

Stage 4: Sewing

After soldering, Kai sewed the circuit (with the LED, 220 ohms resistor, and wires) onto a piece of blue fabric.

Then, I cut out unnecessary blue fabrics, sewed the Arduino onto a yellow piece, and sewed another piece of yellow fabric on the other side (so as to cover the whole circuit). After sewing both sides together, I cut both sides of yellow fabrics into a star shape.

Stage 5: Final Decoration

I borrowed Marcela’s tiny sealer to heat the semitransparent fabric (it is actually some sort of fabric glue but I forgot the name of it…) so that it can stick to our star.

Actually, we had one black T-shirt before, but then we couldn’t find it anywhere. Therefore, Kai sewed our star onto a piece of white fabric instead.

Finally, I pinned our star to the model, and borrowed a power bank from our fellow Jack as a power supply for the Arduino!

Stage 6: Testing

After stabilizing the star on the model, I did a final test by saying some random words near the star. The louder you speak, the brighter it gets —

When you are meeting with your friends, it will be really cool to have a “blinking shirt!” The hotter your conversation is, then the brighter the LED becomes!

Reflection

  1. We think that it can be a prototype of a T-shirt for concerts or music festivals. With plenty of LEDs on the shirt, the audience can free their hands of glow sticks. We believe that blinking shirts can also create an amazing live concert atmosphere for not only the audience but also performers.
  2. Although we feel that it makes more sense to have a fabrics star as the container in comparison to a fabrics cake, we still have to spend more time thinking about Antonius’ question — “why fabrics.” I think I got what Antonius means by saying so, but still need time to think about the design.
  3. Since we only used one yellow LED, it is kind of hard to recognize its brightness, especially in the case that we also designed a yellow star. Having more LEDs for the design will definitely increase the brightness, so that the whole prototype will be more intuitive.

Special thanks to Antonius, Marcela and Jack!!!

int inValue = 0;
int outValue = 0;

void setup() {
  Serial.begin(9600);
  pinMode(9, OUTPUT);
}

void loop() {
  inValue = analogRead(0);
  outValue = inValue / 4;
  
  analogWrite(9, outValue);
  Serial.println(outValue);
  delay(10);
}

Assignment 4: Microcontrollers

March 30, 2018

To begin our learning process, we had to figure out how to code with an Arduino, and incorporate an Arduino into our fabric. We were to create a social switch that would respond to a sensor. My partner, Phyllis, had a great idea to use an audio sensor. She built up the code, shown below.

From what I gather, I find that the void.setup is for a one time use, and void.loop is for a continuous use. And, the delay is 10 milliseconds. We used analogWrite so that the LED would light up according to the audio sensor.

I worked more through the design process, especially the fabric part. We had to brainstorm way to incorporate the microcontroller along with the audio sensor into fabric. At first, we imagined that a birthday cake would work because people would blow at the audio sensor, and the LED light would light up. However, in the end, we decided not to do this approach because having a fabric birthday cake really wasn’t that joyful, especially when you’d rather have a real birthday cake to eat.

Our second idea was to make a star badge that would light up when spoken to. The star badge would be worn on the left shoulder of the person, and whenever some would say something, it would light up.

This sort of switch, I think, is very creative, because just imagine if we had more of these badges and we were attending a concert, and all these LEDs would light up responding to different sounds. Therefore, to create more of these badges, no matter if it was stars or another object like a sun, would be the next step in this project.

Design Process:

Materials:

Yellow felt

Blue felt

Double sided Fusible

Thread with corresponding colors (blue, yellow)

Arduino Uno

Wires

Portable Battery

Needle

Yellow LED light

Resister

Breadboard

220 Ohm Resistor

We made a prototype with the breadboard, and then transferred it onto fabric after soldering and couching the wires. Nonetheless, we had a finished product at the end, so that’s pretty cool!

                        .                                        

 

Incorporate Arduinos into Textiles – Documentation

For the social interaction project, Sarah and I decided to work on a switch activated by a hug that would light up a heart. Our original idea was that, using PWM pins, the harder you hugged, the brighter the LEDs would light up.

Originally, we started with a blue circle made out felt, a red ribbon and sewable LEDs. The sewable LEDs are great, because the resistor is already integrated in the LED so they greatly simplify the soldering and execution process.

On our first stage, Sarah did an awesome job in sewing everything together. We were working together during the class time to plan the circuit and initially, we started by trying to connect all the grounds of the LEDs. Here we ran into our first problem, because the circuit was too big and some LEDs would not work. Then, Antonius suggested that each of them had its own connection to ground.

We decided to do so, and by using female to male wires, we connected our circuit to a prototyping shield.

This was a great step, as we had a working prototype, but then the second issue came along: the connections were not stable enough, so we moved on to soldering all the LEDs and wires. We had to remove the circuit and almost start from the beginning, but we were certain that this time it would work.

 

Once we got that working, for the hug mechanism, we decided to use the pressure sensor that Antonius taught us in class. Below is a picture of our first test.

For the hug mechanism, we were using conductive thread to connect the conductive tape to our board. Then, we ran into another issue: the thread was somewhat loose and when it touched some parts of the board, it started burning and causing some smoke. We were worried about the state of our project (we did not want to burn down the lab), so we introduced a modification: we created an elongated hoop and tied the thread far away from the board to avoid this issue. If you take a second to check the picture below, you can see that there are two long pieces of wire coming out of the pocket that holds the battery and Arduino. This is how we solved our issue.

We had the circuit and concept ready, and we then proceeded to finalize everything and put it on the t-shirt. The only thing that was left was fixing the code.

Initially, we started with a simple blink to test the state of the project. It worked!

We then moved on to the final piece of code, which was very similar to the code we saw in class. Nonetheless, we were surprised about the intensity of the LEDs and how, regardless of your hug, they were always equally bright. We tried changing the imput value by dividing it by 8, but we faced the same issue.

 

We had a hard time making the circuits stable but after getting them to work and figuring out how to get everything on the shirt, we were both very happy with the final result. To cover it and make sure that you could not see the wires and to make the LEDs slightly dimmer, we put a t-shirt over the other t-shirt. Below check a picture of me hugging our creation: it works!