9. Wearables

Research and Ideation

In textiles, wearable refers to any material or fabric designed to be worn on the body as clothing, accessories, or functional garments. These textiles are typically flexible, durable, and comfortable to suit the needs of the wearer. Wearables also extend to technologically enhanced garments that incorporate electronics or sensors to perform specific functions.

Types of Wearable in Textile

TYPES OF WEARABLE IN TEXTILE

1. Traditional Wearable Textiles:

   • Used for making clothing items such as shirts, pants, dresses, and jackets.

   • Accessories like scarves, hats, and gloves.

   • Crafted from materials like cotton, wool, silk, synthetic fibers, or blends.

2. Functional Wearable Textiles:

   • Serve specialized purposes, such as:

   Sportswear: Moisture-wicking fabrics for athletes.

   Medical Textiles: Compression garments or bandages.

   Protective Gear: Fire-resistant, water-repellent, or UV-protective clothing.

3. Smart Wearable Textiles:

   Incorporate technology for advanced functionality.

   Examples:

   Clothes with built-in sensors to track heart rate, body temperature, or movement.

   Fabrics that change color or adapt to environmental conditions.

   Heated jackets or cooling apparel.

4. Fashion Wearable Textiles:

   • Designed for aesthetics and style.

   • Include unique patterns, embroidery, or modular designs for customization.

5. Sustainable Wearables:

   • Made from eco-friendly materials such as organic cotton, recycled polyester, or bioplastics.

   • Promote circular design for recyclability and reduced waste.

   • Wearables in textiles aim to combine functionality, comfort, and style, meeting various needs from fashion to performance enhancement.

Visual Actuator

A visual actuator in wearable technology is a component that produces visible responses—such as light, color changes, or movement—to communicate information or trigger reactions. Commonly used visual actuators include LEDs, OLED displays, or color-changing materials. In the context of wearables, they are often integrated into clothing or accessories to provide real-time feedback based on data from sensors or user interaction. These actuators not only serve a functional purpose but also enhance the aesthetic and expressive potential of the garment.

Materials needed

Material/Component	Use
LEDs (preferably sewable or small)	Visual output — emit light as feedback or decoration
Conductive thread or wires	To connect LEDs and electronic components in a flexible way
Microcontroller (e.g., Arduino Nano, LilyPad)	Controls the LEDs and responds to sensor inputs
Power source (Li-ion battery or coin cell)	Powers the circuit and wearable device
Resistors (if needed)	Used to limit current to the LEDs
Knitted or crocheted top	The base textile for embedding the visual actuator
Needle and scissors	For sewing conductive thread or attaching components
Fabric adhesive	To secure components in place without damaging the fabric
Optional sensors (e.g., light, motion)	To trigger LED behavior based on user movement or environment
Switch (on/off)	To manually control power to the circuit

Circuit Sketch

The circuit sketch integrates LEDs, a power source, and a Xiao ESP32 to make the scarf interactive and functional. It ensures flexibility, aligns with the scarf’s design, and offers a lightweight, wearable solution with smart connectivity.

Circuit diagram

To simplify the process, I used a TinkerCAD sketch to visualize and experiment with the design before building it. 🧩 Feel free to try it out yourself—here’s the link Check it out on TinkerCAD

CODE

//
// Define the LED pins
const int ledPin1 = 1;  // D1 corresponds to GPIO1 on the ESP32-C3
const int ledPin2 = 2;  // D2 corresponds to GPIO2 on the ESP32-C3
const int ledPin3 = 3;  // D3 corresponds to GPIO3 on the ESP32-C3
const int ledPin4 = 4;  // D4 corresponds to GPIO4 on the ESP32-C3
const int ledPin5 = 5;  // D5 corresponds to GPIO5 on the ESP32-C3

void setup() {
  // Initialize all LED pins as outputs
  pinMode(ledPin1, OUTPUT);
  pinMode(ledPin2, OUTPUT);
  pinMode(ledPin3, OUTPUT);
  pinMode(ledPin4, OUTPUT);
  pinMode(ledPin5, OUTPUT);

  // Ensure all LEDs start off
  digitalWrite(ledPin1, LOW);
  digitalWrite(ledPin2, LOW);
  digitalWrite(ledPin3, LOW);
  digitalWrite(ledPin4, LOW);
  digitalWrite(ledPin5, LOW);
}

void loop() {
  // First, blink all LEDs together
  for (int i = 0; i < 5; i++) {
    digitalWrite(ledPin1, HIGH);
    digitalWrite(ledPin2, HIGH);
    digitalWrite(ledPin3, HIGH);
    digitalWrite(ledPin4, HIGH);
    digitalWrite(ledPin5, HIGH);
    delay(500);  // Wait for 500 milliseconds

    digitalWrite(ledPin1, LOW);
    digitalWrite(ledPin2, LOW);
    digitalWrite(ledPin3, LOW);
    digitalWrite(ledPin4, LOW);
    digitalWrite(ledPin5, LOW);
    delay(500);  // Wait for 500 milliseconds
  }

  // Then, blink LEDs one by one
  digitalWrite(ledPin1, HIGH);
  delay(500);
  digitalWrite(ledPin1, LOW);

  digitalWrite(ledPin2, HIGH);
  delay(500);
  digitalWrite(ledPin2, LOW);

  digitalWrite(ledPin3, HIGH);
  delay(500);
  digitalWrite(ledPin3, LOW);

  digitalWrite(ledPin4, HIGH);
  delay(500);
  digitalWrite(ledPin4, LOW);

  digitalWrite(ledPin5, HIGH);
  delay(500);
  digitalWrite(ledPin5, LOW);
}
                     // wait for a second

Procedure to Integrate Visual Actuators in Wearable Technology

Step 1: Plan Your Design

• Decide where you want the LEDs to be placed on your wearable (e.g., shoulders, chest, sleeve).
• Sketch the circuit path, including where the microcontroller, battery, and any sensors will be located.
• Plan how wires or conductive thread will run through the textile.

Step 2: Prepare the Textile Base

• Lay out your knitted or crocheted top flat.
• Mark LED and component positions using chalk or removable fabric marker.

Step 3: Sew in the Circuit

• Use conductive thread or thin flexible wires to sew or connect:

• The positive (anode) side of the LED to a digital output pin on the microcontroller.

• The negative (cathode) side of the LED to the GND pin on the microcontroller.
• If needed, sew in resistors in line with each LED to limit current.
• Avoid crossing conductive threads; insulate where needed.

Step 4: Attach the Microcontroller

• Use fabric adhesive or hand-sew the microcontroller (e.g., LilyPad or Arduino Nano) to a stable part of the top.
• Connect it to the LED lines using conductive thread or wires.

Step 5: Add Power Supply

• Secure the battery holder to the top.
• Connect the + and – terminals to the microcontroller's VIN and GND pins respectively.
• Add an on/off switch if desired, to control power flow.

Step 6: (Optional) Add Sensors

• Attach optional sensors (motion, light, etc.) as needed.
• Wire them to the analog or digital input pins of the microcontroller.

Step 7: Upload Code

• Connect the microcontroller to your computer via USB.
• Upload a basic program to control the LEDs (e.g., blink when movement is detected or based on sensor input).

Example (for motion sensor):

int ledPin = 6;
int sensorPin = 2;

void setup() {
  pinMode(ledPin, OUTPUT);
  pinMode(sensorPin, INPUT);
}

void loop() {
  if (digitalRead(sensorPin) == HIGH) {
    digitalWrite(ledPin, HIGH);
  } else {
    digitalWrite(ledPin, LOW);
  }
}

Step 8: Test the Wearable

• Power on the system.

• Test that:

• LEDs respond correctly to input.

• Conductive threads are not shorting or broken.
• All components are securely attached.

Step 9: Finish and Secure

• Use fabric adhesive or soft padding to secure and cover electronic parts for safety and comfort.
• Make sure no components are exposed to moisture or skin contact.

Result

This image beautifully captures the successful integration of wearable technology into fashion, showcasing a crocheted top enhanced with glowing blue LEDs. It exemplifies how visual actuators like LEDs can be creatively embedded into handmade garments to combine aesthetics with interactivity. This project not only highlights technical skill and creativity but also reflects the exciting potential of merging traditional craft with modern electronics to create expressive, functional wearables.

Smart Jacket: Vibration Feedback System

The Smart Jacket with Vibration Feedback System is a wearable device designed to deliver tactile alerts through strategically placed vibration motors. It uses sensors or external input (e.g., GPS, obstacle detection, or notifications) to trigger vibrations that guide or inform the wearer. This system is especially useful for visually impaired individuals, cyclists, or workers in noisy environments, offering silent, intuitive feedback for navigation, safety, or real-time communication.

Materials Needed

To build this Smart Jacket, you’ll need:

Component	Use
Vibration Motors (x3–6)	Provide directional or location-based feedback through vibrations.
Arduino Uno / Nano	Acts as the microcontroller to process sensor input and control motors.
Motor Driver Module (e.g., DRV2605 or L293D)	Powers and controls the vibration motors.
Power Source (e.g., Li-ion Battery Pack)	Supplies portable power to the system.
Conductive Thread or Jumper Wires	Connects electronic components within the jacket.
Bluetooth Module (e.g., HC-05) (optional)	Enables wireless control or integration with mobile apps.
Sensors (e.g., Ultrasonic, GPS, or IMU)	Inputs data for triggering vibration (obstacle, direction, etc.).
Jacket or Vest	Base wearable garment for embedding components.
Knitting machine / Yarns	Used for attaching and securing components inside the jacket.
Breadboard or Custom PCB	For prototyping or permanently soldering connections.

Procedure: Building a Knitted Smart Vibration Jacket

1. Design & Placement Planning

• Choose the type of vibration feedback: navigation, alert system, or general haptic feedback.
• Decide where to place the vibration motors—typically on the shoulders, upper back, or sides.
• Plan wire paths along the knit structure (e.g., using loose stitches, loops, or inside sewn-in channels).

2. Gather and Test Components

• Components:

• Vibration motors (coin or pancake-style)

• Arduino Nano (preferred for size)
• Motor driver (like DRV2605)
• Power source (small Li-ion battery)
• Soft conductive thread or ultra-flexible jumper wires
• Optional: sensors (ultrasonic, GPS, etc.)
• Test each component independently to make sure they work before embedding.

3. Sew or Embed the Vibration Motors

• Use conductive thread or soft wires to connect motors to the Arduino.
• Carefully sew motors into the knit, reinforcing them so they don’t sag or pull the fabric.
• Leave space or soft padding behind each motor to prevent discomfort.

4. Embed Wiring Softly

• Route conductive thread or flexible wires along seams or through stitch gaps in the knit.
• Use fabric glue, stretchable tape, or zigzag stitching to secure the wiring without restricting flexibility.
• Avoid crossing threads to reduce short-circuit risks.

5. Secure Electronics

• Mount the Arduino and driver on a small felt or fabric patch and hand-stitch it inside a discreet pocket or area of the jacket.
• Place the battery in a safe, balanced spot (like a side pocket or back patch) to keep weight distributed.

6. Upload and Test Code

• Write Arduino code to:

• Read sensor input (or simulate trigger events).

• Activate specific motors based on data or signals.
• Upload via USB and test motor response.
• Calibrate for comfort and appropriate vibration strength.

CODE

#define LED1 2
#define LED2 3
#define LED3 4
#define LED4 5
#define LED5 6
#define LED6 7
#define LED7 8
#define LED8 9

const int ledPins[] = {LED1, LED2, LED3, LED4, LED5, LED6, LED7, LED8};

const int buttonPin = 10;
bool ledState = false;
bool buttonPressed = false;
unsigned long lastDebounceTime = 0;
unsigned long debounceDelay = 50;

int currentLed = 0;
int direction = 1; // 1 = forward, -1 = backward
unsigned long previousMillis = 0;
const unsigned long interval = 300; // 300ms for each blink

void setup() {
  Serial.begin(115200);
  Serial.println("System Ready. Waiting for button press...");

  for (int i = 0; i < 8; i++) {
    pinMode(ledPins[i], OUTPUT);
    digitalWrite(ledPins[i], LOW);
  }

  pinMode(buttonPin, INPUT_PULLUP);
}

void loop() {
  static bool lastButtonReading = HIGH;
  bool currentReading = digitalRead(buttonPin);

  if (currentReading != lastButtonReading) {
    lastDebounceTime = millis();
  }

  if ((millis() - lastDebounceTime) > debounceDelay) {
    if (currentReading == LOW && !buttonPressed) {
      buttonPressed = true;
      ledState = !ledState;

      if (ledState) {
        Serial.println("Button Pressed: Starting blinking sequence...");
        currentLed = 0;
        direction = 1;
      } else {
        Serial.println("Button Pressed: Stopping and turning OFF all LEDs...");
        for (int i = 0; i < 8; i++) {
          digitalWrite(ledPins[i], LOW);
        }
      }
    }

    if (currentReading == HIGH) {
      buttonPressed = false;
    }
  }

  lastButtonReading = currentReading;

  if (ledState) {
    unsigned long currentMillis = millis();
    if (currentMillis - previousMillis >= interval) {
      previousMillis = currentMillis;

      // Turn OFF all LEDs first
      for (int i = 0; i < 8; i++) {
        digitalWrite(ledPins[i], LOW);
      }

      // Turn ON the current LED
      digitalWrite(ledPins[currentLed], HIGH);
      Serial.print("Blinking LED ");
      Serial.println(currentLed + 1);

      // Move to next LED
      currentLed += direction;

      // If we reach the end, reverse direction
      if (currentLed >= 8) {
        currentLed = 7; // Stay at last LED
        direction = -1; // Reverse
      } else if (currentLed < 0) {
        currentLed = 0; // Stay at first LED
        direction = 1;  // Forward again
      }
    }
  }
}

Code used

7. Final Adjustments

• Test the full system while wearing the jacket:

• Check for overheating, vibration accuracy, and comfort.

• Reinforce any weak connection points and ensure breathability is preserved.
• Make the electronics removable if you plan to wash the jacket.

Smart Jacket Result