Kaylan’s Sculptural Light


This interactive table light fixture was inspired by the work of famous mid-century designer, Gerrit Rietveld. Each panel is touch-activated and is independent from one another, allowing for endless color possibilities.



The making part went pretty smoothly since I’ve used acrylic in a previous project at POD.


1. Soldering

Pretty amazing how big of a difference 1mm makes. I initially bought 4mm extra narrow LED strip and it was impossible to solder. The wires kept falling off. I ended up getting a new 5mm strip last minute and it worked much better.

2. Switching from Huzzah back to Uno
Arduino Huzzah
Arduino Uno

I initially started on the Huzzah board but couldn’t figure out how to sync the LED strip to the sensors, even though the sensors were working. Because I didn’t need internet connectivity anyway, I decided to switch back to Uno.

3. Coding

Coding has always been my weakest skill. After a lot of back and forth, I came across the “buttoncycler” code which I was able to modify and perfected with the help of Becky.

4. Only 2 out of 3 panels work…

In the initial test, all 3 panels work perfectly independently but once assembled, in the first test run, something must have happened because the sensors become not so sensitive anymore and I had to tap repeatedly in different spots for quite a while to trigger the animation.

Edited version
Unedited version

Next Steps

  1. I would love to take apart the two panels that are not working and try to fix them.
  2. I did not anticipate the wires to be so bulky – makes sense since there are 4 from each panel – I would like to try using all white wires for a more refined minimal look.



Final Project Concepts

1. Thinking of you

This product comes in a pair, you keep one and gift a loved one the other. When you want to let the person know you’re thinking about them, you can place your palm onto the shape and the other person’s shape will light up. When both yours and their hand are on the shape, both will light up in a different color.

2. long ceiling lamp

Unlike most ceiling lamps which are globe-shaped and hang very high up, I want to create a sculptural light design that is quite flat and at eye level, which you can change the dimness by tapping the center or when you come closer, it dims.

3. FINAL – cube light

Each of the three panels has its own circuit so you can tap change the color on each individual panel by tapping them, allowing for fun, experimental, and truly customizable light experience.

Shopping List
– 3 Standalone Momentary Capacitive Touch Sensor Breakout – AT42QT1010
– frosted white acrylic sheets
– LED light strips
– Plastic glue
– Conductive tape

Kaylan as Edna Mode


Why this costume?
Although not the main character, Edna Mode is such an iconic and memorable character from The Incredibles animation saga. I really relate to her spunky attitude (have also been told many times how similar I am to her, personality and look-wise).

How was it to wear?
I didn’t take the weather into consideration when choosing this character but was grateful for this decision because her outfit is pretty covered up and I was able to add some warm layers to beef it up even more.

The LED pink neck piece was made out of felt so it was also very comfortable to wear.


1. Neckpiece

– 2 pieces of pink felt
– pattern designed on Illustrator
– hot glue gun
– velcro
– 2 6 LED bulbs strips
– battery
– Gemma
– pins
– wires
– soldering machine
– tubings
– wire tape

Cut out fabric from pattern
Fit test
Glue soldered circuit onto one side
Hot glue another piece of felt on top with a small opening for battery change.

2. Cigarette holder

– 1 bamboo straw
– paints
– paintbrush
– 1 red light bulb
– 1 resistor
– battery pack
– AA batteries
– wires
– soldering machine
– tubings
– wire tape

painting the straw to look like a cigarette holder
Wire left long and wrapped in black tape to fit nicely into one’s palm


// NeoPixel test program showing use of the WHITE channel for RGBW
// pixels only (won't look correct on regular RGB NeoPixel strips).

#include <Adafruit_NeoPixel.h>
#ifdef __AVR__
 #include <avr/power.h> // Required for 16 MHz Adafruit Trinket

// Which pin on the Arduino is connected to the NeoPixels?
// On a Trinket or Gemma we suggest changing this to 1:
#define LED_PIN     1

// How many NeoPixels are attached to the Arduino?
#define LED_COUNT  12

// NeoPixel brightness, 0 (min) to 255 (max)
#define BRIGHTNESS 70 // Set BRIGHTNESS to about 1/5 (max = 255)

// Declare our NeoPixel strip object:
Adafruit_NeoPixel strip(LED_COUNT, LED_PIN, NEO_GRBW + NEO_KHZ800);
// Argument 1 = Number of pixels in NeoPixel strip
// Argument 2 = Arduino pin number (most are valid)
// Argument 3 = Pixel type flags, add together as needed:
//   NEO_KHZ800  800 KHz bitstream (most NeoPixel products w/WS2812 LEDs)
//   NEO_KHZ400  400 KHz (classic 'v1' (not v2) FLORA pixels, WS2811 drivers)
//   NEO_GRB     Pixels are wired for GRB bitstream (most NeoPixel products)
//   NEO_RGB     Pixels are wired for RGB bitstream (v1 FLORA pixels, not v2)
//   NEO_RGBW    Pixels are wired for RGBW bitstream (NeoPixel RGBW products)

void setup() {
  // These lines are specifically to support the Adafruit Trinket 5V 16 MHz.
  // Any other board, you can remove this part (but no harm leaving it):
#if defined(__AVR_ATtiny85__) && (F_CPU == 16000000)
  // END of Trinket-specific code.

  strip.begin();           // INITIALIZE NeoPixel strip object (REQUIRED)
  strip.show();            // Turn OFF all pixels ASAP

void loop() {
  // Fill along the length of the strip in various colors...
  //colorWipe(strip.Color(255,   0,   0)     , 50); // Red
  //colorWipe(strip.Color(  0, 255,   0)     , 50); // Green
  //colorWipe(strip.Color(  0,   0, 255)     , 50); // Blue
  //colorWipe(strip.Color(  0,   0,   0, 255), 50); // True white (not RGB white)

  //whiteOverRainbow(75, 5);


  //rainbowFade2White(3, 3, 1);

// Fill strip pixels one after another with a color. Strip is NOT cleared
// first; anything there will be covered pixel by pixel. Pass in color
// (as a single 'packed' 32-bit value, which you can get by calling
// strip.Color(red, green, blue) as shown in the loop() function above),
// and a delay time (in milliseconds) between pixels.
void colorWipe(uint32_t color, int wait) {
  for(int i=0; i<strip.numPixels(); i++) { // For each pixel in strip...
    strip.setPixelColor(i, color);         //  Set pixel's color (in RAM)
    strip.show();                          //  Update strip to match
    delay(wait);                           //  Pause for a moment

void whiteOverRainbow(int whiteSpeed, int whiteLength) {

  if(whiteLength >= strip.numPixels()) whiteLength = strip.numPixels() - 1;

  int      head          = whiteLength - 1;
  int      tail          = 0;
  int      loops         = 3;
  int      loopNum       = 0;
  uint32_t lastTime      = millis();
  uint32_t firstPixelHue = 0;

  for(;;) { // Repeat forever (or until a 'break' or 'return')
    for(int i=0; i<strip.numPixels(); i++) {  // For each pixel in strip...
      if(((i >= tail) && (i <= head)) ||      //  If between head & tail...
         ((tail > head) && ((i >= tail) || (i <= head)))) {
        strip.setPixelColor(i, strip.Color(0, 0, 0, 255)); // Set white
      } else {                                             // else set rainbow
        int pixelHue = firstPixelHue + (i * 65536L / strip.numPixels());
        strip.setPixelColor(i, strip.gamma32(strip.ColorHSV(pixelHue)));

    strip.show(); // Update strip with new contents
    // There's no delay here, it just runs full-tilt until the timer and
    // counter combination below runs out.

    firstPixelHue += 40; // Advance just a little along the color wheel

    if((millis() - lastTime) > whiteSpeed) { // Time to update head/tail?
      if(++head >= strip.numPixels()) {      // Advance head, wrap around
        head = 0;
        if(++loopNum >= loops) return;
      if(++tail >= strip.numPixels()) {      // Advance tail, wrap around
        tail = 0;
      lastTime = millis();                   // Save time of last movement

void pulseBlue(uint8_t wait) {
  for(int j=0; j<256; j++) { // Ramp up from 0 to 255
    // Fill entire strip with white at gamma-corrected brightness level 'j':
    strip.fill(strip.Color(j, 0, 0, 0));

  for(int j=255; j>=0; j--) { // Ramp down from 255 to 0
    strip.fill(strip.Color(j, 0, 0, 0));

void rainbowFade2White(int wait, int rainbowLoops, int whiteLoops) {
  int fadeVal=0, fadeMax=100;

  // Hue of first pixel runs 'rainbowLoops' complete loops through the color
  // wheel. Color wheel has a range of 65536 but it's OK if we roll over, so
  // just count from 0 to rainbowLoops*65536, using steps of 256 so we
  // advance around the wheel at a decent clip.
  for(uint32_t firstPixelHue = 0; firstPixelHue < rainbowLoops*65536;
    firstPixelHue += 256) {

    for(int i=0; i<strip.numPixels(); i++) { // For each pixel in strip...

      // Offset pixel hue by an amount to make one full revolution of the
      // color wheel (range of 65536) along the length of the strip
      // (strip.numPixels() steps):
      uint32_t pixelHue = firstPixelHue + (i * 65536L / strip.numPixels());

      // strip.ColorHSV() can take 1 or 3 arguments: a hue (0 to 65535) or
      // optionally add saturation and value (brightness) (each 0 to 255).
      // Here we're using just the three-argument variant, though the
      // second value (saturation) is a constant 255.
      strip.setPixelColor(i, strip.gamma32(strip.ColorHSV(pixelHue, 255,
        255 * fadeVal / fadeMax)));


    if(firstPixelHue < 65536) {                              // First loop,
      if(fadeVal < fadeMax) fadeVal++;                       // fade in
    } else if(firstPixelHue >= ((rainbowLoops-1) * 65536)) { // Last loop,
      if(fadeVal > 0) fadeVal--;                             // fade out
    } else {
      fadeVal = fadeMax; // Interim loop, make sure fade is at max

  for(int k=0; k<whiteLoops; k++) {
    for(int j=0; j<256; j++) { // Ramp up 0 to 255
      // Fill entire strip with white at gamma-corrected brightness level 'j':
      strip.fill(strip.Color(0, 0, 0, strip.gamma8(j)));
    delay(1000); // Pause 1 second
    for(int j=255; j>=0; j--) { // Ramp down 255 to 0
      strip.fill(strip.Color(0, 0, 0, strip.gamma8(j)));

  delay(100); // Pause 1/2 second

Final Products

In the dark – at the parade


What I learned in the process

I was amazed by how many different skills were utilized for this project, from fashion design, prop design, soldering, to coding. Lots of creative problem solving.

Many things learned from working on the Plush Night Light project translate to this project as well. Like knowing which material to use, how to solder properly etc.

What I would do differently
– Take more process photos of the cigarette holder
– Use spray paint for a more polished look for the cigarette holder
– Experiment with more complex code for the neck piece’s animation

Edna Mode

My original idea was to be Sailor Saturn but unfortunately, the main costume won’t be delivered in time so I’ve decided to change to the character Edna Mode from The Incredibles instead.

I will be using a LED light bulb as the tip of her cigarette and have LED a strip running along the inside of the V-shaped pink neck piece.



Shopping list:

1. Cigarette holder
– Red LED bulb – check
– Hollowed bamboo straw – on the way
– cardboard – check
– paint – check
– battery – ?

2. Neck piece
– Satin pink fabric – still need to buy
– LED strip – on the way
– Velcro – check
– Wire – check
– Poly-fill – check
– Arduino – check

3. Other part of the costume
– Glasses – on the way
– Blazer – check
– Dress – check
– Tights – check




  1. Sailor Saturn

My main priority will be her staff. If it works out well, I’ll try to make her bow light up as well.

The blade will be made out of a metallic sheer fabric with LED strips inside. The rest of the outfit, I might buy online.

Shopping List

  • Wooden broom stick – body of the staff
  • Sheer metallic fabric
  • modeling clay/foam
  • on/off button
  • arduino kit
  • Led-strips
  • neopixel jewel
  • LED shoe laces

2. Space Age

I’ll be making this whole outfit from scratch. Both coat and headgear. The two circles on the coat will be lined with LED strips.

Shopping List
– White fabric
– Red fabric
– Led strips
– Zipper
– Patterns
– Arduino kit
– On/off

Charlie the Huggable Chimp

Meet Charlie, a huggable sleeping companion for kids who are afraid of sleeping alone in the dark. The glowing heart represents Charlie’s love for his buddy.

Light on close up
Light off
In the dark
1:1 Pattern
Handsewn/glue gun prototype
Using sewing machine
Tinkercad circuit
Unfortunately only 1 works, I’ll try to redo

Overall, besides the fact that I ran out of time to fix the two lights that didn’t work, this project turns out exactly how I envisioned. There was a lot of trial and error with getting the proportion right and finding suitable fabric.

In the end, this plush toy is perfectly sized and feels very comforting to hug. The soft light draws attention to the heart without being too blinding. Great as a sleep buddy for kids who are afraid of the dark.

It was a lot of fun to use a combination of new skills from soldering, electrical to sewing complex curves with the machine. I had a lot of fun.

With famous supermodel, Cathy

Kaylan’s Plush Toy

The common theme between my 3 concepts is animals with long arms because growing up, I love tying those parts together like ropes and hitting others with those arms.

  1. Octopus
    The suckers on the tenticles will be LED lightbulbs.
  2. Jellyfish
    The legs will each have a LED light strip inside and the body will have fading soft LED glow.
  3. Chimpanzee
    The chimpanzee’s arms will be long enough to hug behind the neck of a child. The magnets at the end will keep them together. The lightbulbs will outline the felt heart, flashing as if the heart is beating.

Roku 1 Media Streamer + Remote Teardown

Roku 1, Remote, and Charger before taken apart

List of the tools and techniques you used to take it apart

– Small screwdrivers for wedging the plastic casing apart and unscrewing the PCB from the bottom casing.

Multiple screwdrivers were needed since it was so tightly shut

– Large flathead screwdriver for prying the casing open.

The yellow screwdriver provided enough support and force to yank it open.

– Small wire-cutting plier for cutting the faraday shields.

The shield came off very easily with this plier

Materials and techniques used for each component

Overview of all the parts

1. Roku’s and Remote casing – made out of ABS plastic. The plastic is heated and injected into a mold to take the shape of the case.

2. Faraday shield – made out of thin aluminum. Made to enclose and block electromagnetic fields.

3. Toshiba TC58NVG1S3HTA00 flash memory – made out of plastic/epoxy

4. Button pad – made out of silicone rubber using a mold. The design and color are UV printed.

5. Circuit board – made out of a combination of prepreg, laminate, copper foil, soldermask, nomenclature, final finish.


1. Toshiba TC58NVG1S3HTA00 – storing data?

2. Samsung K4B4G1646D-BYK0 DRAM Chip – storing data?

3. Broadcom BCM7218 – The brain of the system

4. Broadcom BCM43143 – Wifi IC.

Two interesting design elements

1. The Roku’s plastic case is very tightly shut. I assumed that it was held together with glue since it was so difficult to pry apart but ended up finding no glue at all. It was designed with edges that lock the parts together which does a good job securing all the parts within so that no one will unintentionally open it. 

2. The sheet of buttons is also very fascinating. The way all the raised buttons are connected on a sheet to make sure they all stay together and in order so nothing will get lost or reorganized.