[Wearables] Assignment #3 – Expressive Garment

ASSIGNMENT: Create a garment that expresses a message or information to those around you.

IDEA: Dancer’s wings with sound reactive LEDs



  • https://learn.adafruit.com/getting-started-with-flora/overview
  • https://learn.adafruit.com/flora-rgb-smart-pixels/overview
  • https://learn.adafruit.com/adafruit-neopixel-uberguide/the-magic-of-neopixels


INSPIRATION: I was inspired by the dancers I see in carnaval and Pride parades, and in the costumes of drag and burlesque performers to create something flashy. This is meant to go along with a performance––it’s part of a larger goal of mine within ITP to find interactive ways of enhancing live performance organically, rather than just with cool gimmicks. Whether this project lives up to that standard remains to be seen.

FABRIC: In order to save on costs I decided to only use fabric that I could find in the ITP Soft Lab. I found a metallic sheer fabric with a floral print that was the right weight:

LEDs: Initially, I was going to try to position the LEDs to correspond to the floral print (is, make the LEDs the center of the flowers). However, the weight of the LEDs and the overly complicated soft circuit that would have to be sewn to connect them all––as well as the aesthetic consideration of having the lights in a recognizable pattern when in the dark––led me to place the LEDs along the edges of the fabric.

I thought at first that I might use 3mm Super Bright LEDs because of their delicate aesthetic profile and lighter weight, as well the power of their light output.

However, the convenience of the sewable NeoPixels outweighed their price and their slightly greater weight.

I bought the individual sewable NeoPixels rather than a strip because I wanted the freedom to place them where I wanted and they were a lot lighter. I knew this would create much more work for me but at the time the aesthetic considerations outweighed (ha) the inconvenience.

I have since come to regret that decision.

Wings: I used the following tutorials as jumping off points for how to construct my wings:

Here is what my plan looked like before I started building:

An illustration of the the layout and basic construction of the wings.

My idea was to have two pieces of semicircle fabric––a front and back –– sewn together with the wrong side in, in order to hide the hardware and the circuit. In order to take advantage of the diffusion of the light through the semi-translucent fabric, the NeoPixels would be sewn on the inside (wrong side) of the fabric, alternating facing frontward and back so that no matter which way the wearer was facing, the lights would be visible. The conductive thread connecting each NeoPixel would serve a dual purposed of connecting the front and back pieces. This did not take into consider the fact the NeoPixels only go one-way as will elaborate on below.

An illustration of the seam allowance and hardware placement


How to make the wings:

Measure the “wingspan” with a measuring tape: fingertip to fingertip plus half the length of the dowels. I initially measured the full width of the dowels which you can see in the final photos where I’m barely able to hold onto the ends of the dowels at their full extension.

Cut out two semi-circles from your fabric the length of your wingspan + 4 inches (2 inches of seam allowance on each side):

Two pieces of fabric folded together in half

First, cut the length of the wingspan + seam allowance; then, line the two semi-circles up, fold them in half, and pin the halves together to avoid slippage.

Once pinned and lined up evenly, use tailor’s chalk to draw half of a semicircle with the middle of the semicircle landing on the folded side of the fabric and cut it out:

Close up view of the pins holding together the two pieces of

Using a measuring tape, measure out the circumference of your neck. Add two inches to each end and cut out two pieces of fabric that length and 4 inches wide. These will be sewn together and then to the wings to form the collar.

As I will explain below, I ended up only using one of the semi-circles, so I used a chiffon hemming technique to hem the curved edges of the wings.

I used a standard hemming along the top straight edge and left pockets on each end to slip in the dowels and then close.

How to sew the NeoPixels:

On the front-facing semicircle, measure out and mark with tailors chalk where each NeoPixel will be using the curved tailor’s ruler, about 12 inches apart from each other, and about 4 inches from the edge of the fabric (allowing for the two inch seam allowance).

Take the ribbon and measure out each segment, cutting at the length that will allow the fabric to extend to its full length within each section, without the ribbon pulling on it and affecting its shape.

On each ribbon, sew a NeoPixel on the end as well as a ground, power, and data line using conductive thread.

Using regular, non-conductive thread, attach each ribbon section to the corresponding part of the wing fabric. With conductive thread, connect each line and NeoPixel correspondingly. It took a few tries for me to find the best way of doing this:

First, I tried sewing the NeoPixels and the conductive thread directly onto the fabric. I figured that I could use the fabric glue to insulate it afterwards and that this method would give me the most freedom. However it resulted in unsightly bunching wherever the stitches were made.

Second, I tried sewing the NeoPixels directly to the wing fabric with conductive thread and then connecting each one with ribbon. This resulted in good connections but ugly crimping in the fabric where the neopixels were sewn.

Third, I tired sewing the NeoPixels directly onto the ribbon’s end. I made the conductive thread as long as I dared (the longer I made it, the more unwieldy it became and the slower the hand stitching went) and hand-stitched the three lines directly to the pixel, and left enough thread hanging to be able to sew it directly to the next ribbon.

I didn’t always measure correctly so often I would have to connect them with different strands of thread, making awkward balls of conductive thread at the ends of each ribbon in an attempt to ensure a secure connection.

Once all the ribbons were properly threaded, I took grey thread and, as discreetly as I could, used it to sew the end of the ribbons to the wing fabric.

Where I went wrong with the NeoPixels:

Unfortunately, I made some fundamental mistakes with the construction of my circuit: a) I put the power and data source connecting to the strips of NeoPixels in the center; b) I sewed the NeoPixels mirroring each other; and c) I sewed all the NeoPixels in a daisy chain with all the data in and out pins connected:

I knew the the data connection on NeoPixels only went one way but I thought that if I had a connection in the middle with two NeoPixel strips each running away from that power/data source, the data would travel to both strips. It’s obvious to me now how that data does not work that way.

How I fixed it:

It was fairly straightforward to cut the thread connecting the in and out data pins on each NeoPixel, trim the ends, and quickly re-sew and knot a separate thread through each data pin to secure the connection. I used the multimeter to check that each line was connected.

Since it took me many, many, many, many, many (many) hours to sew the NeoPixel ribbons, AND because I was concerned that the 3.7V LiPo wouldn’t be enough to power all 20 of my originally intended NeoPixels, I kept the FLORA and battery in their original central position, but I retooled my design to connect the left and right strings to two different pins on the FLORA. I also decided not to make a back piece to time considerations and because I didn’t think I could power more than 10 pixels max with my current power considerations.

A semi-finished product view of the back showing the two white-ish strips of NeoPixel ribbons.

How I attached the FLORA and LiPo battery to the back:

Now you see it…
Now you don’t!

Making the collar:

Wiring the sensor, FLORA, and NeoPixels:

Mic Amp: PIN A9, 3.3V, GRD
Left NeoPixels: PIN #10, VBATT, GRD
Right NeoPixels: PIN # 12, VBATT, GRD

Some views of the ALMOST finished garment:

Special thanks to Shu Ju for doing this at 1 in the morning.


I used the Ampli-tie example from Adafruit’s NeoPixels tutorial as the basis of my code. While I understand the basic NeoPixel coding framework, I didn’t completely understand the math done to get the values from the microphone. That said, it still worked when I tested in on a few leds alligator clipped together.

Do it for the Gram


Once the NeoPixel ribbons had been sewn, I used the simple “strandtest” example provided in the Adafrui_NeoPixel Library to make sure they work and to see how much brightness was lost as the strings got longer:

At the time, I was satisfied that although I could see some decrease in brightness between the first and last NeoPixel in the string, it was enough to move forward in the project without reinforcing the power line with more conductive thread.

In order to adapt the program to be able to run the same code on two different pins, I initially took some bad advice from the internet.

The first example I found used the FastLED library instead of the Adafruit_NeoPixel library and indeed I found the documentation to be superb. It seemed so straightforward! You don’t even need to declare different FastLED objects!

First I found an example of someone using FastLED to make sound reactive NeoPixels (but using a different sensor, atuline’s soundmems.ino.

Ignoring that the mic he used probably uses different math than the one I was using, I forged ahead and tried to recode it using the Multiple Controller Example from the FastLED documentation. But I didn’t understand how atuline declared his FastLED objects. He used LEDS instead of FastLED… wut?

Then I found another example of atuline’s that adapted the Ampli-tie code to FastLED. Again he uses LEDS.addLeds to declare the object but then uses FastLEDS to declare the brightness??? What is going on! Needless to say, none of this worked.

I eventually went back to the Adafruit_Neopixel library and came up with following code that ALSO DID NOT WORK.

Here’s the NeoPixel framework for multiple controllers as I understand it:

Here’s is what I did when attempted to include the code related to the microphone: