For my halloween project assignment I wanted to make something that would be easily portable and detachable without the need for execessive fabric, components, or deep storage.

I wanted the LED part to make sense as an effective component that would help me communicate my costume not add an extra layer to it.

In thinking of the best scifi characters I’d seen I stumbled across a favorite that I often go back to as a reference — Eve, the robot from Wall-E.

Eve

I liked how expressive Eve’s eyes are in comparison to her otherwise sterile Apple inspired form. Not only where her eyes useful for expressing her mood and character, they also seemed to have a specific pattern of states the character designers repeated across the film. This would be perfect for my costume idea and would also lend itself to a clean detachable wearable.

Components

In selecting compontents that would work for my costume I was extra selective of visors/sunglasses that would fit the futuristic aesthetic I was lookign for but also would provide enough ‘real estate’ to house all of the necessary components while still allowing me to see.

This was the same story with lighting and while being knowledgable enough to know I should not dive into wiring together a bunch of strips, I didn’t know enough about what I should order. Again I read product dimensions for a series of different lights in order to decide what would best fit and I also did a few drawings of the different eye states to validate that and 8×8 matrix grid would work to communicate my design.

The Code

Once I ordered all compontents, I dove into the code part. After some initial research I knew that making the different eye states would be simple enough, as I’d just be telling which pixel to turn on in each of my grids — and boy was I wrong.

Setting up the Pins and Color were pretty straightforward and looked clean in the code.

The state switching to button press was also relatively straightforward even though I inititially thought we could use the native switch on the Gemma which come to find out is a hard-wire reset button.

Even setting up the eye states were pretty simple although alot of manual work trying to not mistype coordinate data for the x and y positions.

What was a challenge was the coordinate setup for the LED matrices and the way to make it work for two different light panels.

The Wiring

When I did the initial wireup test on the Arduino and bread-board I had only tested it with a single matrix, assuming it would be easy to extend the display to the second matrix. This was something I struggled with later on once wiring to my final Gemma version.

With help from Manya, I wired up my visor with everything installed and taped up nicely and to my surprise it was no longer working

With trouble shooting support from Becky, I realized it was a wiring issue. I insisted I had wired it perfectly but deep down I knew that it was too ‘perfect’ to be true. I had taped up and packaged everything so nicely that I was bound to have to go back and undo some of it.

I then realized that when wiring up my board I had been looking at the OUT nodes on my LED matrix and so the wires going IN were in the wrong order.

I rewired it…

It’s working!! Sort of….

I had one eye working at this point (and one dot in the second panel for some reason). This is the part I fought with in the end as I really wanted to tell the code my 8×8 matrix was a 16×8 matrix to basically extend the display.

While setting that up I began tweaking my states to reflect a 16×8 grid. However once setup the second eye didn’t wouldn’t display the eye correctly. The eye was always backwards or rotated or skewed in a different direction.

At one point I even ripped off the second eye and manually rotated the panel 180 degrees in the hope that it would fix this problem — it didnt and I ended up mirroring the displays which proved to be a really simple fix.

At this point I wanted something to show for all of my fiddling so I decided to continue with my original plan and add a blink animation to my eyes to give them more character. Instead of animating a blink I went with just togglign between the states and a blink state which is just a horizontal line. In the code it toggles to a blink every 6 seconds with a 250ms blink.

In the end

I learned alot from this process and while my costume looks more like a creepy NEO facotry robot more than it does Eve from Wall-e, I’m happy with the result.

If I were to take this process a step further I’d want to increase visibility in the visor while also finding a way to hook up a smaller battery in the visor to make it more self contained.

https://docs.google.com/presentation/d/1O_y3t_LMQEgUsuWVn4fftuYmNXf8ajmH0e4Q5ACRW4Y/edit?usp=sharing

Description and Intention

This project recreates the iconic “?” Question Box from the Super Mario video game series as an interactive prop.
When someone punches or taps the bottom of the box, it lights up brightly and plays a Mario coin sound, just like in the game when Mario collects a coin or power-up.

The intention behind this costume prop is to bring nostalgia and fun to Halloween.
It’s not designed to scare people — it’s designed to make people smile and feel like they’re inside the Mario world.
When friends see the glowing box and hear the coin sound, they immediately recognize it and often want to “hit” it themselves!
It’s both interactive and playful, perfect for a group or gaming-themed costume.

Concept:
Inspired by the iconic Question Block from the Super Mario games, this interactive box lights up and changes color whenever it’s “hit” from below — just like in the game when Mario punches it to release a coin or power-up.
The project uses NeoPixel LEDs for vivid lighting effects and an impact sensor (or push button) at the bottom to detect the punch or tap.

Objective:
To recreate a nostalgic video game interaction using Arduino and NeoPixel LEDs, demonstrating how sensors can trigger real-time lighting animations.

Take Away…

I chose the Mario Question Box as my Halloween costume because Super Mario has always been one of my favorite games. I’m obsessed with its playful, dynamic style—so I decided to bring the iconic question mark box to life! My first plan was to buy the costume online and then build the box myself. After discussing the idea with Becky, I began modeling the design, bought two rolls of filament, and started 3D printing in the wood shop. Everything went smoothly, except for the printing time—it took almost two full days! Thankfully, Becky kindly provided me with a sound board, and Wini helped me a lot with the circuit assembly.Besides， thanks for woodshop staff members helping me to set up the printer!

During the soldering phase, I experimented with different ways to prevent short circuits on the Gemma board while ensuring there was enough power for the speaker. It was a long and sometimes frustrating process, but eventually, the LEDs worked perfectly and the soundboard played flawlessly. Through this project, I learned two important lessons: patience in problem-solving and the true value of teamwork.

If I had the chance to redo it, I would design a more elastic mechanism to switch the lights on and off, and connect the sound board to a more stable power source for better performance.

Thank You!

What my costume is:
For this project, I chose to cosplay Karen, the electronic wife of Plankton from SpongeBob SquarePants.
I mainly focused on recreating Karen’s head—the computer screen, and turned it into a handheld interactive device.
To complete the look, I paired it with a silver outfit that enhances the metallic, robotic feel of the character.

Why I made it:
I grew up watching SpongeBob SquarePants, and Karen has always been one of my favorite characters.
Cosplaying an intelligent computer felt both funny and fascinating—it’s not just a character, but also a machine with a personality.
Another reason I wanted to make this costume is the interactive potential: I can design multiple facial expressions and animations for the screen and switch between them during the Halloween parade, which makes the performance dynamic and playful.

How it is to wear it:
Since the device is handheld, I carried it throughout the parade.
The grip felt quite comfortable and the overall weight was manageable.
It was fun to hold and show to others, although I did notice that the screen tended to tilt slightly forward when posing for photos—something I’ll try to adjust in the future.

What I learned in the process:
This project taught me a lot—from building circuits based on my own design, to modifying Arduino code and making my idea come to life through interactive electronics.
It was a great opportunity to overcome my fear of circuitry and programming.
Now I feel much more confident about creating interactive and responsive objects in future design projects.

What I would do differently:
If I had more time, I would add more animated expressions to the screen.
Right now, Karen only has three facial states, but adding more—like a dramatic shift from a happy face to an angry red one, then transitioning into moving lines—could create a small visual “storyline.”
That would make the character’s expression and behavior even more alive and theatrical.

List (with links) of materials and parts used

1️⃣ BTF-LIGHTING WS2812B 16×16 RGB LED Matrix Panels (2 packs)
https://www.amazon.com/dp/B09XWQTZZN?ref=ppx_yo2ov_dt_b_fed_asin_title&th=1 (Wini Recomand)

2️⃣ Arduino Gemma Microcontroller Board

3️⃣ Push Button Switch

4️⃣ Black Translucent Acrylic Sheet (VFL)+ Black Silicone Sealant（Borrowed from Wini）
5️⃣ Foam Board

6️⃣ Silver Metallic Cardstock Paper （Bought from Blick)

7️⃣ Electrical Wires for Soldering

8️⃣ Portable Power Bank

Circuit diagram

Arduino code

In-progress images/sketches

🙏 Special Thanks

Huge thanks to Wini — honestly, I couldn’t have even started this project without her. She helped me with everything — from figuring out the circuit wiring to writing and debugging the Arduino code. She was super patient and always there when I got stuck. I’m so, so grateful for all her help.
And also to Jay, who gave me tons of guidance with the circuit setup — your advice really made things a lot smoother.

Thank you both so much!

The thought behind the project

The severed Minecraft head is a prop for a halloween costume, acting like a trick or treat basket. Constructed from acrylic/polyethylene/polypropylene sheets, the head is painted with the signature pixelated aesthetic and features internal RGBW LED strips inside the box. The primary function is to express four distinct “moods”—Angry (red light), Sad (blue light), Disgust (green light), and Happy (yellow light)—by dynamically shifting the color of the internal lighting. The basket includes a red handle and a “severed neck” base, with black paint for the eyes and mouth, ensuring both visual impact and a clear pathway for the light to shine through. The shades of the pixels are created by painting multiple coats of acrylic paint on the surface to help create a opaque and translucent light dispersal.

The prop’s intention is to blend the nostalgia of my brother and my shared love for Minecraft with a playful Halloween fright. By presenting the instantly recognizable Creeper head in a dark context—a “severed neck” basket—it introduces a darkly humorous twist on a beloved game element. The dynamic, shifting NeoPixel lights (from “angry” red to “sad” blue) use in-game visuals to create an eerie, mood-depicting glow, transforming our childhood interests into a uniquely personal and subtly unsettling costume piece.

Materials & Parts

• 1/4″ white translucent acrylic sheet – For the main structure, laser cut to make a 8×8″ cube. Purchased from the VFL.
• (2) RGBW LED Neopixel Sticks – For the light source, I had one in my kit. Borrowed another one from Jay.
• Adafruit Gemma M0 – For the code, already there in my kit.
• Electrical wires – For the light source, already there in my kit.
• USB Battery Pack – For the battery, already there in my kit.
• Solder – For the light source, taken from the VFL.
• Acrylic paint – For the tones in the light, to paint the pixels on the inside surface of the sheet.
• Acrylic cement – Solvent that helps join the acrylic together.
• Paint brushes – To paint the pixels. Already had them, any paintbrushes work.
• Hot glue gun – To glue the top and bottom to the acrylic box. Taken from PoD.
• Foam board – To make the severed neck of the head. Already had some.
• 2.5 mm wire – To make the handle, taken from the VFL.

TinkerCAD circuit

https://www.tinkercad.com/things/39yYl1YGqdN-halloween-tinkering

Code

Process

The Plague Doctor

My Halloween costume is composed of three main parts: a 3D-printed white PLA crow mask, a black cape with a hood, and a set of three mechanical finger claws. The mask takes most of the technical work. I first used the Polycam app to scan my head and modeled the crow form around it so it would fit perfectly.

Each eye has a 12-pixel NeoPixel ring, friction-fit into an indent with wiring channels and openings for two frosted acrylic donut-shaped plates that diffuse the light. A small side button placed near my temple switches between two light patterns—a loading animation and a red glowing one.

All electronics sit inside the mask, with the wiring taped neatly along the inner surface. Felt pads and EVA foam along the edges add comfort where it touches the face, and an elastic headband—stitched through pre-modeled holes—keeps it secure. The circuit board itself is sewn to the back of the band, making everything self-contained.

The cape is store-bought, simple, and helps emphasize the mysterious silhouette of the mask.
The finger claws are fully mechanical: each uses a parallelogram linkage system that extends or retracts the claw as I curl and straighten my fingers, creating a kind of living, mechanical gesture.

Wearing it feels quite straightforward. The claws are pretty identical, so I marked them inside to avoid confusion when putting them on. The mask, however, demands more patience. Since the wiring runs along the same path as the elastic band, the band stretches but the wires don’t, which sometimes causes them to curl up or catch slightly in my hair. The visibility is also limited—mainly because the eye holes are thickened to fit both the LED rings and the acrylic diffusers—so it feels like looking through a narrow tunnel of light.

Through this project, I get to integrate electronics with 3D-printed structures for the first time—how to design around wires, embed boards, and plan assembly digitally before making it physical. I also learned about comfort, weight, and cable management that only appear when you actually wear what you’ve built. If I were to do it again, I would refine the eye geometry to widen the field of view and create more space between the LED ring and the acrylic to enhance the diffusion effect. I would also add more internal padding, especially near the forehead, to keep the wires from pressing awkwardly against the skin.

Material List

1. 3D pRinter (https://us.store.bambulab.com/products/a1?from=navigation)
2. PLA filament (https://us.store.bambulab.com/products/pla-matte)
3. Neo-Pixel Ring *2 (https://www.adafruit.com/product/1643)
4. Electrical Tape (https://www.amazon.com/Avery-Dennison-Electrical-Commercial-Insulating/dp/B0DQKJV3J4/ref=sr_1_1_sspa?crid=2EQY92WV5OXXZ&dib=eyJ2IjoiMSJ9.lNltt7cumfXsZCkJlMxFYYmx3VDRxwNZBWDZ6mlwLvOONifJA0cbp78rUD3IUGnUBvTgeALCPv1XYlRk49YMiQcDfasuAocTQKEx0ukAZe4KMaFOgrWSC-I5Hq4JO5K8iaXtCNuLT73f79heuIttAIeKtHWw0fzF2GeUK58IKy_nhB-tkTxc7c1VouFUgAj6QsIeQWvo1lfSxh4sSySpATnl2hiqPk1k5m_RY5Fg91ojRj3V-GyE6N9Kb6xyM4gzwqog3yt4mFePmF_iSGklsKl0BiICiTtYsUYw01d_A30.XL2Oq-d_vKzHNwKh_-I81-xds2quiTYmpFHD4Gb_WYk&dib_tag=se&keywords=electrical%2Btape&qid=1762299049&s=industrial&sprefix=electrical%2Btap%2Cindustrial%2C263&sr=1-1-spons&sp_csd=d2lkZ2V0TmFtZT1zcF9hdGY&th=1)
5. Wires (https://www.amazon.com/TUOFENG-Hookup-Wires-6-Different-Colored/dp/B07TX6BX47/ref=sr_1_1?crid=KVXX8XCZZ5NZ&dib=eyJ2IjoiMSJ9.7QKOdOh0TX6RJzvhBg5Wt1hMobRmxA8YSVMtDCQYCIWI36E-BTkWi1kmCKoq1bvwgGOWhBP7xjQOfb1znb9dQG8fNdqo_7EdUEhqQcJYXGXaPngwFeiIRaaDJqGL22EBsCL5HPtJkmogqW8nxikbR8RWb2fhLNQ1Ed6hr-aQEMO7HF27m281Ci0bJsmk2aptTEuFhorgAikTcjRD_azFEjU_Q0_Pj-SqXF8GHJeWxYEaMiZGTUnc1Fjd2JtemYwE-XwELjimlfLSCtwjFk5NE44CRLG4MdSieIm3UtuSO4I.TIY2x1I6rTAkLZ9KPQinD521UtCnT1EoPmRl5swzVQ8&dib_tag=se&keywords=wire&qid=1762299071&s=industrial&sprefix=wi%2Cindustrial%2C355&sr=1-1&th=1)
6. EVA Foam 4mm (https://www.amazon.com/Premium-Cosplay-Density-Projects-MEARCOOH/dp/B0BC8RN251/ref=sr_1_1_sspa?crid=OG4F3FRY7IT6&dib=eyJ2IjoiMSJ9.oPwXWY4rs4WfXiN6Et0T3JOS4TOqEbsVcFm2sRnqlYmqM5P59vwxAtHcVN488Osa8uvGeV5EbCFbyara6aSjwubKr3pnUazGggwwY1xf2cLWo2Uymwpj7HV4lIfwh0fLrTBF0TNdTa32R0av8xp_AX2_dvvUmE3kZpkZ4RjcI7se38bam_a-scvIHRL4ZtJSUJ_mfe9-8mNvsRj-DG6mw5x4uMSJ2D2KbgSxcKpQL9Ujy29yiW7jzMqWmgRTnrMKVB8rruPGn5h-4F3N8cUmgWDRETmiJsUgBhw-BaWLw6w.Uqkh7_Iq5tuSXMyyYD7P3O6MwU1GlZdZ–vCyWuuAQ8&dib_tag=se&keywords=eva%2Bfoam&qid=1762298981&s=industrial&sprefix=eva%2Bfoam%2Cindustrial%2C204&sr=1-1-spons&sp_csd=d2lkZ2V0TmFtZT1zcF9hdGY&th=1)
7. Frosted Acrylic (https://www.amazon.com/dp/B07R9YJ29T?ref=ppx_yo2ov_dt_b_fed_asin_title)
8. Cape (https://www.amazon.com/dp/B0DSRPDYDZ?ref=ppx_yo2ov_dt_b_fed_asin_title&th=1)
9. GEMMA M0 (https://www.adafruit.com/product/3501)

Circuit Diagram

Arduino code

#include <Adafruit_NeoPixel.h>

// Pin definitions
#define BUTTON_PIN 0
#define RING1_PIN 1
#define RING2_PIN 2
#define NUM_LEDS 12

Adafruit_NeoPixel ring1 = Adafruit_NeoPixel(NUM_LEDS, RING1_PIN, NEO_GRB + NEO_KHZ800);
Adafruit_NeoPixel ring2 = Adafruit_NeoPixel(NUM_LEDS, RING2_PIN, NEO_GRB + NEO_KHZ800);

int currentMode = 0;
int buttonState = 0;
int lastButtonState = 0;
unsigned long lastDebounceTime = 0;
unsigned long debounceDelay = 50;

int loadingPos = 0;
unsigned long lastLoadingUpdate = 0;
int loadingDelay = 100;

bool oddLedsOn = true;
unsigned long lastAlternateUpdate = 0;
int alternateDelay = 250;

void setup() {
  pinMode(BUTTON_PIN, INPUT_PULLUP);
  
  ring1.begin();
  ring2.begin();
  ring1.show();
  ring2.show();
  ring1.setBrightness(50);
  ring2.setBrightness(50);
}

void loop() {
  handleButton();
  
  if (currentMode == 0) {
    loadingPattern();
  } else {
    alternatingRedPattern();
  }
}

void handleButton() {
  int reading = digitalRead(BUTTON_PIN);
  
  if (reading != lastButtonState) {
    lastDebounceTime = millis();
  }
  
  if ((millis() - lastDebounceTime) > debounceDelay) {
    if (reading != buttonState) {
      buttonState = reading;
      
      if (buttonState == LOW) {
        currentMode = 1 - currentMode;
        
        clearRings();
      }
    }
  }
  
  lastButtonState = reading;
}

void loadingPattern() {
  if (millis() - lastLoadingUpdate > loadingDelay) {
    lastLoadingUpdate = millis();
    
    for (int i = 0; i < NUM_LEDS; i++) {
      if (i == loadingPos || i == (loadingPos + 1) % NUM_LEDS) {
        ring1.setPixelColor(i, ring1.Color(0, 0, 0));
      } else {
        ring1.setPixelColor(i, ring1.Color(255, 255, 255));
      }
    }
    
    for (int i = 0; i < NUM_LEDS; i++) {
      int mirrorPos = (NUM_LEDS - loadingPos) % NUM_LEDS;
      if (i == mirrorPos || i == (mirrorPos + 1) % NUM_LEDS) {
        ring2.setPixelColor(i, ring2.Color(0, 0, 0));
      } else {
        ring2.setPixelColor(i, ring2.Color(255, 255, 255)); 
      }
    }
    
    ring1.show();
    ring2.show();
    
    loadingPos = (loadingPos + 1) % NUM_LEDS;
  }
}

void alternatingRedPattern() {
  if (millis() - lastAlternateUpdate > alternateDelay) {
    lastAlternateUpdate = millis();
    
    oddLedsOn = !oddLedsOn;
    
    for (int i = 0; i < NUM_LEDS; i++) {
      if ((i % 2 == 0 && oddLedsOn) || (i % 2 == 1 && !oddLedsOn)) {
        ring1.setPixelColor(i, ring1.Color(255, 0, 0));
        ring2.setPixelColor(i, ring2.Color(255, 0, 0));
      } else {
        ring1.setPixelColor(i, ring1.Color(0, 0, 0));
        ring2.setPixelColor(i, ring2.Color(0, 0, 0));
      }
    }
    
    ring1.show();
    ring2.show();
  }
}

void clearRings() {
  for (int i = 0; i < NUM_LEDS; i++) {
    ring1.setPixelColor(i, ring1.Color(0, 0, 0));
    ring2.setPixelColor(i, ring2.Color(0, 0, 0));
  }
  ring1.show();
  ring2.show();
}

Powerpuff Girls with LED Light-Up Oversized Eye glasses👓✨

Hi! We’re the Powerpuff Girls!
Batu❤️(Blossom), Jisu💚(Buttercup), Yennie💙(Bubbles)

Batu❤️, Jisu💚, and Yennie💙

Descriptions:

Throughout the process, we faced several challenges, especially when soldering the two LED rings without causing errors.
We all participated in soldering, helping each other and working together to solve the issues. We also encountered coding errors during the setup.
In the final assembly, we faced a problem where the red light appeared green—possibly due to a soldering issue. We adjusted parts of the code to fix this color error.

Making Process

Yennie_Mainly focused on creating the glasses and coding.

Code

Links

Key Takeaways🎃

Yennie : I’m really glad to have worked with Jisu and Batu, who are both spontaneous and very supportive. We never felt disappointed when our soldering failed, the lights didn’t turn on, or coding errors occurred — instead, we just laughed it off and kept trying to figure things out together.

Jisu : I was so happy to be one of the Powerpuff Girls with Yennie and Batu. We cheered each other up even when our soldering or coding didn’t work, and those moments turned into such fun and meaningful memories. It wasn’t just about finishing the project, we genuinely enjoyed the process, laughed a lot during our late-night problem-solving, and supported each other every step of the way.

Batu : I was really excited to collaborate with two creatives whose work I admire. It was so much fun working with Yennie and Jisu — printing shirts with Jisu and soldering and coding with Yennie were definitely the highlights. If we were to make a second version of this project, we’d probably focus more on improving the cabling and soldering, since the red glasses sometimes worked and sometimes glitched. We shared so many laughs in the studio — such a great experience overall.

Thanks for reading🌻

Making my Edward Scissorhands costume was really fun! I feel like I was finally able to bring all my goth dreams to life. I’ve always been interested in incorporating technology into clothing and this was my first project doing so and I’m pretty proud of how it turned out.

Starting out, I ordered my gloves and Becky recommend 3d printing the Scissorhands (I was considering chipboard or foil initially). I slowly realized though that pushing myself beyond that which I already knew and collaborating with my peers was way better than sticking to what I already knew. I started out by printing one scissorhand out to test it then printed the rest. Jimmy helped me with 3d printing and ofcourse the VFL staff!

I then moved on to soldering. Based on my tinkercad, I knew soldering was a big part of my project and it did end up taking a lot of time. I had to measure out how long the wires had to be for each scissorhands and use black wiring only to add to the goth look which made the whole thing confusing at times. Using the gemma was also very new to me and thanks to Kyle and Becky, I was able to understand it better. I started out with trying out one neopixel on the arduino uno and breadboard (known territory) to test it out – and it went well and then moved on to the gemma ( unknown territory).

The back is maybe not the prettiest 🤣maybe in the future I will try to 3d print in a way to insert the wires through the Scissorhands. I did use some black canvas cloth though to cover up all the wiring.

The final step on my journey was the code. I have to admit this was the hardest step even though I initially assumed it would take the least amount of time. Becky initially taught me how to use the serial monitor to test the bend for the flex sensor. I then worked with Kyle to convert this into code. We were able to get the sensor to work but it only went from white to multicolor not white to red like I hoped. I looked up why this might have been happening and chat gpt told me perhaps the gemma couldn’t handle 40 leds and I doubted this was true.

Thanks to Becky though, on the day of Halloween, she told me I just had to change my code from RGB to RGBW and although it worked for like a second, it ending up leading to a short circuit and I wasn’t able to take any pictures ☹️. Super bummed about that because I worked really hard on this but this program has taught me to expect the unexpected. I came back in on Monday and realized the sodder was touching two pins on a neopixel so once I fixed that and rebooted the gemma, IT WORKED 🥳. It felt amazing to see my hard work come into fruition.

Materials and Parts

Costume Build: gloves (https://tinyurl.com/mwx8ranh), Black canvas cloth, E600 (https://www.michaels.com/product/e6000-amazing-crafting-glues-multipack-10269679) filament (https://www.amazon.com/dp/B0F18YP1CJ?ref=ppx_pop_dt_b_product_details&th=1) , 3d printer

Electronics core: Gemma, wires, 1 Flex sensor (https://www.adafruit.com/product/1070), 10kΩ resistor, 5 470Ω resistors, 5 neopixel sticks (thanks to my classmates), sodder equipment, shrink tubing

Power System: power bank, USB cable

Circuit Diagram

https://www.tinkercad.com/things/eN3zMSDHtZz-copy-of-rhea-oct-30

Arduino Code

BIG thank you to Jimmy, Manya, Anusha, Chris, Yiran, Tristan (and everyone that lent me their neopixels!), Kyle, Huy, Gabriel and ofc Becky <3

Thank you!

The Luxe Capacitor

DESCRIPTION:
I started out aiming to recreate the Flux Capacitor from Back to the Future, as part of my Marty McFly costume. I wanted to recreate a prop as I’m interested in prop design, and design for entertainment. However, I wanted to put my own spin on it, and decided that I would make a Luxe Capacitor, and I would wear it be wearable.

I came away with quite a few learnings from this process. Overall, I struggled to figure out the order in which to complete steps. For example, I spray painted individual components and then realized that it prevented adhesion when I started to glue everything together. Upon completion, I think I have a better (not perfect) sense in how I would order my to do list if repeating this process. I created my own dielines for the box (which I then laser cut), and I made the mistake of not leaving extra room for the insert to fit into the box. Lastly, I didn’t test my circuit while soldering. It worked out, but if I encountered errors then I wouldn’t have had any idea which connection was causing the issue.

PROGRESS:

MATERIALS:

Hardware
– 3 RGBW NeoPixels (8 LEDs per strip)
– Adafruit Gemma M0
– Tactile Switch Button
– Power Bank

Other Supplies
– Chipboard
– Solder
– Stranded Wire
– Gold Spray paint
– Transparent polyester film (from Artist & Craftsman Supply)
– Clear PVC tubing (from Canal Rubber)
– Thin silicon tubing (from Canal Rubber, leftover from 3DPD1)
– Hose (from Canal Rubber)
– Large flat washers (from Canal Lighting & Parts)
– Chain (from Canal Lighting & Parts)
– Gold lable tape
– Silicon Spark plug Boot
– Paint for spark plug (orange, yellow)

Tools
– Soldering Iron
– Wire Snips
– Wire Strippers
– Hot Glue Gun/
– Box Cutter/X-Acto
– Label Maker (Thank you Tristan!)
– Drill

CIRCUIT DIAGRAM:

ARDUINO CODE:

// Simple demonstration on using an input device to trigger changes on your
// NeoPixels. Wire a momentary push button to connect from ground to a
// digital IO pin. When the button is pressed it will change to a new pixel
// animation. Initial state has all pixels off -- press the button once to
// start the first animation. As written, the button does not interrupt an
// animation in-progress, it works only when idle.

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

// Digital IO pin connected to the button. This will be driven with a
// pull-up resistor so the switch pulls the pin to ground momentarily.
// On a high -> low transition the button press logic will execute.
#define BUTTON_PIN 0  // Gemma M0 D0 for button input

#define PIXEL_PIN 1  // Digital IO pin connected to the NeoPixels (Gemma M0 default)

#define PIXEL_COUNT 8  // Number of NeoPixels

// Declare our NeoPixel strip object:
Adafruit_NeoPixel strip(PIXEL_COUNT, PIXEL_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)

boolean oldState = HIGH;
int     mode     = 0;    // Currently-active animation mode, 0-9

void setup() {
  pinMode(BUTTON_PIN, INPUT_PULLUP);
  strip.begin(); // Initialize NeoPixel strip object (REQUIRED)
  strip.show();  // Initialize all pixels to 'off'
}

void loop() {
  // Get current button state.
  boolean newState = digitalRead(BUTTON_PIN);

  // Check if state changed from high to low (button press).
  if ((newState == LOW) && (oldState == HIGH)) {
    // Short delay to debounce button.
    delay(20);
    // Check if button is still low after debounce.
    newState = digitalRead(BUTTON_PIN);
    if (newState == LOW) {      // Yes, still low
      if (++mode > 3) mode = 0; // Advance to next mode, wrap around after #3
      switch (mode) {           // Start the new animation...
        case 0:
          fluxChase(0, 0, 0, 0, 0);  // off
          break;
        case 1:
          fluxChase(255, 180, 0, 20, 100);  // light chase, 100ms delay per frame
          break;
        case 2:
          fadeEffect(255, 180, 0, 20, 5); // slow fade
          break;
        case 3:
          fadeEffect(255, 180, 0, 20, 2);  // fast fade
          break;
      }
    }
  }
  // Set the last-read button state to the old state.
  oldState = newState;
}

// Animated chasing glow
void fluxChase(uint8_t r, uint8_t g, uint8_t b, uint8_t w, int delayTime) {
  for (int loop = 0; loop < 6; loop++) { // looping - renamed from 'i' to avoid shadowing
    for (int step = 0; step < PIXEL_COUNT * 1; step++) {
      strip.clear();
      for (int i = 0; i < PIXEL_COUNT; i++) {
        int offset = (step + i) % PIXEL_COUNT;
        float fade = 1.0 - (float)i / PIXEL_COUNT; // trailing dimmer effect
        strip.setPixelColor(offset, strip.Color(r * fade, g * fade, b * fade, w * fade));
      }
      strip.show();
      delay(delayTime);
    }
  }
}

// Smooth fade in/out
void fadeEffect(uint8_t r, uint8_t g, uint8_t b, uint8_t w, int speed) {
  for (int loop = 0; loop < 4; loop++) { // looping - renamed from 'i' for clarity
    // Fade in
    for (int brightness = 0; brightness <= 255; brightness++) {
      setAllBrightness(r, g, b, w, brightness);
      delay(speed);
    }
    // Fade out
    for (int brightness = 255; brightness >= 0; brightness--) {
      setAllBrightness(r, g, b, w, brightness);
      delay(speed);
    }
  }
}

// Helper for setting all pixels to same brightness
void setAllBrightness(uint8_t r, uint8_t g, uint8_t b, uint8_t w, uint8_t brightness) {
  for (int i = 0; i < PIXEL_COUNT; i++) {
    strip.setPixelColor(i, strip.Color(
      (r * brightness) / 255,
      (g * brightness) / 255,
      (b * brightness) / 255,
      (w * brightness) / 255
    ));
  }
  strip.show();
}