Halo Energy Sword by Mattel NeoPixel Upgrade

Halo Energy Sword by Mattel

This cosplay prop is made by Mattel and officially licensed by Microsoft. You can find these exclusively at GameStop. It features two modes: Trigger mode use's a button to trigger sound effects and lights. The other mode uses a tilt switch to activate the sound effects and lighting. It has a sturdy construction and features details like weathering and edge lit texture in the blades.

MOAR LEDs!!

This cosplay prop only features 11 LEDs, leaving a lot to be desired. The stock lighting is underwhelming but we can easily modify it with lots of NeoPixel LEDs. In this project, we'll tear it down and replace the LEDs with NeoPixel LED strips. We'll wire up an Adafruit Trinket and power everything with the built in 3x AAA battery power supply.

Prerequisite Guides

We recommend walking through the following tutorial to get familiar with the components used in this project.

Parts

You'll need the following parts to build this project.

Tools & Supplies

The following tools and supplies will help you complete this project.

Project Expectations

If you attempt this project, we aren't liable for any damage made to your product. This will most likely void any warranty (if any). This project requires a bit of soldering experience – If you're new to soldering, this might a bit involved. If you have any technical issues with this project, please post them up on https://forums.adafruit.com/

Getting Code Onto Trinket

Before we start disassembling or building the circuit, it's a good idea to get code uploaded to the micro-controller first. If you don't write / understand code, don't to worry! You don't need to be a programmer to be able to upload prewritten code :-)

We'll walk you through the whole process.

First, visit the Trinket tutorial page by clicking the button below. Follow the instructions to download & setup the Arduino IDE and install drivers.

Getting Started with Trinket

Make sure you are able to get sketches compiled and uploaded, especially the blink example in the tutorial. Once you are comfortable with using the Trinket, you can continue!

Install Adafruit NeoPixel Library

Next, we need to add support for NeoPixels.

Visit the Adafruit NeoPixel tutorial to install the NeoPixel library!

Install NeoPixel Library

Uploading Code to Board

Now that we have the Adafruit boards & NeoPixel library installed, we can get our code ready to upload onto the board. Select all of the code listed below in the black box and copy it to your clip board. Then, in Arduino IDE, paste it in the sketch window (making sure to overwrite anything currently there). Next, goto the Tools menu > Board and select Adafruit Trinket (if you're using the 3V Adafruit Trinket version use Trinket 8Mhz. If you're using the 5V Trinket, select Trinket 12Mhz). Now you can click on the "check mark" icon to verify the code. If it's all good, we can continue to upload the code to the board.

Connect USB Data Cable to Trinket

Be sure to use a micro USB cable that can transfer data - A USB cable that ONLY charges devices will simply not work. Plug it into the microUSB port on the Adafruit Trinket board and the USB port on your computer (try to avoid connecting to a USB hub). As soon as you plug it in, you'll see a red LED blink on the Adaruit Trinket - This let's you know the board is ready to except code. While the LED is blinking, click on the Upload button (It's a right arrow icon, next to the check mark). The Arduino IDE will notify you if the upload is successful and completed.

Download File

Copy Code

// This is a demonstration on how to use an input device to trigger changes on your neo pixels.
// You should wire a momentary push button to connect from ground to a digital IO pin.  When you
// press the button it will change to a new pixel animation.  Note that you need to press the
// button once to start the first animation!

#include <Adafruit_NeoPixel.h>

#ifdef __AVR__
  #include <avr/power.h>
#endif


#define BUTTON_PIN   2    // Digital IO pin connected to the button.  This will be
                          // driven with a pull-up resistor so the switch should
                          // pull the pin to ground momentarily.  On a high -> low
                          // transition the button press logic will execute.

#define PIXEL_PIN    0    // Digital IO pin connected to the NeoPixels.

#define PIXEL_COUNT 43

// Parameter 1 = number of pixels in strip,  neopixel stick has 8
// Parameter 2 = pin number (most are valid)
// Parameter 3 = pixel type flags, add together as needed:
//   NEO_RGB     Pixels are wired for RGB bitstream
//   NEO_GRB     Pixels are wired for GRB bitstream, correct for neopixel stick
//   NEO_KHZ400  400 KHz bitstream (e.g. FLORA pixels)
//   NEO_KHZ800  800 KHz bitstream (e.g. High Density LED strip), correct for neopixel stick
Adafruit_NeoPixel strip = Adafruit_NeoPixel(PIXEL_COUNT, PIXEL_PIN, NEO_GRB + NEO_KHZ800);

bool oldState = HIGH;
int showType = 0;

void setup() {
  #if defined (__AVR_ATtiny85__)
    if (F_CPU == 16000000) clock_prescale_set(clock_div_1);
  #endif
  pinMode(BUTTON_PIN, INPUT_PULLUP);
  strip.begin();
  strip.show(); // Initialize all pixels to 'off'
}

void loop() {
  // Get current button state.
  bool 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) {
      showType++;
      if (showType > 9)
        showType=0;
      startShow(showType);
    }
  }

  // Set the last button state to the old state.
  oldState = newState;
}

void startShow(int i) {
  switch(i){
    case 0: colorWipe(strip.Color(0, 0, 0), 10);    // Black/off
            break;
    case 1: colorWipe(strip.Color(255, 255, 255), 10);  // White
            break;
    case 2: colorWipe(strip.Color(0, 0, 255), 10);  // Blue
            break;
    case 3: colorWipe(strip.Color(0, 100, 255), 10);  // Bluish Green
            break;
    case 4: colorWipe(strip.Color(0, 255, 80), 10);  // Greenish Blue
            break;
    case 5: colorWipe(strip.Color(190, 0, 255), 10);  // Purple
            break;
    case 6: rainbow(20);
            break;
    case 7: colorWipe(strip.Color(0, 0, 0), 10);    // Black/off
            break;
    case 8: rainbowCycle(20);
            break;
  }
}

// Fill the dots one after the other with a color
void colorWipe(uint32_t c, uint8_t wait) {
  for(uint16_t i=0; i<strip.numPixels(); i++) {
    strip.setPixelColor(i, c);
    strip.show();
    delay(wait);
  }
}

void rainbow(uint8_t wait) {
  uint16_t i, j;

  for(j=0; j<256; j++) {
    for(i=0; i<strip.numPixels(); i++) {
      strip.setPixelColor(i, Wheel((i+j) & 255));
    }
    strip.show();
    delay(wait);
  }
}

// Slightly different, this makes the rainbow equally distributed throughout
void rainbowCycle(uint8_t wait) {
  uint16_t i, j;

  for(j=0; j<256*2; j++) { // 5 cycles of all colors on wheel
    for(i=0; i< strip.numPixels(); i++) {
      strip.setPixelColor(i, Wheel(((i * 256 / strip.numPixels()) + j) & 255));
    }
    strip.show();
    delay(wait);
  }
}

//Theatre-style crawling lights.
void theaterChase(uint32_t c, uint8_t wait) {
  for (int j=0; j<10; j++) {  //do 10 cycles of chasing
    for (int q=0; q < 3; q++) {
      for (int i=0; i < strip.numPixels(); i=i+3) {
        strip.setPixelColor(i+q, c);    //turn every third pixel on
      }
      strip.show();

      delay(wait);

      for (int i=0; i < strip.numPixels(); i=i+3) {
        strip.setPixelColor(i+q, 0);        //turn every third pixel off
      }
    }
  }
}

//Theatre-style crawling lights with rainbow effect
void theaterChaseRainbow(uint8_t wait) {
  for (int j=0; j < 256; j++) {     // cycle all 256 colors in the wheel
    for (int q=0; q < 3; q++) {
      for (int i=0; i < strip.numPixels(); i=i+3) {
        strip.setPixelColor(i+q, Wheel( (i+j) % 255));    //turn every third pixel on
      }
      strip.show();

      delay(wait);

      for (int i=0; i < strip.numPixels(); i=i+3) {
        strip.setPixelColor(i+q, 0);        //turn every third pixel off
      }
    }
  }
}

// Input a value 0 to 255 to get a color value.
// The colours are a transition r - g - b - back to r.
uint32_t Wheel(byte WheelPos) {
  WheelPos = 255 - WheelPos;
  if(WheelPos < 85) {
    return strip.Color(255 - WheelPos * 3, 0, WheelPos * 3);
  }
  if(WheelPos < 170) {
    WheelPos -= 85;
    return strip.Color(0, WheelPos * 3, 255 - WheelPos * 3);
  }
  WheelPos -= 170;
  return strip.Color(WheelPos * 3, 255 - WheelPos * 3, 0);
}

// This is a demonstration on how to use an input device to trigger changes on your neo pixels.
// You should wire a momentary push button to connect from ground to a digital IO pin.  When you
// press the button it will change to a new pixel animation.  Note that you need to press the
// button once to start the first animation!

#include <Adafruit_NeoPixel.h>

#ifdef __AVR__
  #include <avr/power.h>
#endif


#define BUTTON_PIN   2    // Digital IO pin connected to the button.  This will be
                          // driven with a pull-up resistor so the switch should
                          // pull the pin to ground momentarily.  On a high -> low
                          // transition the button press logic will execute.

#define PIXEL_PIN    0    // Digital IO pin connected to the NeoPixels.

#define PIXEL_COUNT 43

// Parameter 1 = number of pixels in strip,  neopixel stick has 8
// Parameter 2 = pin number (most are valid)
// Parameter 3 = pixel type flags, add together as needed:
//   NEO_RGB     Pixels are wired for RGB bitstream
//   NEO_GRB     Pixels are wired for GRB bitstream, correct for neopixel stick
//   NEO_KHZ400  400 KHz bitstream (e.g. FLORA pixels)
//   NEO_KHZ800  800 KHz bitstream (e.g. High Density LED strip), correct for neopixel stick
Adafruit_NeoPixel strip = Adafruit_NeoPixel(PIXEL_COUNT, PIXEL_PIN, NEO_GRB + NEO_KHZ800);

bool oldState = HIGH;
int showType = 0;

void setup() {
  #if defined (__AVR_ATtiny85__)
    if (F_CPU == 16000000) clock_prescale_set(clock_div_1);
  #endif
  pinMode(BUTTON_PIN, INPUT_PULLUP);
  strip.begin();
  strip.show(); // Initialize all pixels to 'off'
}

void loop() {
  // Get current button state.
  bool 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) {
      showType++;
      if (showType > 9)
        showType=0;
      startShow(showType);
    }
  }

  // Set the last button state to the old state.
  oldState = newState;
}

void startShow(int i) {
  switch(i){
    case 0: colorWipe(strip.Color(0, 0, 0), 10);    // Black/off
            break;
    case 1: colorWipe(strip.Color(255, 255, 255), 10);  // White
            break;
    case 2: colorWipe(strip.Color(0, 0, 255), 10);  // Blue
            break;
    case 3: colorWipe(strip.Color(0, 100, 255), 10);  // Bluish Green
            break;
    case 4: colorWipe(strip.Color(0, 255, 80), 10);  // Greenish Blue
            break;
    case 5: colorWipe(strip.Color(190, 0, 255), 10);  // Purple
            break;
    case 6: rainbow(20);
            break;
    case 7: colorWipe(strip.Color(0, 0, 0), 10);    // Black/off
            break;
    case 8: rainbowCycle(20);
            break;
  }
}

// Fill the dots one after the other with a color
void colorWipe(uint32_t c, uint8_t wait) {
  for(uint16_t i=0; i<strip.numPixels(); i++) {
    strip.setPixelColor(i, c);
    strip.show();
    delay(wait);
  }
}

void rainbow(uint8_t wait) {
  uint16_t i, j;

  for(j=0; j<256; j++) {
    for(i=0; i<strip.numPixels(); i++) {
      strip.setPixelColor(i, Wheel((i+j) & 255));
    }
    strip.show();
    delay(wait);
  }
}

// Slightly different, this makes the rainbow equally distributed throughout
void rainbowCycle(uint8_t wait) {
  uint16_t i, j;

  for(j=0; j<256*2; j++) { // 5 cycles of all colors on wheel
    for(i=0; i< strip.numPixels(); i++) {
      strip.setPixelColor(i, Wheel(((i * 256 / strip.numPixels()) + j) & 255));
    }
    strip.show();
    delay(wait);
  }
}

//Theatre-style crawling lights.
void theaterChase(uint32_t c, uint8_t wait) {
  for (int j=0; j<10; j++) {  //do 10 cycles of chasing
    for (int q=0; q < 3; q++) {
      for (int i=0; i < strip.numPixels(); i=i+3) {
        strip.setPixelColor(i+q, c);    //turn every third pixel on
      }
      strip.show();

      delay(wait);

      for (int i=0; i < strip.numPixels(); i=i+3) {
        strip.setPixelColor(i+q, 0);        //turn every third pixel off
      }
    }
  }
}

//Theatre-style crawling lights with rainbow effect
void theaterChaseRainbow(uint8_t wait) {
  for (int j=0; j < 256; j++) {     // cycle all 256 colors in the wheel
    for (int q=0; q < 3; q++) {
      for (int i=0; i < strip.numPixels(); i=i+3) {
        strip.setPixelColor(i+q, Wheel( (i+j) % 255));    //turn every third pixel on
      }
      strip.show();

      delay(wait);

      for (int i=0; i < strip.numPixels(); i=i+3) {
        strip.setPixelColor(i+q, 0);        //turn every third pixel off
      }
    }
  }
}

// Input a value 0 to 255 to get a color value.
// The colours are a transition r - g - b - back to r.
uint32_t Wheel(byte WheelPos) {
  WheelPos = 255 - WheelPos;
  if(WheelPos < 85) {
    return strip.Color(255 - WheelPos * 3, 0, WheelPos * 3);
  }
  if(WheelPos < 170) {
    WheelPos -= 85;
    return strip.Color(0, WheelPos * 3, 255 - WheelPos * 3);
  }
  WheelPos -= 170;
  return strip.Color(WheelPos * 3, 255 - WheelPos * 3, 0);
}

Wired Connections

The circuit diagram above shows how the components will be wired together on a breadboard. The NeoPixel shown is a breadboard-friendly version – The NeoPixel strip has similar connections. The actual connections will be slightly different. Use this diagram to reference how the connections can be wired.

Data In from NeoPixel to Pin #0 on Trinket
Pwr from NeoPixel to BAT on Trinket
GND from NeoPixel to GND on Trinket
Button to Pin #2 on Trinket
Button to GND on Trinket

Battery Power

The circuit will be powered by the 3x AAA batteries via the battery hold built into the handle. This should provide about 4.5v and 1500mAh of power. This will power ~80 NeoPixels for about an hour.

Remove Cover & Batteries

Let's start this mod by removing the batteries. There's a screw that secures the battery cover to the handle. Use a screwdriver to remove the screw and take out the 3x AAA batteries.

Remove Screws from Handle

Next, we'll remove the screws from the handle. There's a total of 7 and they're all the same length.

Remove Screws from Blades

The blades are attached to the handle with brackets. Remove the four screws from each blade. Notice they're longer than the ones from the handle. There's a total of 8 screws for the blade brackets.

Remove Screws from Joiners

The two blades are secured together with two joiner brackets. Each has 4 screws. We'll also need to remove these. They're the same size as the ones in the handle.

Remove Brackets from Blades

With all of the screws removed, we can now start taking it apart. Start by separating the brackets from the blades. They're in two halves that "click" together. Carefully pull these part.

Crack Open Handle

Carefully lift the handle off the brackets. Once loose, you should be able to separate the two halves of the handle. And here's all of the electronics!

Inspect, Search and Learn

Take a moment to examine the components and wiring. See the trigger button? Take it apart and reassemble it. Is that the speaker? Follow the wiring and note where it's connected. Do you see any good spots to mount the microcontroller? Where are the batteries connected?

The LED Wiring

Mounted to the handle, are two main PCBs (Printed Circuit Boards). These contain all of the components that drive the LEDs, speaker and audio amplifier. On one of the PCBs are two connectors. These "plugs" are connected to the wiring of the LEDs. Each one is routed to a blade.

Disconnect LED Wiring

We'll be replacing all of the stock LEDs, so we can go ahead and carefully pull out the connectors from the PCB. They're a little tight, so you'll need to apply some force.

Remove LED Wiring

With the connectors removed, carefully remove the wiring from the harness in the handle. There's a few pieces of tape holding them down, remove these to unbundle them.

Tilt Switch

Inside one of the blades is a tilt switch. When in the "motion activated" mode, this little guy triggers sound effects when the energy sword is swung around. It's mounted to a bracket within the blade. We'll need to remove it from the bracket, but reattach it once we remove the LEDs.

Remove Glue

There's a small amount of glue that secures the bracket inside of the blade. We'll need to remove it so we can remove the bracket. Use a hobby knife or similar to scrape off the glue.

Remove Plate from Blade

With the glue removed, you should be able to remove the bracket from inside the blade. Do this slowly and pull it out, little by little. Once the bracket is outside of the blade, pull out the inner plate. This features a mounting bit that contains the LEDs. Tip: You can pull apart the sides of the blade to allow the mounting bracket to come out. It's some strong plastic!

Remove Tilt Switch

The tilt switch is fixed to a standalone PCB which is mounted to the bracket. To remove it, you'll need to clip the two standoffs that hold it in place. Pull it off the standoffs and carefully separate the wiring from the LED wiring.

Remove LEDs

The LEDs are mounted to a fixture that's secured to the bottom of the clear plate. In order to remove the LEDs, I suggest using a pair of cutters to snip away the standoffs that hold them in place.

Remove LED Bracket from Plate

I found the bottom bracket from the plate prevented the NeoPixel strip from being installed into the blade, so I removed it. The easiest way I was able to do this was by trimming pieces off to free it from the inserts. You might be able to find a more non-destructive away to achieve this. Do not remove the second bracket on the end of the clear plate – This is necessary for aligning and mounting the clear plate back into the blade.

Second Blade

You'll need to repeat this process for the second blade. It should be a little bit easier since only one contains the tilt switch. You'll find most of the disassembly process is the same for the second blade. Oddly, one blade has five LEDs, the other has six. Not sure why.

Next Steps

In the next section, we'll sort out our power distribution and prepair wiring for the NeoPixel LED strips and Trinket micro-controller.

Reinstall Batteries

Now that we have our LEDs and wiring removed from the handle, we can start sorting out our power situation. Let's start by putting the batteries back in and reinstalling the cover. We're going to use a multimeter to find out where the voltage is coming from.

Switch PCB

Look for the PCB that's next to the speaker. This PCB has the trigger button and slide switch. There is a ribbon cable that connects this PCB to the other PCB where we disconnected the LEDs. Notice how the ground(black) and power(red) wires from the battery holder is connected to the PCB with the switch.

Measuring Voltage

We'll use the multimeter to find out which wires on the PCB are voltage and ground. Set the DC voltage mode on the Pocket Multimeter. We can use the two probes to determine which wires are voltage and ground. Poke one of the dots or "pins" on the PCB with the tip of the testing leads. Then use the second lead to "probe" another pin. In my energy sword, the pin with the green wire was ground, and the yellow was voltage – This is of course subject to change. The colored wires might be different in your energy sword. The pins, however, should be in the same positions.

Unmount Switch PCB

Since we'll be working with the PCB, I suggest removing it from the handle so we get better access to the pins. It's secured in place with two machine screws. Remove these and lift the PCB out of the handle.

Switch PCB Pinouts

With the PCB free from the handle, we can flip it over and inspect the back. You'll notice some labels, yaay! Each wire has a label (SW, TRY, OFF, VDD, GND). The VDD label is voltage, and GND is ground. We'll connect wires to these pins to power the Trinket micro-controller and NeoPixel LEDs.

Trinket Power

Now that we know where we'll be getting power from, we can start planning where to mount the Trinket micro-controller. Next to the speaker, is an empty spot, perfect for the micro-controller. Place the Trinket in that spot and gauge how long the wires connections need to be.

Power Wires

Let's make some wires for powering the Trinket! Cut two pieces of wires using wire cutters. Make sure they're long enough to connect the switch PCB to the Trinket. I recommend using 30AWG silicone coated wires because they're more flexible and reliable than wire wrap. We'll need two wires, one for voltage, and the other for ground. Then, use wire strippers to remove a bit of insulation from the tips of each wire. It's good practice to tin the tips of exposed stranded wires to prevent fraying. A pair of helping third hands can assist you while soldering.

Connect Wires to Trinket

On the back of the Trinket are two pads. These are voltage and ground (labeled with a +positive and –negative symbol). We'll need to connect our two wires to them. I recommend tinning the pads with solder to make it easier to attach the wires. I found it better if the wire is positioned outwards from the microUSB port. Again, a pair of helping third hands is nice and well, handy.

Heat Shrink Tubing

I recommend using pieces of heat shrink tubing. They're like sheathing for wires that need insultation. These also help keep the wires nice and tidy. Cut short pieces. They slip over multiple wires and can shrink when heat is applied to it. Tip: Don't use the tip of your soldering. Use the edge of the pen, or a flame from a lighter. Careful not to over heat!

Connect Trinket to Power

Now we can connect the wires from the Trinket to the voltage and ground pins on the switch PCB. I recommend securing the PCB to helping third hands to assist while soldering. You'll need to apply heat to the pins on the PCB in order to connect the wires to them.

Test Power

With voltage and ground connected to the Trinket micro-controller, we can now do a quick test to see if the power works. Temporarily place the switch PCB back into the handle and flip it over. Then, insert the 3x AAA batteries into the holder and turn the switch to power the circuit on. If we have a solid connection (and wired to the correct pins) our Trinket will power on (indicated by a green LED). Woohoo! Next we can start working on hooking up the NeoPixel LEDs.

Measure NeoPixel Strip

Now it's time to work on our LED strips. Start by measuring how many NeoPixel LEDs we can fit into the blades. I was able to fit 43 pixels per blade (a total of 86), but you might be able to squeeze one or two more (or less if you want!).

Cut LED Strip

Once you've decided how many NeoPixel LEDs you want in the blades, use your finger to mark where on the strip needs to end. Then, use a pair of scissors to cut in between two NeoPixels. These strips are designed to be cut across the three copper pads. Make sure you cut in the middle to provide each end with sufficent area for making soldered connections.

Trim Wired Connectors

You may find it necessary to remove the wired connectors from the LED strip. They're too bulky to reuse in this project and we'll be making wires with various lengths so we don't really need them.

Remove Sheating

I didn't find it necessary to keep the sheating on the LED strip. It was difficult to insert it into the blade with the sheathing on so that's why I removed it. If you wanted, you might be able to install it with the sheating, but I found it cumbersome.

Support NeoPixel LED Strips

Now's a good time to plan and test out how to install the Neopixel strips into the blades. Try it with the sheathing, without and see how well it rests inside. I eventually found the strip to be "wiggly" and not straight while inside the blade. A good solution is to provide support to the back of the strips. My solution was to 3D print thin strips and secure them to the back of the strip. This provides support and keeps them straight while inserting them into the blades. You could use a sheet of plastic or precut material. Time to get creative!

Attach Supports to Strips

Now you'll need to sort out how to keep the supports secured to the LED strips. I used double sided nitto tape and cut strips in half so they're the same width (5mm) as the LED strips. Pull off the non-adhesive backing and stick them to the back of the strips. You'll need multiple pieces to cover most of the LED strip.

Heat Shrink Tubing

I also used pieces of heat shrink tubbing to secure multiple sticks together. That kept the joints sturdy and more secure.

Second NeoPixel Strip

You'll need to repeat this process for the second NeoPixel LED strip.

Next Steps

OK now is a good check point. At this point, we should have our code uploaded to the Trinket and powered via the switch PCB and 3x AAA batteries. We have two NeoPixel LED strips cut and prepped. In the next section, we're start wiring our components together.

Flex Perma-Proto PCB

I used a flexible breadboard PCB to make extra voltage, data and ground pins. This provides us with more available connections. The Adafruit Trinket micro-controller only provides a few connections, so adding extra pinouts will make connecting components much easier. We only need a small piece, 3x5 pins should be plenty. You can use a pair of scissors to cut a piece. Save the rest for other projects. This stuff is super handy!

Connect Flex PCB to Trinket

Now that we have our piece of flex PCB, we need to connect it to the ground pin on the Adafruit Trinket. We'll need a short wire (about 2in in length). Just like the other wires, strip and tin the tips of both ends. Then, tin the pins on the flex breadboard PCB. Connect our newly cut wire into one of the pins on the flex PCB.

Connect GND to Flex PCB

Next, we'll need to connect the wire from the flex PCB to the ground pin on the Adafruit Trinket. There's only one available ground pin on the Trinket and we need to connect several components to that, hence why we're using the flex PCB to essentially break out more ground connections.

Trace Button Connections

We'll use the trigger button on the handle to cycle between different colors and animations on the NeoPixel LEDs. Todo this, we'll connect wires to the PCB that has the button component (and mode switch). To find out which pins we'll need to connect to, we'll use the multimeter. Look at the orientation shown in the photo, the middle pin is signal, and the one on the far right is ground.

Button Wires

Now that we know which pins we'll be connecting to, we need to measure and cut two new wires. These wires will connect the Trinket to the pins of the trigger button. We measure, cut, strip and tin the wires.

Connect Wires to PCB

With our two new wires, we'll connect them to the corresponding pins on the button/switch PCB. Again, reference the photo to see which pins to connect to.

Connect Button to Trinket

Then, connect the signal wire to pin #2 on the Adafruit Trinket. In our code, we have pin #2 setup as an input GPIO – Anything connected to that pin will trigger a new color or animation whenever it's tied to ground (essentially when the trigger is pressed).

Mount Switch PCB

With four wires now connected to the switch/button PCB, we can go ahead and mount the PCB back to the handle.

Connect Ground to Button

Now we can connect the ground wire from the button/switch PCB to the ground connections on the Flex PCB. Use an available pin on the Flex PCB. Just make sures it's a column/row that is connected to the ground connection wired to the ground pin on the Trinket.

Connect Wire to 5V on Trinket

Now we need to connect the 5V pin from Adafruit Trinket to an avilable column/row on the Flex PCB. This will allow us to connect power to the LED strips. Measure the distance between the Trinket and the Flex PCB to determine the required length of wire. Then cut, strip and tin the wire. Connect the wire to the 5V pin on the Adafruit Trinket.

Connect 5V to Flex PCB

Now we can connect the 5V wire from the Trinket to an available row/column on the Flex PCB.

Connect Data Wire to Flex PCB

Since we'll have two NeoPixel strips, we'll need two data connections. The Trinket has only one pin per GPIO/data connections, so we'll need to connect one wire to pin #0 on the Trinket to an available column/row on the Flex PCB. So far we've done this process for power and ground. Now we need to do this for our data connection for the NeoPixel strips.

Connect Data to Trinket

Now we can connect our data wire from the Flex PCB to pin #0 on the Adafruit Trinket. So far we should have following connections wired

5V from Trinket to Flex PCB
GND from Trinket to Flex PCB
Pin#0 from Trinket to Flex PCB
Pin#2 from Trinket to Button/Switch PCB
GND from button/switch PCB to GND on Flex PCB

Wiring NeoPixel LED Strips

In the next section, we'll start working on wiring our NeoPixel LED strips to the Adafruit Trinket via the Flex PCB.

NeoPixel Wires

Now it's time to start working on wiring our NeoPixel LED strips. Go ahead and grab one of the two strips and position it close to the handle as pictured. We'll need to create 3 new wires that will connect the NeoPixel strip to the flex PCB. This will require lengthy wires, so be sure to measure and add a little extra slack (can always shorten later). Once cut, strip and tin the tips of each wire.

Connect Wires to NeoPixel

With our three wires measured, cut, stripped and tinned, now we can connect them to one of the NeoPixel LED strips. I suggest tinning the three pads (5V, Data In, and Ground) with solder first. This will make it easier to solder our three wires to these pads. Be sure to solder the end which has "Data In", denoted with an arrow symbol pointing away from the pads.

Insert NeoPixels in Blade

Now we can start install the NeoPixel strip into one of the blades. Insert the non-wired end of the NeoPixel strip into the blade like pictured. Run it all the way through until it reaches the tip of the blade.

Set NeoPixels

Once fully inserted, move the NeoPixel strip to one side. This will ensure the strip doesn't get kinked when inserting the clear plate back into the blade. Doesn't matter which side, as long it's set away from the middle. Then, carefully insert the clear plate back into the blade, making sure not to dislodge the NeoPixel strip.

Adjust NeoPixel Strip

Before inserting the clear plate all the way into the blade, we'll need to adjust the NeoPixel strip so that it curves around the mount on the end. Carefully fit the NeoPixel strip onto the end bracket so that it rests on top of it. Then, pull the wires out so its free from the bracket and blade.

Mount Bracket Inside Blade

Once we have our LED strip situated, we can then fit the bracket back into the blade so it's fully installed. It should "click" into place with it being nested into the blade. You may need to firmly apply some force to fully seat the bracket back into the blade. Tip: Pull the ends of the blade apart to allow the lips of the end bracket to insert into the blade.

Mount Blade to Handle

Now we can install the blade-to-handle bracket back onto the blade and set it onto the handle. Ensure the blade and bracket are in the correct position where the holes line up with the standoffs.

Connect NeoPixel to Flex PCB

Now we need to connect the three wires (5V, data in, and ground) from the NeoPixel strip to our Flex PCB. Go ahead and connect 5V to voltage, ground to ground and data in to data.

Second Blade

Now that we have our first NeoPixel strip installed and wired, we need to repeat the same process for the second blade. Fun! We should have plenty of pinouts on the flexible PCB to connect a second pair of wires (power, data and ground).

Test Circuit

Now's a good time to test out the circuit. Power on the circuit by setting the switch, being careful the connections on the flexible breadboard PCB doesn't touch the trinket or other PCBs. Pressing the trigger should turn on the NeoPixel LEDs.

Secure Flex PCB

It's a good idea to secure the Flex PCB to the surface on the handle. That way it doesn't accidentally cause a short when we reassemble the handle. I stuck a piece of mounting underneath the flex PCB and stuck it to the mounting plate of the speaker.

Secure Tilt Switch

Now is a good time to secure the tilt switch back into the end bracket on the blade which had it before. Only one of the blade has the standoffs, so locate it and install it back onto the standoffs. I also used some mounting tack here to secure it in place.

Install 2nd Blade to Handle

Now we can reassemble the second blade and fit that back onto the handle.

Wire Harness

It's a good idea to fit the wires from the NeoPixel strips through the wire harness built into the handle.

Secure Wiring

Before we close the handle up, we should secure our wires together. Bundle them up and use a piece of packaging tape to hold them in place. This will ensure any of the wires kink when we close up the handle.

Close Handle

With our wires neatly bundled and contained, we should be able to install the second piece of the handle and close them together. Again, make sure none of the wired connections are kinked.

Mount Blade Brackets to Handle

Install the top brackets which attach the blade to the handle back onto both of the blade. They should "click" together and fit correctly when joined together.

Reinstall Machine Screws

Now flip the whole sword over so the screw holes are facing up. Then insert and fasten the machine screws back into all of the holes. Hold the halves together while fastening to ensure they are flush and fully tightened.

Final Test

Now it's time for a final test! Turn the mode switch on and squeeze the trigger. We should see the NeoPixel LED strips power on. woohoo!! Pick it up and see how well the LED strips stay mounted inside the blade when swung around. Adjust them if necessary.

Maintenance and Reprogramming

If any of the connections short, come loose, or you want to reprogram the microcontroller, you'll need to take it apart and gain access to the microUSB port.