Final Project — HardWear: Cyber-Organic Jewelry Line

Project Video

Lots of soldering.

Conductive Ring for Capacitive Touch Control

I initially attempted to metal cast a ring using a 3D printed mold. However, I discovered that investment casting was needed for this process, and the shop didn't have the facilities for that.

Instead, I pivoted to 3D printing a conductive ring using conductive filament. This ring connects to the capacitive touch pins in the ESP32-S3. I have two connectors for it, allowing it to function as a control button/reader.

Final Push for Final Project

I started this project by visually designing the jewelry piece, laying out elements first through sketches and then arranging them physically on paper. My initial intention was to explore jewelry as a system, not just an object—something modular, electronic, and wearable.

Early on, I experimented with metal casting to test the limits of what could work as beads and structural elements. Through this process, I realized that the surface area was too small to meaningfully integrate electronics in the way I wanted. That realization became a turning point.

Instead of forcing electronics into traditional jewelry forms, I decided to turn the electronics themselves into the beads.

PCB Design + Form Exploration

I redesigned the concept around PCB-based LED beads. I created the schematic and decided to work with hexagonal board shapes, which allowed for modularity and repetition while still reading as jewelry.

To explore more organic forms, I also experimented with blobs using:

• Blob Creator
• Adobe Illustrator

I exported the board outlines from Illustrator and then brought them into Fusion, where I made sure all components fit precisely within the board geometry. Once finalized, I milled the boards and moved into assembly.

Assembly + Soldering

The soldering phase was by far the most labor-intensive part of the project.

I used magnet wire, which meant that every single connection required manually scraping the enamel coating off the wire ends before soldering. This made the process extremely slow and precise. At this stage, I became very aware of how much patience and repetition traditional crafts demand—every connection mattered.

I braided the magnet wire intentionally:

• to increase conductivity
• to prevent failure if a single thin wire broke during wear
• to improve the structural integrity of the piece
• and because copper allowed the wiring to visually disappear instead of making the piece look bulky or unattractive

At some point during testing, I started feeling a slight sting when handling exposed copper—not an electric shock, but enough to make me confident that current was actually moving through the system. That moment gave me a bit of reassurance that the circuit was alive.

Debugging + Overnight Build

After lining everything up, I went back to the lab around 9 p.m. and stayed until 6 a.m., soldering, troubleshooting, fixing joints, and redoing connections.

Beading:

I left that morning with three NeoPixels not working. The next day, after flipping components and reworking connections, I managed to get all five LEDs functioning.

The system worked.

Unfortunately, I only documented this moment with a photograph and not a video.

Final Review + Failure Mode

By the time I arrived at the final review, some of the very sensitive magnet wire connections had shorted against each other, likely due to movement and handling. I sat in the corner with a soldering iron trying to fix it in time, but I wasn't able to restore full functionality before presenting to Neil.

Although the piece did work, I was unable to demonstrate it live or show video documentation of it operating.

Reflection

This project taught me a lot about:

• designing electronics at a jewelry scale
• the limits of magnet wire for wearables
• the fragility of exposed connections
• and the importance of strain relief, insulation, and encapsulation in future iterations

What I successfully demonstrated was:

• custom PCB design
• schematic creation
• milling and assembly
• LED control
• system-level thinking at a very small scale

What I would improve next:

• better insulation between conductors
• more robust connectors
• a housing or coating to protect connections
• and improved documentation during moments of success

Code + Documentation

The code used for this project is included below. All images of the process, boards, soldering, and final assembly are included in this documentation.

Initial NeoPixel Test Code

#include <Adafruit_NeoPixel.h>

#define NEOPIXEL_PIN  3     // GPIO number (NOT D3)
#define NUM_PIXELS    5

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

void setup() {
  pixels.begin();        // initialize NeoPixel
  pixels.clear();        // clear all pixels
  pixels.setBrightness(80);

  // turn ALL pixels ON (white)
  for (int i = 0; i < NUM_PIXELS; i++) {
    pixels.setPixelColor(i, pixels.Color(50, 50, 50));
  }
  pixels.show();
}

void loop() {
  // do nothing
}

Motion-Triggered Breathing LED Code

#include <Wire.h>
#include <Adafruit_MPU6050.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_NeoPixel.h>

// ---------- EDIT THESE ----------
#define I2C_SDA       8       // your SDA pin
#define I2C_SCL       9       // your SCL pin

#define NEOPIXEL_PIN  3       // use a GPIO number (NOT D3)
#define NUM_PIXELS    5
#define BASE_BRIGHTNESS  80   // max brightness during breathing (0-255)
// ------------------------------

// Motion detection tuning
float baselineG = 1.0f;
float AGITATED_DELTA_G = 0.30f;     // higher = needs stronger movement to count
uint32_t HIT_DEBOUNCE_MS = 250;     // prevent one shake from counting many times

// "5 times in a minute"
const int TRIGGER_HITS = 5;
const uint32_t WINDOW_MS = 60000;   // 1 minute

Adafruit_MPU6050 mpu;
Adafruit_NeoPixel pixels(NUM_PIXELS, NEOPIXEL_PIN, NEO_GRB + NEO_KHZ800);

// We store hit timestamps to implement a rolling 60s window
uint32_t hitTimes[32];  // enough room for plenty of hits
int hitCount = 0;

uint32_t lastHitMs = 0;

float mag3(float x, float y, float z) {
  return sqrtf(x*x + y*y + z*z);
}

void setAll(uint8_t r, uint8_t g, uint8_t b) {
  for (int i = 0; i < NUM_PIXELS; i++) {
    pixels.setPixelColor(i, pixels.Color(r, g, b));
  }
  pixels.show();
}

void calibrateBaseline() {
  const int samples = 200;
  float sum = 0;
  for (int i = 0; i < samples; i++) {
    sensors_event_t a, g, t;
    mpu.getEvent(&a, &g, &t);
    float accelMagG = mag3(a.acceleration.x, a.acceleration.y, a.acceleration.z) / 9.80665f;
    sum += accelMagG;
    delay(5);
  }
  baselineG = sum / samples;
}

// Remove hits older than 60 seconds
void pruneOldHits(uint32_t now) {
  int writeIdx = 0;
  for (int i = 0; i < hitCount; i++) {
    if (now - hitTimes[i] <= WINDOW_MS) {
      hitTimes[writeIdx++] = hitTimes[i];
    }
  }
  hitCount = writeIdx;
}

void addHit(uint32_t now) {
  if (hitCount < (int)(sizeof(hitTimes) / sizeof(hitTimes[0]))) {
    hitTimes[hitCount++] = now;
  } else {
    // If array full, drop oldest by shifting left (rare)
    for (int i = 1; i < hitCount; i++) hitTimes[i - 1] = hitTimes[i];
    hitTimes[hitCount - 1] = now;
  }
}

// Smooth breathing brightness: 0..BASE_BRIGHTNESS..0
// Uses a sine wave for soft transitions.
uint8_t breathingBrightness(uint32_t now) {
  // period of one full inhale+exhale (ms)
  const float periodMs = 7000.0f; // slower breathing, tweak if you want
  float phase = fmodf((float)now, periodMs) / periodMs; // 0..1

  // sine wave mapped to 0..1
  float s = 0.5f - 0.5f * cosf(2.0f * PI * phase);

  return (uint8_t)(s * BASE_BRIGHTNESS);
}

void setup() {
  Serial.begin(115200);
  delay(200);

  pixels.begin();
  pixels.clear();
  pixels.show();

  Wire.begin(I2C_SDA, I2C_SCL);
  Wire.setClock(400000);

  if (!mpu.begin()) {
    // blink red if MPU not found
    while (true) {
      setAll(60, 0, 0); delay(200);
      setAll(0, 0, 0);  delay(200);
    }
  }

  mpu.setAccelerometerRange(MPU6050_RANGE_8_G);
  mpu.setGyroRange(MPU6050_RANGE_500_DEG);
  mpu.setFilterBandwidth(MPU6050_BAND_21_HZ);

  // ready indicator
  setAll(0, 0, 20);
  calibrateBaseline();
  setAll(0, 0, 0);
}

void loop() {
  uint32_t now = millis();

  // Read accel
  sensors_event_t a, g, t;
  mpu.getEvent(&a, &g, &t);

  float accelMagG = mag3(a.acceleration.x, a.acceleration.y, a.acceleration.z) / 9.80665f;
  float delta = fabsf(accelMagG - baselineG);

  // Rolling minute window maintenance
  pruneOldHits(now);

  // Detect an "agitated" movement event
  if (delta > AGITATED_DELTA_G && (now - lastHitMs) > HIT_DEBOUNCE_MS) {
    lastHitMs = now;
    addHit(now);

    // optional tiny feedback flash
    // setAll(20, 0, 20); delay(20); setAll(0,0,0);
  }

  bool breathingMode = (hitCount >= TRIGGER_HITS);

  if (breathingMode) {
    // Breathing: dim in/out smoothly
    uint8_t b = breathingBrightness(now);
    pixels.setBrightness(b);

    // Choose a calming color (teal). Change if you want.
    for (int i = 0; i < NUM_PIXELS; i++) {
      pixels.setPixelColor(i, pixels.Color(0, 40, 80));
    }
    pixels.show();

  } else {
    // Calm state: lights off (or very faint)
    pixels.setBrightness(255);
    setAll(0, 0, 0);
  }

  delay(20);
}

What does it do?

This project is a wearable electronic jewelry piece composed of custom PCB-based LED beads connected through braided conductive wiring. The system integrates light, motion, and biometric sensing, allowing the jewelry to function as an active, responsive object rather than a static ornament.

The LEDs are controlled by a microcontroller, while body movement is sensed through an MPU6050 accelerometer and gyroscope, and biometric data is explored through a MAX30102 pulse reader. A button allows for direct user interaction, such as switching modes or resetting behavior.

The project explores the limits of electronics at jewelry scale, where fragility, surface area, and craft labor become dominant design constraints.

Who's done what beforehand?

This work builds on existing precedents in:

• wearable computing and electronic jewelry
• NeoPixel-based LED wearables
• soft circuits and e-textiles
• cyber-jewelry where electronics are made visible

Most existing examples rely on flexible PCBs, fabric substrates, or larger wearable formats. This project differs by focusing on:

• rigid PCB beads
• extremely small surface areas
• traditional jewelry logic (beads, braiding, modular assembly)

What sources did you use?

Technical sources

• HTMAA lectures and class documentation
• Adafruit NeoPixel documentation
• ESP32 documentation
• MPU6050 and MAX30102 datasheets
• Fab Academy PCB milling workflows

Design sources

• traditional jewelry construction methods
• craft practices involving repetitive hand labor
• Blob Creator for organic form generation
• Adobe Illustrator and Fusion 360 for layout and fabrication

What did you design?

I designed:

• the overall wearable system
• custom PCB bead geometries (hexagonal and organic blob forms)
• the electronic schematic and board layout
• the wiring and braiding strategy
• the physical assembly logic as a wearable object

What materials and components were used?

Electronics Components

• ESP32 microcontroller
• NeoPixel LEDs (WS2812-type, 5x)
• MPU6050 accelerometer + gyroscope
• MAX30102 pulse reader
• Momentary button
• Custom milled PCBs
• Magnet wire (enameled copper)
• Copper wire
• Solder (no flux used)
• USB cable

Materials

• FR-1 copper-clad board
• Copper wiring
• Solder
• Minimal insulation (identified as a limitation)

Where did they come from?

• Electronics components (ESP32, NeoPixels, MPU6050, MAX30102, button): Ordered on Amazon, coordinated through Anthony, and supplemented with MIT shop inventory.
• PCB material, wire, solder: Sourced from the MIT shop.
• Fabrication tools and machines: MIT Media Lab and shop facilities.

How Much did they cost? (approximate)

Item	Approx. Cost (USD)
ESP32 microcontroller	$8 – $12
NeoPixels (5x)	$5 – $8
MPU6050	$3 – $6
MAX30102	$8 – $15
Button	~$1
FR-1 copper board	~$5
Magnet wire	~$6
Copper wire + misc.	~$3
Solder	~$3
Estimated total	$40 – $55

What parts and systems were made?

• Custom PCB LED beads
• Integrated sensor system (motion + pulse)
• Electrical power and data distribution system
• Braided conductive wiring system
• Fully assembled wearable prototype

What tools and processes were used?

Design

• Hand sketching
• Blob Creator
• Adobe Illustrator
• Fusion 360 (schematic, PCB layout, CAM)

Fabrication

• PCB milling
• Extensive manual soldering
• Magnet wire scraping and preparation
• Wire braiding and jewelry-style assembly

Programming

• Arduino environment
• NeoPixel control code
• Sensor integration (MPU6050 and MAX30102)

What questions were answered?

• Can PCBs function as jewelry beads?
• How small can wearable electronics become before fragility dominates?
• Can motion and biometric sensors function at jewelry scale?
• How does craft labor scale in electronic fabrication?
• What happens when electronics are treated as ornament rather than hidden infrastructure?

What worked? What didn't?

What worked

• PCB design and milling
• LED control and system logic
• Braided wiring for redundancy and strength
• Conceptual framing of electronics as jewelry

What didn't

• Magnet wire insulation reliability
• Strain relief between beads
• Long-term durability
• Stability of extremely sensitive connections
• Full documentation of the working state

How was it evaluated?

• Functional LED testing
• Sensor testing during assembly
• Physical wear and handling tests
• Visual and spatial evaluation as jewelry
• Final review feedback

The system did function, but shorting occurred by the time of final presentation, preventing live demonstration.

What are the implications?

This project reveals:

• the limits of miniaturization in wearable electronics
• the necessity of insulation, encapsulation, and strain relief
• the overlap between electronics, craft, and labor
• how failure exposes critical design constraints

Future iterations would involve:

• encapsulated wiring
• improved connectors
• flexible PCBs or hybrid rigid-flex systems
• intentional documentation of functional moments

Sun Pendant PCB — Week 04-05 (October 2024)

What I tried

• Designed circular PCB with capacitive touch center and six LED rays in Fusion 360 Electronics
• Milled prototype on FR-1 using Roland SRM-20
• Soldered Seeed XIAO RP2040, LEDs, and resistors
• Programmed capacitive touch sensing and LED animations

Process notes

• Used Fusion 360 Electronics for schematic and board layout
• Material: FR-1 for prototype, planning ENIG finish for final version
• Components: XIAO RP2040, 6x warm-white LEDs, 470Ω resistors, 1MΩ for touch bias
• Programming: Arduino IDE with capacitive touch library

Results / Evidence

• Successfully milled and assembled first prototype
• Capacitive touch works reliably at jewelry scale
• LED animations create desired "breathing" and "chasing" effects
• Form factor works well as pendant—comfortable to wear
• Some challenges with LED brightness consistency (resolved with resistor adjustments)

Decisions

• Keeping the circular sun motif—it works both functionally and aesthetically
• Moving forward with ENIG gold finish for final version (jewelry-quality appearance)
• Refining LED placement and brightness for better visual effect
• Exploring battery power options for future iterations (earring designs)

Next steps

• Order final boards with ENIG finish from board house
• Refine firmware for more sophisticated light patterns
• Explore additional sensor integration (temperature, motion)
• Design mounting system (jump rings, chain, earring hooks)