9. Wearables

Research

Researching Soft robotics

Research

Fashion and artistic expression come together in wearable art. It transcends clothing, transforming clothing into means of expressing individuality and creativity.

Wearable art prioritizes individuality, expertise, and fresh ideas, as opposed to traditional fashion, which concentrates on producing a large number of clothing for everyone. By creating ensembles that defy conventional notions of beauty and style, wearable art blurs the boundaries between clothing and art. Through the use of unconventional materials and techniques, these designs frequently enable individuals to boldly express themselves through their attire.

Detailed explanation of the components involved in wearable technology

Flexible electronic systems:

Allow seamless integration into garments or accessories. Conductive threads and inks enable the embedding of circuits that bend and stretch, making wearables comfortable and lightweight. These materials are vital in creating circuits that remain functional even when the fabric moves or folds.

Small yet powerful controllers:

Are often central to wearable systems. These devices can process input from various sensors, run programs, and communicate data to external systems via wireless technologies like Bluetooth or Wi-Fi. Their compact size and low energy consumption are ideal for applications in clothing or accessories.

Wearables frequently:

Include tools to monitor the wearer's body or the surrounding environment. These can range from sensors that track physical activity, like accelerometers and gyroscopes, to those measuring physiological signals such as heart rate, temperature, or muscle activity. Some systems even include optical components for advanced measurements, such as blood oxygen levels.

Power systems:

For wearables are designed to balance efficiency, size, and capacity. They typically use lightweight batteries or rely on energy harvesting methods like solar panels or movement-based systems to extend their operation. Energy-efficient design ensures that these devices remain functional for extended periods without bulky power sources.

Wearables also often incorporate elements designed to provide feedback or interaction, such as small motors or light-emitting components. These features respond to inputs from the user or the environment, creating dynamic and responsive garments or accessories.

References & Inspiration

CuteCircuit

CuteCircuit is the first wearable technology fashion company in the world, having been founded in 2004. CuteCircuit is a trailblazer in this area, fusing cutting-edge fashion design with cutting-edge technologies and intelligent textiles to produce stunning garments with amazing interactive features. The co-founders of CuteCircuit, Francesca Rosella and Ryan Genz, have backgrounds in anthropology and interaction design, respectively, and couture fashion design (Valentino).

Link https://cutecircuit.com/

Ruff

Ruff, which was created by fashion designer Pauline van Dongen and architect Behnaz Farahi, gets its name from the protective folded collar that was common in Western Europe between the middle of the 16th and the middle of the 17th centuries and is frequently visible in pictures from that era.The study demonstrates how wearables can be given dynamic, responsive qualities and nearly lifelike behaviors. It also serves as an example of how 3D printing may be used to enhance physiological experiences and provide new ways for clothes to act as a mediator between the body and its environment. Both designers were interested in improving how bodies interacted with their surroundings.

Tools

• FLORA Board: A compact, sewable microcontroller designed for wearable projects. It handles inputs and controls devices like NeoPixels, making it ideal for fabric-based electronics.

• **FLORA RGB NeoPixel A small, programmable LED capable of displaying a wide range of vibrant colors. It works seamlessly with the FLORA board for dynamic lighting effects.

• **Conductive Thread: Electrically conductive sewing thread used to connect electronic components in wearable projects while maintaining flexibility.

• **Seeed Xiao RP2040: A tiny yet powerful microcontroller based on the RP2040 chip. It’s suitable for compact wearables, offering powerful processing and GPIO capabilities.

• **Buzzer: An electronic component that emits sound, often used for creating alerts, tones, or melodies in wearable projects.

• **Microphones: Sensors used to capture sound in wearable designs, enabling voice control, sound sensing, or interactive audio applications.

• **Servo Motor: A small actuator that enables precise control of angular or linear motion, ideal for creating movement in wearable designs, such as animating fabric elements.

• **Arduino Uno: A beginner-friendly microcontroller board widely used for prototyping. It supports various sensors and actuators, making it versatile for wearable projects.

• **Arduino IDE: An integrated development environment used to program microcontrollers like Arduino boards and Seeed Xiao RP2040. It provides a user-friendly platform to write, test, and upload code.

Process and workflow

Exploring the Basics of Wearables and E-Textiles

I started my investigation into wearables and e-textiles by learning the fundamental ideas of this cutting-edge industry. The smooth incorporation of electronics into fabrics and the possibility of producing useful, interactive designs piqued my interest. I used Adafruit's learning platform to expand my expertise, and it soon proved to be a valuable tool. In addition to being simple to follow, the project guides and tutorials were jam-packed with imaginative ideas. The sections on sensors, actuators, and microcontrollers were very beneficial as they provided insights into how to make clothing and accessories interactive and responsive.

Experimentation with Flora

To create an interactive circuit that changes the Adafruit Flora’s NeoPixel color upon touching a handmade Velostat touch sensor, I followed these steps:

Step 1: Preparing the Circuit

Velostat Sensor Creation: I crafted a pressure-sensitive touch sensor using Velostat sandwiched between two conductive layers (such as conductive thread or fabric). This setup changes resistance when pressed. Adding a Resistor: I incorporated a 1-ohm resistor in series with the sensor to ensure the circuit could detect resistance changes effectively.

Step 2: Connecting to Adafruit Flora

Sensor Connection: One side of the Velostat was connected to an analog input pin on the Adafruit Flora, and the other was connected to ground (GND). The resistor connected the circuit to a 3.3V power source on the Flora board. NeoPixel Setup: I used the onboard NeoPixel LED, connecting it directly to the Flora’s built-in functionality without additional wiring.

Step 3: Programming the Arduino

Arduino IDE: I opened the Arduino IDE and programmed the Flora to read the analog input values from the Velostat sensor. Code Logic: The code was designed to detect pressure changes on the Velostat. When touched, the resistance dropped, changing the analog input value. This value was used to trigger a color change on the onboard NeoPixel. Serial Monitor: I included a Serial.print() command to send the analog values from the Flora to the computer for monitoring. This allowed me to observe how the sensor responded in real time.

Step 4: Testing and Refining

Connecting to the Computer: I connected the Adafruit Flora to my computer via a USB cable, ensuring the board was recognized by the Arduino IDE. Running the Program: Upon uploading the code to the Flora, I monitored the sensor values in the Serial Monitor. When I touched the Velostat, the onboard NeoPixel changed color, confirming the system was working as intended. Fine-tuning: I adjusted the code to map specific pressure levels to unique colors on the NeoPixel, creating a visually dynamic response.

Code Example

#include <Adafruit_NeoPixel.h>


// Define the analog pin where the touch sensor is connected
int touchPin = A9;  // A9 is an analog input pin on Flora


// Define the pin where the onboard NeoPixel is connected
#define PIN 8  // Onboard NeoPixel on Adafruit Flora is connected to D6


// Create a NeoPixel object for controlling the pixel
Adafruit_NeoPixel strip = Adafruit_NeoPixel(1, PIN, NEO_GRB + NEO_KHZ800);


// Variable to store the sensor reading
int touchValue = 0;


void setup() {
  // Start the serial communication
  Serial.begin(9600);


  // Initialize the NeoPixel strip
  strip.begin();
  strip.show();  // Initialize the pixel to be off
}


void loop() {
  // Read the analog value from the touch sensor
  touchValue = analogRead(touchPin);

  // Print the value to the Serial Monitor
  Serial.println(touchValue);


  // Map the touch value to a range suitable for RGB colors (0 to 255)
  int red = map(touchValue, 0, 1023, 0, 255);   // Map touch value to red component
  int green = map(touchValue, 0, 1023, 255, 0); // Map touch value to green component
  int blue = map(touchValue, 0, 1023, 128, 255); // Map touch value to blue component


  Serial.print("RED: ");
  Serial.println(red);


  // Set the NeoPixel color based on the touch value
  strip.setPixelColor(0, strip.Color(red, green, blue));
  strip.show();  // Update the NeoPixel


  // Delay for a short period to avoid overwhelming the serial output
  delay(100);
}

Results

From Vimeo

DESIGN

I used a solar system to create the pattern, which was then laser-cut and will eventually be on a tote bag.

Connect two types of speakers to an Adafruit Flora

I connected two types of speakers to an Adafruit Flora, using a digital pin for sound output and the onboard NeoPixel to synchronize lighting effects with the tones. The process involved coding the NeoPixel to change colors in response to different tones played by the speakers.

Experementation with SEED Studio Xiao RP2040

Step 1: Gather the Components

To control a servo motor with your Seeed Studio Xiao RP2040, you'll need the following components:

1. Seeed Studio Xiao RP2040 board
2. Servo motor (standard 9g or 180° servo)
3. Jumper wires for connections
4. USB cable to connect the RP2040 to your computer

Step 2: Connect the Servo Motor

The servo motor has three pins: Signal (S), Power (VCC), and Ground (GND).

1. Wiring the Servo to the Xiao RP2040:
2. Signal Pin (S): Connect the signal pin of the servo to GPIO 7 (or any available digital pin, in this case, we’ll use D7 for this example) on the Xiao RP2040.

Power Pin (VCC): Connect the VCC pin of the servo to the 5V pin of the RP2040.

Step 3: Install the Servo Library

You need to install the Servo library in your Arduino IDE, which allows easy control of servo motors.

1. Open the Arduino IDE on your computer.
2. Go to Sketch > Include Library > Manage Libraries.
3. In the Library Manager, type "Servo" in the search bar.
4. Install the Servo library by Michael Margolis.

Code

#include <Servo.h>

// Define the pin where the servo motor is connected
int servoPin = 7;  // Connect the servo control pin to GPIO 7 on the RP2040

// Create a Servo object to control the servo
Servo myServo;

void setup() {
  // Attach the servo control pin to the Servo object
  myServo.attach(servoPin);
}

void loop() {
  // Rotate the servo to 0 degrees
  myServo.write(0);
  delay(1000);  // Wait for 1 second

  // Rotate the servo to 90 degrees
  myServo.write(90);
  delay(1000);  // Wait for 1 second

  // Rotate the servo to 180 degrees
  myServo.write(180);
  delay(1000);  // Wait for 1 second
}

Result

Fabrication files

---

1. File: xxx ↩

2. File: xxx ↩