9. Wearables

Research

Thermochromic Technology:

Explore the chemistry behind thermochromic pigments and how temperature changes affect their color. Research how these pigments can be applied to textiles and the best practices for maintaining their responsiveness over time.

Wearable Actuators:

Investigate various actuators used in wearable tech, such as vibration motors, heat pads, and LEDs. Understand their power consumption, efficiency, and integration methods with microcontrollers like the ATtiny and Arduino.

Soft Circuitry:

Study the use of conductive threads, fabric circuits, and hard-soft connection methods to seamlessly integrate electronics into textiles without compromising comfort or flexibility.

Microcontroller Capabilities:

Examine the differences between using an ATtiny, Arduino, or Adafruit microcontrollers, focusing on programming capabilities, power management, and input/output options.

Body Sensors:

Research the types of body sensors available (e.g., temperature, humidity, or heart rate sensors) that can trigger a response in wearable tech.

Power Management:

Study power consumption in wearable devices and battery solutions suitable for small-scale applications, such as coin cells or rechargeable Li-ion batteries.

References & Inspiration

• FLT Licht inspires wearable tech design through its blend of technology and artistry. Their interactive, adaptable lighting responds to its environment, offering a dynamic experience—an approach that can be applied to wearables. The company’s focus on sustainability, minimalist aesthetics, and smart integration highlights how wearables can be eco-friendly, elegant, and user-responsive.

FLT Licht’s work emphasizes personalization, with products that can be customized, reflecting a trend towards wearables that adapt to user preferences and surroundings. Their designs are a perfect source of inspiration for creating innovative, functional, and sustainable wearable technology.

• Zac Posen Zac Posen’s incorporation of fiber optic woven organza in his dress, sourced from France, is a remarkable example of blending fashion with technology. The fabric itself, embedded with fiber optics, creates a glowing, ethereal effect that enhances the gown's visual appeal. What sets this design apart is the integration of 30 mini battery packs sewn into the gown, enabling the fiber optics to light up. This innovative approach marries the elegance of couture with cutting-edge technology, resulting in a garment that is not only a fashion statement but also a dynamic, interactive piece of art.

Posen’s use of fiber optics reflects his ability to push the boundaries of design, creating garments that are not only visually captivating but also immersive. The choice of organza—light, delicate, and translucent—complements the glowing fiber optics, producing a mesmerizing effect that changes with movement and light. By incorporating battery-powered illumination into the dress, Posen has introduced an exciting dimension to wearable tech, paving the way for more dynamic, interactive designs in the fashion world.

Process and workflow

Based on the insights I gained during the fifth week of the course, I initially focused on experimenting with a variety of circuits using different components. This process allowed me to familiarize myself with their functionalities and behaviors, laying a strong foundation for designing the wearable device I envisioned. I explored how these components interacted, tested their compatibility, and adjusted configurations to optimize performance, ensuring I could integrate them effectively into my final wearable project.

Flora board

1. Light sensor and buzzer

The inspiration for my project originated from the concept of the Sunscreen Reminder Hat, a wearable device designed to remind users to reapply sunscreen by integrating a UV sensor directly into a hat. However, due to our lab's lack of UV sensors, I adapted the idea of using a light sensor instead. This adjustment maintains the core functionality of the project—monitoring sunlight exposure and prompting the wearer accordingly—while utilizing the resources at my disposal. By incorporating the light sensor, the wearable can still detect the ambient light and remind the user, ensuring the essential feature of sun protection awareness is preserved.

1. Materials Needed

• Flora board: The main microcontroller for your wearable project.
• Light Sensor: Detects ambient light levels.
• Buzzer: Provides an audible alert when the light threshold is met.
• Jumper wires: To connect the components.
• Battery pack: To power the Flora board when worn.

2. Setting Up the Circuit

1. Connect the Light Sensor:Connect one leg of the LDR to the 3.3V or VBATT pin on the Flora.
2. Connect the Buzzer:
   • Connect the positive terminal of the buzzer to a digital pin on the Flora (e.g., D9).
   • Connect the negative terminal of the buzzer to the ground (GND).

Here's an Arduino code that I used to read the data from the digital light sensor and make the buzzer sound when the light level crosses a threshold:

Code Example

Light sensor and buzzer

// Pin definitions
const int lightSensorPin = 6;  // The 'out' pin of the digital light sensor connected to digital pin D6
const int buzzerPin = 9;       // Buzzer connected to digital pin D9

void setup() {
  // Set up the sensor pin as input
 pinMode(lightSensorPin, INPUT);

 // Set up the buzzer pin as output
 pinMode(buzzerPin, OUTPUT);

 // Start serial communication for debugging
 Serial.begin(9600);
}

void loop() {
 // Read the value from the light sensor
 int sensorValue = digitalRead(lightSensorPin);

// Print the sensor value for debugging
Serial.println(sensorValue);

// If light is detected (assuming HIGH means light and LOW means dark)
if (sensorValue == HIGH) {
 // Turn on the buzzer
 digitalWrite(buzzerPin, HIGH);
} else {
 // Turn off the buzzer
 digitalWrite(buzzerPin, LOW);
}

// Small delay to avoid excessive readings
delay(100);
}

2. How to make a simple reflective sensor?

1. Understanding the Components

• LED (Light Emitting Diode): A component that emits light when an electric current passes through it. LEDs are widely used in various electronic circuits as indicators or light sources.

• LDR (Light Dependent Resistor): A type of resistor whose resistance varies based on the intensity of light it is exposed to. In the dark, the LDR exhibits high resistance, effectively blocking current. In the presence of light, its resistance decreases, allowing current to flow more easily.

2. How the Sensor Works

The sensor works by detecting the reflection of light emitted by the LED. When an object approaches the sensor, the LED’s light reflects off the object and hits the LDR, causing its resistance to change. This change in resistance can be detected by measuring the voltage across the LDR, which can then be used to trigger an action or signal.

3. Materials Needed

• An LED (any color, but bright LEDs are preferable for better reflection)
• An LDR
• A power source (e.g., a battery or a power supply)
• A fixed resistor (to create a voltage divider circuit)
• Breadboard and jumper wires for easy connections
• Multimeter (optional, for testing)

4. Setting Up the Circuit

1. Position the LED and LDR: Place the LED and LDR on the breadboard, close to each other but not touching. The LED will emit light, and the LDR will sense the reflected light.
2. Connect the LED:
   • Connect the anode (longer leg) of the LED to the positive rail of the power source.
   • Connect the cathode (shorter leg) to a current-limiting resistor (e.g., 220Ω) to protect the LED and connect this to the ground rail.
3. Create a Voltage Divider with the LDR:
   • Connect one leg of the LDR to the positive rail of the power source.
   • Connect the other leg of the LDR to one leg of a fixed resistor (e.g., 10kΩ).
   • Connect the free leg of the fixed resistor to the ground rail.
   • Take a jumper wire from the junction between the LDR and the fixed resistor to an analog input pin if using a microcontroller or connect it to a multimeter for testing.
4. Power the Circuit: Ensure all connections are secure and power up the circuit.

5. Testing the Sensor

• When no object is near, the LED's light will scatter, and the LDR will remain at a high resistance state, resulting in minimal current flow.
• When an object approaches, the LED’s light reflects onto the LDR, decreasing its resistance. This change can be observed by measuring the voltage across the LDR using a multimeter or an analog input of a microcontroller.

6. Calibration and Adjustments

• If you are using a microcontroller (e.g., Arduino), write a simple code to read the analog input from the LDR and print it to the serial monitor for real-time observation.
• Adjust the distance of the LED and LDR to optimize the sensor's sensitivity and range.

7. Applications

This simple reflective sensor can be used for:

• Detecting obstacles or the presence of an object in robotic projects.
• Creating touchless light switches.
• Making a basic proximity sensor for various DIY electronics.

Code Example

Reflective sensor

// Define the pin where the LDR is connected
const int LDR_PIN = A0; // Connect the junction of LDR and resistor to analog pin A0

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

 void loop() {
  // Read the analog value from the LDR
  int ldrValue = analogRead(LDR_PIN);

 // Print the LDR value to the Serial Monitor
 Serial.print("LDR Value: ");
 Serial.println(ldrValue);

 // Add a small delay for stability
 delay(500);
}

What to Expect:

• When the LDR is exposed to light, the printed value will be lower (depending on light intensity).
• When the LDR is in darkness or not receiving light, the value will be higher.
• You can observe changes in the values as an object comes closer and reflects the LED light onto the LDR.

3. create a circuit where a sound sensor triggers a NeoPixel color change

Components Needed:

• Adafruit Flora board
• Sound sensor module
• Flora NeoPixels (single or a chain)
• Jumper wires

Wiring:

1. Sound Sensor:

   • OUT pin to digital pin D6 on the Flora.
   • VCC to 3.3V or 5V on the Flora.
   • GND to GND on the Flora.

2. Flora NeoPixel:

   • DIN (data input) to D9 on the Flora.
   • VCC to 3.3V or 5V on the Flora.
   • GND to GND on the Flora.

Code Example

Sound sensor triggers a NeoPixel color change

#include <Adafruit_NeoPixel.h>

#define SOUND_SENSOR_PIN A0  // Analog pin connected to the sound sensor
#define NEOPIXEL_PIN 9       // Pin where the NeoPixel data line is connected
#define NUM_PIXELS 1         // Number of NeoPixels in the chain

Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NUM_PIXELS, NEOPIXEL_PIN, NEO_GRB + NEO_KHZ800);

void setup() {
 pinMode(SOUND_SENSOR_PIN, INPUT);
 pixels.begin();  // Initialize the NeoPixel library
 pixels.show();   // Turn off all pixels initially
 Serial.begin(9600); // For debugging purposes
}

void loop() {
 int soundValue = analogRead(SOUND_SENSOR_PIN);
 Serial.println(soundValue); // Print the sensor value to the serial monitor

 // Map sound values to colors
 if (soundValue < 200) {
 // Low sound level - blue
 pixels.setPixelColor(0, pixels.Color(0, 0, 255)); // Blue color
} else if (soundValue >= 200 && soundValue < 600) {
  // Medium sound level - green
  pixels.setPixelColor(0, pixels.Color(0, 255, 0)); // Green color
} else if (soundValue >= 600) {
  // High sound level - red
  pixels.setPixelColor(0, pixels.Color(255, 0, 0)); // Red color
}

// Show the color change
pixels.show();

delay(100); // Delay to allow for stable readings
}

Color Ranges:

• Low sound (0-199): The NeoPixel lights up blue.
• Medium sound (200-599): The NeoPixel lights up green.
• High sound (600-1023): The NeoPixel lights up red.

Customizing Colors and Ranges:

• Adjust the thresholds (e.g., 200, 600) based on the sensitivity of your sensor.
• Modify the RGB values in pixels.Color() to change the color representation.

Failure:

Initially, I assembled the circuit using thin copper wire. However, the circuit failed to conduct current

Possible Reasons

• High resistance of thin wire: Thin copper wires may have a higher resistance, limiting their ability to conduct sufficient current.
• Inadequate current capacity: The wire's small cross-sectional area might not support the required current for the circuit.
• Poor connections: Loose or incomplete connections can prevent proper current flow through the circuit.
• Oxidation or damage: If the wire's surface was oxidized or damaged, it could have reduced conductivity.
• Voltage drop: The thin wire may have caused a significant voltage drop, rendering the circuit inoperable.
• Fragility: Thin wires are prone to breakage, which could have interrupted the current flow.

Results

When the previous codes worked well, I had the idea to create a code with much shorter intervals, designed to provide a dynamic response similar to an equalizer.

This would allow for a more rapid and continuous variation in output, offering a more engaging and responsive interaction, akin to how an equalizer adjusts to different audio frequencies. The system could react faster to incoming signals by shortening the intervals, giving a real-time visual representation of the sound levels or other stimuli, and adding more fluidity and energy to the output.

Code Example

Equalizer code

#include <Adafruit_NeoPixel.h> // Include the NeoPixel library

#define SOUND_SENSOR_PIN 9 // Use digital pin 9 for the sound sensor
#define NEOPIXEL_PIN 6     // Pin connected to the NeoPixel
#define NUM_PIXELS 3       // Number of NeoPixels

// Initialize the NeoPixel object
Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NUM_PIXELS, NEOPIXEL_PIN, NEO_GRB + NEO_KHZ800);

bool lastState = LOW; // Variable to track the last state of the sound sensor

void setup() {
 pinMode(SOUND_SENSOR_PIN, INPUT); // Set the sound sensor pin as input
 pixels.begin();  // Initialize the NeoPixel library
 pixels.show();   // Turn off all pixels initially
 Serial.begin(9600); // Initialize serial communication for debugging
}

void loop() {
 int soundValue = digitalRead(SOUND_SENSOR_PIN); // Read the value from the digital sound sensor

 // Only update the NeoPixels if the sound state changes
 if (soundValue != lastState) {
 lastState = soundValue; // Update the last state

if (soundValue == HIGH) {
  // When sound is detected, set all NeoPixels to blue
  for (int i = 0; i < NUM_PIXELS; i++) {
    pixels.setPixelColor(i, pixels.Color(0, 0, 255)); // Blue for noise
  }
  } else {
  // When no sound is detected, set all NeoPixels to red
  for (int i = 0; i < NUM_PIXELS; i++) {
    pixels.setPixelColor(i, pixels.Color(255, 0, 0)); // Red for no noise
  }
  }

 pixels.show(); // Update the NeoPixels with the new colors
  }

Serial.println(soundValue); // Print the value to the serial monitor for debugging
}

XIAO RP2040

XIAO RP2040 Integration Process
To ensure smooth functionality between the XIAO RP2040 board and the main board, we carefully aligned the two components before beginning the soldering process. This step was crucial for proper integration, as precise alignment of the pins and pads on both boards was necessary. The compact size of the XIAO RP2040 made this step particularly delicate, requiring steady hands and attention to detail to ensure that the pins lined up correctly for a solid connection. Each pin was soldered individually to ensure a strong electrical bond without causing any short circuits.

Step-by-Step Process for Soldering the XIAO RP2040 Board and Components

• Step 1: Preparing the Components Before starting the soldering process, gather all necessary components:
  • XIAO RP2040 board
  • Main board
  • Soldering iron and solder
  • Tweezers (optional)
  • Multimeter (for testing)

• Step 2: Aligning the XIAO RP2040 Board with the Main Board
  • Carefully position the XIAO RP2040 board over the main board.
  • Ensure the pins of the XIAO RP2040 align with the corresponding pads on the main board.
  • Double-check the alignment to avoid any misconnection, as the small size of the XIAO RP2040 makes it prone to misalignment.

• Step 3: Soldering the XIAO RP2040 to the Main Board

  • Heat the soldering iron to the appropriate temperature (usually around 350°C for small components).
  • Starting with the corner pins, apply solder to each of the XIAO RP2040’s pins one by one.
  • Gently press the pins of the XIAO RP2040 to the pads of the main board while applying the solder.
  • Ensure that the solder flows smoothly and forms a solid connection between the pin and the pad.
  • Use a magnifying glass or inspect with the naked eye to confirm that the solder joints are clean, with no bridges between adjacent pins.

• Step 4: Inspecting the Solder Joints

  • Visually inspect all the solder joints to make sure the connections are solid.
  • Use a multimeter to check for continuity between the components and ensure there are no shorts.
  • Clean up any excess solder or flux using a desoldering braid or a solder sucker, if needed.

To show time with sound in a horological way, like the Octo Finissimo Ultra COSC

Inspired by the Bulgari Octo Finissimo Ultra COSC , I developed a coding project to display time through sound, drawing from the innovative concept of auditory time-telling seen in this horological marvel. The Octo Finissimo Ultra COSC, known for its sleek design and sound-based hour indication, provided a perfect foundation for my project, where I translated the passage of time into beeps and tones.

Much like the watch, which uses discrete sounds for each hour and interval, I designed a code that integrates short beeps for each hour, double beeps for quarters, and continuous tones for seconds. This approach brings an entirely new dimension to how we perceive time, creating an immersive auditory experience that mirrors the elegance and precision of the Octo Finissimo Ultra.

To show time with sound in a horological way, like the Octo Finissimo Ultra COSC (or similar sound-based designs), you could integrate a unique system that uses different auditory signals for various time-related intervals. Here's a breakdown of how you could structure such a system:

1. Hourly Signals (Single Ring or Beep for Each Hour) Each hour could be signaled by a specific number of sounds (beeps, rings, or tones). For example:

   • One beep per hour: The number of beeps would correspond to the hour. For instance, 11 beeps would indicate 11:00.
   • Distinct sound pattern for each hour: Each hour could have a unique tone or sequence for auditory differentiation.

2. Quarter-Hour Signals (Double Beeps for Each Quarter) Quarter-hour intervals can be signaled by a double beep or a pair of sounds:

   • Double beep: Every 15-minute mark could be represented by a double beep. For example, 3 double beeps could indicate 45 minutes.
   • Variation in tone or pitch: Different tones or pitches could represent different quarters (e.g., a lower pitch for 15 minutes, higher pitch for 30 minutes, etc.).

3. Seconds (Longer Sound for Seconds) Seconds could be represented by a longer, continuous beep or sound. The length of the tone could correlate with the passage of seconds:

   • Short beep for each second: The tone could be activated every second, or a brief tone could represent each second's passage.
   • Continuous sound for a full second: A continuous beep for one full second might add a tactile quality to timekeeping.

Code Example

Horological watch

#define BUZZER_PIN 9 // Pin connected to the buzzer

unsigned long previousMillis = 0; // Stores the last time an action was taken
unsigned long interval = 1000;    // 1 second interval for time simulation
int simulatedSeconds = 0;         // Tracks seconds
int simulatedMinutes = 0;         // Tracks minutes
int simulatedHours = 12;          // Tracks hours (12-hour clock format)

void setup() {
  pinMode(BUZZER_PIN, OUTPUT); // Set the buzzer pin as output
} 

void loop() {
  unsigned long currentMillis = millis();

  // Update time every second
if (currentMillis - previousMillis >= interval) {
  previousMillis = currentMillis;
  simulatedSeconds++;

  // Update minutes and hours
if (simulatedSeconds >= 60) {
  simulatedSeconds = 0;
  simulatedMinutes++;
  }
if (simulatedMinutes >= 60) {
  simulatedMinutes = 0;
  simulatedHours++;
  }
if (simulatedHours > 12) {
  simulatedHours = 1; // Reset to 1 for 12-hour format
  }

 // Generate sound for the current time
 generateSound(simulatedHours, simulatedMinutes, simulatedSeconds);
}
}

void generateSound(int hours, int minutes, int seconds) {
  // Hours: Single beep per hour
  for (int i = 0; i < hours; i++) {
  singleBeep();
  delay(500); // Short pause between beeps
}

// Quarters: Double beep for each quarter past the hour
int quarters = minutes / 15;
for (int i = 0; i < quarters; i++) {
doubleBeep();
delay(500); // Short pause between double beeps
}

// Seconds: Long beep every 15 seconds
if (seconds % 15 == 0) {
longBeep();
}
}

void singleBeep() {
 tone(BUZZER_PIN, 1000, 300); // 1 kHz frequency, 300 ms duration
 delay(300); // Wait before next action
}

void doubleBeep() {
 tone(BUZZER_PIN, 1000, 200); // First beep
 delay(200);                  // Short pause
 tone(BUZZER_PIN, 1000, 200); // Second beep
 delay(300);                  // Wait before next action
}

void longBeep() {
 tone(BUZZER_PIN, 1000, 1000); // Long beep for 1 second
 delay(1000); // Wait before next action
}

Explanation

1. Simulated Time:

   • The millis() function is used to simulate a clock without an RTC.
   • Hours, minutes, and seconds are incremented in software.

2. Sound Logic:

   • Hours: Single beep for each hour (e.g., 3 beeps for 3 o'clock).
   • Quarters: Double beep for every 15 minutes past the hour (e.g., 2 double beeps for 30 minutes).
   • Seconds: A long beep every 15 seconds.

3. Hardware Connections:

   • Connect the buzzer's positive terminal to pin 9 on the FabriXiao.
   • Connect the buzzer's negative terminal to GND.

4. Adjustable Parameters:

   • interval: Modify the interval to slow down or speed up the time simulation.
   • Sound frequencies and durations can be adjusted in the tone() function.

Limitations

• This simulation lacks real-time accuracy due to the absence of an RTC.
• The time resets each time the board restarts.

Inputs:

None in this specific setup: The code does not use external inputs like buttons or sensors to control time or behavior dynamically. The program relies on the internal clock (millis function) of the microcontroller to simulate time.

Outputs:

Buzzer: - Produces different sounds to represent hours, minutes, and seconds: - Single beep for each hour. - Double beep for each quarter hour. - Long beep for every 15 seconds. The buzzer serves as the auditory output to convey time through a series of tones. It is controlled using the tone() function, which sets the frequency and duration of each sound.

Circuit Overview:

• The FabriXiao board is the central controller.
• The buzzer is the output device that converts electrical signals into sound.