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 ⬇

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․

The final resalte ⬇

Front and back view:

Fabrication files¶

Tools¶

File: xxx ↩
File: xxx ↩