9. WEARABLES¶

Introduction: What Are Wearables?¶

Wearables are interactive objects or garments worn on the body that integrate technology, electronics, and textiles. They respond to the body or the environment and generate feedback through light, movement, heat, sound, or digital communication. Wearables extend the functionality of clothing—ranging from aesthetic effects to close-to-the-body interactions such as haptics or sensory feedback.

3 Main Categories of Wearables¶

Wearables can be broadly grouped into 3 functional areas:

1. Visual Wearables (Light-Based Outputs)¶

This category includes LEDs, neopixels, fiber optics, and thermochromic materials that create visual effects or cause patterns and colors to change.

2. Motion Wearables (Movement & Shape Change)¶

Motion is produced through actuators such as shape memory alloys (SMA), heating wires, or flip-dots, which bend, curl, fold, structure, or magnetically switch materials.

3. Haptic & Sonic Wearables (Touch & Sound)¶

These include vibrotactile motors, textile speakers, and other feedback systems that generate haptic sensations or sound directly on the body.

Assignment – Tasks for This Week¶

For this Wearables week, we created a total of 3 swatches:

1. Two Actuator / Output Swatches¶

Each swatch should be intentionally designed to be worn on the body.

Examples include: - Neopixel swatch - SMA (Shape Memory Alloy) swatch - Thermochromic heat sample - Flip-dot module - Vibration motor swatch

Each swatch should be tested using the microcontroller of your choice.

2. One Swatch with Input & Output¶

This swatch must include one sensor (input) and one actuator (output) of your choice. It must be intentionally designed as a wearable piece that can be worn on the body.

Example combinations: - Stretch sensor → LED - Button → Vibration motor - Light sensor → Neopixel - Soft pressure sensor → SMA element

INSPIRATION & REFERENCES¶

JOANNE PETIT FRERE¶

Joanne Petit-Frère is a sculptor & conceptual artist whose work blends hair architecture, adornment, & diaspora traditions. She creates intricate braided structures & wearable sculptures that explore identity, ritual & form — often activated through performance.

Joanne Petit Frere

YING GAO¶

Ying Gao is a Montreal-based fashion designer & professor whose experimental work blends fashion, product design, & media technology. Exhibited internationally & featured in major publications like Vogue & The New York Times, her designs explore clothing as a responsive, transitional space shaped by social & urban environments.

Ying Gao instagram: livingpod

LISA JIANG¶

Fashion & Illustration

Lisa Jiang is a London-based fashion designer & illustrator specializing in wearable kinetics — fashion that integrates movement, structure, & dynamic form. She studied Fashion Design Womenswear at the renowned Central Saint Martins & has since been developing innovative concepts at the intersection of fashion, technology, & performance.

I met Lisa during my internship at Iris van Herpen in Amsterdam.

Instagram: Lisa Jiang www.lisajiang.co.uk

BEHNAZ FARAHI¶

Behnaz Farahi is an Iranian-American architect & designer known for her interactive wearable technologies. such as a 3D-printed garment that responds to the viewer’s gaze by opening & closing its surface — exploring the relationship between technology, perception, & the body.

Behnaz Farahi

ANOUK WIPPRECHT¶

Anouk Wipprecht is a Dutch FashionTech designer who merges fashion with robotics, sensors, & microcontrollers to create interactive “technological couture.” Her pieces move, react, & communicate with the environment, turning clothing into intelligent systems. Her Spider Dress is a key example, using sensors & robotic arms to protect personal space. She collaborates with companies such as Intel, Google, Microsoft, & Audi, & works internationally between the US & Amsterdam.

www.anoukwipprecht.nl instagram: anoukwipprechtt

WILLIAM DARRELL¶

William Darrell is a kinetic artist who creates mechanical sculptures inspired by organic life forms & cosmic phenomena.

instagram: williamdarrell Thangs: William Darrell

CASEY CURRAN¶

Casey Curran is an artist known for his intricate hand-powered kinetic sculptures that explore the hidden structures of nature & existence. His works animate delicate systems of flora & fauna, inviting viewers to activate & experience them. Combining ornate craftsmanship with precise mechanics, his sculptures reflect themes of pattern, chaos, & emergence.

Curran has also collaborated with Iris van Herpen, creating kinetic elements for her haute couture collections, where his mechanical artistry merges seamlessly with her experimental fashion design.

www.caseycurran.com Instagram: Casey Curran

WEEK 9: WEARABLES¶

For this Assignment i creat a Anemone Reef on the Chest as an interactive, body-worn organism placed over the heart that uses soft movement & pulsating light to mirror bodily rhythms, exploring the dialogue between human physiology & marine life.

The project combines silicone-based anemone forms, Neopixel LEDs, a Seeed XIAO RP2040 microcontroller, a DC motor with driver, & custom Arduino code to recreate organic, breathing-like behavior through technological means.

IDEA & CONCEPT¶

Anemone Reef on the Chest - OceanHeart / Heartreef¶

Sea anemones are animals disguised as flowers— organisms that blur the boundaries between motion & stillness, between instinct & aesthetics. By placing their gentle forms on the chest, this wearable explores the dialogue between human physiology & marine biology. The soft movement & pulsing light recreate the subtle behaviors of these creatures, turning the body into a host ecosystem where human & anemone rhythms intertwine.

This project ends where contradiction begins: the most organic forms recreated through the most artificial means. Placing this technological organism on the chest reveals how naturally we welcome technology into intimate spaces— even AI— when it moves, pulses, & behaves like something alive. It makes us question what “natural” really means when machines can echo the rhythms of life so convincingly.

In the end, the piece carries a quiet paradox: the attempt to recreate something profoundly organic through technology. The anemone—soft, breathing, alive—is embodied here through code, circuits, & artificial intelligence.

& yet, when worn close to the heart, it feels strangely natural, as if the boundary between organism & machine softens for a moment. It reminds us how readily we allow technology to come close to us— even closer than we ever expected— simply because it learns to imitate life so well.

entering a state of calm attention— as if you are sharing a quiet conversation with another "living" being, not through words, but through movement, rhythm, and presence. ...

Anemone Reef on the Chest¶

Component / Element	Role / Function
Body-worn structure (chest placement)	Positions the object close to the heart, aligning the wearable with bodily rhythms such as breath & pulse, creating intimacy & embodied interaction.
Soft, anemone-like form	References sea anemones as organisms that blur the line between animal & plant, motion & stillness, reinforcing the biological inspiration.
Gentle movement (expansion & contraction)	Mimics the slow, organic motion of sea anemones, visually translating breathing & internal body rhythms into external movement.
Pulsating light	Acts as a visual rhythm that echoes life processes, creating a soft, breathing glow rather than a mechanical signal.
Color palette (beige, cream, rose, anthracite, dove blue)	Drawn from natural anemone tones to create a calm, organic atmosphere & avoid a technological aesthetic.
Electronics & code (microcontroller, LEDs)	Enable controlled movement & light behavior, allowing artificial systems to imitate organic rhythms.
Artificial intelligence (as design & coding assistant)	Supports the creation of lifelike behavior, reinforcing the paradox of organic qualities emerging from artificial processes.
Human body (wearer)	Becomes a host ecosystem, where human physiology & the wearable organism interact & synchronize.
Interaction through presence (no direct input)	Encourages calm attention and sensory awareness rather than explicit control, fostering a quiet, non-verbal dialogue.
Conceptual paradox	Explores the tension between nature & technology by recreating organic life through code, circuits, & machines.

STEP 2 - MOTION STRATEGY¶

As a first step, I needed to decide how the anemones could be moved using a small motor. To do this, I explored different motion mechanisms & ultimately chose to use a small rotational motor.

The motor drives a set of differently sized gears, causing them to rotate. Small, rounded wire loops are attached to the gears, & through their rotation they gently transfer movement to the silicone anemones.

Charly / CARLOS PÉREZ RAMÍREZ

Motion Mechanism – Development Timeline¶

Why This Planning Approach Matters¶

Creating a concrete project plan is especially helpful when time is limited. By listing all components, techniques, machines, & software in advance, it becomes possible to define a clear working order & execute the project step by step without losing time or overlooking dependencies — such as the silicone curing process, which required the anemone fabrication to happen early in this project.

Logical Step-by-Step Workflow¶

Step 1 – Concept & System Planning - Define interaction, placement on the body, & desired behavior - Decide early which movement, light, & material qualities are essential - ○ Create a full component + process list before building

Step 2 – Motion Strategy - Research possible motion mechanisms - Decide on rotational motor + gear system - Define how motion will be translated into soft, organic movement

Step 3 – Anemone Form Design - Collect natural references - Generate anemone geometries (Studio.Trip) - Refine models & design negative molds in Rhino

Step 4 – Mold Making & Silicone Casting - 3D-print molds in PLA - Cast silicone anemones - Allow sufficient curing time (critical dependency) - This step must happen early due to material drying & curing constraints.

Step 5 – Electronics & Light Design - Define colour palette inspired by real sea anemones - Plan LED layout (Pixels 1–5, mirrored by 6–10) - Wire Neopixels & microcontroller

Step 6 – Programming - Write Arduino code for: Pulsating LED animations - Button-controlled motor toggle - Safe motor driver handling - Test lighting & motion independently

Step 7 – Mechanical Assembly - Mount motor & gears - Attach rounded wire loops - Connect silicone anemones to motion system - Fine-tune movement softness

Step 8 – System Integration - Combine electronics, mechanics, & silicone elements - Integrate power supply - Ensure all grounds are shared & connections stable

Step 9 – Wearable Placement & Testing - Position system on the chest (over the heart) - Test comfort, balance, & behavior on the body - Observe interaction between body rhythm, light, & motion

Step 10 – Documentation & Reflection - Document each stage clearly - Reflect on the contrast between organic appearance & artificial means - Evaluate how technology becomes acceptable when it mimics life

OVERVIEW¶

COMPONENTS¶

Category	Component	Purpose
Actuation	DC motor	Generates rotational movement
	Gear set (various sizes)	Translates rotation into differentiated motion
	Rounded wire loops	Transfers motion to silicone anemones
Electronics	Seeed XIAO RP2040	Main microcontroller
	Neopixels (10x)	Pulsating light output
	TB6612FNG motor driver	Controls motor safely
	Push button	Toggle motor ON/OFF
Power	Power bank / battery	Mobile power supply
	Step-down converter	Voltage regulation
Material	Silicone (translucent)	Anemone bodies
	PLA filament	3D-printed molds
Structure	Wires, connectors, fasteners	Assembly & mounting

TOOLS, MACHINES, SOFTWEARS¶

Category	Tool / Machine / Software	Use
Design	Studio.Trip	Generate organic anemone forms
	Rhino	Model refinement & mold design
Fabrication	3D printer (PLA)	Print negative molds
	Laser cutter	Cut structural parts (if needed)
Electronics	Arduino IDE	Programming logic & behavior
	Adafruit NeoPixel library	LED control
Assembly	Soldering iron	Electrical connections
	Hand tools	Mechanical assembly
Logic & Planning	ChatGPT	Code development & iteration

STEP 3 - ANEMONE FORM DESIGN¶

To develop the anemone forms, I first collected natural references, including my own photographs and visual material from marine biology sources. Based on these references, I generated organic anemone geometries using Studio.Trip, transforming selected images into 3D models.

STL FILE¶

STL FILE - ANEMONE

STEP 4 - MOLD MAKING & SILICONE CASTING¶

After finalizing the anemone geometries, the models were imported into Rhino, where the shapes were refined and a negative mold was designed. The molds were then 3D-printed in PLA using Cura as the slicer.

see: WEEK 6 - COMPUTIONAL COUTURE

For the final material, I chose silicone, as its texture & flexibility closely resemble the natural qualities of real sea anemones. The silicone used is translucent to semi-transparent, allowing each element to be illuminated from within and enhancing their lifelike appearance. This step had to be carried out early in the process, as silicone requires sufficient curing time, making it a critical dependency within the overall project timeline.

Natural alternatives such as alginate-based bioplastics were considered but ultimately rejected due to their long curing times & significant shrinkage during the drying process.

STEP 5 - ELECTRONICS & LIGHT DESIGN¶

For the electronic & visual design, I first defined a color palette inspired by real sea anemones, informed by natural references & the RAL - TREND REPORT 20206.

The palette consists of soft, organic tones such as beige, cream, rose, anthracite, & dove blue, supporting a calm & non-intrusive visual atmosphere.

The lighting system is based on 10 Neopixels, programmed using the Arduino IDE on a Seeed XIAO RP2040. Neopixels were chosen because they allow precise, individual control of each LED, making it possible to create gentle pulsations, subtle timing variations, & an organic, breathing light behavior.

The LED layout was planned symmetrically: Pixels 1–5 each transition between 2 colors from the palette at slightly different rhythms, while Pixels 6–10 mirror this sequence to maintain balance across the wearable. The animations avoid rigid mechanical timing & instead evoke a soft, living glow. For example, Pixel 1 fades slowly between cream & dove blue over a 3-second cycle, followed by a brief pause before repeating—echoing the slow, hypnotic movements of sea anemones.

The Arduino code controlling the Neopixels was developed with the assistance of ChatGPT, allowing for rapid prototyping, iteration, and fine-tuning of the light behaviors.

SET UP¶

10 Neopixels on a Seeed XIAO RP2040, with:¶

10 LEDs
Pixels 1–5 each have their own color pair + speed
Pixels 6–10 repeat 1–5
Pixel 1 (& 6) = cream ↔ dove blue, 3-second pulsing cycle

All in a soft palette: beige, cream, rose, anthracite, dove blue You can paste this directly into the Arduino IDE.

THE COLOUR CODE¶

STEP 6 - PROGRAMMING¶

Wiring Overview Table¶

The interactive behavior of the wearable was implemented using the Arduino IDE on a Seeed XIAO RP2040 microcontroller. The programming process focused on 3 main aspects: - light animation, - motor control, & - system stability. External libraries, such as the Adafruit NeoPixel library, were used to enable precise & efficient control of the LEDs.

LED Animation Logic¶

The LED behavior was implemented using the Adafruit NeoPixel library within the Arduino IDE on a Seeed XIAO RP2040. Each Neopixel is addressed individually & controlled through timed color interpolation. Pixels 1–5 are assigned unique color pairs & transition speeds, while Pixels 6–10 repeat the same parameter sets to maintain symmetry. Smooth fading is achieved by incrementally interpolating RGB values over defined time intervals, avoiding abrupt changes.

The animation logic is based on non-blocking loops using millis() to ensure stable system performance and to allow parallel motor control and user input handling. This structure enables consistent LED behavior without interfering with other interactive functions of the wearable.

Arduino Code – Neopixel Pulsing Animation¶

#include <Adafruit_NeoPixel.h>

#define LED_PIN     D1        // Change if needed
#define LED_COUNT   10

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

// ---------- Color Definitions (RGB) ----------
uint32_t colorsA[5] = {
  strip.Color(245, 240, 220), // cream
  strip.Color(210, 190, 180), // beige
  strip.Color(200, 170, 175), // rose
  strip.Color(90,  95,  105), // anthracite
  strip.Color(180, 195, 210)  // dove blue
};

uint32_t colorsB[5] = {
  strip.Color(180, 195, 210), // dove blue
  strip.Color(200, 170, 175), // rose
  strip.Color(90,  95,  105), // anthracite
  strip.Color(245, 240, 220), // cream
  strip.Color(210, 190, 180)  // beige
};

// ---------- Timing (ms) ----------
unsigned long cycleTime[5] = {
  3000,  // Pixel 1
  3500,  // Pixel 2
  4000,  // Pixel 3
  4500,  // Pixel 4
  5000   // Pixel 5
};

unsigned long previousMillis[5] = {0, 0, 0, 0, 0};

void setup() {
  strip.begin();
  strip.show();
}

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

  for (int i = 0; i < 5; i++) {
    float phase = float(currentMillis % cycleTime[i]) / cycleTime[i];
    float t = (sin(phase * TWO_PI - HALF_PI) + 1.0) * 0.5;

    uint32_t c1 = colorsA[i];
    uint32_t c2 = colorsB[i];

    uint8_t r = lerp(red(c1), red(c2), t);
    uint8_t g = lerp(green(c1), green(c2), t);
    uint8_t b = lerp(blue(c1), blue(c2), t);

    strip.setPixelColor(i,     strip.Color(r, g, b));     // Pixels 1–5
    strip.setPixelColor(i + 5, strip.Color(r, g, b));     // Pixels 6–10 (mirror)
  }

  strip.show();
}

// ---------- Helper Functions ----------
uint8_t lerp(uint8_t a, uint8_t b, float t) {
  return a + (b - a) * t;
}

uint8_t red(uint32_t c)   { return (uint8_t)(c >> 16); }
uint8_t green(uint32_t c) { return (uint8_t)(c >> 8);  }
uint8_t blue(uint32_t c)  { return (uint8_t)c;         }

What this code does (technical summary)¶

Individually controls 10 Neopixels
Pixels 1–5 have unique color pairs & timing
Pixels 6–10 mirror 1–5
Uses sine-based interpolation for organic pulsing
Fully non-blocking (millis() based)
Stable foundation for adding motor control or button input

Motor Control Logic¶

To control the movement of the anemones, a push button was implemented that toggles the motor on & off. The motor is driven through a TB6612FNG motor driver, which ensures safe operation by separating the motor’s power requirements from the microcontroller logic. Each button press switches the motor state, allowing the wearer to activate or deactivate the movement intuitively.

Hardware assumptions¶

Motor Driver: TB6612FNG
Microcontroller: Seeed XIAO RP2040
Button: connected to D2 (with INPUT_PULLUP)
Motor PWM: D6 → PWMA
Motor Direction: D9 → AIN1, D10 → AIN2
STBY: D7 → HIGH to enable driver

Arduino Code – Motor Toggle¶

// ---------- Pin Definitions ----------
#define PWMA   D6    // PWM for motor speed
#define AIN1   D9    // Motor direction
#define AIN2   D10
#define STBY   D7    // Standby for TB6612FNG
#define BUTTON D2    // Button input (INPUT_PULLUP)

// ---------- Motor State ----------
bool motorOn = false;          // Current motor state
bool lastButtonState = HIGH;   // For debounce
unsigned long lastDebounceTime = 0;
const unsigned long debounceDelay = 50; // ms

// ---------- Setup ----------
void setup() {
  pinMode(PWMA, OUTPUT);
  pinMode(AIN1, OUTPUT);
  pinMode(AIN2, OUTPUT);
  pinMode(STBY, OUTPUT);

  pinMode(BUTTON, INPUT_PULLUP); // Active LOW

  digitalWrite(STBY, HIGH);      // Enable driver
  updateMotor();                 // Ensure motor starts OFF
}

// ---------- Main Loop ----------
void loop() {
  bool reading = digitalRead(BUTTON);

  // Debounce button
  if (reading != lastButtonState) {
    lastDebounceTime = millis();
  }

  if ((millis() - lastDebounceTime) > debounceDelay) {
    static bool stableButtonState = HIGH;
    if (reading != stableButtonState) {
      stableButtonState = reading;

      if (stableButtonState == LOW) { // Button pressed
        motorOn = !motorOn;           // Toggle motor
        updateMotor();
      }
    }
  }

  lastButtonState = reading;
}

// ---------- Apply motor state ----------
void updateMotor() {
  if (motorOn) {
    digitalWrite(AIN1, HIGH);   // Forward
    digitalWrite(AIN2, LOW);
    analogWrite(PWMA, 255);     // Full speed
  } else {
    analogWrite(PWMA, 0);       // Stop
  }
}

Debouncing & System Stability¶

To prevent false triggering caused by mechanical button noise, a software debouncing mechanism was implemented. This ensures that only deliberate button presses are registered, resulting in stable & predictable system behavior. Safe standby handling was also included to protect the motor driver & ensure reliable operation during repeated use.

Independent Testing¶

Before combining all elements into the final wearable, the LED animations & motor control were tested independently. This modular testing approach simplified debugging & allowed each subsystem to be refined before full integration.

Toggle DC Motor with Button (Debounced) - XIAO RP2040 — TB6612FNG¶

Press button → Motor ON
Press button again → Motor OFF
Debounce included
Safe standby handling
PWM speed = 255 (full speed)

Wiring Guide¶

Component	Pin
XIAO D6 →	TB6612 PWMA
XIAO D9 →	TB6612 AIN1
XIAO D10 →	TB6612 AIN2
XIAO D7 →	TB6612 STBY
XIAO D2 →	Button → GND
XIAO 3V3 →	TB6612 VCC
XIAO GND →	TB6612 GND
Step-Down +	TB6612 VM
Step-Down –	GND (shared)
TB6612 A01 →	Motor +
TB6612 A02 →	Motor –

All grounds MUST be shared (XIAO GND ↔ TB6612 GND ↔ Power supply GND)

Power & GND¶

#	From (Component & Pin)	To (Component & Pin)	Purpose / Note
1	Powerbank	XIAO RP2040: USB C	Supplies Power to XIAO
2	5V	Driver VM	voltage input (9V)
3	-	Driver GND	Shared ground with entire system
4	Battery	XIAO 9V	Shared ground with entire system

NeoPixels¶

#	From	To	Purpose
5	XIAO D0	NeoPixel Strip DIN	Data signal for all 10 NeoPixels
6	XIAO 5V	NeoPixel 5V	Power supply
7	XIAO GND	NeoPixel GND	Data signal reference

Button¶

#	From	To	Purpose
8	XIAO D2	Button +	Input pin for button (with INPUT_PULLUP enabled)
9	Button –	XIAO GND	Connects D2 to GND when pressed

Motor + Driver Bridge¶

#	From	To	Purpose
10	XIAO 6	Driver PWMA	PWM signal (controls motor speed)
11	XIAO D6	Driver STBY	Enables driver (HIGH = active)
12	Driver AO1	Motor +	Motor output
13	Driver AO2	Motor –	Motor output
14	Driver AIN1	XIAO D9	Motor direction / terminal 1
15	Driver AIN2	XIAO D10	Motor direction / terminal 2
16	Driver GND	System GND / XIAO GND	Common ground for stable operation
17	Driver VCC	XIAO 3.3 V	Logic voltage for clip

Code Development Process¶

The Arduino code was developed iteratively with the assistance of ChatGPT, which supported rapid prototyping, logic structuring, & refinement of timing & animation behavior. This approach allowed for efficient development while maintaining clarity & control over the system’s interaction logic.

THE CODE¶

/**
* Project: Motor Toggle Control (TB6612FNG + XIAO RP2040)
* Behaviour:
*  - On each button press -> toggle motor ON/OFF
*  - Uses INPUT_PULLUP (button to GND)
*  - Full speed (PWM = 255)
*
* Hardware:
*  - DC Motor on TB6612 Channel A
*  - TB6612FNG driver
*  - Seeed XIAO RP2040
*
* Wiring (Pins below):
*    PWMA = Motor PWM (speed)
*    AIN1/AIN2 = Motor direction
*    STBY = Enable TB6612
*    BUTTON = GND when pressed
*/

#define PWMA   D6
#define AIN1   D9
#define AIN2   D10
#define STBY   D7
#define BUTTON D2

// Button + motor state
bool motorOn = false;
bool lastButtonState = HIGH;       // Because of INPUT_PULLUP
unsigned long lastDebounceTime = 0;
const unsigned long debounceDelay = 50; // ms

void setup() {

  // Motor driver pins
  pinMode(PWMA, OUTPUT);
  pinMode(AIN1, OUTPUT);
  pinMode(AIN2, OUTPUT);
  pinMode(STBY, OUTPUT);

  // Button via INPUT_PULLUP (active LOW)
  pinMode(BUTTON, INPUT_PULLUP);

  // Enable TB6612FNG
  digitalWrite(STBY, HIGH);

  // Initial motor OFF
  updateMotor();
}

void loop() {

  bool reading = digitalRead(BUTTON);

  // Button changed? Start debounce window
  if (reading != lastButtonState) {
    lastDebounceTime = millis();
  }

  // After debounce delay, process a stable state
  if ((millis() - lastDebounceTime) > debounceDelay) {
    static bool stableButtonState = HIGH;

    // Only react to changes in STABLE state
    if (reading != stableButtonState) {
      stableButtonState = reading;

      // LOW = button pressed (INPUT_PULLUP)
      if (stableButtonState == LOW) {
        motorOn = !motorOn;  // toggle motor state
        updateMotor();
      }
    }
  }

  lastButtonState = reading;
}

/**
* Applies motor state:
* - ON: direction forward + max speed
* - OFF: PWM=0 (coast)
*/
void updateMotor() {
  if (motorOn) {
    digitalWrite(AIN1, HIGH);
    digitalWrite(AIN2, LOW);
    analogWrite(PWMA, 255);  // full speed
  } else {
    analogWrite(PWMA, 0);
  }
}

STEP 7 - MECHANICAL ASSEMBLY¶

In this step, the focus is on Assembling the physical components that bring the anemones to life: - Motor & Gear Installation: Secure the rotational motor in place & mount the set of differently sized gears. Ensure they rotate smoothly without friction or misalignment. The gears were designed by me using a gear generator & then cut from 3 mm acrylic sheets using the CFL-CMA1080K CO₂ laser. - Laser settings: 100 W, speed 15 mm/s, power 70 %.

THE GEARS¶

Attach Wire Loops: Place small, rounded wire loops onto the gears. These loops act as intermediaries transferring motion from the gears to the silicone anemones.
Connect Silicone Anemones: Carefully attach the silicone anemones to the corresponding wire loop, ensuring they are balanced & positioned correctly for optimal movement.
Fine-Tune Motion: Test the rotation & adjust the placement or tightness of the wire loops to achieve a gentle, soft, & natural movement that mimics the subtle swaying of real sea anemones. This assembly step is critical, as the mechanical setup directly determines the realism & fluidity of the wearable’s motion.

STEP 8- SYSTEM INTEGRATION¶

Integrate all components—electronics, motorized gears, & silicone anemones—into a single functional unit.
Connect the power supply & ensure all grounds are shared across the system for stable & safe operation.
Double-check all wiring, connectors, & motor links to guarantee reliable performance without interference or mechanical friction.

THE SET-UP¶

STEP 9 - WARABLE PLACEMENT & TESTING¶

THE PLACEMENT¶

The following screenshots from Rhino illustrate the planned placement of the silicone anemones on the chest, showing their alignment, spacing, & orientation before testing the wearable on the body.

POSITION¶

position the complete system on the chest, over the heart, to align the motion & lighting with the wearer’s body.
Test for comfort, balance, & secure attachment, to avoid strain or wobbling.
Observe the interaction between the wearer’s natural body rhythm, LED animations, & mechanical motion to ensure the anemones respond in a visually harmonious, organic manner.

STEP 10 - DOCUMENT & REFLECTION¶

Document all stages of the project, including sketches, 3D models, wiring diagrams, laser/gear parameters, & photos of assembly.

REFLECTION¶

This project explores the paradox of recreating organic forms through artificial means. Subtle motion & soft lighting make the wearable feel alive, encouraging a connection between the wearer & the artificial organism.

It demonstrates how technology becomes more acceptable when it mimics natural rhythms, blending human & machine experiences.

Lessons learned include the importance of precise timing, material choice, & assembly for smooth, lifelike movement. Observations confirmed that wearing the system near the heart creates a sense of calm engagement, as if sharing a quiet dialogue with a living companion.