Skip to content

9. Wearables

Research and Ideation

This week is all about wearable garments, and I’m excited to explore lights, movements, and sound! Inspired by fireflies, I’m focusing on their shapes, colors, and fluid motions to create designs that mimic their magical glow and delicate flight, blending technology with nature’s beauty.

describe what you see in this image

Credits
Top dress
paper fire fly
fire flies
Tiger Jelly fish
Jelly fish
Fireworm

Process and workflow

Flip Dot

Introduction to Flip-Dot Technology

Flip-dot displays are a type of electromechanical display technology that uses small, rotatable dots (or disks) to create images or text. Each dot is flipped between two states—visible or invisible—by applying a magnetic field, allowing the display to form patterns or characters. These displays were commonly used in older bus signs, clocks, and airport flight boards due to their durability and visibility in various lighting conditions. Despite their age, flip-dot technology remains an interesting and innovative solution for visual displays, especially in retro or interactive design projects.

This video by BREAKFAST explores the creative use of flip-dot displays in modern interactive installations. It highlights the potential of flip-dot technology for artistic applications, showing how this retro display can be repurposed in innovative and visually engaging ways.

we stared the week by exploring the flip dot

we started burning the thread to reach the copper thread inside and burn let's say the cover of the thread then we make sure that we burn enough by usig the mulimeter to check CONDUCTIVITY

Then we started wraping the thread to get the shape we want

After that we put it on a fabric and add a piece og magnetic inside the circle we made

we use 9v battery and place it on the two side of the thread then we do with opposite way

LDR Sensor

An LDR, or Light Dependent Resistor, is a type of sensor that changes its resistance based on the amount of light it is exposed to. LDR sensors are commonly used in applications where light detection is crucial, such as in automatic lighting systems, solar panels, and alarm systems. When exposed to light, the resistance of the LDR decreases, allowing more current to flow through the circuit. Conversely, in darkness, the resistance increases, limiting the current. LDRs are easy to integrate with microcontrollers like Arduino, making them a popular choice for interactive and automation projects.

LED

Overview
This project demonstrates how to use a Light-Dependent Resistor (LDR) to sense ambient light levels and control an LED based on the brightness of the surroundings. The circuit is designed to turn the LED on in darkness and off in bright conditions.

Components Used 1. Arduino Board (e.g., Arduino Uno)

  1. Light-Dependent Resistor (LDR)

  2. 10kΩ Resistor (Pull-down resistor for the LDR)

  3. LED

  4. 220Ω Resistor (Current-limiting resistor for the LED)

  5. Breadboard

  6. Connecting wires

Required Libraries
No additional libraries are required for this project. The code uses built-in Arduino functions, such as analogRead, digitalWrite, and Serial for communication.

Tools in Arduino IDE

  • Serial Monitor: Used to view the real-time analog readings from the LDR. Access it via:

  • Tools → Serial Monitor (or press Ctrl + Shift + M on Windows/Linux or Cmd + Shift + M on macOS).

  • Board Selection: Ensure you select the correct board from:

  • Tools → Board → Your Arduino Board (e.g., Arduino Uno).

  • Port Selection: Ensure the correct port is selected:

  • Tools → Port → Your Arduino's COM Port.

Schematic Diagram

Design

LDR Circuit:

One leg of the LDR to 5V. The other leg to analog pin A2 and one end of the 10kΩ resistor. The other end of the resistor to GND.

LED Circuit:

Positive leg (long leg) of the LED to digital pin 2 via the 220Ω resistor. Negative leg (short leg) of the LED to GND.


//
int LED1 = 2;          // LED Pin 2 (to indicate whether it's dark or bright)
int sensorPin = A2;    // Light sensor connected to analog pin A2
int value = 0;          // Variable to store light sensor reading

void setup() {
  Serial.begin(9600);   // Start the serial communication at 9600 baud rate
  pinMode(LED1, OUTPUT); // Set LED pin as an output
}

void loop() {
  value = analogRead(sensorPin);  // Read the value from the light sensor

  // Print the actual sensor value to the Serial Monitor for debugging
  Serial.print("The analog reading of LDR is ");
  Serial.println(value);  // Print the sensor value to Serial Monitor

  // Turn on LED if it's dark (light sensor value is low)
  if (value < 40) {  // Adjust this threshold based on your environment and the LDR
    digitalWrite(LED1, HIGH);  // LED on (dark)
  } else {
    digitalWrite(LED1, LOW);   // LED off (bright)
  }

  delay(1000);  // Small delay to avoid flooding the Serial Monitor
}

LED Strip (1)

Components Used

  1. Arduino Board (e.g., Arduino Uno)

  2. Adafruit NeoPixel LED Strip (10 LEDs)

  3. Light-Dependent Resistor (LDR)

  4. 10kΩ Resistor (Pull-down resistor for the LDR)

  5. Breadboard

  6. Connecting wires

  7. Adafruit NeoPixel Library

  8. Install the library through the Arduino IDE Library Manager:

    1. Go to Tools → Manage Libraries.

    2. Search for Adafruit NeoPixel.

    3. Click Install.

Tools in Arduino IDE

  • Serial Monitor: Used to view the LDR readings for debugging. Access it via:

  • Tools → Serial Monitor (or press Ctrl + Shift + M on Windows/Linux or Cmd + Shift + M on macOS).

  • Board Selection: Ensure you select the correct board from:

  • Tools → Board → Your Arduino Board (e.g., Arduino Uno).

  • Port Selection: Ensure the correct port is selected:

  • Tools → Port → Your Arduino's COM Port.

// #include <Adafruit_NeoPixel.h>

#define LED_PIN 6      // Pin connected to the LED strip
#define NUM_LEDS 10    // Number of LEDs in the strip
#define LDR_PIN A0     // Analog pin connected to the photoresistor

Adafruit_NeoPixel strip(NUM_LEDS, LED_PIN, NEO_GRB + NEO_KHZ800);

void setup() {
  strip.begin();       // Initialize the LED strip
  strip.show();        // Turn off all LEDs initially
  Serial.begin(9600);  // For debugging the LDR readings
}

void loop() {
  int lightLevel = analogRead(LDR_PIN);  // Read the light level (0-1023)
  Serial.println(lightLevel);            // Print the value for debugging

  int threshold = 440; // Adjust this value based on your environment

  if (lightLevel > threshold) {
    // Room lights are ON, turn on LEDs
    for (int i = 0; i < NUM_LEDS; i++) {
      strip.setPixelColor(i, strip.Color(0, 255, 255, 50)); // White light
    }
  } else {
    // Room lights are OFF, turn off LEDs
    for (int i = 0; i < NUM_LEDS; i++) {
      strip.setPixelColor(i, strip.Color(0, 0, 0)); // Off
    }
  }

  strip.show(); // Update LED strip
  delay(100);   // Small delay for stability
}

LED Strip (2)

Servo Motor (Tower Pro Micro Servo)

The Tower Pro Micro Servo 9g is a small, lightweight servo motor commonly used in robotics, RC models, and DIY projects.

Tower Pro Micro Servo 9g: Features Table

Feature Details
Weight 9 grams
Dimensions 23mm x 12mm x 29mm
Torque 1.8 kg·cm at 4.8V
Rotation Range ~0° to 180°
Operating Voltage 4.8V to 6.0V
Speed 0.12 sec/60° at 4.8V
Connector 3-pin (GND, VCC, Signal)

Applications of Tower Pro Micro Servo 9g

Robotic arms, grippers, and animatronics RC cars, airplanes, and boats DIY automation and educational projects

#include <Servo.h>

Servo servo;

int angle = 10;

void setup() {
  servo.attach(8);
  servo.write(angle);
}


void loop() 
{ 
 // scan from 0 to 180 degrees
  for(angle = 10; angle < 180; angle++)  
  {                                  
    servo.write(angle);               
    delay(15);                   
  } 
  // now scan back from 180 to 0 degrees
  for(angle = 180; angle > 10; angle--)    
  {                                
    servo.write(angle);           
    delay(15);       
  } 
}

FK 260SA 4280 KD 235321 Motor

The FK 260SA 4280 KD 235321 motor is a powerful and reliable electric motor designed for demanding industrial applications. Known for its robustness and efficiency, this motor is engineered to deliver consistent performance in various machinery and equipment. It features advanced construction, making it ideal for tasks requiring high precision and durability. Whether used in automation, manufacturing, or other engineering sectors, the FK 260SA 4280 KD 235321 motor ensures longevity and high performance, even in challenging environments.

FK 260SA 4280 KD 235321 Motor: Features Table

Feature Description
Model FK 260SA 4280 KD 235321
Type Electric Motor
Design Durable, high-efficiency construction
Efficiency Energy-saving, optimized for continuous use
Applications Automation, machinery, industrial pumps, robotics
Durability Built for rigorous industrial use
Power Delivery Consistent, reliable for various mechanical systems
Industries Manufacturing, Automation, Engineering
Size/Dimensions [Insert dimensions here if available]
Voltage/Current [Insert voltage and current specs here]
Warranty [Insert warranty details here if applicable]

Let's light fabrics !

Lighting up fabric with optical fiber effects opens up exciting possibilities in wearable technology and costume design. To achieve this, I experimented with creating a fabric-like structure using PLA filament, allowing me to integrate an LED strip within it. By incorporating small transparent pipes, I aimed to mimic the glow and light diffusion of optical fibers, enhancing the illuminated effect. This approach offers a creative and accessible way to bring light into textiles without using actual optical fibers, making it a versatile technique for futuristic and interactive fashion pieces.


I started the first step by experimenting with materials, beginning with TPU. However, I realized I needed something more rigid, so I decided to use PLA filament instead.

Next, I took precise measurements of the LED strip to ensure proper integration. The spacing between two LEDs was 12mm, and each LED measured 5×5mm.

The measurements were essential in designing a structure that could house the LEDs effectively.

I extruded the surface to 0.8mm and the cubes to 5mm.
then I export the file as STL file and slice on cura to be ready for printing

Setting Recommended Value
Printing Temperature 190-220°C
Build Plate Temperature 50-60°C
Print Speed 40-60 mm/s
Layer Height 0.1-0.2 mm
Wall Thickness 0.8 mm (typically 2 walls)
Retraction Distance 4-6 mm
Retraction Speed 25-45 mm/s
Cooling Fan Speed 100% (for better detail)
Bed Adhesion Type Brim or Raft (if needed)

then I started doing the connection

Component Connection
LED Strip (Data In) Pin 6 on Arduino
LED Strip (Power) 5V on Arduino
LED Strip (Ground) GND on Arduino
LDR (One Leg) A0 on Arduino
LDR (Other Leg) 5V & 10kΩ Resistor to GND
10kΩ Resistor Between LDR and GND

This is the code I used to make the LED strip light up in pairs, creating a firefly effect. The program reads the light level from an LDR sensor and controls the LEDs accordingly.

  • If the light level is low, the LEDs will light up in pairs, fading in and out gradually.
  • If the light level is high, all LEDs will turn off.

How It Works:

  1. The LDR sensor reads the ambient light level.
  2. If the light level is below 1000, the LEDs will light up two at a time using the fireFlyEffect() function.
  3. Each pair of LEDs fades in, holds brightness, and fades out, then the next pair lights up.
  4. If the light level is above 1000, the LEDs remain off.

This effect creates a dynamic and organic lighting pattern, similar to the glow of fireflies.

#include <Adafruit_NeoPixel.h>

#define PIN 6              // Pin where the LED strip is connected
#define NUM_LEDS 50        // Number of LEDs in the strip
#define FADE_DURATION 1000 // Duration for fade in and out in milliseconds
#define LDR_PIN A0         // Pin where the LDR is connected

Adafruit_NeoPixel strip = Adafruit_NeoPixel(NUM_LEDS, PIN, NEO_GRB + NEO_KHZ800);

void setup() {
  strip.begin();
  strip.show(); // Initialize all pixels to 'off'
  Serial.begin(9600); // For debugging
}

void loop() {
  int lightLevel = analogRead(LDR_PIN); // Read light level from LDR
  Serial.println(lightLevel); // Print the light level for debugging

  if (lightLevel < 1000) { // Light up LEDs unless the environment is fully bright
    for (int i = 0; i < NUM_LEDS; i += 2) {
      fireFlyEffect(i, i + 1); // Apply the firefly effect to each pair of LEDs
    }
  } else {
    strip.clear(); // Turn off LEDs if the environment is fully bright
    strip.show();
  }
}

// Function to simulate a firefly effect (fade in and out) for two LEDs
void fireFlyEffect(int led1, int led2) {
  // Fade in
  for (int brightness = 0; brightness <= 255; brightness++) {
    strip.setPixelColor(led1, strip.Color(brightness, brightness / 2, 0)); // Firefly color (yellowish)
    strip.setPixelColor(led2, strip.Color(brightness, brightness / 2, 0)); // Same color for both LEDs
    strip.show();
    delay(FADE_DURATION / 255);
  }

  // Hold for a moment at max brightness
  delay(100);

  // Fade out
  for (int brightness = 255; brightness >= 0; brightness--) {
    strip.setPixelColor(led1, strip.Color(brightness, brightness / 2, 0));
    strip.setPixelColor(led2, strip.Color(brightness, brightness / 2, 0));
    strip.show();
    delay(FADE_DURATION / 255);
  }

  // Short delay before the next pair of LEDs
  delay(100);
}

Here you can see how the serial monitor in Arduino read the values

I soldered the LED connections together to integrate 50 LEDs into the fabric following the arrow on the strip

Then I started placing the pipes in the positions where I wanted the lights to appear

Testing...

This is the code that helped me to light up only the specific LED groups that I selected for the firefly effect. I chose certain pairs of LEDs and applied the effect to them, creating a dynamic and gradual fade-in and fade-out lighting pattern.

#include <Adafruit_NeoPixel.h>

#define PIN 6              // Pin where the LED strip is connected
#define NUM_LEDS 50        // Number of LEDs in the strip
#define FADE_DURATION 1000 // Duration for fade in and out in milliseconds
#define LDR_PIN A0         // Pin where the LDR is connected

Adafruit_NeoPixel strip = Adafruit_NeoPixel(NUM_LEDS, PIN, NEO_GRB + NEO_KHZ800);

// Define the specific LEDs to light up
const int groups[][2] = {
  {1, 15},
  {5, 28},
  {8, 13},
  {11, 24},
  {16, 34},
  {19, 43},
  {21, 39},
  {25, 35},
  {26, 49}
};
const int numGroups = sizeof(groups) / sizeof(groups[0]);

void setup() {
  strip.begin();
  strip.show(); // Initialize all pixels to 'off'
  Serial.begin(9600); // For debugging
}

void loop() {
  int lightLevel = analogRead(LDR_PIN); // Read light level from LDR
  Serial.println(lightLevel); // Print the light level for debugging

  if (lightLevel < 1000) { 
    for (int i = 0; i < numGroups; i++) {
      strip.clear(); // Turn off all LEDs before lighting the next group
      lightGroup(groups[i]); // Light up only the LEDs in the current group
    }
  } else {
    strip.clear(); // Turn off all LEDs if the environment is fully bright
    strip.show();
  }
}

// Function to light up specific LEDs in a group
void lightGroup(const int group[]) {
  int led1 = group[0];
  int led2 = group[1];

  // Fade in
  for (int brightness = 0; brightness <= 255; brightness++) {
    strip.setPixelColor(led1, strip.Color(brightness, brightness / 2, 0)); // Firefly color (yellowish)
    strip.setPixelColor(led2, strip.Color(brightness, brightness / 2, 0)); // Same color for both LEDs
    strip.show();
    delay(FADE_DURATION / 255);
  }

  // Hold for a moment at max brightness
  delay(100);

  // Fade out
  for (int brightness = 255; brightness >= 0; brightness--) {
    strip.setPixelColor(led1, strip.Color(brightness, brightness / 2, 0));
    strip.setPixelColor(led2, strip.Color(brightness, brightness / 2, 0));
    strip.show();
    delay(FADE_DURATION / 255);
  }

  // Short delay before moving to the next group
  delay(100);
}