Here’s a project to dazzle onlookers at Halloween parties, cosplay conventions, raves or at Burning Man. These full-color animated LED goggles attract a LOT of attention!

Adafruit NeoPixel LED rings fit perfectly inside the eyecups of most 50mm round goggles — a very common size. It’s almost as if these rings were made with this project in mind!

Tools Needed

This is a soldering project, albeit a small one. You will need the common soldering paraphernalia of a soldering iron, solder and tools for cutting and stripping wire.

You’ll need some method of securing the electronics inside the goggles. Hot-melt glue (requiring a glue gun) works well for this. Watch your fingers! Or craft glue (such as E6000) is an Adafruit favorite. Tape could be used for a quick and temporary setup.

Parts Needed

We have a DIY kit with all the necessary pieces (including goggles), or you can “bring your own goggles” for a custom-made design.

…or Bring-Your-Own-Goggles

If you already have a favorite pair of goggles that you’d rather build this around, then you just need to add the electronic parts linked above. You also then have the option of stepping up to a larger 500 mAh LiPoly battery or a less costly 3x AAA battery case. You’ll need to provide your own wire and perhaps some heat-shrink tubing.

If you go the custom route, the design must be adapted to fit your reality.

Great thing about our costume goggles is that you can assemble all the electronics first, outside the goggles, then install them. That’s not always the case with these alternates…you may need to snake wires in and out of the eye cups and solder parts with them already in the goggles…this can be tricky! Soldering novices may prefer the kit version for this reason.

If you choose a 3x AAA battery case (instead of a rechargeable LiPoly battery), it won’t fit inside the goggles. This could be attached to the strap, or run longer wires and keep the battery pack in a pocket.

If this is your first time using the Adafruit Trinket microcontroller, work through the Adafruit Trinket M0 or Introducing Trinket guide first. This explains how to set up the Arduino IDE software or CircuitPython and load code onto the board. Don’t continue here until you have something like the “blink” example working.

If you encounter problems, post on the Adafruit Forums for help…it’s much easier to troubleshoot and replace parts before they’re soldered together and glued into some goggles!

Let’s get the trickiest soldering out of the way first, installing the JST battery connector on the underside side of the Trinket board…

The USB battery charger in the kit is a separate part — it does not get incorporated into the goggles. You must disconnect the battery from the goggles and use the charger to top it off.

Here’s a circuit diagram of what we’re aiming for. Of course the real thing won’t be all rectilinear like this…we’ll walk you through each step.

Solder one end of the 3-wire cables to the IN, V+ and G points on the two NeoPixel rings. There are two V+ and two G holes on each ring…either one is fine, they’re connected.

Keep track of the colors you use for IN, V+ and G…it’s vitally important to make the right connections at the other end.

(These are the labels on the front of the rings. The back-side labels are a little more verbose.)

Notice how the wires are inserted from the front, then soldered on the back of the ring. Do it this way if you’re new to soldering…it’s much easier. It can work the other way too…insert from back, solder on front…but the component tolerances are extremely tight and beginners often get a blob of solder in the wrong place and the LEDs don’t work.

Next we connect the other ends of the 3-wire cables…first one to the Trinket, second one joins the two rings…

The second cable is the “visible from the outside” one, if that matters to your color scheme.

Notice here how the second cable enters the first ring from behind, then the wires are inserted from the front and soldered on the back…the cables should not overlap any LEDs on the front.

If possible, try to align the rings so they’re pointed nearly the same direction (use a landmark like the Adafruit logo for reference). This is not required, but it’s a little easier to program animation effects when both rings have the same orientation.

We’ll clip the wire ends flush in a moment, but let’s test that everything works first…

If you haven’t already worked through the Adafruit Trinket M0 or Introducing Trinket guide, do that first. Once you have the Arduino IDE up and running, then download and install the NeoPixel library:

Installing Arduino libraries is a frequent stumbling block. If this is your first time, or simply needing a refresher, please read the All About Arduino Libraries tutorial.

Create a new Arduino sketch (File→New), then copy and paste the following code:

// SPDX-FileCopyrightText: 2017 Mikey Sklar for Adafruit Industries
//
// SPDX-License-Identifier: MIT

// Low power NeoPixel goggles example.  Makes a nice blinky display
// with just a few LEDs on at any time.

#include <Adafruit_NeoPixel.h>
#ifdef __AVR_ATtiny85__ // Trinket, Gemma, etc.
 #include <avr/power.h>
#endif

#define PIN 0

Adafruit_NeoPixel pixels = Adafruit_NeoPixel(32, PIN);

uint8_t  mode   = 0, // Current animation effect
         offset = 0; // Position of spinny eyes
uint32_t color  = 0xFF0000; // Start red
uint32_t prevTime;

void setup() {
#ifdef __AVR_ATtiny85__ // Trinket, Gemma, etc.
  if(F_CPU == 16000000) clock_prescale_set(clock_div_1);
#endif
  pixels.begin();
  pixels.setBrightness(85); // 1/3 brightness
  prevTime = millis();
}

void loop() {
  uint8_t  i;
  uint32_t t;

  switch(mode) {

   case 0: // Random sparks - just one LED on at a time!
    i = random(32);
    pixels.setPixelColor(i, color);
    pixels.show();
    delay(10);
    pixels.setPixelColor(i, 0);
    break;
 
   case 1: // Spinny wheels (8 LEDs on at a time)
    for(i=0; i<16; i++) {
      uint32_t c = 0;
      if(((offset + i) & 7) < 2) c = color; // 4 pixels on...
      pixels.setPixelColor(   i, c); // First eye
      pixels.setPixelColor(31-i, c); // Second eye (flipped)
    }
    pixels.show();
    offset++;
    delay(50);
    break;
  }

  t = millis();
  if((t - prevTime) > 8000) {      // Every 8 seconds...
    mode++;                        // Next mode
    if(mode > 1) {                 // End of modes?
      mode = 0;                    // Start modes over
      color >>= 8;                 // Next color R->G->B
      if(!color) color = 0xFF0000; // Reset to red
    }
    for(i=0; i<32; i++) pixels.setPixelColor(i, 0);
    prevTime = t;
  }
}

// SPDX-FileCopyrightText: 2017 Mikey Sklar for Adafruit Industries
//
// SPDX-License-Identifier: MIT

// Low power NeoPixel goggles example.  Makes a nice blinky display
// with just a few LEDs on at any time.

#include <Adafruit_NeoPixel.h>
#ifdef __AVR_ATtiny85__ // Trinket, Gemma, etc.
 #include <avr/power.h>
#endif

#define PIN 0

Adafruit_NeoPixel pixels = Adafruit_NeoPixel(32, PIN);

uint8_t  mode   = 0, // Current animation effect
         offset = 0; // Position of spinny eyes
uint32_t color  = 0xFF0000; // Start red
uint32_t prevTime;

void setup() {
#ifdef __AVR_ATtiny85__ // Trinket, Gemma, etc.
  if(F_CPU == 16000000) clock_prescale_set(clock_div_1);
#endif
  pixels.begin();
  pixels.setBrightness(85); // 1/3 brightness
  prevTime = millis();
}

void loop() {
  uint8_t  i;
  uint32_t t;

  switch(mode) {

   case 0: // Random sparks - just one LED on at a time!
    i = random(32);
    pixels.setPixelColor(i, color);
    pixels.show();
    delay(10);
    pixels.setPixelColor(i, 0);
    break;
 
   case 1: // Spinny wheels (8 LEDs on at a time)
    for(i=0; i<16; i++) {
      uint32_t c = 0;
      if(((offset + i) & 7) < 2) c = color; // 4 pixels on...
      pixels.setPixelColor(   i, c); // First eye
      pixels.setPixelColor(31-i, c); // Second eye (flipped)
    }
    pixels.show();
    offset++;
    delay(50);
    break;
  }

  t = millis();
  if((t - prevTime) > 8000) {      // Every 8 seconds...
    mode++;                        // Next mode
    if(mode > 1) {                 // End of modes?
      mode = 0;                    // Start modes over
      color >>= 8;                 // Next color R->G->B
      if(!color) color = 0xFF0000; // Reset to red
    }
    for(i=0; i<32; i++) pixels.setPixelColor(i, 0);
    prevTime = t;
  }
}

From the Tools→Board menu, select either Adafruit Trinket 8 MHz or Adafruit Trinket 16 MHz (either one will work). Also make sure to select USBTinyISP from the Tools:Programmer menu. Connect the USB cable between the computer and Trinket, press the reset button on the board, then click the upload button (right arrow icon) in the Arduino IDE.

Nothing will happen at first, this is normal. The LEDs only work on battery power! Unplug the USB cable, then connect the battery to the JST plug on the back of the Trinket. If all goes well, you should get a sparkly light show from the LEDs.

If the code refuses to compile it’s usually one of the following:

• The Trinket extensions to the Arduino IDE are not correctly installed (use the ready-made IDE, it’s easier).
• The NeoPixel library is not correctly installed.
• The wrong board type is selected (should be Adafruit Trinket M0,  Adafruit Trinket 8 MHz or 16 MHz, not any version of the Pro Trinket).

If the code compiles and uploads but nothing happens with the battery connected:

• Compare your connections against the wiring diagram…for example, maybe you’ve accidentally connected Trinket pin #0 to the first ring’s OUT instead of IN?
• An electrical short…a blob of solder or bit of wire making inadvertent contact with something nearby.
• A cold solder joint…solder isn’t properly melted between the wire and board.

If you can’t identify the source of the problem, you can post in the Adafruit Forums for assistance. It’s very helpful if you can get a well-lit, in-focus photo (or several) of the project, showing all the wires and solder connections. We’ll look it over for any gremlins and recommend fixes.

If using a Trinket M0 board (not the earlier “AVR” type), you have the option of using CircuitPython instead of Arduino. Once installed, it’s usually easier to program this way.

Trinket M0 Setup for CircuitPython

If you haven't already, follow this guide to preparing the Trinket M0, including updating it with the latest version of CircuitPython.

CircuitPython Goggles Code

With CircuitPython properly installed (the Trinket should show up as a small flash drive called “CIRCUITPY” when connected to USB), you can then load up the goggles code.

Click the “Download Project Bundle” below. This will download a ZIP file containing the project code and required libraries. Uncompress the ZIP file, look in the folder corresponding to the version of CircuitPython you installed, then drag the “code.py” file and the “lib” directory to the CIRCUITPY drive. It should then start running automatically (though the pixels will only light when a battery is also connected).

# SPDX-FileCopyrightText: 2017 Mikey Sklar for Adafruit Industries
#
# SPDX-License-Identifier: MIT

#
# Kaleidoscope_Eyes_NeoPixel_LED_Goggles.py
#
import time

import board
import neopixel

try:
    import urandom as random  # for v1.0 API support
except ImportError:
    import random

numpix = 32  # Number of NeoPixels
pixpin = board.D0  # Pin where NeoPixels are connected

mode = 0  # Current animation effect
offset = 0  # Position of spinny eyes

rgb_colors = ([255, 0, 0],  # red
              [0, 255, 0],  # green
              [0, 0, 255])  # blue

rgb_idx = 0  # index counter - primary color we are on
color = rgb_colors[rgb_idx]
prevtime = 0

pixels = neopixel.NeoPixel(pixpin, numpix, brightness=.3, auto_write=False)

prevtime = time.monotonic()

while True:
    i = 0
    t = 0

    # Random sparks - just one LED on at a time!
    if mode == 0:
        i = random.randint(0, (numpix - 1))
        pixels[i] = color
        pixels.write()
        time.sleep(0.01)
        pixels[i] = (0, 0, 0)

    # Spinny wheels (8 LEDs on at a time)
    elif mode == 1:
        for i in range(0, numpix):
            c = 0

            # 4 pixels on...
            if ((offset + i) & 7) < 2:
                c = color

            pixels[i] = c  # First eye
            pixels[(numpix - 1) - i] = c  # Second eye (flipped)

        pixels.write()
        offset += 1
        time.sleep(0.05)

    t = time.monotonic()

    if (t - prevtime) > 8:  # Every 8 seconds...
        mode += 1  # Next mode
        if mode > 1:  # End of modes?
            mode = 0  # Start modes over

        if rgb_idx > 2:  # reset R-->G-->B rotation
            rgb_idx = 0

        color = rgb_colors[rgb_idx]  # next color assignment
        rgb_idx += 1

        for i in range(0, numpix):
            pixels[i] = (0, 0, 0)

        prevtime = t

# SPDX-FileCopyrightText: 2017 Mikey Sklar for Adafruit Industries
#
# SPDX-License-Identifier: MIT

#
# Kaleidoscope_Eyes_NeoPixel_LED_Goggles.py
#
import time

import board
import neopixel

try:
    import urandom as random  # for v1.0 API support
except ImportError:
    import random

numpix = 32  # Number of NeoPixels
pixpin = board.D0  # Pin where NeoPixels are connected

mode = 0  # Current animation effect
offset = 0  # Position of spinny eyes

rgb_colors = ([255, 0, 0],  # red
              [0, 255, 0],  # green
              [0, 0, 255])  # blue

rgb_idx = 0  # index counter - primary color we are on
color = rgb_colors[rgb_idx]
prevtime = 0

pixels = neopixel.NeoPixel(pixpin, numpix, brightness=.3, auto_write=False)

prevtime = time.monotonic()

while True:
    i = 0
    t = 0

    # Random sparks - just one LED on at a time!
    if mode == 0:
        i = random.randint(0, (numpix - 1))
        pixels[i] = color
        pixels.write()
        time.sleep(0.01)
        pixels[i] = (0, 0, 0)

    # Spinny wheels (8 LEDs on at a time)
    elif mode == 1:
        for i in range(0, numpix):
            c = 0

            # 4 pixels on...
            if ((offset + i) & 7) < 2:
                c = color

            pixels[i] = c  # First eye
            pixels[(numpix - 1) - i] = c  # Second eye (flipped)

        pixels.write()
        offset += 1
        time.sleep(0.05)

    t = time.monotonic()

    if (t - prevtime) > 8:  # Every 8 seconds...
        mode += 1  # Next mode
        if mode > 1:  # End of modes?
            mode = 0  # Start modes over

        if rgb_idx > 2:  # reset R-->G-->B rotation
            rgb_idx = 0

        color = rgb_colors[rgb_idx]  # next color assignment
        rgb_idx += 1

        for i in range(0, numpix):
            pixels[i] = (0, 0, 0)

        prevtime = t

With the electronics squared away, let’s move on to the arts & crafts part of the project!

The NeoPixel LEDs are very bright and focused. Let’s make some diffusers to soften the light. (This is optional)

Trace one of the lenses on a piece of paper, then cut it out with scissors. Ordinary printer/copier paper works just fine, or I had this fancy-pants vellum on-hand (it required two layers).

If you have access to a laser cutter (through a local hackerspace, your school, whatever), measure the diameter of the lenses for cutting new ones. 1/16" white acrylic works well for this.

Some of our early photos show ring-shaped diffusers, but we found the goggles were best used as a decorative hatband and not worn (more on this later). So go ahead and make solid diffusers. It’s much easier and looks cool.

Connect the battery briefly to make sure all the electronics are happy prior to final assembly. It’s easier to troubleshoot while everything’s out in the open.

If using metal goggles, make sure there’s no contact between the goggles and any exposed conductors.

The rings are then secured in place with a few dabs of hot glue or fast-setting epoxy. Glue just a couple spots at a time, so you can hold the rings centered while it sets.

Finally, the Trinket is then glued to the outer edge of the eye cup, with the USB port and battery connector both accessible. (If using metal goggles, use tape or something to provide an insulating layer.) The wires can be folded and held in place with additional dabs of glue.

PRO TIP: if you used hot glue and need to remove the rings later, dip a Q-Tip in rubbing alcohol, touch it to the edge of each blob of glue and allow it to soak in for a few seconds. This doesn’t dissolve the glue; it seeps between the two parts and cleanly breaks the bond. The glue should peel away with little effort. Science!

SAFETY AND COMMON SENSE

Your LED goggles are a fashion accessory — they should be worn on your forehead or on a hat, not over your eyes. Even if you block most of the light inside, even a small scattered bit is still very bright and will cause headaches, maybe even vomiting. If you leave out the diffusers and try to see through the rings, peripheral vision is severely limited. Wearing these goggles on one’s face is just not smart…stick them up above!

If you’ve modified a pair of welding or safety goggles, their design is now compromised and they should no longer be used for welding or safety!

For the same reasons, if attending an event like Burning Man, take one (or several) pairs of “real” sealed dust goggles in addition to your LED “fun” goggles. Don’t rely on the latter for protection.

Safety Checklist:

• Never use the altered goggles for safety or eyewear; they’re strictly a fashion item.
• If your goggles have metal frames, make sure there's no contact with exposed conductors on the Trinket board, NeoPixel rings or wires.