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.

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

  • Ebb by Laura Devendorf explores textile computation through heat-activated design, using crochet and tapestry techniques with thermochromic pigments and soft circuits.
  • 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:

Wool bracelet/sweater cuff with integrated flip-dot actuator that activates when closed around the wrist.

bracelet

bracelet2

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

linen

I also experimented with different thermochromic pigment colors on various fabrics.

pigments

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 (What's Next section). 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.


Adding Input/Output: looking at the piece, I imagined it as a bracelet or a sweater cuff, so I needed a way to close it. I found some conductive sew‑on snaps in the lab and used them to complete the circuit: when the piece closes around my wrist, the circuit is completed and the flip-dot mechanism is activated through the Arduino Code configuration.

Once the piece was completed and working, I added some leftover threads from the Kniterate machine to create a more creative and textured design.

bracelet

bracelet2

Note: video speed 1.2x

Considerations: this is clearly not a finished product, just a prototype to show functionality. I still need to solder the terminals properly, secure all wires and test a configuration that avoids manually reversing the current (H-bridge would have been required, but it wasn’t available in the lab). I also need to review the setup with a more suitable battery: I tested 3.7, 5, and 9 V, and the video was recorded with 9 V, but the magnet still struggles to move.

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 pigments: a purple that turns pink, a blue that turns white, a red that turns white and a green that shifts to a soft yellow when heated. 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

Once dry, I added conductive threads to fabrics, sometimes drawing embroidered patterns, and measured their resistance. Heating tests were done with a hair dryer, a 9V battery and an Arduino circuit. All fabrics responded well to the hair dryer, but wool was almost impossible to heat electrically, even when using double threads, likely due to its insulating properties and the limited battery power. I still want to experiment further to find ways to make it work.

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 (still to do): I intended to add an input also to this circuit using a shirt, but I didn’t have time; I will do it as soon as possible. The idea is that when the shirt is closed, a conductive button at the top would complete the circuit and activate the thermochromic pigment, using Arduino board and this code. The garment wouldn’t be final, as cables would still be visible but it should work in principle.

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 how light and movement can be controlled using Neopixels, fiber optics, and vibration motors to expand my hands-on experience.
Also, I would like to move away from the Arduino board.

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