How To: Make A Temperature Sensing Necklace For Safe Partying


Reinforced sewing
Reinforced sewing



Collaborators: Oriana Neidecker


As mentioned in last week’s midterm brief, I am interested in wearables, soft circuits, and movement; and my partner is interested in wearables as well -particularly those that aid the wearer’s health.

A soft circuit with a switch that I worked on at the beginning of October. The small square of metal fabric on the bottom is a pouch holding a battery. The flap of fabric on top is a switch that closes the circuit when pressed down.

Our Goal for our midterm project was to make a necklace that measures various vitals of the wearer, ie temperature, heart rate, etc. and displays fun, ambient lighting until set thresholds are passed for each vital being read. Once the threshold is passed, the necklace displays a different signal that alerts the friends of the wearer that their friend should be watched over. If additional thresholds are passed, the lighting of the necklace changes with increased urgency until all lights on the necklace are blinking urgent red, signifying that the wearer is in need of immediate medical assistance.

What We Actually Did Create We succeeded in creating a soft circuit necklace that accurately reads the temperature of the wearer and  displays flashing red lights (as opposed to ambient mood lighting) whenever the wearer’s temperature exceeds a set temperature threshold.

What Got Left Behind For ease of use, we decided to limit the readings being taken by the necklace (or choker -so trendy right now) to temperature alone. We also limited the stages for the lights being displayed to simply “having a fever” or “not having a fever”. We did this for a few reasons:

  1. We were warned by several sources that the lilypad pulse sensor we were planning on using was notoriously temperamental. (Indeed -even the most advanced products like the apple watch still have trouble reading pulse).
  2. Unforseen complications with our code discouraged us from spending more time on it, and we decided to kill our darlings in favor of producing a better finished product.



Materials & Tools

Felt, Velcro, Hot Glue Felt is the most forgiving fabric to sew conductive thread. We used a simple velcro attachment in order to easily remove the front of the choker.

-Conductive Thread We used 3 ply adafruit medium conductive thread, which was the strongest, thickest thread that was still relatively flexible.

-Neopixels We decided we wanted to work with neopixels as opposed to dumb LEDs, and that we wanted to do so with individual neopixels as opposed to using a strip; this offered more versatility in the form and also lent itself to a greater understanding of the neopixels themselves.

-Microcontroller We wanted to use a Lily Tiny (pictured below) but our project would work with any microcontroller with analog output/digital input capabilities.

-Lillypad Temperature Sensor This was the smallest wearable sensor we could find on the market, and our research told us it was reliable.


We also soldered our sensor to stranded core wire from the output for a more accurate read:


-Wire Strippers, Foam (for prototyping board), Solder, Alligator Clips, Wires, Stranded Core Wire We needed stranded core wire for its flexibility and in order to sew

Running our first neopixel strand test after an hour of neopixel tutorials and coding.
Running our first neopixel strand test after an hour of neopixel tutorials and coding. You can tell we’re excited. #soundon


Of Note We learned we needed to download the neopixel library in order to run various strand tests and start programming the neopixels. We also had a few learning moments when it came to doing things like:

  • tripple checking your port
  • selecting the proper microcontroller
  • reviewing the types of microcontrollers that best serve your project before ordering them because…

Our lily tiny microcontroller wouldn’t work.

Our little engine that couldn’t 🙁

I just wouldn’t. We scheduled sessions with two different residents and they couldn’t get it to work either. Lesson learned: research your parts to see whether a) the community that uses said controllers have good things to say about it. Something like “this microcontoller works and I like it because it’s also easy to use” would have been perfect.


We decided that once we got out neopixels up and running, and that we were acquainted enough with the code, it was time to set up our prototyping board. This is what it looked like:

Partial setup of prototype with alligator clips.
Partial setup of prototype with alligator clips.


We used foam board with conductive thread and pins to replicate the setup that we'd use in our wearable.
We used foam board with conductive thread and pins to replicate the setup that we’d use in our wearable.
Neopixel closeup
Neopixel closeup


Here’s a video of our working prototype:


Printing the temperature sensor output.
Printing the temperature sensor output.

Transferring To Wearable

Now that our prototype was working, it was time to transfer the prototype to our wearable. This involved careful planning:

Mapping out our wearable.
Mapping out our wearable.
Not your mother’s sewing circle.

Transferring the prototype to the wearable was probably the most challenging part of the project. It involved many false starts, redos, and tons of conductivity testing:




Finally, it worked:



Pro Tip Don’t wear a necklace under your choker:

“It’s burning.”

But now it’s working.


What We Learned

Hey! Wearables are difficult. Conductive thread, though super flexible and even pretty to see from a design standpoint, is not always the most reliable medium.

If I were to start this project over, I think I would have definitely made a point of researching the types of sensors I was going to use more extensively beforehand. Though our sensor worked the majority of the time, it would also get overloaded and start spitting nonsense on our reader.

On the whole, I am definitely more comfortable with soft fabrication now. Particularly with conductive thread and sewing soft circuits, and also converting those soft circuits to hard circuits. I also learned how to solder!

Cat Attack! (With Browser Controls)



This week I wanted to use my cats for a little, uncomplicated game involving buttons and a counter. I 95% succeeded.

The problem:

I couldn’t get my number to refresh without breaking all of my code.

13 Cats
Obviously not 17 cats.







I already had to develop a bit of a cheat where I drew a rectangle in the draw() loop so that the numbers wouldn’t continue to write on top of one another. But I suspect that because my cat is a function that’s been called vs. the counter which is in draw, I can’t reset my numbers the way I’d like to while the code is structured as it is.

I hope to overhaul the problem this weekend.

DIY Business Card

When I set out to complete this assignment my approach had a few callbacks to the first few weeks of the semester. The first day of class, I had mentioned that my favorite color was red and also that I think, when executed correctly, there’s nothing that looks better than the simple color scheme of black, red, and white.

Inspired by the geometric ease of Piet Mondrian and motivated by his reverence for primary colors, I decided the design side of my card would incorporate riffs off geometric elements, most likely squares.















I also wanted to utilize my initials as a sort of hybrid letter logo/design:








In the end, I reduced the total number of elements in my design to have a clean, clear look that made much use of negative space.


personal-business-card_back        screen-shot-2016-10-19-at-11-58-14-am

Midterms, Commence


Collaboraters: Oriana Neidecker

This week we met to discuss the possibilities for our midterm assignment.

I have a strong interested in wearables and both Oriana and I have a strong interest in movement. The idea:

Create both a necklace and/or wristband prototype that is easily movable and measures the temperature of the wearer. If the temperature of the wearer exceeds a set danger point, the necklace/wristband will blink.

Part I: Brainstorming



Part II: Materials Exploration







Part III: Concept & Execution

necklace-1 necklace-2



ITP Show Postcard



Create a postcard design for the ITP Winter Show; showcase a more human side of the program.


This week was a series of non-starters. Initially, I wanted to stage an elaborate shoot at the Standard Hotel but at the last minute was unable to secure the space. I was back to square one. This is a familiar feeling at ITP. Lots of missteps, restarts, failures. I realized that it might be fun to capture this sentiment in the show poster. I decided


First, there was light testing and stage setting.

Contact Sheet 1


Then, framing:

img_9031 img_9038 img_9042


Lighting fix & color correction

img_9052 img_9053

img_9048 img_9050

Final staging:

img_9069 img_9080 img_9082

On to edits:

img_9162itp-show-poster img_9155

Framing/no framing/ font options:

1 2

3 4

Final choice:



I wholly underestimated the amount of time it would take to stage the photograph, correct lighting, and shoot for the winning shot. Given the time allotment of ~5 hours, I probably spent too much time on staging and not enough on post. If I had more time, I would have flattened the table curves and toyed with perspective a bit more. I would have also used professional two-point lighting (LEDs) on stands, and spent more time toying with font, etc.


Synthesis Session

This week we experimented for the first time with serial communication in our Synthesis Session. My partner and I mapped a potentiometer to the mouseX function in some code, that opened and closed a window and started and stopped some rain. Then, for good measure, we added a photo of Dan Schiffman for the heck of it. This was our process:


We started with a push sensor, and that didn’t work out so well because it was a bit wonky to the touch and couldn’t achieve the sliding effect we wanted. (Or at least, not without some additional coding we were worried we wouldn’t have time for.

Then, we switched to a potentiometer because we thought we might have a bit more control, which was correct, but the data wasn’t buffering as effectively.

We added a serial read function so that we could see if our input was sliding gradually.

We realized we were having a buffering problem, and restarted the p5 serial control app. The result was a much more controlled manifestation of the sensor.

This was an exciting week in Physical Computing, because for the first time we are finally starting to hint at the full scope of what we’ll be able to do now that we understand (at least a little bit) about how to make machines talk to one another. It’ll be exciting to see what the rest of the semester brings.

City Cat/ City Mouse Revisited

This week our assignment was to use functions in order to refine the code from an earlier piece and make it more elegant.

Here’s my first composition.

You might recall there was a lot of long, ugly, unnecessary code, most of which looked like this:

//lights 2nd closest;

fill(255, 255, 0);

This time, I used nested for loops to draw the windows on my building. The code looks like this:

function drawWindows(windowX,windowY, rad, spaceX, spaceY, nRow, nCol) {
for (i = 0; i < nRow; i++) {
for (j = 0; j < nCol; j++) {
ellipse (windowX+j*spaceX, windowY+i*spaceY, rad, rad);

Definitely more simple. I then called the function four times within my code. It was exponentially easier for me to maneuver the number of rows and columns of lights I had on a given building using this structure. I called the function four times, but the basic structure was:

//building three
noStroke ();
drawWindows (115,85,5,15,20,9,6);

(I added in the random color function to make the composition a little less static as well).

This was the result.

Ultimately, it’s the same composition, but with tons less guesswork and tons more ease of use and flexibility, which is why mastering  for loops and nested for loops and functions is so nice and lovely and useful.

Everyday Color


  1. Take the color hue test. Post the image of your score to your blog.

I'm not colorblind! Yayz.

2. Over a period of 3 days document your life by taking photographs of various scenes and experiences. Focus on any aspect of your environment: your personal space or personal possessions or public spaces that you engage in. Track the recurring colors in your photos, and the anomalies? Think about how they resonate with your interests, ideals, emotions, and creative instincts?

Everyday Color

I chose to focus on my personal space and observe the variations in tone and hue depending on the time of day. I specifically captured patterns on my carpet, curtains, pillows, and bedsheets, to more easily compare variations.


What colors do you consider the ‘foreground’ colors of your life? What are the persistent ‘background’ colors? How does the palette change based on context or time?

I was surprised by how much warmer my evening tones were; thought I knew direct sunlight would diffuse my daytime color scheme I thought there would also be enhanced, brighter hues to compare.

I also examined the tonality of my environment:





and finally, examined the recurring shapes in my life; circles for saucers, large and small blocks for buildings, etc. A good representation of this recurrence would be via instagram:










PComp: Servos & Resistors & Sensors Oh My!

Here’s the servo lab that we completed in class, that I was successfully able to replicate on my own.  I set the parameters fro 10-170 deg. Here’s the code:

//turn servo

int analogValue = analogRead(potPin);
int mappedValue = map (analogValue, 0,1023, 10, 170);
myServo.write (mappedValue);

I also successfully replicated the sound lab that we did last week, this time with light sensitive resistors:

Unfortunately (and dumbly) I didn’t check my video after I recorded so I don’t have the tone changing as I held my hand over the photo sensitive resistors. But I promise it did.


Finally, I completed the lab with three sound features, though my final push sensor wasn’t as great sounding:

I’m excited to apply these new possibilities to a project. So satisfying when the function *actually* works…