9. Wearables¶
Research & Inspiration¶
In the E-textile week, I wrote a lot about textile elements that inspired me. That week I focused on interior elements that become alive — wallpapers or textiles with light inside. It was interesting.
But this week feels completely different for me because of the context. When I first read the headline of the week, I couldn’t understand what it was about. But when I started learning the topic, my brain went BOOOM.
It’s a fantastic field — so many projects, so many designers whose work I already liked, but I never knew they were connected to wearables.
Do you remember my inspiration part from Week 1? I talked about Hussein Chalayan. Did you think I knew that one of my favorite works by him was wearable? Exactly — NO.
Was I shocked? Honestly, no — but it opened my eyes to how his projects were made. I loved them, I was inspired by them, but I never thought about their technical background, their making history, and the real process behind them.
The surprising part is that I never asked how he did it. I was blind, thinking I could never understand a designer so brilliant. But now I see that I actually CAN — I just need to research and truly try.
Digital Skin: The Convergence of Fashion, Design, and Technology ⬇
This Sign Speaks¶
I guess every one of us at least once communicated with a person who can’t hear, but only a few people who can hear actually know sign language. And then the question appears — how can they communicate with each other? Sometimes it happens with translators or sound devices, sometimes with text, and sometimes there is no way at all.
Looking at this problem inspired the project called Smart Sign Language Interpreter. It is a convenient device that helps hearing-impaired people communicate with those who can hear, using sign language. Isn’t it perfect? I think yes.
This device works with an EMG sensor, a gyro sensor, and a distance sensor to detect and interpret the movements of the hands and fingers.
Small distance sensors are applied to the tips of the user’s fingernails. When a hearing-impaired person uses signs to communicate to a non-hearing-impaired person (who can not use sign language), the signs are tracked, converted into voice or text data, and sent to the recipient’s smartphone. The device also contains speakers that can transmit the voice data directly. When a non-hearing-impaired person speaks to a hearing-impaired person, their voice is converted into text by the device, and displayed on its built-in screen. The text can be converted into signing diagrams.
Designers: Jeon Sung-Su, Ku Ja-Yun & Lee Seo-Young
AIR CLICKER¶
When we talk about a camera, we usually imagine a small (or big) lens with a clicker, maybe a phone, or something else. Sometimes when we want to take a photo, we first need to take the phone, unlock it, open the camera, and only after that we can make a photo — and sometimes we lose the moment. The idea of this project is to make this process easier, lighter, and faster — a way to activate it instantly, maybe with an on/off button for moments between shoots.
The idea is a super-easy construction — the Air Clicker Bluetooth camera concept by Yeon Su Kim. This device is made from just two silicone rings worn on your fingers. It is already on your hand, and you can take a photo immediately without losing special and important moments.
The forefinger module senses whether your finger is straight, bent, or bent together with the rest of your fingers. When only the forefinger is bent, the device takes a photo. When several fingers are bent, it starts recording video.
The thumb module contains the camera lens and the on/off button, and is responsible for both capturing the media and sending the files directly to your smartphone.
Using today’s technologies, this project is still unreal, but with the fast development of technology, it may become real tomorrow — after a month, a year, or five years. But whenever it becomes real, this project will be lovely, useful, and special for people who love capturing moments — like me.
What is Werable ?¶
Wearables (correct spelling) are electronic devices that you can wear on your body. They combine technology with clothing, accessories, or textiles.
Simple explanation:
Wearables = wear + electronics.
Examples:
- Smartwatches
- Fitness trackers
- VR headsets
- Smart rings
- E-textile clothing with sensors or LEDs
- Medical patches that monitor heart rate
- Heated jackets
- Clothing that changes color or reacts to movement
In our context (e-textiles):
Wearables include any textile or accessory that has electronics inside — sensors, LEDs, microcontrollers, touch pads, etc.
IT'S TIME TO DIVE INTO PROCESS¶
Returning to the Basic Rules of Electronics.¶
Saying that electronics is hard for me is honestly saying nothing — it felt like jumping into cold water without knowing how to swim. I really couldn’t remember most of the things from last electronics week. Ahhh… total panic mode.
But Anoush Arshakyan was incredibly helpful. She started explaining every detail to me, every moment, everything from the very beginning, and it was amazing. Her explanation was like a bright light, and I finally started thinking about my projects for this week and what I could do.
After that, we went through the whole thing together again, remembering electronics piece by piece, and only then started diving deeper.
This is the first experiment we did. I remembered it from last time, but I didn’t remember how to make this connection.
To understand this simple connection, we first need to understand how the board’s connection lines work. The name of this board is BB83. It is designed for easy connections and helps us test whether our project will work with this type of wiring, without building everything permanently or mixing things up.
The red lines are the pluses, and the blue lines are the minuses. They are connected horizontally. The green lines go vertically — the green ones are our pins. If we want to make the connections correctly, the circuit must start from + and end at –. Following this principle and the direction of the lines we discussed, we create a working connection.
In my example, I took the first clip and placed it on the plus line, then connected it to the Arduino Uno 5V pin. The next component in the circuit is the resistor. The resistor is placed on the plus line so it stays connected to the previous clipper. The second leg of the resistor goes into a randomly chosen point in the middle section. After that, the first leg of the LED goes into the same line where the resistor’s second leg is placed. The second leg of the LED goes into another middle line. Finally, that line is connected to the minus line, and from the minus line we connect the wire to the GND pin of the Arduino Uno.
Why do we need a resistor? Our LED is not powerful and does not need the full 5V to light. In fact, if we give it the full 5V, it can burn out. The resistor keeps part of the voltage for itself and gives the LED a lower, safer amount of voltage so it can work without problems.
Arduni IDE¶
After all these manipulations, we move to the Arduino using the Arduino IDE app.
What is Arduino IDE ?
The Arduino IDE is a free, open-source software application that allows users to write code and upload it to an Arduino board. It is a simplified, beginner-friendly environment with a text editor, menu bar, and toolbar for functions like verifying code, uploading, and opening files. The code written in the IDE, called a "sketch," is written in C/C++ using a specific Arduino programming language and is compiled into a hex file to be uploaded to the board.
Here is how it works:
- Connect the Arduino board with a Type-C cable and open the program.
- Open Tools and set the correct board type, then choose the port.
- Start coding.
For the first time, you can open the Examples section and choose an easy code to use.
How to do that:
File → Examples → Basics → Blink
What Are void setup() and void loop() ?
When we write code for Arduino, the program always has two main parts: void setup() and void loop(). They are like two rooms where different things happen.
- Void setup()
Void setup() runs only one time, right after we upload the code or turn on the Arduino.
It is used to set up everything:
- Telling which pins are outputs or inputs
- Starting communication (like Serial)
- Preparing sensors or modules
Think of it like preparing the stage before the show starts.
Example:
void setup() {
pinMode(13, OUTPUT);
}
This means:
“Pin 13 will be used as an output.” The Arduino reads this once and remembers it.
- Void loop()
Void loop() runs again and again in a continuous cycle. This is where the Arduino repeats the actions.
Everything inside void loop() loops forever until you turn off the board.
Example:
void loop() {
digitalWrite(13, HIGH);
delay(1000);
digitalWrite(13, LOW);
delay(1000);
}
This means:
“Turn the LED on for 1 second, off for 1 second — repeat forever.”
A video that will help you understand Arduino IDE deeper and see how people work with it ⬇
XIO RP2040¶
What is XIAO RP2040 ?
The XIAO RP2040 is a small but powerful microcontroller board made by Seeed Studio. It is based on the Raspberry Pi RP2040 chip, the same chip used in the Raspberry Pi Pico.
We use it in both of our projects. it is too usefull and i will use it with already connected board and one poard i will connect with microcontroller.
What I Did First
I with Onik Babajanyan, who was a Fab Academy student in 2022 and is now the CEO of Dilijan’s Fab Lab.
He taught me how to use a *soldering iron. We soldered the XIAO RP2040 following standards so it could connect easily with the BB83 board, without creating poor or unstable connections.
How it was ⬇
It was realy fun experiance for me.
Now time for connections with BB83. We wanted connect it with serbo mator for my future broject wich you will see a bit later. We connect serbo mator tree connections (plus, ground and pin) with the BB83 and code it with the easist code just to mode the serbo had on 180 graduce and beack.
The code:
#include <Servo.h>
Servo myServo; // create servo object
#define SERVO_PIN 10 // connect servo signal wire to D10
void setup() {
myServo.attach(SERVO_PIN); // attach servo
}
void loop() {
myServo.write(0); // move to 0°
delay(1000); // wait 1 second
myServo.write(180); // move to 180°
delay(1000); // wait 1 second
}
Between the voltage and the servo motor, we added another resistor. This time, the resistor was used for touch detection.
It can detect not only if you touch it, but also how strongly you press. In my project I didn’t need pressure-level detection, but it was interesting to experiment with different touch intensities and see how the coding reacts to them.
How We Extracted the High-Power Resistor
We didn’t have a resistor with enough power to detect movement, so we started looking for one. We took old boards, used a multimeter, and measured the power of every resistor we could find.
Mariam found a really powerful resistor — it was 1 MOhm. I couldn’t find that strong one but found a 0.3 kOhm resistor, which was enough for my project.
Now comes the most interesting part: how we separated the resistor from the board. On the back side, we heated it and pulled it off.
It looked really funny. Let’s watch this part together ⬇
FabriXiao¶
The FabriXiao is an innovative microcontroller platform designed to simplify e-textile projects, particularly for educational purposes like Fabricademy. It emerged as a response to the challenges of using earlier microcontrollers such as the ATtiny45 or the Lilypad, which required more complex programming and assembly. Developed by Adrián Torres, the FabriXiao leverages Seeed Studio Xiao RP2040 and Xiao ESP32-C3 microcontrollers to offer greater accessibility, versatility, and ease of use. Its compact design, compatibility with USB-C, multiple input/output options, and ability to connect to wireless networks make it ideal for wearable and small-scale interactive projects. The board also supports various programming environments like Arduino, MicroPython, and CircuitPython, making it beginner-friendly and powerful.
This information and photo are from our wonderful Anush Arshakyan's page . Thank you to her for this detailed information.
FabriXiao is soft and flexible, but we need to connect them to the RP2040.
Last time I used the soldering iron for the first time, and now it’s time to learn new ways of connecting and a new working system.
Put a little metal alloy on the pad and hold the soldering iron on it for a few seconds.
The first one is more difficult, but after you fix that, the rest of the work goes smoothly.
How I did it ⬇
The First Project Was Called "Sheep Melody"¶
Firstly, I connected the XIAO RP2040 with alligator clips to a resistor and a piezoelectric speaker. You can code your own melody on it, but I used a melody from Anush's documentation. It sounds like the Game of Thrones soundtrack. It's not too common for sheep, but I like it!
First, I built the circuit and then used Arduino IDE to write the code so it would start playing when I touched it.
The first alligator clip circuit looked like this ⬇
The code:
#include <CapacitiveSensor.h>
#include "pitches.h"
// Capacitive sensor pins
CapacitiveSensor touchSensor = CapacitiveSensor(9, 6); // send pin, receive pin
// Buzzer pin
#define BUZZER_PIN A11 // You can change this to a free pin
// Melody arrays
int melody[] = {
NOTE_G4, NOTE_C4, NOTE_DS4, NOTE_F4, NOTE_G4, NOTE_C4, NOTE_DS4, NOTE_F4,
NOTE_G4, NOTE_C4, NOTE_DS4, NOTE_F4, NOTE_G4, NOTE_C4, NOTE_DS4, NOTE_F4,
NOTE_G4, NOTE_C4, NOTE_E4, NOTE_F4, NOTE_G4, NOTE_C4, NOTE_E4, NOTE_F4,
NOTE_G4, NOTE_C4, NOTE_E4, NOTE_F4, NOTE_G4, NOTE_C4, NOTE_E4, NOTE_F4,
NOTE_G4, NOTE_C4,
NOTE_DS4, NOTE_F4, NOTE_G4, NOTE_C4, NOTE_DS4, NOTE_F4,
NOTE_D4,
NOTE_F4, NOTE_AS3,
NOTE_DS4, NOTE_D4, NOTE_F4, NOTE_AS3,
NOTE_DS4, NOTE_D4, NOTE_C4
};
int durations[] = {
8, 8, 16, 16, 8, 8, 16, 16,
8, 8, 16, 16, 8, 8, 16, 16,
8, 8, 16, 16, 8, 8, 16, 16,
8, 8, 16, 16, 8, 8, 16, 16,
4, 4,
16, 16, 4, 4, 16, 16,
1,
4, 4,
16, 16, 4, 4,
16, 16, 1
};
void setup() {
Serial.begin(9600);
pinMode(BUZZER_PIN, OUTPUT);
Serial.println("Capacitive Touch with Melody");
}
void loop() {
long sensorValue = touchSensor.capacitiveSensor(30); // average of 30 samples
Serial.println(sensorValue);
// Threshold for 33 kΩ resistor
if (sensorValue > 0) {
Serial.println("Touched!");
playMelody(); // play the melody when touched
}
delay(100);
}
// Function to play melody once
void playMelody() {
int size = sizeof(durations) / sizeof(int);
for (int note = 0; note < size; note++) {
int duration = 1000 / durations[note];
tone(BUZZER_PIN, melody[note], duration);
// pause between notes
int pauseBetweenNotes = duration * 1.30;
delay(pauseBetweenNotes);
// stop the tone
noTone(BUZZER_PIN);
}
}
After I remoce crocodile clipers and use only conductive threads․
Final resalte ⬇¶
Front and back view:
Fabrication files¶
FLOW SCARF¶
The second project is more interesting for me, because I really understand where, when, and why I want to make it — and it is a truly wearable item that I actually need.
I want to make a scarf with electronic parts that will close around my neck when the wind blows toward me. It should detect the wind direction and lift or fold the needed surface of the scarf. The wind sensor I wanted to use wasn’t available during this week, but a pressure sensor can work as well. The person who wears the scarf can simply press it when they feel the wind.
The idea for this project was born in my mind when I was on Ara Mountain. It is a beautiful mountain in Armenia with an elevation of 2,614 m (8,576 ft) (although some sources mention 2,576 m).
Ara Mountain photos:
I was very close to the top — only the last steps were left — but it was extremely cold and windy. My scarf kept sliding down all the time. I tried again and again to pull it up and close my neck, but the wind immediately pushed it down. I was tired, cold, and had no energy left. I couldn’t stop every few seconds to fix my scarf, and my hands were busy. My neck stayed exposed, and I felt uncomfortable, unsafe, and close to getting ill. The scarf I had was large, but it simply didn’t stay in place and didn’t protect my neck when I needed it the most. While continuing the last part of the hike in this uncomfortable state, I started to think:
Why can’t objects work for us ?
How my idea will look and work:
After this, I started experimenting with 3D printing on fabric. My first try was printing with PLA. The
The second experiment was with TPU. TPU is more flexible and soft, so I changed the distance between the modules a bit and tried printing again. I had some fails, but also some really good results. Let’s look at the successful one first:
This time it was grait and i make origami shape and put the fabric under press for some houers (it’s better to soak it a little — this gives a better result.).
The construction of serbo mator work:
How it look in real with press sensor:
The code with serbo sensor and press sensor:
#include <Servo.h>
const int sensorPin = A1; // Your touch/pressure sensor
const int servoPin = A3; // Servo signal pin
Servo myServo;
int threshold = 200; // Adjust based on your sensor
bool servoState = false; // false = 0°, true = 180°
bool lastPressed = false; // Track previous press
int sensorValue;
void setup() {
Serial.begin(9600);
myServo.attach(servoPin);
myServo.write(0); // Start at 0°
}
void loop() {
sensorValue = analogRead(sensorPin);
Serial.println(sensorValue);
bool isPressed = sensorValue > threshold;
// Detect rising edge of press
if (isPressed && !lastPressed) {
servoState = !servoState; // Toggle servo state
if (servoState) {
myServo.write(180);
} else {
myServo.write(0);
}
}
lastPressed = isPressed; // Save current state
delay(50); // Debounce
}
I wrote tis code with ChatGbt and runsfer to Arduino IDE program.
I threaded a string through the origami parts so that every time I pull the string toward me, my object contracts, and when I release it, it returns to its original shape. This origami form allowed me to achieve that. I attached the bottom part to the lower fabric and connected it to the STUDIO XIAO RT2040 and a Pressure Sensor. Let’s see how it works.
I assembled this construction with conductive threads three times. You might ask why. Well, my hands weren’t very skilled the first time. The first attempt was quite loose, so I tried tying it with more threads, but it didn’t work because the threads didn’t have the right conductivity. I disassembled everything and made a new, tighter construction, and this time it worked.
All tree versions: