Skip to content

9. Wearables

Research and Understanding

This week can be considered a continuation of the E-textiles class. This section collects the key theoretical ideas that form the basis of my process.

Basic concepts

Wearable project is a system: a continuous dialogue between hardware and material.

Actuator is a device that enables a wearable system to produce a perceivable change in response to signals. It can create visual effects (lighting up LEDs), sound (generating tones) or motion (vibrating, expanding, or contracting). Actuators are the “action” part of a wearable, turning digital commands into tangible experiences.

type Credit: Liza Stark slides

A transistor is an electronic component that acts as a switch and it is used with different circuit configurations with the actuator. It allows to manage a much larger current and the N-channel MOSFET type is commonly used for this purpose. It has three legs: Gate, Drain, and Source. The Gate receives the control signal, which opens or closes the flow of current between the Drain and the Source. Since transistors generate heat when conducting power, the metal tab in the opposite side helps dissipate excess heat.

mosfet Credit: Liza Stark slides

The basic circuit for actuators uses a microcontroller (Arduino Uno, Xiao, etc.) to send control signals, but its pins can provide only about 40 mA, which is not enough to drive most actuators. The transistor therefore becomes essential: it allows an external power source to supply the higher current required, while the microcontroller only controls the switching. All the actuators I tested follow this same circuit structure.

Note: the transistor board I used was already available in the lab, originally built by former Fabricademy alumni. circuit Credit: Emma Pareschi slides

Alumni pages that guided me

References & Inspiration

Liza Stark’s lecture featured many inspiring projects. I selected some relevant to my current and future experimentations (more in her website).

  • Wifi Tapestry by Richard Vijgen changes colour in response to Wi-Fi signals, visualising the invisible flow of data through delicate thermochromic fabric.

  • The embroidered computer by Irene Posch turns traditional gold embroidery into a functional computational system, using magnetic textile components and a flip-dot-like switching mechanism to make binary logic tangible.

  • Artificial Intelligence and its False Lies by Mika Satomi is a wearable embroidered with an artificial neural network, using fiber-optic threads to sense and “dream” the wearer’s movements, creating a ghostly intelligence of thread and light.

  • 100 Electronic Art Years by Maggie Orth is a handwoven textile that changes color with conductive threads and thermochromic inks, using electrothermal actuation to create continuously shifting patterns.

  • Ebb by Laura Devendorf explores textile computation through heat-activated design, using crochet and tapestry techniques with thermochromic pigments and soft circuits.

ref Credits: images sourced from the websites mentioned above for each creator.

The Seam UK inspired me to rethink discarded garments using actuators. The platform connects people with skilled makers to repair and restore clothing, promoting sustainability by giving new life to old items.

seam Credit to Seam UK

Results

This weekly assignments included:

  • Create two actuators designed for the body. Test them with the board of your choice.

  • Create one swatch using a board of your choice with one input and one output of your choice. It should be intentionally designed to be worn on the body.

In response, I created:

Sweater cuff with integrated flip-dot actuator that activates when closed around the wrist.

bracelet

Patch with thermochromic pigment for repairing or decorating clothes (in my case, a shirt).

linen

Process to get there

For this week, I focused on flip-dot as a motion actuator and thermochromic as a visual actuator. I was also curious about sound and I hope to explore more types of actuators in the future. Since Lyon Lab is part of EU Woolshed, my aim was to test wool as extensively as possible.

Flip dot

Key Concepts

Flip dots use a small magnetic hematite bead that flips when a current passes through a coil, as the electromagnetic field attracts or repels the bead depending on current direction.

To flip the bead: the current must be reversed by swapping the battery’s positive and negative leads.

Securing the bead: thread tension is key: too tight and the bead won’t flip, too loose and it can pop out of the coil.

Coil preparation: the coil is a crucial element for proper flipping. Its wire ends should be cleaned by sanding or burning the enamel, so the current flows correctly. The wire material, usually copper, ensures good conductivity and final cleaning removes insulation residues that could block current.

Circuit: reversing current requires an H-bridge, a component that lets microcontrollers control both direction and speed of magnetic movements. Without an H-bridge (e.g., using only Arduino pins), the bead won't change direction unless you physically swap the connections after it flips.

First test

For this actuator, I first followed Emma Pareschi's tutorial and also used Pauline Gamore prototype available in the lab to understand the logic.

dot

Credit to Pauline Gamore

My experiment

Some weeks ago, Pauline tested the Kniterate machine in the lab and left an unfinished piece made of ochre merino wool with incomplete threads.

knitting

I cleaned it up and began adding coils and magnets to the top. I crocheted my first coil, then made three more. After testing each one with a battery and in a circuit, I sewed them onto the wool piece. The charge was too weak though, so I’ll need more time to experiment with this combination.

magnets

Testing three magnets united with conductive thread

I then started again with a simpler setup: one coil. Later, I decided to use Pauline’s piece because her magnet was bigger and I loved the contrast between the ochre and pink wool.

Note: The video quality isn’t perfect, but you can see the white part of the dot flipping when the current is reversed.

Adding input/output:

  • The piece was imagined as a bracelet or sweater cuff, requiring a closure mechanism.

  • Conductive sew‑on snaps were found in the lab and used to complete the circuit when the piece is closed around the wrist.

  • When the piece closes around the wrist, the circuit is completed and the flip-dot mechanism is activated through the Arduino Code.

  • Once the prototype was functional, leftover threads from the Kniterate machine were added to create a more textured and expressive surface.

bracelet

bracelet2

Note: video speed 1.2x

Prototype considerations:

  • This is a functional prototype, not a finished product, developed to demonstrate basic functionality.

  • Soldering needed to secure all terminals and wires.

  • The current setup relies on manual current reversal: a proper solution would involve an H-bridge but it was not available in the lab.

  • Power supply needs optimization: 3.7 V, 5 V, and 9 V were tested. The video was recorded at 9 V, but the magnet still struggles to move, indicating the need for further optimization.

Thermochromic

Key Concepts

Thermochromic pigments/inks change color with heat. Their speed and intensity depend on pigment concentration, substrate type (tracing paper reacts faster than canvas), and ambient temperature.

Application methods (e.g., brushing) affect how evenly the color changes.

Electrical behavior: resistance in the heating element must be balanced: too high = no color change; too low = risk of short circuit.

Heating needs more current than an Arduino pin can deliver, so a transistor is used to switch a stronger external power source. The transistor also generates heat and includes a hole for heat dissipation.

First test

I approached this actuator by testing a prototype made by Capucine Robert, first using a battery and then an Arduino UNO, with this codes in Liza's slide. The textile is a net-like fabric dyed with a blue thermochromic pigment that turns pink when heated, with conductive thread stitched behind the lace.

test

In Capucine’s original video, the color change appears more pronounced, so I’m sharing it below. I believe the difference is due to the time passed and the fact that the same fabric has undergone multiple experiments, which likely affected its performance.

My experiments

I tested four thermochromic pigments, each reacting differently to heat: purple turns pink, blue and red fade to white and green shifts to a soft yellow. I didn’t know their final colors beforehand, so part of the test was simply discovering how they would react.
I applied them on three types of light-colored fabrics: cotton, linen and wool I crocheted.

As substrates to mix the pigments, I tested two recipes: one with wood glue (available in the lab and inspired by Capucine Robert recipe) and one with gum arabic. Wood glue makes the fabric harder, while gum arabic helps preserve softness, which was important for wool.

material

  • 6 g Wood glue
  • 0.5 g pigment powder
  • a petri dish
  • a small container
  • a balance
  • a spatula
  • brush
  • Weight both ingredients in two separate containers/petri dishes.
  • Add the pigment to the glue while mixing it. Note: I did the opposite and the pigment was hard to incorporate.
  • Apply to fabric and let air-dry completely.
  • 0.8 g gum arabic powder (8%)
  • 2 g water
  • 6.2 g water (62%)
  • 1 g thermochromic pigment powder (10%)
  • petri dish
  • a small container
  • a balance
  • a spatula
  • brush
  • Mix 0.8 g gum arabic powder with 2 g water until fully hydrated.
  • Add 6.2 g water and stir gently.
  • Add 1 g pigment and mix until uniform.
  • Apply to fabric and let air-dry completely.

color

Material considerations:

  • Once dry, conductive threads were added to the fabrics, sometimes using embroidered patterns, and their electrical resistance was measured.

  • Heating tests were conducted using a hair dryer, a 9 V battery, and an Arduino-based circuit.

  • All fabrics responded well to the hair dryer, while wool was extremely difficult to heat electrically, even when using double conductive threads.

  • Wool behavior is likely due to its insulating properties combined with the limited power of the battery and further experimentation is needed to identify the best configuration.

Final piece
I focused on the linen sample with a small embroidered drawing and imagined it as a patch for a garment that might otherwise be discarded due to a hole or a stubborn stain.

linen


Adding input/output (work in progress):

  • An input element was planned for this circuit using a shirt, but it was not implemented due to time constraints.

  • The intended behavior is that, when the shirt is closed, a conductive button at the top completes the circuit. This action would activate the thermochromic pigment through an Arduino board, using this code.

  • The garment would remain a non-final prototype, with visible cables, but should work in principle as a proof of concept.

shirt

Sound: Speaker

Key Concepts

Sound is produced when the fabric vibrates and creates pressure waves in the air.

Speakers use magnets (permanent + electromagnet): electrical signals make the coil’s magnetic field fluctuate, causing vibration and sound.

Magnet placement affects volume, but material interaction matters more than loudness. Keep enough spacing to avoid short circuits; aim for coils around ~8 Ω.

Circuit: sound can be driven directly from microcontrollers for small tests, but dedicated amplification is usually needed for clearer, louder output.

My goal wasn’t to build a new sound actuator but simply to understand how it works. So I decided to test a speaker already available in the lab, made by our local reviewer, Diane Wakim. Coincidentally, Diane visited us at Le Textile Lab this week, so it was a perfect opportunity to test it together! We used the same code and melody she originally created for her project.

Compared to the standard actuator setup, we decided to keep her configuration without an external battery and power it directly from the Arduino pins, since the sound was already extremely loud.

speaker

What's next: more to explore

I would like to experiment with controlling light and movement using Neopixels and vibration motor to expand my hands-on experience. Although a circuit without Arduino UNO wasn’t required this week, I’m interested in moving away from the board for a cleaner setup using conductive threads and a battery.

Images: Martina Muroni unless otherwise stated.

Arduino code

Code 1: Sound (Diane Wakim code)

/* Generating a melody with Arduino Tone() and the pitches library */

#include "pitches.h"

const int speaker = 3; //speaker to arduino pin 3

// notes in the melody:
int melody[] = {
  NOTE_DS4, NOTE_DS4, NOTE_DS4, NOTE_DS4, NOTE_B3, NOTE_CS4, NOTE_DS4, NOTE_CS4, NOTE_DS4
};

// note durations: 4 = quarter note, 8 = eighth note, etc.:
int noteDurations[] = {
  8, 8, 8, 2, 2, 2, 3, 8, 2
};


void setup(){

  pinMode(speaker, OUTPUT);

}

void loop(){

  noTone(speaker);     // Stop sound...
  delay(1000);        // ...for 1sec

  for (int thisNote = 0; thisNote < 9; thisNote++) {
    // to calculate the note duration, take one second divided by the note type.
    //e.g. quarter note = 1000 / 4, eighth note = 1000/8, etc.
    int noteDuration = 1000 / noteDurations[thisNote];
    tone(speaker, melody[thisNote], noteDuration);

    // to distinguish the notes, set a minimum time between them.
    // the note's duration + 30% seems to work well:
    int pauseBetweenNotes = noteDuration * 1.30;
    delay(pauseBetweenNotes);
    // stop the tone playing:
    noTone(speaker);
  }

}

Code 2: flip dot (blink code)

void setup() {
  // put your setup code here, to run once:
  pinMode(3, OUTPUT);

}

void loop() {
  // put your main code here, to run repeatedly:
digitalWrite(3,HIGH);  //max voltage of my board, for Xiao is 3.3V for example
delay(1000);          //wait 1 sec
digitalWrite(3,LOW); //0V I turn it off
delay(1000);         //wait 1 sec
}

Code 3: Thermochromic with digital pin

int heatingElementPin = 3;  //set your pin

void setup() {
  pinMode(heatingElementPin, OUTPUT);
}

void loop() {
  // Full power heating
  digitalWrite(heatingElementPin, HIGH);
  delay(2000);

  // Rest time
  digitalWrite(heatingElementPin, LOW);
  delay(1000);
}

Code 4: Thermochromic in a circuit

int heatingElementPin = 3;   // Pin collegato al riscaldatore
int inputPin = 2;            // Pin collegato al pulsante o circuito di controllo

void setup() {
  pinMode(heatingElementPin, OUTPUT);
  pinMode(inputPin, INPUT_PULLUP);  // Usa INPUT_PULLUP se il pulsante chiude verso GND
}

void loop() {
  int inputState = digitalRead(inputPin);

  if (inputState == LOW) {  // Switch 
    // Ciclo di riscaldamento: 2s ON, 1s OFF
    digitalWrite(heatingElementPin, HIGH);
    delay(2000);
    digitalWrite(heatingElementPin, LOW);
    delay(1000);
  } else {  
    digitalWrite(heatingElementPin, LOW);  // Turn off the heating condition
  }
}

Tools & Resources