9. Wearables¶
Artistic Research¶
The Crying Dress: Hannah Perner-Wilson and Mika Satomi have been pioneering e-textiles together since 2006. Their projects include The Crying Dress and a collecion of sensor-laden conductive textiles. IN 2017, they launched KOBA by KOBAKANT, a tailoring shop for for e-textiles in Berlin, linked here.
 |
 |
 |
The following information is taken from this website
"In 2028, the artisans KOBAKANT were commissioned to make an Extravagant Electronic funeral gown, also known as The Crying Dress. The gown was worn by the wife of the deceased commissioner in attendance of his funeral, where the dress shed endless tears of mourning. There has been much speculation on the commissioner’s motivation for ordering the gown prior to his death, but it is widely believed that he intended for it to console his wife and accompany her mourning."
The making of the Crying Dress can be linked on a website here. The whole process is wonderfully documented, very inspiring!!!! I would LOVE to work with a team to create such an amazing design, in terms of its form, the actual shape and design of the dress, and its function. The Crying Dress was a garment designed to
1) Express emotions through technology, using sensors to detect the wearer's emotional state.
2) When the wearer is sad, the dress activates and produces sound resembling crying.
3) The sound is intended to provoke empathy and awareness in others.
4) It serves as a commentary on emotional expression and societal perceptions of sadness.
5) The project combines fashion with interactive technology to explore human feelings.
 |
 |
For just one year, KOBA by KOBAKANT shared everything they built as as an open-souce online tutorial. Their website states "The duo’s experimental work focused on creating bespoke garments. It is funded by WEARsustain, an initiative set up by the EU."
"The Crying Dress" is a conceptual art piece exploring themes of emotion and identity. It features a dress that visually represents the act of crying through its design and materials. The work invites viewers to reflect on the relationship between clothing and personal expression. It challenges societal norms regarding vulnerability and emotional display. The piece is part of a broader dialogue on fashion as a medium for storytelling. It encourages audience interaction and personal interpretation of the artwork.
Useful Websites and Publications for Learning about Electronics Vocabulary and Processes¶
Terminology taken from "Wearable Electronics"¶
1) Microcontroller: A tiny computer, the brain of the project that lives in your clothing or items you wear on your body.
2) Arduino and Arduino compatible products: open source electronics prototyping paltform intended to be used by artists, designers, educators, hobbyists, and anyone who wants to make a physical interactive project but isn't an electrical engineer.
3) Arduino hardware. Arduino boards: circuit boards with a microcontroller and its related components and circuits including pin breakouts, status LEDs, a reset button, and more. Most common is the basic Aduino Uno.
4) LilyPad Arduino: Arduino in a LilyPad package, intended for use in electronic textile and wearable electronics applications. It has "sewtabs" or "petals" around the edge of teh circuit board to facilitate electrical connections using conductive thread. It has the same min=crocontroller as Arduino Uno and the same number of inputs and outputs. A variation is the LilyPad Arduino Simple, a simplified version of the LilyPad Arduino with some pins removed to make it easier to make connections.
5) Actuators: the hardware that makes things happen incluing blinking, buzzing, etc. through light, sound, movement, and heat. Using these components facilitates making garments that can glow, shake, and sing.
6) Leds/neopixels: This definiton is from the Autodesk Instructable website linked here:"the addressable RGB LED (WS2812 ), popularly known as Adafruit NeoPixel, is a family of rings, strips, boards & sticks of pulsing, colourful miniature LEDs. These are chainable from one to the next so you can power and program a long line of NeoPixels together to form an endless string of LEDs. You can use these LED strips to add complex lighting effects to any of your project."
Books¶
To help me understand the terminology and processes, and to do the technical work required in this module, I have discovered two excellent books I already had in my library but had mostly not used. 1) Wearable Elecronics: Design, Prototype, and Wear your Own Interactive Garments, by Kate Harmen, linked here] on Amazon. 2) Wearable Tech Projects: 30 Projects to Make, Sew, and Wear! by Sophy Wong. This book is open source, linked from this source.
Creating Wearable Devices with Microcontrollers: A Complete Guide¶
This useful guide, linked here, offers a comprehensive, step-by-step framework covering everything from selecting the best microcontroller platform for wearable projects to optimizing power consumption and integrating sensors and communication modules.
Five Great Microcontrollers for wearables¶
Useful information on a variety of microcontrollers can be found here.
Creating Wearable Devices with Microcontrollers: A Complete Guide¶
This step-by-step guide, linked here, explores and details microcontroller basics and practical implementation for 1) the best microcontroller platforms for wearable projects 2) optimizing power consumption and 3)integrating sensors and communication modules.
Actuator Swatches¶
1) I plan to make the parallel circuit below using Lily's Tiny Twinkle from an example in my Wearable Electronics book.
 |
 |
 |
Lily Tiny Twinkle Sparkling!¶
From the SparkFun Electronics website linked here that sells LilyPad's Tiny Twinkle microcontroller: "Product Overview The LilyTwinkle is a tiny little LilyPad board designed to add some twinkle to your project. Even though it's as small as some of the LilyPad sensors, this board actually has an ATtiny microcontroller on it so it's actually pretty smart! Simply sew on 4 LEDs and connect a battery and the LEDs will twinkle-fade (a lot like fireflies... or lightning bugs, if that's what you call them). LilyTwinkle is a quick and easy way to add twinkling lights to a project without any programming or a bulky Main Board."
My Results¶
I had to do this project above twice. I could not get the first one to work. So, I ordered new Tiny Twinkle's in case the microcontroller wasn/t working, I just wasn't sure. For my second attempt, I prepared a larger piece of fabric to try to keep my positive and negative circuits separated. It worked!
First Try, Didn't Work¶
 |
 |
 |
 |
Second Try, It Works!¶
 |
 |
 |
Below is a video of the LED lights twinkling.
My Second Project¶
I plan to create the lighting effect for Sophy Wong's 3D-printed jacket mod with LEDs. I made the tulle with 3D printed mesh for my Week 6 Comptational Couture assignment. The list of supplies for the whole project, which can be found through this link, is below:
| 
|
3D Printed Design Project: Sophie Wong's 3D-Printed Jacket Mod with LEDs¶
I have always admired the work of designer Sophie Wong, whose website can be linked here.
For this project, I am replicating Sophie's design for her leather coat with areas of 3D-printed mesh and neopixels. I am using her jacket design for both the Comutational Couture and the Wearables Module. I will explore lighting the 3D mesh with NeoPixels, connected by soldered wires and a microcontroller. I'll program the lights with a chosen animation effect.
Below are images of the jacket. The seam in the middle is the division between panels. Logically, 3D printed panels need to be made in pieces and put together, in-part based on the size of the 3D printer bed. Sophy has made holes in the back of her leather jacket under four of the hexagonal parametric 3D printed pieces. The slightly irregular design of the hexagons and placement of the neopixels creates interesting light effects on the jacket.
Steps of the Process¶
I soldered four wires to each of my four neopixels to make them into a chain. The wires allow the chain to be flexible so I'll be able to have them show through holes I'll cut in a piece of leather, to replicate applying this project to a leather jacket, through which the light of the neopixels will show.
I attached wires of one of the neopixels to my Arduino Uno.
 |
 |
 |
 |
 |
 |
The video below is of my functioning soldered, wired, coded neopixels.
Connecting the 3D printing to the pattern¶
Sophie Wong has a downloadable pattern to use with the 3D printed mesh. I realize in trying to match them up that my prinitng is smalller than the paper pattern. The numbers of and overall pattern for the hexagons is the same, but my printed hexagons are physically smaller, so I made my own pattern for the placement of the neopixels.
1) Make 1/4" holes in my leather to align with where I want the neopixels to go. The center point of the neopixel that lights-up is 1/4."
2) I have outlined the jacket back panel as if this project was being applied to a jacket. I've clipped the 3D printed fabric to the leather, and taped the neopixels to the back with the lights lined-up with the holes I punched. The video shows the effect working.
3) To apply this idea to a real jacket, I would have to run the programming through a circular flat microcontroller and include a battery.
 |
 |
 |
 |
| --- | --- | --- |
 |
 |
The video below shows the neopixels under the 3D printing from Week 6, Computational Couture.
The Code¶
Code Example¶
This is the example code provided by Adafruit for the Neopixels. Minor adjustments have been made.
In the Arduino IDE, this example can be accessed after the "Adafruit Neopixels" library is installed. Simply go to File > Examples > Adafruit Neopixel > strandtest to load this example. Please note that the line specifying the value of LED_COUNT must be updated to the number of neopixels you wish to use. In our case, this value was 4.
// A basic everyday NeoPixel strip test program.
// NEOPIXEL BEST PRACTICES for most reliable operation:
// - Add 1000 uF CAPACITOR between NeoPixel strip's + and - connections.
// - MINIMIZE WIRING LENGTH between microcontroller board and first pixel.
// - NeoPixel strip's DATA-IN should pass through a 300-500 OHM RESISTOR.
// - AVOID connecting NeoPixels on a LIVE CIRCUIT. If you must, ALWAYS
// connect GROUND (-) first, then +, then data.
// - When using a 3.3V microcontroller with a 5V-powered NeoPixel strip,
// a LOGIC-LEVEL CONVERTER on the data line is STRONGLY RECOMMENDED.
// (Skipping these may work OK on your workbench but can fail in the field)
#include <Adafruit_NeoPixel.h>
#ifdef __AVR__
#include <avr/power.h> // Required for 16 MHz Adafruit Trinket
#endif
// Which pin on the Arduino is connected to the NeoPixels?
// On a Trinket or Gemma we suggest changing this to 1:
#define LED_PIN 6
// How many NeoPixels are attached to the Arduino?
#define LED_COUNT 4
// Declare our NeoPixel strip object:
Adafruit_NeoPixel strip(LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800);
// Argument 1 = Number of pixels in NeoPixel strip
// Argument 2 = Arduino pin number (most are valid)
// Argument 3 = Pixel type flags, add together as needed:
// NEO_KHZ800 800 KHz bitstream (most NeoPixel products w/WS2812 LEDs)
// NEO_KHZ400 400 KHz (classic 'v1' (not v2) FLORA pixels, WS2811 drivers)
// NEO_GRB Pixels are wired for GRB bitstream (most NeoPixel products)
// NEO_RGB Pixels are wired for RGB bitstream (v1 FLORA pixels, not v2)
// NEO_RGBW Pixels are wired for RGBW bitstream (NeoPixel RGBW products)
// setup() function -- runs once at startup --------------------------------
void setup() {
// These lines are specifically to support the Adafruit Trinket 5V 16 MHz.
// Any other board, you can remove this part (but no harm leaving it):
#if defined(__AVR_ATtiny85__) && (F_CPU == 16000000)
clock_prescale_set(clock_div_1);
#endif
// END of Trinket-specific code.
strip.begin(); // INITIALIZE NeoPixel strip object (REQUIRED)
strip.show(); // Turn OFF all pixels ASAP
strip.setBrightness(50); // Set BRIGHTNESS to about 1/5 (max = 255)
}
// loop() function -- runs repeatedly as long as board is on ---------------
void loop() {
// Fill along the length of the strip in various colors...
colorWipe(strip.Color(255, 0, 0), 50); // Red
colorWipe(strip.Color( 0, 255, 0), 50); // Green
colorWipe(strip.Color( 0, 0, 255), 50); // Blue
// Do a theater marquee effect in various colors...
theaterChase(strip.Color(127, 127, 127), 50); // White, half brightness
theaterChase(strip.Color(127, 0, 0), 50); // Red, half brightness
theaterChase(strip.Color( 0, 0, 127), 50); // Blue, half brightness
rainbow(10); // Flowing rainbow cycle along the whole strip
theaterChaseRainbow(50); // Rainbow-enhanced theaterChase variant
}
// Some functions of our own for creating animated effects -----------------
// Fill strip pixels one after another with a color. Strip is NOT cleared
// first; anything there will be covered pixel by pixel. Pass in color
// (as a single 'packed' 32-bit value, which you can get by calling
// strip.Color(red, green, blue) as shown in the loop() function above),
// and a delay time (in milliseconds) between pixels.
void colorWipe(uint32_t color, int wait) {
for(int i=0; i<strip.numPixels(); i++) { // For each pixel in strip...
strip.setPixelColor(i, color); // Set pixel's color (in RAM)
strip.show(); // Update strip to match
delay(wait); // Pause for a moment
}
}
// Theater-marquee-style chasing lights. Pass in a color (32-bit value,
// a la strip.Color(r,g,b) as mentioned above), and a delay time (in ms)
// between frames.
void theaterChase(uint32_t color, int wait) {
for(int a=0; a<10; a++) { // Repeat 10 times...
for(int b=0; b<3; b++) { // 'b' counts from 0 to 2...
strip.clear(); // Set all pixels in RAM to 0 (off)
// 'c' counts up from 'b' to end of strip in steps of 3...
for(int c=b; c<strip.numPixels(); c += 3) {
strip.setPixelColor(c, color); // Set pixel 'c' to value 'color'
}
strip.show(); // Update strip with new contents
delay(wait); // Pause for a moment
}
}
}
// Rainbow cycle along whole strip. Pass delay time (in ms) between frames.
void rainbow(int wait) {
// Hue of first pixel runs 5 complete loops through the color wheel.
// Color wheel has a range of 65536 but it's OK if we roll over, so
// just count from 0 to 5*65536. Adding 256 to firstPixelHue each time
// means we'll make 5*65536/256 = 1280 passes through this loop:
for(long firstPixelHue = 0; firstPixelHue < 5*65536; firstPixelHue += 256) {
// strip.rainbow() can take a single argument (first pixel hue) or
// optionally a few extras: number of rainbow repetitions (default 1),
// saturation and value (brightness) (both 0-255, similar to the
// ColorHSV() function, default 255), and a true/false flag for whether
// to apply gamma correction to provide 'truer' colors (default true).
strip.rainbow(firstPixelHue);
// Above line is equivalent to:
// strip.rainbow(firstPixelHue, 1, 255, 255, true);
strip.show(); // Update strip with new contents
delay(wait); // Pause for a moment
}
}
// Rainbow-enhanced theater marquee. Pass delay time (in ms) between frames.
void theaterChaseRainbow(int wait) {
int firstPixelHue = 0; // First pixel starts at red (hue 0)
for(int a=0; a<30; a++) { // Repeat 30 times...
for(int b=0; b<3; b++) { // 'b' counts from 0 to 2...
strip.clear(); // Set all pixels in RAM to 0 (off)
// 'c' counts up from 'b' to end of strip in increments of 3...
for(int c=b; c<strip.numPixels(); c += 3) {
// hue of pixel 'c' is offset by an amount to make one full
// revolution of the color wheel (range 65536) along the length
// of the strip (strip.numPixels() steps):
int hue = firstPixelHue + c * 65536L / strip.numPixels();
uint32_t color = strip.gamma32(strip.ColorHSV(hue)); // hue -> RGB
strip.setPixelColor(c, color); // Set pixel 'c' to value 'color'
}
strip.show(); // Update strip with new contents
delay(wait); // Pause for a moment
firstPixelHue += 65536 / 90; // One cycle of color wheel over 90 frames
}
}
}
Arduino Uno code:
// the setup routine runs once when you press reset:
void setup() {
// initialize serial communication at 9600 bits per second:
Serial.begin(9600);
pinMode(8, OUTPUT);
}
// the loop routine runs over and over again forever:
void loop() {
// read the input on analog pin 0:
int sensorValue = analogRead(A0);
if (sensorValue < 520){
digitalWrite(8, HIGH);
}
else{
digitalWrite(8, LOW);
}
// print out the value you read:
Serial.println(sensorValue);
delay(100); // delay in between reads for stability
}
Alumni Pages for Inspiration for Projects at a Later Date:¶
* Thermochromic screenprint - [Ruby Lennox - FabLab Bcn](https://class.textile-academy.org/2024/ruby-lennox/assignments/week08/#process-and-workflow)
* Led responsive glove - [Marion Guillaud - Le TextileLab lyon](https://class.textile-academy.org/2024/marion-guillaud/assignments/week08/#video-final-result-with-glove)
* Thermochromic and sound research - [Stephanie Johnson - TextileLab Amsterdam](https://class.textile-academy.org/2024/stephanie-johnson/assignments/week08/#t-h-e-r-m-o-c-h-r-o-m-i-c)
* Interactive glove - [Stephanie Vilayphiou- Green Fabric](https://class.textile-academy.org/2024/stephanie-vilayphiou/assignments/week08/)
Tools¶
Additional Project ideas¶
I originally hoped to make a soft speaker. I didn't get it done. i am leaving the instructions I downloaded for a potential future project.
(https://www.instructables.com/Embroidered-Fabric-Speaker/)
Instructions to make a soft speaker:¶
1) To create a functional speaker using an embroidery machine, you will embroider a coil pattern with highly conductive thread, which acts as the speaker's voice coil, onto a suitable fabric.
Materials Needed 1) Embroidery machine 2) Highly conductive thread (copper or metallic threads work, but can be brittle) 3) Regular thread 4) Fabric: Choose a material with appropriate stiffness; too soft and it will absorb vibrations, too stiff and it won't be able to move. Digital embroidery design: A tight spiral or arithmetic spiral design is recommended. 5) Permanent magnet (a strong, rare-earth magnet works well) Audio amplifier and power source: A 20W class-D audio amplifier (like the MAX9744) and a 5V DC power adapter are an example of components used in a project. 6) Cables: For transmitting the audio signal.
Cables and connection points: Snaps or solder for connections.¶
Instructions 1) Digitize the Design: Create or obtain a digital embroidery file with a tight spiral or arithmetic spiral coil design. The coil's dimensions should align with the size of your permanent magnet to ensure the magnetic fields can effectively interact.
Machine Setup:¶
1) Place the conductive thread in the bobbin spool, as the thread is less likely to break or knot there due to friction. 2) Use regular thread for the top spool. 3) Upload the spiral design to the embroidery machine.
Embroidery Process:¶
1) Hoop and stabilize your chosen fabric. 2) Run the embroidery machine to stitch the coil pattern. 3) Connect the Electronics: Ensure the signal is transmitted effectively by using cables to connect the ends of the conductive thread coil to your amplifier circuit. Connection points can be made with snaps or by carefully soldering the wires. 4) Connect the amplifier to an audio source (like a phone or music player).
Assemble and Test:¶
1) Hold or fix a permanent magnet close to the embroidered coil on the fabric. 2) Run an amplified sound source through the coil. The interaction between the electric current in the coil and the magnetic field of the permanent magnet will cause the fabric to vibrate, producing sound. The stiffness of the fabric and the tightness of the coil will affect the speaker's volume and sound quality.
_Fabrication files_ are a necessary element for evaluation. You can add the _fabrication files_ at the bottom of the page and simply link them as a footnote. This was your work stays organised and files will be all together at the bottom of the page. Footnotes are created using [ ^ 1 ] (without spaces, and referenced as you see at the last chapter of this page) You can reference the fabrication files to multiple places on your page as you see for footnote nr. 2 also present in the Gallery.
Code Example¶
Use the three backticks to separate code.
``` // the setup function runs once when you press reset or power the board void setup() { // initialize digital pin LED_BUILTIN as an output. pinMode(LED_BUILTIN, OUTPUT); }
// the loop function runs over and over again forever void loop() { digitalWrite(LED_BUILTIN, HIGH); // turn the LED on (HIGH is the voltage level) delay(1000); // wait for a second digitalWrite(LED_BUILTIN, LOW); // turn the LED off by making the voltage LOW delay(1000); // wait for a second
From Vimeo¶
Sound Waves from George Gally (Radarboy) on Vimeo.