5. E-textiles¶

Research and Understanding¶

This week has been quite intense from a theoretical point of view. All my research this week stayed within the Fabricademy ecosystem: mainly based on Liza Stark’s lecture, Emma Pareschi’s earlier training materials and pages from former students. More in Tools and Links.

Electronic textiles¶

E-textiles combine electronics with soft materials such as fabric, yarn or felt. They can sense, react or communicate through embedded circuits, making the textiles interactive and responsive. Traces are conductive paths that carry electricity, created with conductive thread, fabric or paint.

Some common materials used to create e-textiles. Images from Lize Stark's slide.

Basic concepts¶

Credit to Freeing Energy

ELECTRICITY: Movement of electrons through a conductive path, enabling circuits and interaction.
VOLTAGE (V): Electrical pressure that pushes current through a circuit, provided by power sources.
CURRENT (I, A): Flow of electrons in a circuit, like water through a pipe, from + to –.
CIRCUIT: Closed loop where current flows through components using a power source and conductive path.

Inputs & Outputs
A circuit connects inputs and outputs: sensors detect changes in the environment and LEDs provide visual feedback.

SENSORS generate an electrical signal (voltage) and can be Digital (on/off signals) or Analog (a range of values).

LEDs (Light Emitting Diodes) emit light when current flows, composed by two legs (anode (+) and cathode (–)) and with typical voltage 2–3.2 V but depending on the color (red:1.8 V, blue:3.2 V). The recommendation is to connect them in parallel for stable circuits.

Sensor Visual Summary

Credit: Emma Pareschi's slide

Click on image to see it bigger. Credit: images from Lize Stark's slide

Multimeter
A tool used to diagnose problems in a circuit. I mainly used it to check continuity, so if connections are complete (OL means no connection, a value means the path is closed.)

Credit: Emma Pareschi

Arduino
It is an open-source platform used to read signals from sensors, process them and control outputs such as LEDs.

Arduino IDE: software to write and upload code to the board. It lets you program the board and see sensor or device outputs.

Arduino UNO: the microcontroller board where you connect sensors and LEDs to run your circuits. It has pins along its edges to connect and control components.

Alumni page that guided me¶

Easy-to-follow project with a digital button: Capucine Robert - Le Textile Lab
Crochet switch and sensor: Louise Massacrier - Le Textile Lab
Digital embroidery project: Diane Wakim - Le Textile Lab
Felted Digital Touch Sensor: Carolina Beirao - TextileLab Amsterdam Waag FutureLab

References & Inspiration¶

Mengjie Zheng’s project
Inspired by traditional playground games, it's an interactive textile installation that makes different piano sounds when pressure is applied, highlighting the importance of play.

Credit: Instagram

Maria Lai
A pioneering Sardinian artist, renowned for her “stitched books,” which combine narrative and textile, turning storytelling into delicate, hand-embroidered works. Her books draw inspiration from Sardinian folklore and popular tales, transforming them into poetic, imaginative narratives.

Holding the shadow by the hand - Maria Lai

The Janas
In Sardinian legends, the Janas are ethereal beings, often depicted as fairies. They are believed to reside in ancient tombs carved into the rock, known as Domus de Janas (UNESCO World Heritage Site from July 2025) These mythical figures are said to possess the ability to weave intricate patterns and are ambivalent in nature: benevolent and protective toward children and the pure-hearted, but capable of turning vengeful if offended or disappearing if seen directly.

Sand artist Nicola Urru celebrated the Janas with an art piece created on a beach near my hometown.

Credit: Instagram

Crochet Granny Square
This traditional motif, made entirely with a crochet hook, originated in the 19th century. Named for its patchwork-like square shape, it has remained popular for creating blankets, garments and decorative items, traditionally made in wool or cotton.

One of my typical research in Pinterest while looking for inspirations. Artist names not found despite research.

Final results¶

This weekly assignments included:

Creating one digital and one analog sensor using Arduino to control signals.
Developing a textile project that includes a sensor and is powered directly by a battery-operated circuit without an Arduino board.

As a digital and analog sensor to test with Arduino, I created a small crochet prototype. Process described in section Digital Sensor and proceed in Analog Sensor.

For the textile project, I developed Janas’ Lights, inspired by an ancient Sardinian legend: Janas fairies wove with golden threads during the night; if someone saw them, they would disappear, leaving behind only a glowing thread.

A digital sensor (button) activates the light of three blue LEDs, while the viewer can also touch and explore the different decorative materials: beads, sparkling thread and wool, a material I try to include whenever possible. The drawing also features a conductive trace designed for further circuit implementation. Process described in section Digital Embrodery Machine.

Process to get there¶

In addition to the materials and components presented in the Research and Understanding section, this week I used the following materials.

Credit: Photo from Capucine Robert's page, as we are from the same lab and use the same materials.

Breadboard: plastic board for building circuits without soldering. Side rails provide power (red = +, blue = –) and central rows let components connect in the same line.
Jumper Wires: flexible wires to connect components on the breadboard or to Arduino.
Alligator Clips: clips for quick temporary connections to switches or sensors.
Resistors: control current, especially for LEDs.
USB Cable: powers the Arduino board and connected components.

In the laboratory, we ran a first test without sensors to learn how to make an LED blink and change its frequency, following Emma Pareschi's training.

I followed below guidelines to work on my prototypes:

Start small with rough prototypes and build up gradually to your final version.
Don't jump into Arduino before testing your prototype with multimeter.
Troubleshooting tip: if something isn’t working, isolate the problem. Check both sides: hardware (connections, assembly) and software (Arduino code).
Sketch your circuit and test the setup before sewing, using tape or your hands to keep the materials in place.

Digital Sensors¶

Digital sensors, also called "switches", are made of two conductive parts that can touch each other. When they touch, the switch is closed and the circuit is complete; when they don’t, it’s open. They produce only two states: on/off (1/0).

I decided to create a simple botton, a momentary switch.

Quick and dirty switch¶

I started experimenting by building a simple ‘sandwich’ with minimal materials.

MATERIAL & STEPS

Material:

Copper conductive fabric
Conductive thread
Tape
Neoprene

Steps:

Cut two squares of copper fabric.
Attach a conductive thread to one side of the first copper square, and repeat for the second square.
Cut a square of neoprene slightly larger than the copper squares and place it between them. IMPORTANT: make sure the conductive threads attached to the copper fabrics are on opposite sides, as they represent the positive and negative poles of the circuit.
Use tape to keep everything together and you’re done!

Test with multimeter using the continuity mode.

Connecting to Arduino and replicating two configuration in Emma Pareschi's tutorial

READING SERIAL NUMBERS

Circuit scheme to build

Credit to Emma Pareschi

I run Code 1 in Arduino IDE to monitor the sensor’s digital readings through the serial monitor. The output alternates between 1 and 0, where 0 indicates the sensor is being pressed.

To read results, activate related views by clicking on: "Tools > Serial Monitor" or "> Serial Plotter".

Click on image to see it bigger.

USING THE BUTTON TO BLINK A LED

Scheme to add Led and resistor to the circuit

Credit to Emma Pareschi

I run Code 2 in Arduino IDE, which connects the sensor to the LED. Pressing the sensor turns the LED off and it lights up again when released.

Everything worked as expected so I felt confident to move on and create the final prototype.

Final prototype¶

As we are part of the EU Woolshed in Lyon, my idea was to use wool, since it’s a great electrical insulator, for this week’s assignments.

I missed using my crochet hooks, so I came up with this prototype: two crocheted wool "granny" squares that act as a button when touched in the middle.
I liked the idea because it looks like a finished object: a small storage pouch you can keep in your bag.
There are many tutorials on how to make a granny square, such as this one.

MATERIAL & STEPS

Material:

White Merino conductive yarn with 18% stainless steel alloy
Green wool yarn (my left-over from a previous project)
Crochet hooks (I used different size)

Steps:

Create a granny square using normal wool yarn mixed with conductive yarn for the first rows. Keep the condutive yarn only for the middle part and leave a tail that can be "the pole". Note: in my case I used both yarns at the beginning as the conductive one was very thin but it's not necessary. Note: a bigger hook is suggested for this step.
Replicate the process for the second square, leaving again a tail from the conductive yarn.
Sew the granny squares together using regular wool, making sure that the conductive threads, which act as the positive and negative poles, are positioned on opposite sides and extend out from the edges so they are not sewn into the squares. Keep open the top side.
In my case, the conductive thread was very thin and made no contact, so I added an extra row of conductive yarn sewn inside.

Note: The wool yarn and stitched edges keep the two layers slightly apart, so the center doesn’t touch unless pressed (the thickness of the material works as a natural spacer).

I tested it with the multimeter and then connected to Arduino UNO using alligators and Code 2 to turn on/off a LED. The video below summarizes the various steps.

Analog Sensor¶

Analog sensors act as variable resistors, meaning their resistance changes depending on external conditions (like pressure or light), allowing measurement of a wide range of values (not just 0 or 1).

I decided to proceed with a pressure sensor. In the future, I'd also like to explore stretching sensors made in wool.

Quick and dirty sensor¶

MATERIAL & STEPS

Material:

Velostat (carbon-based conductive material)
Conductive thread
Tape

Steps:
1. Cut a small piece of velostat
2. Attach the conductive thread along the entire side with tape
3. Turn the velostat over and repeat on the other side, making sure the conductive thread is on the opposite side.

Test with multimeter the resistance variation. Set your multimeter to the Ohm (Ω) mode.

When using an analog sensor in a circuit, you also need a fixed resistor to create a change in voltage as the output. This mechanism is known as a "voltage divider".

To choose the correct resistor for your breadboard later, you can calculate it with a multimeter by following the steps in the box below, shared by Emma Pareschi.

CHOOSE THE RIGHT RESISTOR

With the multimeter measure the resistance on the sensor while you interact with it.
Take note of the min and max resistance values
Calculate the average of the min and max. 4.The average is the optimal value of the extra resistor to use with the analog sensor. In my case, about 2k Ohm.

Note: You can also just try with a 5k or 10k Ohm. I had with me 1k and 10k Ohm and I proceeded with the second one to keep it safety and avoid damages.

Testing with Arduino pin and replicating two configurations in Emma Pareschi's training

READING SERIAL NUMBERS

Circuit scheme to build

Credit to Emma Pareschi

Note: I used a 10k Ohm resistor instead of a 5k Ohm, as explained in "Choose the right resistor" box.

I run Code 3 in Arduino IDE to monitor the sensor’s analog readings through the serial monitor. The output alternates between various values this time.

To read results, activate two views by clicking on: "Tools > Serial Monitor" or "> Serial Plotter". I also test the code "Smoothing" (File > Example > Analog > Last tab) for better reading and fewer peaks.

Click on image to see it bigger.

USING THE SENSOR TO FADE A LED

Scheme to add Led and resistor to the circuit

I run Code 4 in Arduino IDE to visualize and test the analog behavior of my sensor. The code reads the changing resistance values, maps them to a 0–255 scale and uses them to modulate the LED brightness in real time.

Final prototype¶

Conscious of the limited time available and inspired by a solution from Nuria Roble’s slides, I continued developing the crocheted tile used for the digital sensor.

The central conductive threads already provide a good foundation for analog applications, so I added a layer of velostat (a carbon-based conductive material) in the middle to obtain a range of variable values rather than simple on/off responses.

I tested it with the multimeter and then connected to Arduino UNO using alligators and Code 4 to fade a LED.
Note: In the Arduino code, I adjusted the mapped values according to my sensor’s range to achieve a better variation in the light intensity. The video shows an early test that was less accurate: the LED intensity did change but the variation wasn’t very visible on camera.

Digital Embrodery project¶

On Thursday, Diana and I had the chance to test the digital embroidery machine at Le Textile Lab, with Marion (2023 Fabricademy Alumni) guiding us through the process. The machine allows embroidery with both regular and conductive threads, so the idea was to create an interactive e-textile project.

Credit photo: Capucine using my camera

Since I was just getting familiar with the theoretical concepts, I decided to focus on a switch sensor, inspired by Capucine's project that I saw in the lab.

Project concept: according to legend, Janas fairies wove with gold thread at night. If seen, they disappeared, leaving only a glowing thread.

E-textile translation: when the button is pressed, three LEDs light up, powered by the battery connection, while the rest stay off as if the Janas were revealed.

My sketch designed in Circuit Diagram tool

Embrodery machine settings: to work with the machine, the design must be in SVG format. I created an initial draft in Canva, then moved to Inkscape to resize it to 18 cm × 18 cm to fit the machine settings. For more precise adjustments, especially for text, Marion recommended doing the final tweaks directly in the machine software (PE Design II), which is installed on the lab computer.

Final piece: I simplified my initial design to save time and focus on the switch concept.
On a base of synthetic blue felt, we embroidered three key elements, with this order:
1. The hands stitched with regular thread
2. Conductive thread to connect a circuit composed by parallel LEDs, a switch sensor (button) and a 3V battery.
3. Conductive thread for the text, as the final one and without cutting the thread between words. However, the machine did cut the thread between lines. This part was intended for future extensions and was not implemented due to time constraints.

The machine at work

Once the embroidery was complete, I added the LEDs, then I created the battery pocket and made the button using neoprene and conductive fabric.

Notes on the image indicate the materials used and the correct contact points for the circuit.

What's next: more to explore¶

I would like to experiment with using a conductive zipper as an additional switch in the crocheted digital sensor. I’m aware that this element can be challenging to work with, but it will be interesting to see if I can make it work.

I also aim to enhance the embroidered projects by incorporating the conductive thread from the textile part to implement another circuit. For this project, it may be useful to solder the conductive points and threads to ensure stable connections and prevent short circuits.

Tools and Links¶

Images: Martina Muroni unless otherwise stated.

Arduino IDE Codes¶

Code 1: Read Digital serial numbers

int digital_sensor_pin = 8;
int digital_sensor_value =0;
int led_pin=3;

// the setup routine runs once when you press reset:
void setup() {
  // adding the button as input
  pinMode(digital_sensor_pin, INPUT);
  // initialize serial communication at 9600 bits per second:
  Serial.begin(9600);
  //adding the led as output
  pinMode(led_pin, OUPUT);
}

// the loop routine runs over and over again forever:
void loop() {

  digital_sensor_value = digitalRead(digital_sensor_pin);  // read the input pin, sensor
  // print out the state of the button:
  Serial.println( digital_sensor_value);
  delay(100);  // delay in between reads for stability
}

Code 2: Digital sensor turns on/off the led

// constants won't change. They're used here to set pin numbers:
int buttonPin = 8;  // the number of the pushbutton pin
const int ledPin = 3;    // the number of the LED pin

// variables will change:
int buttonState = 0;  // variable for reading the pushbutton status

void setup() {
  // initialize the LED pin as an output:
  pinMode(ledPin, OUTPUT);
  // initialize the pushbutton pin as an input:
  pinMode(buttonPin, INPUT);
}

void loop() {
  // read the state of the pushbutton value:
  buttonState = digitalRead(buttonPin);

  // check if the pushbutton is pressed. If it is, the buttonState is HIGH:
  if (buttonState == HIGH) {
    // turn LED on:
    digitalWrite(ledPin, HIGH);
  } else {
    // turn LED off:
    digitalWrite(ledPin, LOW);
  }
}

Code 3: Read analog sensor value

int analog_sensor_pin = A0;
int analog_sensor_value = 0;

// the setup routine runs once when you press reset:
void setup() {
  // adding the button as input
  pinMode(analog_sensor_pin, INPUT);
  // initialize serial communication at 9600 bits per second:
  Serial.begin(9600);

}

// the loop routine runs over and over again forever:
void loop() {

  analog_sensor_value = analogRead(analog_sensor_pin);  // read the input pin, sensor
  // print out the state of the button:
  Serial.println(analog_sensor_value); 
  delay(100);  // delay in between reads for stability

}

Code 4: LED fading

/*arduino {#code4}
  We use this sketch to connect a LED and read a range of values

// analog pin 2 has a pushbutton attached to it. Give it a name:
int analog_sensor_pin = A0;
int analog_sensor_value = 0;
int led_pin=3;

// the setup routine runs once when you press reset:
void setup() {
  // adding the button as input
  pinMode(analog_sensor_pin, INPUT);
  // initialize serial communication at 9600 bits per second:
  pinMode(led_pin, OUTPUT);
  Serial.begin(9600);

}

// the loop routine runs over and over again forever:
void loop() {

 //original range
 //min: 110
 //max: 220
 //new range: 0/255

  analog_sensor_value = analogRead(analog_sensor_pin);  // read the input pin, sensor
   analog_sensor_value = map(analog_sensor_value, 110, 220, 0, 255); // We need to be precise to see changes in light so map function to change my original range to new range
   analog_sensor_value = constrain(analog_sensor_value, 0, 255);

  analogWrite(led_pin, analog_sensor_value);
  Serial.println(analog_sensor_value); 
  delay(10);  // delay in between reads for stability

}