Touch Project

I got the inspiration for my final project while brainstorming ideas with Antonius at the time of the sight project. For my sight project, I wanted to create something which represented home, something that could be an expression of identity and culture. Normally, when I feel homesick, I listen to music from home. As such, I knew I wanted to work with music. I decided to create an instrument which acts as a common denominator to most Trinidadian music, the Steelpan. This is also our national instrument. I wanted to create a small, portable steelpan, using fabric, that would be flexible, portable and fun to play a basic rhythm on. I felt that something like this would also serve well in Trinidadian culture as locals always love to join in the fun of making music, and they normally do this by knocking a bottle with a spoon. So why not create a new way that would allow people to do the same thing?

The main design stages of this project were done for the sight project. This involved using a small, circular cutout of felt as the base for my steelpan. I then designed the irregular shaped notes on the surface of the pan using red felt cutouts. On the notes, I used the embroidery machine to design various images which are representative of Trinidadian culture. These images included 4 traditional folklore characters and the shape of the islands of Trinidad and Tobago on the map. I decided to use the folklore characters on the pan as both the characters and the steelpan are important elements of Trinidad and Tobago’s carnival, and they originated around the same time. To this day, the steelpan music is closely linked to carnival festivities as well as these 4 popular carnival characters; the Midnight Robber, Jab Molassies, the Dame Lorrain and the Mokojumbies/Stilt Walkers.

After the main design was completed, I decided to take this project further in my final project. The goal was to make what I had created playable. I started by prototyping using the following materials:

  1. 2 breadboards
  2. Arduino Micro
  3. 5 push buttons
  4. connecting wires
  5. 5 10 K Ohm resistors.
  6. Garage band software

The objective was to create an external keyboard that could be connected to my steelpan. This external keyboard would then connect to my laptop, which would receive input from it and generate sounds on Garage Band.

For the circuit, it was slightly different working with the Arduino Micro, however, only these boards have the ability to send keystrokes to the computer. The Micro required a breadboard of its own as it needed to be plugged into a breadboard so that connections could be made to the other breadboard. There were 5 pushbuttons, on one side, each button was connected to pins 2-6 on the Arduino Micro using wire. On the other side of the push button, was connected to 5V on the Arduino. The resistors were then connected by inserting one side of it in the row with the wire leading to the respective pin(2,3,4,5 or 6) and the other side led to ground.

The next step was the code. Firstly, it was important to declare the pin numbers for the five buttons. Also, I needed to declare a Boolean variable that would check whether the buttons were pressed or not. The Boolean was initialized as false or not pressed

Example: const int buttonPin1 = 6; (for each buttonPin)

bool pressed = false;

In the setup function, I set each button’s pinMode to input and in addition to serial.begin(), I needed to add keyboard.begin() and mouse.begin() functions. These were needed to initialize control over the keyboard.

Example: pinMode(buttonPin1, INPUT); (for each buttonPin)




The logic of the setup function is as follows:

  1. If the reading for pinButton1 was high meaning that it was pressed then if pressed is initialized at false, it must change to true.
  2. Next the output function would display ‘a’. ( the letter ‘a’ would correspond to a note on a garage band keyboard and thus play that note.)
  3. However, if the pinButton1 was low, meaning it had not been pressed, then we want no output thus, there is no output function. But we write that pressed is false so that once the button is released, the pressed variable returns to false mode.

With this logic, the code worked. However, there was a problem with how the note sounded. It lasted too long and sounded as though the note was being played multiple times very quickly, a problem known as bouncing. The program sound would therefore be helped by debouncing which would ensure that upon pressing, only one digital signal would be sent for a single closing of contact or pressing of the switch.

Thank to Antonius’s help, we were able to solve this problem using 3 two Arduino functions. Arduino functions: keyboard.pressed(), delay() and keyboard.release(). Keyboard.pressed acts as if a key was pressed and held on your computer. To end this key press, keyboard.release was needed to end the key press. The delay in between the two determined helped with the length of the note being played. A sample of this code can be found below.

Once this prototype worked, it was time to move it onto fabric. The goal was to replace the physical buttons on the breadboard with soft buttons made on the fabric steelpan. I started by placing one wire next to the side of the button which was connected to the pin on the Arduino, then placing another wire in line with the side of the button which connected to 5V. Next I removed the button. Once the two loose ends of those wires were touched, it returned the same output as pushing the button. That output on the serial monitor wrote the letter corresponding to the keyboard.pressed function. Thus in Garage Band, it played the note corresponding to the letter the button returned.

Since this worked, I began working on the soft buttons. I started by cutting out small pieces of conductive fabric in the shape of the notes. Theses pieces would then be stuck onto the back side of the pan. Next, I cutout another circular piece of felt that would cover the soft circuit inside. I then covered one side of that cutout with conductive fabric as well.


In between this sandwich, I would need non-conductive material to separate the surfaces for when the button is not being pressed. I cutout circular piece of neoprene for this as it was soft enough to allow for pushing while being thick enough to prevent the contact between the conductive surfaces when not pressed. I cut out five small holes in the neoprene which corresponded to the five note placements on the outer surface. Finally, from the circuit, I took one end of loose wire and taped it to the top surface of the conductive fabric. Next, I took the other side of loose wire and taped it to the other side of conductive fabric. It was important that these connections lined up directly with each other, so that once pressed, they would make contact through the hole in the neoprene. Pictures of this can be found below.

Finally, I sewed all three layers of fabric together.

Once this worked, I set out to find different sound effects as Garage band did not have sounds which were true to the steelpan. Luckily, I found an online virtual keyboard which played the notes on the steelpan. Thus, I used this software rather than Garage Band.

One problem I faced with this project was that the external keyboard often took over your laptop, pressing random keys regardless of my input. This happened a few times while working, however, generally restarting my laptop worked. In the final stages, I had one unique problem which was that one particular key played constantly. In troubleshooting, I commented out the code for that key and noticed that everything else played normally. Next, I moved on to check the connections and noticed that I had taped each side of lose wire to the wrong side of the conductive fabric. Therefore fixing this fixed my final problem. Below you can find a link to a video of my final project.

Final Touch Project

At the IMA show, my project went through many rounds of user testing. This alerted me to its flaws and its strengths. Based on their feedback and interaction with the product, moving forward with this project, I would implement a 5th note in the middle of the pan as people often tried to press that area as well. Moreover, people who could play a simple tune were often missing one more tone (‘a’) in order to complete the song. However, ideally I would find a way to make this more playable for people who do not know music or how to play the steelpan. I mostly intended it to be a fun way to produce a beat without actually knowing the correct combination of notes that would make sound. Therefore, these would be my major changes.

Finally, thank you to Antonius who was very supportive throughout this process, helping me to bring my initial idea to life. I also want to say thank you to my classmates who helped me refine my concept in our brainstorm stages and the IMA fellow Nicholas, who assisted me at times when my circuit went wrong.

Wearable Therapy Tracker

     When I started this project, I wanted to create a piano on a stuffed animal so that my grandmother, who has Alzheimer’s, could play the piano again. I found that a lot of other students were using sound as the communicating element of their projects, and I decided I wanted to create something that didn’t use sound but that would still be usable for my grandmother. My next project idea, that I suddenly scribbled into a notebook while someone else was presenting their idea (sorry about that!), was to create a tracker inside a stuffed animal that when pressed would record a data point. The idea being that when an Alzheimer’s patient was anxious or felt uncomfortable, the amount of data points would go up, helping the care provider to know if something was bothering them, even if they couldn’t verbally tell them. I posed the problem to my mother (ICU nurse and my grandmother’s primary caretaker) to bounce some ideas back and forth. Her suggestions were to create a tracker with a time element and a gps that could be placed inside a person’s comfort item to track when and where the patient felt anxious. For example, a tracker could be sewn into the corner of a blanket for a patient with nonverbal autism, nonverbal down syndrome etc. to help understand what is making the patient anxious. Identifying what the problem is can be extremely difficult for patients that are nonverbal or can’t communicate with you because they can’t simply tell you what the problem is. The other suggestion, which is what I went with, was to create a wearable tracker for behavior modification therapy in patients with things like Anxiety, OCD, ADHD, etc. These can be extremely debilitating for the patient– interrupting daily life. Therapy can also be extremely difficult because of the time it may take for a therapy to work, which can be frustrating and discouraging, and the judgement from others against those with mental illness (“It’s all in your head” “Get over yourself” “I get nervous sometimes too”). Therapy itself can be be a trigger for some because they worry that the therapist and others may judge them if the therapy doesn’t work immediately. Many patients will give a false positive report that the therapy is working because they worry the therapist or others will judge them if it doesn’t. In the long run, this hurts the patient even more because they aren’t able to find a therapy method that truly does work for them. By creating a therapy tracker, the goal was to help alleviate any anxiety caused by therapy and to give an objective way for therapists to see if the therapy is helping the patient. The basic principle of the tracker is like a stress ball that can count for you. The patient will press on the center of the striped fabric when they feel anxious and the arduino records a data point. By hiding the number count within the arduino rather than in something like a tally counter, it can help prevent any anxiety that could be caused by seeing the number go up. This data could then be seen by the therapist as a way to understand if the patient is anxious. By comparing the number of presses to a baseline it would be possible to see if the therapy is working. If the number is lower than baseline, then the therapy is working. If the number is higher or the same as the baseline, then the therapy is not working. There is a two-fold purpose in hiding the tracker in a bracelet. First, by hiding it in a bracelet, it looks like normal clothing preventing any anxiety or judgment from knowing that someone is wearing a tracker. Second, people tend to play with clothing, jewelry, pens, etc. when they are nervous. This allows the person to continue those calming, physical ways of alleviating any nervousness or anxiety in a way that can be quantified in a helpful way.

     Once I had the idea of what I wanted to do, my first major hurdle was coding the arduino. I do very poorly when it comes to coding, so I owe a big thanks to Professor Antonius for helping me write the code. In order to record data into the Arduino, we wrote in an EEPROM record function. When the button, ultimately the pressure sensor, was pressed it would record in the EEPROM an increase in the variable. However, with this alone, it may record three, six, or a whole bunch of points depending on the length of the press in the EEPROM instead of just once when the button was pressed. Professor Antonius suggested to use a debouncer into the code to make it record one data point in the EEPROM when the button was pressed once. In order to do this we wrote in a Boolean variable. When the button was pressed it would register that as a “false” and update the EEPROM once. It would then change the “false” to “true”. If the button was still registering as “true” (ie holding the button) it would not update the number. When the button was released, it would go back to “false.” So in simple terms, even if you press and hold the button, it will still only record one data point, making it just like a stress ball. To record six data points, press six times, etc.

      Once the Arduino was coded, I could start on transferring the hardware from a bulky breadboard and button into the  slim(mer), wireless bracelet that I wanted to create. I asking the equipment room for a prototyping shield with a breadboard so I could slim down the design, all they had with a breadboard was a cellphone shield, but it still ultimately worked for my prototyping. I put the button, a resistor, and two 3.7 V battery packs onto this using wires. I used all black wires so it would blend in with the black fabric. In order to make sure I didn’t short circuit it, I used tape to create a system I could understand for plugging all the wires in. Masking tape went to the same battery and green electrical tape were the positives. The sensor was created by using two pieces of conductive tape and two places of stranded core wire. The wires are plugged into the Arduino and then each attached to one of the pieces of tape respectively. The wires are stripped and spread on the end connected to the tape. I spread the strands apart and used electrical tape to press them onto the conductive tape. Touching the two pieces of conductive tape together completes the circuit, acting like a button-press.

      I used black neoprene for the bracelet body because it was stretchy for going onto different sized wrists and it the fabric was thick and dark to hide any color on the Arduino and blunt any sharp edges. To make it easier to sew together, I used a water bottle to act as a wrist form kind of like a dress form you would use for creating a T-shirt. This kept me from sewing it so small that I would be the only person it would fit on. I cut out a piece of fabric long and wide enough to create a bracelet when the ends were sewn together. I also added a section at the top that could be folded over the Arduino to create a rudimentary pocket-hem-like-thing. I sewed the ends of the bracelet into the circle shape while it was inside-out so the seam would be on the inside. I then put this on the water bottle so I could add the electronics. I had the Arduino, shield, sensor, and batteries all wired together at this point so I detached the batteries so I could sew it on. I placed the Arduino and shield on the top and folded the fabric over it, sewing the sides down to hold it in place. I left the end open so it was still possible to access the spot for the computer plug-in and see the LED to make sure the Arduino was actually receiving power. I then cut another long piece of the black neoprene so I could make another band over the rest of the band to create a pocket for the batteries to sit in and to act like a rubber band to hold on the Arduino as securely as possible. I taped the batteries together in a V-like shape so they would be more ergonomic on the wrist. I also taped their connection wires together and to the side. I sewed the band around on the rest of the band starting with a seam just around the top first. I then put the batteries in the half pocket that was created. I pulled the connection wires of the batteries close to the Arduino and the Arduino power wires to the same side. When I did the seam around the bottom I did a very long stitch over these wires to hold them in place for easy access but to also make sure they didn’t move once they were wired together. To create an opening for the Arduino in the bottom like I did with the pocket-sem-like opening, I did what I’ve done before to create gathered lace. I did a simple running stitch through the fabric without connecting it to the bottom piece of fabric. Once I got to the other side, I pushed the needle through both piece of fabric and pulled the thread tight to bunch the fabric together around the opening. It’s kinda like the opening in a sock without the elastic. You want it to stretch and be big enough to get your foot in, but not so big it falls off. Gathering the fabric here makes it so you can access the Arduino when you need to, but it holds it in place otherwise. Having this opening also allowed for the wires going from the sensor to the Arduino. I then went to sew the sensor on top of the bracelet, but I discovered one of the wires came untaped so I had to bust it apart to retape everything. Once I repaired it, the wires were still very touchy and required constant fixing. Even when I couched the wires in place they still tended to pull out of the tape, so I should have looked for another method to attach the wires. Here I used 2 pieces of striped woven fabric to hide the conductive tape sensor because stripes are very popular right now (makes it look even more like regular clothing) and they were already the size I needed for my project. In retrospect, I should have used a serger hem on the edge of these pieces because they were beginning to pull apart. After the sensor was sewn on, it covered a seam on the top band and the project was completely put together barring any problem.

     But, there are always problems.

     Once I had it all together, I had a problem with getting it to record data. After showing it to Professor Antonius, we found that I had wired the breadboard incorrectly. Fixing the breadboard wiring did ultimately fix that problem. I then put electrical tape over the top of this so that the wires wouldn’t disconnect when I put the Arduino back in the bracelet. Luckily the opening I left in the bottom was just large enough to remove and put the Arduino back in without having to rip the seam out.

     After this problem was fixed, the project worked just like I had intended, even if the sensor was a little finicky.

     For the future of this project, I would like to add a GPS tracker and a clock to add in the potential to see if particular times of day or a particular place causes the patient anxiety. I’d also like to make the microcontroller and battery pack much smaller and more flexible. A button switch for the battery pack would also be an ideal addition so you are able to turn it on and off without unplugging it.

Further projects with this could include other versions of it for other applications. For example, create a sensor that could be placed on object for OCD patients, such as light switches or faucet handles. It would also be ideal if there was an App on a smart device like a phone or tablet to have a patient recorded therapy evaluation (similar to current models) that could be coupled with the data received by the device to provide additional information for the therapist.

The presentation I created for the IMA show has some additional info in an easily viewable way:


-Sarah Brooker

#include <EEPROM.h>
int addr = 0;
int val;
boolean pressed = false;

void setup() {
  // put your setup code here, to run once:
  pinMode(13, INPUT);
  val =;

void loop() {
  // put your main code here, to run repeatedly:
  if (digitalRead(13) == 1) {
    if (pressed == false) {
      EEPROM.update(addr, val);
      pressed = true;
  } else {
    if (pressed == true) {
      pressed = false;

Sewing on the Circuit Board: Project 2

For my second project, I was tasked with the challenge of sewing a circuit onto a piece of felt. First, I used a a fabric ring to hold the felt together. I found this tool to be useful while sewing, making the process of stiching wires to be more stable and efficient. I first stitched on a red wire and connected it to a resister. The resister was then connected to a LED light. The small light was then connected to a small button to be used to turn on the light. This button connected to a blue wire, which then was attached to the battery. I connected all of these components together using conductive thread. While at the beginning I found the process of turning on a light with a battery to be slightly complex, translating the configuration from a breadboard to felt helped me understand just how simple the circuit really is. This made it easier for me to visualize the connections with the wires easier. In the future, I think it would be interesting to put LEDs on a jacket pocket as a embellishment using wires and small batteries.

Touch Project Documentation (Leah)

Date:  May 18th, 2018
Project Name: The lap Piano
Description: This touch project creates a piano keyboard on a pair of jeans. There are fives for five fingers and each one in turns corresponding notes Do to sew. The circuit is connected with Bluetooth to the computer, and the notes are made through processing.
Idea: When learning piano, students may unconsciously tap on their lap when they are set as if they are playing the piano. So I came up with the idea to have a “The Lap Piano”. There will be a keyboard on the lap to let the user who wears it tap on the keys and it will actually make the sound from the computer.
I started with coding the notes. I searched for source code on “processing piano”. I found sources using mini library.  The source code allows the user to play with the keyboard.
 Here is the source code link:
Then I changed the code to serve my purpose. I want to let my Arduino control the keys instead of the keyboard of the computer. For the Arduino, it could be as easy as the circuit being connected or not using a button since I don’t need to control the volume so I just need value 1 or 0 to tell whether the sound is made. So I used if statement to do that, letting if the value == 1 than the processing would make a sound.
Then I started my circuit with the breadboard. I tested the circuit with a button and resistor. I didn’t use Bluetooth connect at this time for I need to ensure the circuit work in the first place then go to the next step.
Then I tried to connect with HC-05 Bluetooth connect to connect my circuit. However, I had big trouble uploading the code. The circuit was right but I can’t upload my code to Arduino when connecting to the port HC-05. I asked Professor Antonius for help, I found that I made the mistake of Bluetooth connection. I should first upload code to Arduino wire, then Bluetooth is just a way of sending single. When first uploading code with wire, I should unplug the RX and TX to make sure the Bluetooth connection would not affect the wire connection. Then after uploading the code, just change the port to the HC-05 Bluetooth connection and I don’t have to upload code again since the Arduino had been programmed. I did that and succeed got Bluetooth connection worked.
Here is my final Arduino Code
Antonius then gave me another important suggestion, I don’t have to use buttons to control the circuit since the button is not wearable and comfortable on the clothes. Instead, the button just served to cut or reconnect the circuit, so I can just use conductive tapes and other material to make a wearable switch. It reminds me of the “sandwich switch” in our textbook, so I referred to the textbook to make the switch.
Then is to actually connect the circuit to the jeans. I choose a hole jeans so it is more convenient for me to put the wires around. I first sewed the resistors with the sandwich switches together with conductive thread. Then I soldered resistors with the wires connected to the ground (black wires). I used other two wires connected with power (red wires), and digital output pines ( yellow wires). I finished with the first button but when I was testing with the second button, it didn’t work and got short-circuited, I tested servals, but didn’t figure out why, during this process, my Arduino board was burnt due to the short circuit.
Here is one demo before the Arduino was burnt
I borrow another Arduino board and found out the reason. When I sewed the resistor to the switch with conductive thread, I accidentally sewed two conductive sides of the switch together which caused the short circuit. I took the switches apart and re-sewed them with normal threads. Then instead of using conductive thread, I made holes on the switches and made a loop on the resistor. In this way, the resistors and wires are still connected to the switch but it would connect with each other and cause the short circuit.
I finished the other four switches and made the switch black and white to make it looks like keys of a piano.
Here is the demo
Lessons learned and further improvement:
1 I could use glue to product the connects. Both to make the connections more stable and prevent the short circuit.
2 I could couch the wires to the jeans to make the wires more stable
3 design and debugging take much more time than coding.

Arizona Final Project








For my final project, I was interested in doing something connected to a passion I have outside of school. I have been a active kick boxer for the last two years, and use it as a sport as well as a form of exercise. kickboxing. I originally thought it could be interesting to have a sensor attached to a punching bag that makes a loud noise whenever a punching glove came into contact with the sensor. I used the Makey makey idea presented in class as inspiration, and as a method of execution. This provided me with a simpler approach to making a noise through sensors using garage band and speakers from my computer. I connected the maker makey to my computer, enabling it to attach to the key board in garage band. This allowed for me to create a sound when the the punching gloves hits
the sensor. In the future, I would like to take this project further by not having wires connected to the gloves. There are types of sophisticated micro chips implanted into footballl helmets that calculate the pressure made against helmets when a ball player is tackled. It would be interesting to find something along similar lines but for boxing gloves. I think I could possibly in the future use something with blue tooth for the overall sound effect.

TF: Group Project- The Trust T-shirt

At first our group brainstormed many ideas until eventually deciding that we wanted to use a blindfold to take away someone’s sense of sight, then use our project to guide them. This is how the project would work:

  1. Person A wears a blindfold to augment their sense of sight
  2. Person B uses a flashlight to guide person A
  3. We design a T-shirt for Person A which would contain two light sensors (one to the right of the chest and one to the left of the chest), which would detect Person B’s flashlight cue. Depending on what cue is sent, a vibration motor corresponding to the side of the sensor would vibrate
  4. If person B aims the flashlight to the right sided sensor a vibration motor (on the right side of the shirt) would be activated indicating that person A should turn right and vice versa.

After thinking about functionality a bit more, we noticed that placing the light sensors on the front of the shirt would be a bit awkward, especially as the leader would have to walk backward to guide the follower.

We thought that placing the sensors on the back of the follower’s shirt would be much more practical and so we moved ahead with that idea.

Next, we prototyped the basics. We created our circuit using a breadboard and Arduino. You can find a rough sketch of the circuit below.

Next we experimented with the code and thankfully it worked. We tried the following code for the LDR, declaring them as the inputs and giving them a range of light to detect:

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




For the motor we used this code, declaring them as the outputs:

const int motorPin = 9;

void setup(){

pinMode(motorPin, OUTPUT);


void loop(){

digitalWrite(motorPin, HIGH);


digitalWrite(motorPin, LOW);



We then tested to see if these worked by shining light on each sensor and monitoring whether the corresponding motor vibrated. Since this worked, we proceeded to think about how we could make a more compact circuit to be placed onto a T-shirt, so that it could be wearable.

We decided to move all the components onto a lilipad which could be sewn onto fabric. However, before moving any circuit onto a lilipad, it was important to carefully plan how this would be done. We found sketching very helpful. You can find a picture of the sketch below.

We started by couching ground on the Lillipad to a white piece of cotton fabric. From there we did a backward stitch leading a looped piece of wire. We couched one side to ground. On the other side, we would use conductive thread to sew two separate branches which would then connect to each of the two 10 ohm resistors needed for the LDRs. Using wires and conductive thread, we sewed these components to a1 and a2 respectively.


We did the same procedure for the 5V, starting with one wore which would then branch out into two parts for the left-sided LDR and the right-sided LDR. The other side of the LDR would then connect with the resistor branches at a1 and a2 respectively.

The motors were connected to the circuit via pins 6 and pins 13. For the left-sided motor, one of its wires connected to pin 6, while the other side was rejoined to the first branch created at ground. The same was done for the right-sided motor, with one end connected to pin 13 and the other joining the other wire branch at ground.

A picture of the final outcome could be found below. The LDRs are at the bottom and the motors are at the sides, just slightly above the LDRs.

After this process, we secured the white cotton fabric onto the t-shirt using double-sided tape. We also spent a substantial amount of time securing all connections. We used nail polish remover to secure frayed ends of conductive thread and electrical tape to insulate any wires which were twirled around each other. We then couched the motors onto the back of the shirt and created small holes in the t-shirt for the LDRs to peek through. Finally we had a working product.

We left our finished project over the weekend, then returned to it on Monday to meet a fully functioning project. However, by Tuesday, when we had to present, we noticed that the left-sided motor did not work. While troubleshooting the problem, we noticed that when we aimed light at the LDR, it started returning absurd values to the serial monitor. It was evident that the LDR broke. Soon after, the right-sided LDR and motor, which was still working also stopped. The LDR returned normal values, but while checking the connections, we noticed that one of the tiny, delicate wires which came attached to the motor became disconnected. This happened while we were flipping the shirt inside and out to rectify the issue with the left-sided motor. This was an unfortunate turn of events at the 11th hour. However, one must always be prepared for such troubles and take videos and pictures of  the working project at every step of the way. Thankfully, we had one short video of the working product which you can find below.

Click here for working T-shirt Link

Talking Fabrics: Touch Project (Phyllis)

Title: Sleepy Rabbit

Target: 3-5-year-old Children

Description: This touch project is designed to simulate the process of a mom taking care of a baby (especially calming children down before going to bed). I hope that by playing around with this sleepy rabbit, children may learn to take care of others just as how mom is taking care of them every day.

Documented by: Phyllis

Documented on: May 15th, 2018

Material: RFID*2, RFID Reader*2, Arduino*2, wires, Toy Rabbit, thread, insulating tape, Bluetooth speaker



Basically, my design of this project is to have the toy first “cry” and then sweetly “fall asleep.” It’s quite common for babies to cry when they want to go to bed. Crying babies need more care, and moms often wipe out their tears. Therefore, I wanted to have an interaction of children wiping tears for their toys as if they are comforting them. When children putting sheets on the toy, it falls asleep, just as how moms calming their babies down at night. After talking with Antonius about my idea, I was suggested using RFID to achieve my goals in this project.

Stage 1: Circuit Building and Testing

I searched for an example code of the RFID and tried to make 2 RFID work at the same time on one Arduino. I spent so much time figuring it out but failed… Below is the code that I tried to work with on basis of the example code that I found on the RFID documentation.

After asking Antonius about it, we tried to figure it out together but failed again… The Arduino was just printing wired numbers/letters that were received from the RFID, which we did not understand at all… and only one of them was working at one time. After trying several times again, Antonius suggested having each RFID work on different Arduinos… Therefore, I broke the circuit into two, and got back to using the original Aruidno code from the RFID documentation.

After directly testing with the sample code, I tried to build serial communication between Arduino and Processing. However, I realized that the way that RFID works is actually really different from what I thought it should be. It turned out that I couldn’t successfully translate what RFID received to processing (I asked Nick for help and we were stuck here for more than a whole day)…

Fortunately, Luis helped me find a processing example code on GitHub for building serial communication with RFID. As is shown in the testing video below, it worked!!! Then I added sound files that I found on freesound (crying sound, snoring sound) in processing.

After making sure that my code was working fine, I tried to make the whole circuit more solid. I used the insulating tape to stabilize the RFID and twined the Arduino with some thread.


Stage 2: Moving the Circuit into the Toy

Since I wanted to hide the circuit inside the toy rabbit, I made a huge “hole” on both the back and the head of the toy and took out 40% of the foam.


Then I hid the circuits inside the toy. I placed one RFID from the back and one from the head (the USB of the Arduino comes all the way through the toy’s tummy) so that when the toy is facing children, children may interact with it at its right eye and its tummy. I had to be really careful because the space was so limited and I was also afraid of taking my circuit apart.


I succeeded finally!! The two USB wires all come out from the back of the toy, which could be hidden by covering the rabbit’s shirt.

Below is a rough testing video after I finished 90% of the final fabrication.

Stage 3: Final Decoration

In order to make the whole project more connected, I sewed one smaller RFID reader in a piece of white fabric so that it seems to be like a napkin.

Then I sewed another card-shape RFID reader into another piece of fabric to make it look more like a sheet. The left photo is actually how the “sheet” looks like in the front, and the right photo is how it looks in the back.

In terms of the way of sewing… I actually sewed a pocket for the RFID reader card. The photo below shows how the pocket looks like on the side (but honestly, it’s not quite intuitive though).

I also sewed the head and the back after placing the circuits inside of the toy (as you may see in the photo below).

This is how my sleepy rabbit looks like after all the fabrication and decoration.


I feel that sound choice is really important meanwhile hard to make a good one. Although I spent plenty of time searching for the most appropriate crying audio, I still feel that the crying sound is kind of too creepy for children to play with (I guess…). The current crying audio in this project is actually a cartoonish one, which I consider the best in comparison to the rest… However, if the sound file is not good enough, it might change the whole initial concept of my project.

import processing.serial.*;
import processing.sound.*;

Serial myPort;
String inBuffer = " ";

SoundFile soundfile1; 
SoundFile soundfile2; 

void setup() {
  size(512, 512);

  //myPort = new Serial(this, Serial.list()[3], 9600);
  myPort = new Serial(this, Serial.list()[4], 9600);

  soundfile1 = new SoundFile(this, "cry_cartoon.wav");
  soundfile2 = new SoundFile(this, "snoring_baby.wav");

void draw() {
  if (inBuffer != " ") {

void serialEvent(Serial myPort) {
  while (myPort.available() > 13) {
    inBuffer = myPort.readString();   
    inBuffer = inBuffer.trim();
    if (inBuffer != null) {

void drawTag(String tagVal) {

  if (tagVal.equals("18002700C9F6")) {
    fill(255, 0, 0);
    ellipse(width/2, height/2, 100, 100);
    // stop crying with the blue snap
  if (tagVal.equals("0300B4A34155")) {
    fill(255, 255, 0);
    ellipse(width/2, height/2, 100, 100);
    // start snoring;
  inBuffer = " ";

Talking Fabric Final Project: Love Always Wins in Triangle Identity

Date: 2018/5/14

Project Name: Love Always Wins in Triangle Identity

Documented by: Angelina Ye



  • I start this project with an idea to do something about Allyship
    • Allyship is not an identity—it is a lifelong process of building relationships based on trust, consistency, and accountability with marginalized individuals or groups of people.
    • Unlearning and re-evaluating beliefs and actions
  • In terms of the media to convey this message, I think of LED matrix. My first idea was to create some game on the LED matrix, such as Tetris and Snake game, however, after trying to work this idea for two weeks, I finally give up because of two reasons: 1) to create an interactive game on the LED matrix is beyond my own programming skills; 2) these two game settings do not match with the Allyship idea I want to convey and do not contribute to convey the key message. Later I came up with the LOVE flag idea, which is to raise a heart flag on the LED matrix by spinning the potentiometer and giving arduino different values.
  • Thanks to Antonius, he inspires me to discover the story behind Ally logo and the importance of triangle patterns. Then I find that the triangle patterns have some historic meanings and they were used to indicate prisoner identity in WWII, then I start my idea of reconstructing the triangle identity
    • Triangle Badge has been used in Nazi concentration camp as part of the system of identification in Nazi camps. They were used to identify the reason the prisoners had been placed there.
    • The use of a triangle being a sort of visual shorthand to symbolize all camp victims.           Source:
    • I want to do a project in response to the camp identification system, and I want to create triangles with different color and different shapes to stand for different identities. The users can define what the triangles mean to them by themselves and choose the ones to “pin” on their T-shirt, and they can change their identity combination at their will and wish at any time. The “pin” is actually the stick of the potentiometer, which can be used not only to control the LOVE flag to raise up on the LED matrix, but also “pin” the colorful triangles on the T-shirt.

Key Message:

Your pride will “empower” the love.

  • I hope everyone to be proud of their identity
    • Wearing different Triangle Identity on the Ally T-shirt
    • Put on different identity combinations
    • No identity discrimination any more
  • Love will always wins
    • Press the “Pin” to light up the LOVE flag
    • More identities pinned, easier to light up the LOVE flag
    • Love is Love


Actually I struggled a lot in the whole process of identifying my idea and programming for the LED matrix, and great thanks to Antonius for continuous support and guidance along the way.

  1. LED Matrix testing

Two important lessons to learn here: 1) Understand the version of LED matrix you will use before searching for sample codes and do the programming; 2) If you still have no idea what to do with your LED matrix, search for the instruction book with the exact version online, and it will be your best friend! From this instruction, I understand how it works and connects my circuit based on that:

I tried the sample code to test my display a test pattern:


Tried to use potentiometer to change the LED patterns:

Then I did the programming to create the heart flag pattern raised up in the LED matrix by using potentiometer to send different values:

After the code worked well to raise the love flag, I removed the two breadboards from the LED Matrix and redesign the circuit and use male wires to connect, in order to make it less bulky and more wearable on the T-shirt.

2. Sewing the LED matrix and the circuit onto the T-shirt and design the T-shirt:

I sewed the LED matrix and the circuits all inside the T-shirt, and started to work on how to design the front side of the T-shirt. At first I was thinking of putting a upside-down triangle in front of the T-shirt and put decorations on it. But when I put them all on, I found the upside-down triangle seem unnecessary and too noisy to convey the idea of Allyship, at that time I realized the concept that “Less is More”.



So I removed this triangle and looked for other possibilities. Antonius inspired me to discover the meaning of triangle patterns here and take advantage of the stick of potentiometer. Therefore I came up with the idea of using triangles of different color and size to indicate different identities, and use the stick of the potentiometer as the pin to stick the triangle on the T-shirt. Although it is not by design and might be the magical power of nature, I found that the more identity triangles “pinned” to the T-shirt, the easier it is to raise the love flag by simply pressing the top of the stick, which I think is also a beautiful metaphor.



  1. The circuit inside the T-shirt is still bulky, so next time I will try to use the Lilypad to reduce the size of these components.
  2. I will try to place a soft button on the “pin” stick, and hope it will provide users a better sense of pressing to raise the lOVE flag.
  3. So far there are too many wires inside the T-shirt, which might be not safe when people wear it, especially when it is raining. Therefore I hope to find a new way to have less wires and make this T-shirt more wearable.

   Example Code for an 8 x 8 LED Matrix
   For More Details Visit

   Displays a test pattern lighting one LED after another
   To Play around with modifying the bitmap, un comment Example #2

int speed = 5; //the delay time in milliseconds

int pauseDelay = 1;    //the number of milliseconds to display each scanned line

//Pin Definitions
int rowA[] = {9, 8, 7, 6, 5, 4, 3, 2};   //An Array defining which pin each row is attached to
//(rows are common anode (drive HIGH))
int colA[] = {17, 16, 15, 14, 13, 12, 11, 10}; //An Array defining which pin each column is attached to
//(columns are common cathode (drive LOW))

//The array used to hold a bitmap of the display
//(if you wish to do something other than scrolling marque change the data in this
//variable then display)
byte data[] = {0, 0, 0, 0, 0, 0, 0, 0};
int x;

//Setup runs once when power is applied
void setup()
  Serial.begin(9600);         //Open the Serial port for debugging
  for (int i = 0; i < 9; i++) { //Set the 16 pins used to control the array as OUTPUTs
    pinMode(rowA[i], OUTPUT);
    pinMode(colA[i], OUTPUT);
  data[0] = B00000000; //row 1s bit mask (1 LED is on 0 LED is off)
  data[1] = B00000000; //row 1s bit mask (1 LED is on 0 LED is off)
  data[2] = B00000000; //row 1s bit mask (1 LED is on 0 LED is off)
  data[3] = B00000000; //row 1s bit mask (1 LED is on 0 LED is off)
  data[4] = B00000000; //row 1s bit mask (1 LED is on 0 LED is off)
  data[5] = B00000000; //row 1s bit mask (1 LED is on 0 LED is off)
  data[6] = B00000000; //row 1s bit mask (1 LED is on 0 LED is off)
  data[7] = B00000000; //row 1s bit mask (1 LED is on 0 LED is off)
  x = 0;


void loop()
  //Example #1 - test pattern
  //Run a small test program which lights up each light in time
  //  test();

  //Example #2 - static image
  //Display a defined bitmap

  x = map(analogRead(A4), 0, 1023, 0, 10);
  Serial.println('x' + x);
  // heart 
  if (x == 1) {
    data[0] = B00000000; //row 1s bit mask (1 LED is on 0 LED is off)
    data[1] = B00000000; //row 1s bit mask (1 LED is on 0 LED is off)
    data[2] = B00000000; //row 1s bit mask (1 LED is on 0 LED is off)
    data[3] = B00000000; //row 1s bit mask (1 LED is on 0 LED is off)
    data[4] = B00000000; //row 1s bit mask (1 LED is on 0 LED is off)
    data[5] = B00000000; //row 1s bit mask (1 LED is on 0 LED is off)
    data[6] = B00000000; //row 1s bit mask (1 LED is on 0 LED is off)
    data[7] = B00000000;
  } else if (x == 2) {
    data[0] = B00000000; //row 1s bit mask (1 LED is on 0 LED is off)
    data[1] = B00000000; //row 1s bit mask (1 LED is on 0 LED is off)
    data[2] = B00000000; //row 1s bit mask (1 LED is on 0 LED is off)
    data[3] = B00000000; //row 1s bit mask (1 LED is on 0 LED is off)
    data[4] = B00000000; //row 1s bit mask (1 LED is on 0 LED is off)
    data[5] = B00000000; //row 1s bit mask (1 LED is on 0 LED is off)
    data[6] = B00000000; //row 1s bit mask (1 LED is on 0 LED is off)
    data[7] = B00000000;
  } else if (x == 3) {
    data[0] = B00000000; //row 1s bit mask (1 LED is on 0 LED is off)
    data[1] = B00000000; //row 1s bit mask (1 LED is on 0 LED is off)
    data[2] = B00000000; //row 1s bit mask (1 LED is on 0 LED is off)
    data[3] = B00011000; //row 1s bit mask (1 LED is on 0 LED is off)
    data[4] = B00111100; //row 1s bit mask (1 LED is on 0 LED is off)
    data[5] = B00111100; //row 1s bit mask (1 LED is on 0 LED is off)
    data[6] = B00011000; //row 1s bit mask (1 LED is on 0 LED is off)
    data[7] = B00000000;
  } else if (x == 4) {
    data[0] = B00000000; //row 1s bit mask (1 LED is on 0 LED is off)
    data[1] = B00000000; //row 1s bit mask (1 LED is on 0 LED is off)
    data[2] = B01100110; //row 1s bit mask (1 LED is on 0 LED is off)
    data[3] = B11111111; //row 1s bit mask (1 LED is on 0 LED is off)
    data[4] = B11111111; //row 1s bit mask (1 LED is on 0 LED is off)
    data[5] = B01111110; //row 1s bit mask (1 LED is on 0 LED is off)
    data[6] = B00111100; //row 1s bit mask (1 LED is on 0 LED is off)
    data[7] = B00011000;
  } else if (x == 5) {
   data[0] = B00000000; //row 1s bit mask (1 LED is on 0 LED is off)
    data[1] = B01100110; //row 1s bit mask (1 LED is on 0 LED is off)
    data[2] = B11111111; //row 1s bit mask (1 LED is on 0 LED is off)
    data[3] = B11111111; //row 1s bit mask (1 LED is on 0 LED is off)
    data[4] = B01111110; //row 1s bit mask (1 LED is on 0 LED is off)
    data[5] = B00111100; //row 1s bit mask (1 LED is on 0 LED is off)
    data[6] = B00011000; //row 1s bit mask (1 LED is on 0 LED is off)
    data[7] = B00000000;
  } else if (x == 6) {
    data[0] = B01100110; //row 1s bit mask (1 LED is on 0 LED is off)
    data[1] = B11111111; //row 1s bit mask (1 LED is on 0 LED is off)
    data[2] = B11111111; //row 1s bit mask (1 LED is on 0 LED is off)
    data[3] = B01111110; //row 1s bit mask (1 LED is on 0 LED is off)
    data[4] = B00111100; //row 1s bit mask (1 LED is on 0 LED is off)
    data[5] = B00011000; //row 1s bit mask (1 LED is on 0 LED is off)
    data[6] = B00000000; //row 1s bit mask (1 LED is on 0 LED is off)
    data[7] = B00000000;


//An array to store power values to act as bit masks
const int powers[] = {1, 2, 4, 8, 16, 32, 64, 128};

////Runs a pattern where each LED is lit one after another
//void test() {
//  for (int i = 0; i < 8; i++) {
//    for (int ii = 0; ii < 8; ii++) {
//      data[i] = data[i] + powers[ii];  //Goes through each row of lights lighting each column one after another
//      showSprite(speed);
//    }
//  }
//  for (int i = 0; i < 8; i++) {
//    for (int ii = 0; ii < 8; ii++) {
//      data[i] = data[i] - powers[ii];   //Goes through each row of lights turning off each column one after another
//      showSprite(speed);
//    }
//  }
void resetMatrix() {
  data[0] = B00000000; //row 1s bit mask (1 LED is on 0 LED is off)
  data[1] = B00000000; //row 1s bit mask (1 LED is on 0 LED is off)
  data[2] = B00000000; //row 1s bit mask (1 LED is on 0 LED is off)
  data[3] = B00000000; //row 1s bit mask (1 LED is on 0 LED is off)
  data[4] = B00000000; //row 1s bit mask (1 LED is on 0 LED is off)
  data[5] = B00000000; //row 1s bit mask (1 LED is on 0 LED is off)
  data[6] = B00000000; //row 1s bit mask (1 LED is on 0 LED is off)
  data[7] = B00000000; //row 1s bit mask (1 LED is on 0 LED is off)
void showSprite(int speed2) {
  for (int iii = 0; iii < speed2; iii++) {               //show the current frame speed2 times
    for (int column = 0; column < 8; column++) {          //iterate through each column
      for (int i = 0; i < 8; i++) {
        digitalWrite(rowA[i], LOW);                      //turn off all row pins
      for (int i = 0; i < 8; i++) { //Set only the one pin
        if (i == column) {
          digitalWrite(colA[i], LOW); //turns the current row on
        else {
          digitalWrite(colA[i], HIGH);  //turns the rest of the rows off

      for (int row = 0; row < 8; row++) {                  //iterate through each pixel in the current column
        int bit = (data[column] >> row) & 1;
        if (bit == 1) {
          digitalWrite(rowA[row], HIGH);                   //if the bit in the data array is set turn the LED on

      delay(pauseDelay);                       //leave the column on for pauseDelay microseconds (too high a delay causes flicker)

Final Project: Positivity Hat

Positivity Hat Documentation by Kai Zheng


Beginning this final project, I had the inspiration of EFT in mind. I recently went to a health and wellness workshop and was introduced to emotional freedom techniques or EFT. The psychologist got everyone to do tap on their heads, their faces, their chests, all the way to our forearms and hands. I found this process to be very interesting and it really got me inspired for my final talking fabrics project.

The main function of my project is that it’s meant to be a hat that when you touch when tapping, it will teach you how to say the positive, healthful comments to yourself. For example, these 3 phrases:

My Chinese is very good.


Even though [I expect others to validate me], I deeply and completely accept myself.


I will speak the truth to myself.


I recorded these phrases with audacity, converted everything to a .mp3 file, and uploaded all of that to the microSD card. This microSD card was then mounted to the MP3 shield, which Professor Antonius kindly lent out to me. I learned that shields were like hats that allowed the Arduino to have even more functionality. Once the shield was connected to Arduino, they could communicate with each other. However, I also had to put another hat/shield in between the Arduino and the MP3 shield because someone already soldered the holes into the MP3 shield.

Following all of the coding, which I have a screen video of here:


I had to transfer all of this onto an actual piece of fabric. That would be my hat. I made the hat earlier in the day. It looked like this:

Then, I sewed some reinforcements to get the Arduino to not slip off as easily. I also had to make 3 soft push buttons so that those would trigger the audio to play. I made the soft push buttons by cutting a hole in a piece of square shaped fabric. There would be two tails that had conductive thread sewn into them. And, that way, when those two tails touched, it would complete the circuit, and the code would recognize that trigger and play the corresponding track.



Final Version of my Positivity Hat:

Ultimately, I believed I learned a great deal in making my Positivity Hat. However, to improve in the future, I have two suggestions. 1) Make the hat more wearable, meaning, a better design for the fabric part of the hat. I could either come up with a bigger compartment to fit the Arduino and the battery, or move onto learning how to use a Lilypad. In either case, I would need to learn how a hat can be worn on a round head, because right now, it can sit on a flat table, which isn’t its intended purpose. 2) I would make the push buttons either more sensitive or more noticeably present so that people will know exactly what to push. I could experiment with another way to create a more obvious push button that didn’t need to be fiddled in the pull-up-then-down way.  All these suggestions are to make the hat more functional and improve the prototype.

Here are all the materials I used for my Positivity Hat:

Felt (any color)

Conductive thread

Regular thread


Conductive tape

Wires that go into the Arduino

Breadboard to prototype

Push buttons to prototype

Soldering supplies


Arduino hat to put in between the MP3 shield and Arduino

MP3 Shield

MicroSD card


External battery that could be plugged into an Arduino



Group Project

 While all of our ideas appeared to be seemingly different, they could function as one entity that offered similar functions. I originally came in with the idea of touch sensor wrist bands to be used for yoga poses to correct a person’s form. Kai and Sara had similar ideas to each other involving dance and music. We transformed the two ideas into one, creating a wrist band that plays music.

We started by ordering Adidas wristbands to be used to conceal the arduino, and provide an aesthetic appeal to our project. This also allowed us to easily attach the project to our bodies for multi functionality such as twisting our wrists.

We connected our arduino and battery together, and programmed our code to make a sound whenever we twisted our wrist. We also had a remote control to turn on sound  While the three critical components were bulky, they allowed us to create sound.

We programmed our arduino to play different tones depending on the button we preseed with our remote control.  

In the end, our product proved to be successful while presenting to the class. If we were to take this project a step further, I would like to condense the size of the arduinos to make the project more mobile and comfortable for everyday activities. I would also like to take away the remote control aspect of the project, allowing the user to just twist their wrist as opposed to twisting, and pushing a button.