Sunday, November 22, 2015

NeoMickey: Mickey/Minnie Mouse ears using Adafruit's Neopixels by the Brain

This article will show you how to make my NeoMickey ears.  I made a set of ears for both my girlfriend and I to use at Disneyland.  The ears were a huge success and a lot of people wanted to know where to get them.  So this is my best attempt to answer that question.

If anyone makes these and takes them to Disneyland, I would love to see a picture of them in use.  Please post a comment or you can post to my G+ page. 

The cost breakdown is included below.  The ears should run off of 3 Duracell AAA batteries for approximately 3 hours.   Rechargeable batteries have far less life, so test them before you invest in batteries.  There are other battery options for more experienced arduino makers.

I would like to add an IR receiver to this project to integrate the colors into the Glow with the Show hats sold at Disneyland.  If anyone has made significant progress with the IR coding for arduino compatible boards, please leave a comment or contact me on google+.

This article was mistakenly deleted so I am re-writing the entire thing and thus pieces may be incomplete.  Leave a comment if something is not clear and I will update asap.

This guide assumes you already know how to upload a sketch to an arduino compatible board.  If you don't you will need to learn that first.  Also, uploading to a Trinket Pro board requires you to press the reset button just before uploading.  The Flora boards don't needs this as they work just like Arduino Uno boards.

The twinkle code I used for the inner neopixel strips was written by Balázs Suhajda found on Github



Obligatory Disclaimer:
While I shouldn't have to say this anyway....I am not responsible for anything you do.  I don't care if you burn your house down or worse.  This information is for educational purposes only and you are responsible for your own actions.
Physical Warning:
This task does involve some soldering.  If you have no desire to do that, then you can find someone that knows how to solder or just go do a different project.  You can always locate your nearest Hackerspace and there should be plenty of people there that can assist.
Copyright Warning:
This project is my intellectual property that I am giving to the open-source community for non-profit use only.  

Cost estimate:
This project is not exactly cheap.  The average mickey themed illuminated head piece sold at Disneyland costs at least $20 and costs $3-5 to mass produce.   This project is not designed for mass production and thus it's going to be more expensive.  Plus this project is intended to be heavy on the bling compared to most Disney junk.  So in general, this project is going to cost some cake.  Here is a basic breakdown of costs for this project.  See the end of this tutorial for potential cost saving alternatives ideas. 

So the cheapy, not-so-great version of this project is at least $61(after shipping) while the good version is $100 (after shipping).   It may not be cheap, but if you wanna turn some heads at Disneyland/Disney World, they are very much worth the effort and money.  

List of required/optional materials:
  • One 3v microcontroller board. For this tutorial I mainly refer to the Adafruit Flora but a Trinket Pro board will also work.  A Trinket Pro board is technically the best shape to fit on the alice band, but more difficult to use for inexperienced soldering.  You cannot use the smaller Trinket boards as there is not enough memory/flash.  Do NOT use 5v boards.  (see notes below)
  • Two sets of embroidery rings, 4-inch size, one set per ear (I recommend the wood versions, the plastic versions are harder to work with)
  • Silicone or super glue, clear in color
  • Wire strippers
  • Gorilla glue
  • Hot glue & hot glue gun (technically optional)
  • 2 meters of Adafruit Neopixels (60 pixels/meter)
  • Mini push button (optional)
  • One AAA battery pack
  • Exacto knife (or razor blade)
  • Minnie Mouse bow (only needed for the Minnie version.  either buy one or make one)
  • Flat packing material (for diffusion)
  • Bubble wrap material (or a clear plastic bag, the produce bags at grocery stores works great)
  • low voltage wire (cat5 cable works great, but always use threaded core, not solid core)
  • Alice Band
  • Binder clips
  • White and black zip ties, smallest size
  • Solder and soldering iron
  • Heat shrink and heat gun

First grab the embroidery rings and take them apart. You will be using the inner rings for the main project, and the outer rings will be used later for stencilling.  The inner rings will be referred to as "the rings" from this point.

Now take the neopixels and wrap them around the rings to measure the length of neopixels required for this project.   You need to cut two strips for each ring, one for the outside of the ring and one for the inside of the ring.  You should be able to get at least 18 pixels on the inner ring, and 20 pixels on the outer ring.

Cut the strips to their measured length.  The inner strip (the shorter one) should be unsheathed, so remove it from the plastic sheathing.  It's easier to just cut off the plastic cover but dont cut the strip.  The outer strip, however, needs that plastic sheathing so don't remove it unless you know what you are doing.


The neopixel strips have tiny arrows that point the direction of travel for the data signal.  So the first pixel points to the next.  Before the first pixel is the copper contact point to where the wires must be soldered.  See the image below as the strips are cut in the middle of the contact points.  This is where you must cut the strip.  The strips always come with a set of thick wires to connect to other devices.  These wires are too thick to work with here, and the sheathing is too thick at the very start.  So follow the example above and cut the strip starting after the first pixel or two. 

(image from Adafruit's site)

Take the strips and solder a low voltage wire to each contact point.  I advise you make the lengths of each wire at least 2 feet to start with.  This will give you lots of wiggle room later on.   You may need to cut away some of the plastic sheathing for the outer strip in order to attach the wires.

I recommend you use the same color wires for all the 5v (positive) contact points and another color for all the ground (negative) contact points on all four neopixel strips.   The data cables, however, should be all different colors as the program calls for 3 different software strips.   So two of the data cables will join together as one, and the other two cables are independent.  the coordinated use of cable colors will greatly help you later on.  

Once the wires are attached, first test them on your arduino if possible.  If you don't deal with neopixels a lot, then you will want to test them before you start gluing things.   

Test code: (adjust the pin assignments as needed.  refer to the NeoPixel uber guide for basic testing instructions.  you can use their test code or the code included below)
#include <Adafruit_NeoPixel.h>  // load the needed library
#define INPINLEFT 9    // pin for inner right ring 
#define INPINRIGHT 11  // pin for inner left ring 
#define OUTPIN 13      // pin for outer ring 
// 
#define Pixels 10      // # of pixels on inner ring 
#define OUTPixels 10   // # of pixels on outer ring 
Adafruit_NeoPixel stripL = Adafruit_NeoPixel(Pixels, INPINLEFT, NEO_GRB + NEO_KHZ800); 
Adafruit_NeoPixel stripR = Adafruit_NeoPixel(Pixels, INPINRIGHT, NEO_GRB + NEO_KHZ800); 
Adafruit_NeoPixel stripOUT = Adafruit_NeoPixel(OUTPixels, OUTPIN, NEO_GRB + NEO_KHZ800)
float redStatesL[Pixels]; float blueStatesL[Pixels]; float greenStatesL[Pixels]; float redStatesR[Pixels]; 
float blueStatesR[Pixels]; float greenStatesR[Pixels]; float fadeRate = 0.96; 
float a = 0; int f = 0; int state = 1; int count = 0; int loopcount = 0; int masterloop = 0; 
float b = 0; int g= 0; int h= 0; int i = 0; int x = 0; int y = 0; int z = 0; int wait = 5; 
int pause = 5; int count3 = 0; 

void setup() { 
  stripL.begin();  stripL.show(); // Initialize all pixels to 'off' 
  stripR.begin();  stripR.show(); // Initialize all pixels to 'off' 
  stripOUT.begin();  stripOUT.setBrightness(50); 
  stripOUT.show(); // Initialize all pixels to 'off' 
}  
void loop () 
{ stripL.setBrightness(255); 
stripR.setBrightness(255); 
      loopcount++; 
 if(loopcount == 4){ 
    b+=.5;   
    for(float f=0; f<OUTPixels; f++){ 
      stripOUT.setPixelColor(f, stripOUT.Color(170,0,170));   } 
      
      if(b==0){stripOUT.setPixelColor(b, stripOUT.Color(0,0,0));  
    stripOUT.setPixelColor(OUTPixels, stripOUT.Color(5,0,5));  
    stripOUT.setPixelColor(OUTPixels-1, stripOUT.Color(10,0,10));  
    stripOUT.setPixelColor(OUTPixels-2, stripOUT.Color(20,0,20));  
    stripOUT.setPixelColor(OUTPixels-3, stripOUT.Color(170,0,170));  // 
    }else if(b==1){stripOUT.setPixelColor(b, stripOUT.Color(0,0,0));  
    stripOUT.setPixelColor(b-1, stripOUT.Color(5,0,5));  
    stripOUT.setPixelColor(OUTPixels, stripOUT.Color(10,0,10));  
    stripOUT.setPixelColor(OUTPixels-1, stripOUT.Color(20,0,20));  
    stripOUT.setPixelColor(OUTPixels-2, stripOUT.Color(170,0,170));  // 
    }else if(b==2){stripOUT.setPixelColor(b, stripOUT.Color(0,0,0));  
    stripOUT.setPixelColor(b-1, stripOUT.Color(5,0,5));  
    stripOUT.setPixelColor(b-2, stripOUT.Color(10,0,10));  
    stripOUT.setPixelColor(OUTPixels, stripOUT.Color(20,0,20));  
    stripOUT.setPixelColor(OUTPixels-1, stripOUT.Color(170,0,170));  // 
    }else if(b==3){stripOUT.setPixelColor(b, stripOUT.Color(0,0,0));  
    stripOUT.setPixelColor(b-1, stripOUT.Color(5,0,5));  
    stripOUT.setPixelColor(b-2, stripOUT.Color(10,0,10));  
    stripOUT.setPixelColor(b-3, stripOUT.Color(20,0,20));  
    stripOUT.setPixelColor(OUTPixels, stripOUT.Color(170,0,170));  // 
    }else{ 
      stripOUT.setPixelColor(b, stripOUT.Color(0,0,0));   
      stripOUT.setPixelColor(b-1, stripOUT.Color(5,0,5)); 
      stripOUT.setPixelColor(b-2, stripOUT.Color(10,0,10)); 
      stripOUT.setPixelColor(b-3, stripOUT.Color(20,0,20)); 
      stripOUT.setPixelColor(b-4, stripOUT.Color(170,0,170));  } //                     
  loopcount=0; 
  } 
  if(b==OUTPixels){b=0;}   
} // end void loop

After a successful test, use the hot glue gun to glue together the contact points you just soldered on each strip.  This will both waterproof the contact points and also provide additional strength to keep the wires from coming loose.

Now use the hot glue gun and place glue around the inside of the ring.  Then quickly place the inner strip on that path of glue till it cools.   Next, add some gorilla glue to the outer face of the ring all the way around.  This glue won't dry fast so go slowly here and have the binder clips ready.  You want to position the outer strip so that the wires begin at the same place as the inner strip (see image below)

Once the outer strip is placed, use the binder clips to hold it in place.  Give it about an hour to fully dry.   Don't get the glue on the face of the outer strip because once it's dry it will block the light from the LEDs.
  

Do another test if possible to ensure the wires didn't come loose.

Now it's time to cut out some diffusion material.  The diffusion material I used is the packing material used for new monitors but you can also use the flat packing material found at walmart next to the bubble wrap.  If it's very thin, you'll want more than one layer.

Use the outer ring of the embroidery rings as a stencil for this material.  Use an exacto knife to cut out the stencils.

Once you have enough stencils cut, glue on one side using the silicone glue (super glue may not stick well to the plastic sheathing).  While it dries, put some weight on it to ensure all 360 degrees of glue is firmly attached.   After about 40 minutes, the glue should be plenty dry.   Before you attach the other side, first cut up some bubble wrap and place it inside the ring.  You really don't need much here.  The bubble wrap really goes a long way to help carry the light across the center of the ring.  Be careful using hot glue here as it may just melt the material.  So test it first. 
 
(left: no bubble wrap inserted yet.  right: bubble wrap inserted)

Once the bubble wrap has been placed, go ahead and add the other side of the diffusion material.   If you don't have any bubble wrap, you can use a clear plastic bag from the grocery store.

(both sides of diffusion material attached with bubble wrap inside)

Give the ears another test when fully dry. 


Now you need to decide on the positioning of the ears on the alice band.  Too high towards the center and it will look like round antennae while too low and you will look like Deamau5 instead of Mickey Mouse.  Once you find the ideal location, mark the alice band.

A note on the Alice Band:  You can technically use any alice band you want.  The band I am recommending above was the best for this project for two reasons.  1) it has a weave pattern which allowed me to just loop through the zip ties so I didnt have to drill any holes myself.  and 2) the band has a comb built into band which keeps the band firmly attached to your hair/head.  Keep in mind with the ears attached, the project will become somewhat top heavy, and the flat panels will easily catch a gust of wind.  So ensuring they stay affixed to your head is critical.  You don't want them them fall off and break .

Once you find the vertical positions, you need to decide exactly what part of the rings are going to make contact with the alice band.  Using the test code above, you will notice the rotating pattern of the outer strips of LEDs.   Both strips have a starting point, so you will need to make sure the starting point of each strip is identical on both sides.  After that, you need to ensure the direction of rotation pattern is going around clockwise on one ear and counter clockwise on the other ear.

Once you have that all figured out, you will see the point where the rings make contact with the alice band.  From there, you can use the white zip tie to poke a hole through the diffusion material just above the contact point of the ring.  Be careful here as neither the glue or diffusion material is very strong so don't let the zip tie pull off the diffusion material.  Zip tie the ring to the band where you marked it earlier and tighten the zip tie all the way.

Now let's extend the battery pack wires.  If you intend to use the JST connector as shown in the image below, then you will need to make the wire longer in order to reach the board on the other side of the alice band.  You can also buy a JST extension cable from Adafruit or other places. 

Per the image below, the Flora boards have an on/off switch as well.  This can be a more convenient switch compared to the battery pack.  However, if you are using the Trinket Pro board, it will not have an on/off switch (only a reset switch).   Another Flora advantage is you can connect the battery pack's JST cable directly into the JST jack on the Flora board as shown below.  This will allow you to use the on/off switch on the Flora.  However, if you connect the battery pack directly to the BATT and GND pins on the Flora board, you will not be able to use the on/off switch on the Flora.  It will simply always be ON while power is being fed to the board.



If you are not using the JST connector, or if you are using a Trinket Pro board instead, then just cut off the JST end and splice on an extension to the wires.   Once the battery pack has a long enough wire, you can attach the pack to the alice band.  Hot glue works very well here, but if you want room to change your mind, you can use gorilla glue instead. In any case, I suggest attaching it with a rubber band temporarily so you can test and adjust the positioning as needed.  If you glue the pack too low, you won't be able to reach the on/off switch.  I've made that mistake so be careful.  Also, too high and it could make contact with the ear above it, which could put stress on the pack's wires.

(This battery pack was glued too low so the on/off switch is hard to reach)


Now comes the very hard part...organizing the wires.

For a full set of ears, you will have 4 five-volt positive wires, 4 five-volt ground wires, 4 data wires, one positive battery wire, and one ground battery wire.

Between the Trinket Pro and Flora boards, their GPIO pin holes are small and can only fit one small wire.  So you will need to first splice together all the five-volt positive wires and join then to one new low voltage cable that will fit into the holes of the Trinket board.  Same will apply to the data wires for ONLY the outer strips.  The ground wires also need to be spliced into one wire, but you also need to add the ground wire for the battery pack into the group of ground wires.  From there you have all the single wires you will need to connect to the board.  Fyi, cat5 inner wires work perfectly for most boards.

Per the code below, here is how you need to connect the wires.
  • The ground wire goes to the GND pin
  • The 5v power wire (+5v) goes to the 3v pin
  • The wire for the outer strips go to pin 13 for Trinket Pro, or D10 on Flora
  • The wire for the left inner strip goes to pin 11 for Trinket Pro, or D6 for Flora
  • The wire for the right inner strip goes to pin 9 for Trinket Pro, or D12 for Flora
  • (optional) If you want to change programs with a push button, then solder in the push button on pins 6 and 3 on the Trinket Pro.  For Flora boards, use D9 and the adjacent GND pin, and change the code's INbutton to 9. 
You will need to adjust the below code (at the very top) to change the pin numbers depending on your board.  For the Flora boards, leave out the D in the pin number.  So for pin D9, just use 9.  Once the pin numbers have been adjusted to fit your board, you can upload the code to your board.

If you are making both Minnie and Mickey ears, then you will want to change the color of the outer LEDs.  The Minnie code below is set to pink.  So I used blue for the Mickey ears, but you can use whatever color you want.  To adjust the code, locate and change all the text that reads Color(10,0,10) .  From here, change the numbers to match the correct RGB values.

Blue = 0,0,255
Pink = 170,0,170
Red = 255,0,0
Green = 0,255,0
##include <Adafruit_NeoPixel.h>  
#define INPINLEFT 9    // GPIO pin for inner right strip 
#define INPINRIGHT 11  // GPIO pin for inner left strip 
#define OUTPIN 13      // GPIO pin for BOTH outer strips 
// 
#define Pixels 18      // # of pixels on the inner stripas
#define OUTPixels 20   // # of pixels on the outer strips
#define INbutton 6   // # input button (detects the button press)  
#define lowButton 3   // # LOW button  (aka ground), leave as is for Flora (ie not needed)
Adafruit_NeoPixel stripL = Adafruit_NeoPixel(Pixels, INPINLEFT, NEO_GRB + NEO_KHZ800); 
Adafruit_NeoPixel stripR = Adafruit_NeoPixel(Pixels, INPINRIGHT, NEO_GRB + NEO_KHZ800); 
Adafruit_NeoPixel stripOUT = Adafruit_NeoPixel(OUTPixels, OUTPIN, NEO_GRB + NEO_KHZ800); 
  
float redStatesL[Pixels]; float blueStatesL[Pixels]; float greenStatesL[Pixels]; 
float redStatesR[Pixels]; float blueStatesR[Pixels]; float greenStatesR[Pixels]; 
float fadeRate = 0.96; float a = 0; int f = 0; int state = 1; int count = 0; 
int loopcount = 0; int masterloop = 0; int cycle = 1; float b = 0; 
int g= 0; int h= 0; int i = 0; int x = 0; int y = 0; int z = 0; int wait = 5; 
int pause = 5; int count3 = 0; 

void setup() {
  stripL.begin();  stripL.show(); // Initialize all pixels to 'off' 
  stripR.begin();  stripR.show(); // Initialize all pixels to 'off' 
  stripOUT.begin();  stripOUT.setBrightness(50); 
  stripOUT.show(); // Initialize all pixels to 'off' 
 digitalWrite(INbutton, HIGH); 
   
  for(uint16_t l = 0; l < Pixels; l++)  
  { 
    redStatesL[l] = 0; 
    greenStatesL[l] = 0; 
    blueStatesL[l] = 0; 
  } 
void loop ()  { 
if(cycle>3){cycle=1;}  
  int sensor = digitalRead(INbutton); 
if(sensor == LOW){ delay(500); cycle++; }  
  
if(cycle==1){ 
stripL.setBrightness(255); 
stripR.setBrightness(255); 
      loopcount++; 
 if(loopcount == 3){ 
    b+=.5;    
    for(float f=0; f<OUTPixels; f++){ 
      stripOUT.setPixelColor(f, stripOUT.Color(170,0,170));  } 
      if(b==0){stripOUT.setPixelColor(b, stripOUT.Color(0,0,0));  
    stripOUT.setPixelColor(OUTPixels, stripOUT.Color(5,0,5));  
    stripOUT.setPixelColor(OUTPixels-1, stripOUT.Color(10,0,10));  
    stripOUT.setPixelColor(OUTPixels-2, stripOUT.Color(20,0,20));  
    stripOUT.setPixelColor(OUTPixels-3, stripOUT.Color(170,0,170));  // 
    }else if(b==1){stripOUT.setPixelColor(b, stripOUT.Color(0,0,0));  
    stripOUT.setPixelColor(b-1, stripOUT.Color(5,0,5));  
    stripOUT.setPixelColor(OUTPixels, stripOUT.Color(10,0,10));  
    stripOUT.setPixelColor(OUTPixels-1, stripOUT.Color(20,0,20));  
    stripOUT.setPixelColor(OUTPixels-2, stripOUT.Color(170,0,170));  // 
    }else if(b==2){stripOUT.setPixelColor(b, stripOUT.Color(0,0,0));  
    stripOUT.setPixelColor(b-1, stripOUT.Color(5,0,5));  
    stripOUT.setPixelColor(b-2, stripOUT.Color(10,0,10));  
    stripOUT.setPixelColor(OUTPixels, stripOUT.Color(20,0,20));  
    stripOUT.setPixelColor(OUTPixels-1, stripOUT.Color(170,0,170));  // 
    }else if(b==3){stripOUT.setPixelColor(b, stripOUT.Color(0,0,0));  
    stripOUT.setPixelColor(b-1, stripOUT.Color(5,0,5));  
    stripOUT.setPixelColor(b-2, stripOUT.Color(10,0,10));  
    stripOUT.setPixelColor(b-3, stripOUT.Color(20,0,20));  
    stripOUT.setPixelColor(OUTPixels, stripOUT.Color(170,0,170));  // 
    }else{ 
      stripOUT.setPixelColor(b, stripOUT.Color(0,0,0));   
      stripOUT.setPixelColor(b-1, stripOUT.Color(5,0,5)); 
      stripOUT.setPixelColor(b-2, stripOUT.Color(10,0,10)); 
      stripOUT.setPixelColor(b-3, stripOUT.Color(20,0,20)); 
      stripOUT.setPixelColor(b-4, stripOUT.Color(170,0,170));  } // 
                    
  loopcount=0; 
  } 
  if(b==OUTPixels){b=0;}        
/////////////////////////////////////////////////////   
// begin Balázs Suhajda code https://gist.github.com/suhajdab/9716028
   if (random(20) == 1)  
   { 
      uint16_t i = random(Pixels); 
      uint16_t H = random(Pixels); 
      if (redStatesL[i] < 1 && greenStatesL[i] < 1 && blueStatesL[i] < 1)  
      { 
        redStatesL[i] = random(256); 
        greenStatesL[i] = random(256); 
        blueStatesL[i] = random(256); 
      } 
      if (redStatesR[H] < 1 && greenStatesR[H] < 1 && blueStatesR[H] < 1)  
      { 
        redStatesR[H] = random(256); 
        greenStatesR[H] = random(256); 
        blueStatesR[H] = random(256); 
      } 
  } 
/////////////////////     
    for(uint16_t l = 0; l < Pixels; l++)  
    { 
      if (redStatesL[l] > 1 || greenStatesL[l] > 1 || blueStatesL[l] > 1) { 
        stripL.setPixelColor(l, redStatesL[l], greenStatesL[l], blueStatesL[l]);    
        if (redStatesL[l] > 1) { 
          redStatesL[l] = redStatesL[l] * fadeRate; 
        } else { 
          redStatesL[l] = 0; 
        }         
        if (greenStatesL[l] > 1) { 
          greenStatesL[l] = greenStatesL[l] * fadeRate; 
        } else { 
          greenStatesL[l] = 0; 
        }         
        if (blueStatesL[l] > 1) { 
          blueStatesL[l] = blueStatesL[l] * fadeRate; 
        } else { 
          blueStatesL[l] = 0; 
        }         
      } else { 
        stripL.setPixelColor(l, 0, 0, 0); 
      } 
    } 
/////////////////////     
    for(uint16_t g = 0; g < Pixels; g++)  
    { 
      if (redStatesR[g] > 1 || greenStatesR[g] > 1 || blueStatesR[g] > 1) { 
        stripR.setPixelColor(g, redStatesR[g], greenStatesR[g], blueStatesR[g]);    
        if (redStatesR[g] > 1) { 
          redStatesR[g] = redStatesR[g] * fadeRate; 
        } else { 
          redStatesR[g] = 0; 
        }         
        if (greenStatesR[g] > 1) { 
          greenStatesR[g] = greenStatesR[g] * fadeRate; 
        } else { 
          greenStatesR[g] = 0; 
        }         
        if (blueStatesR[g] > 1) { 
          blueStatesR[g] = blueStatesR[g] * fadeRate; 
        } else { 
          blueStatesR[g] = 0; 
        }         
      } else { 
        stripR.setPixelColor(g, 0, 0, 0); 
      } 
    } 
//////////////////////////////////    
    stripL.show();  
    stripR.show();  
    stripOUT.show(); 
    delay(10); 
// end Balázs Suhajda code https://gist.github.com/suhajdab/9716028
} //end cycle =1   
//////////////////////////////////////////////////////////////////////////////////////////////////////// 
//////////////////////////////////////////////////////////////////////////////////////////////////////// 
//////////////////////////////////////////////////////////////////////////////////////////////////////// 
if(cycle == 2) 
stripL.setBrightness(255); 
stripR.setBrightness(255); 
      float jump = 0.25; 
      if(a>100){state = 0;} 
      if(a<3){state = 1;} 
      if(state==0)   /////////////////////////////////// 
      {    
        for(float f=OUTPixels; f>-1; f--){ 
          stripOUT.setPixelColor(f, stripOUT.Color(a,0,a));    
          stripL.setPixelColor(f, stripOUT.Color(a,0,a));    
          stripR.setPixelColor(f, stripOUT.Color(a,0,a));   }  
     a-=jump;            
      } 
      if(state==1)  /////////////////////////////////// 
      { 
        count = 0; 
        for(float f=0; f<OUTPixels; f++){ 
          stripOUT.setPixelColor(f, stripOUT.Color(a,0,a));   
          stripL.setPixelColor(f, stripOUT.Color(a,0,a));   
          stripR.setPixelColor(f, stripOUT.Color(a,0,a));  } 
     a+=jump;      
      } 
    stripL.show();  
    stripR.show();  
    stripOUT.show(); 
} // end cycle == 2 
//////////////////////////////////////////////////////////////////////////////////////////////////////// 
//////////////////////////////////////////////////////////////////////////////////////////////////////// 
//////////////////////////////////////////////////////////////////////////////////////////////////////// 
if(cycle==3){ 

count3++; 
stripR.setBrightness(50); 
stripL.setBrightness(50); 
stripOUT.setBrightness(50); 
g = random(255); 
h = random(255); 
i = random(255); 
x = random(255); 
y = random(255); 
z = random(255); 
if(count3==1500){ 
    for(byte f=0;f<OUTPixels;f++){ 
    stripR.setPixelColor(f, stripR.Color(g,h,i)); 
    stripL.setPixelColor(f, stripL.Color(g,h,i)); 
    stripOUT.setPixelColor(f, stripOUT.Color(x,y,z) );       
    stripOUT.setPixelColor(f-1, stripOUT.Color(x,y,z)); }  
    stripOUT.show();stripL.show();stripR.show();delay(wait);delay(pause);count3=0; 
    } 
}    // end cycle3 
} // end void loop
Once the code is uploaded and all is working, take some time to waterproof any exposed contact points.  You don't have to do this, but Disney parks tend to have water here and there, so it's not a bad idea to waterproof.  If any water comes in contact with any metal on the board while powered on, the whole thing will be ruined forever.  Additionally, this will also provide additional strength to the wires to keep them from ripping out and also prevent them from touching each other and this shorting out the board.   To cover the wires running atop the alice band, you could use some electrical tape and glue to keep it in place.

If you're doing the Minnie version, you can now add the red bow to the alice band. I've not found a good glue that works on the outside of the diffusion material to hold the bow in place.  I used the gorilla glue but it eventually came loose.  The sides won't matter as much.  Just focus on gluing it to the top of the alice band.  Hot glue works quit well here.  

Also be sure to stress test the ears before taking them out for a production run.  Test the alice band's movement and ensure the wires aren't too tight and ripping out of the solder points.  Also ensure the wires aren't causing the ears to move.   Make sure the ears are tightly connected to the alice band.  If they wiggle at all, they are too loose.  Watch for any signs of electrical problems.  If the LED animation freezes on a full battery, then chances are some wires are touching but they shouldn't be.



Adafruit featured my project on their wearable wednesdays episode.  My project begins at 4:36. 

Above all the ears were a huge success.  We heard lots of comments from people such as "look at those" and "where did they get those ears."  But the employees loved them the most.  We had a a few employees come right up to us and ask us all about them.   And Mickey himself was impressed as well.  



Alternative & Cost Saving Options:
  • Instead of using the 60 pixels per meter strips of neopixels, you could settle for the cheaper strips of 30 per meter.  In my opinion, it really doesn't look as good and you would have to adjust the code to make it look decent. 
  • On that note, you could save some  money by buying one 60 pixels/meter strip and one 30 pixels/meter strip, and use the 30/m strip for the inner ear lights.  The ears look best with the 60/m strip on the outside and with the diffusion material covering the inner strip, the fewer pixels won't be as noticeable.
  • Instead of using a Flora board for $20, you could use a Trinket Pro for $10.  Technically this is a more size efficient board, but harder to work with for the inexperienced.  The Flora is bigger and kinda looks odd when placed on the alice band, but it's way easier to solder on wires.   If you are experienced with arduino and soldering, go with Trinket Pro 3v.  Whatever you do, make sure it's 3v and not 5v boards. 
  • Instead of two strips per ear, you could just do one outer strip per ear and ignore the inner strips to save $$ on neopixels. 
  • If you want to spend the extra $$ and go ultra bling, you can get the neopixel strips that are 120 per meter.  The animation of the LEDs will be much smoother, but beware more pixels will eat more battery life.  
  • This project references Adafruit parts which may not be the cheapest but Adafruit is my favorite.  You could find something similar for a better price and use those parts instead.  But you had best know what you are doing because I am not going to help you figure it out.  
  • Some people don't like the looks of the AAA battery pack.  I can't say I blame them but this guide is for somewhat novice users.  So anyone with a deep desire to make it look a tad prettier could switch to a LiPo battery instead. But keep in mind you will also need to buy some kind of a charger and you will want to get at least two batteries so you have a full battery on standby. 
  • UPDATE:  I have recently found what appears to be a cheap knock off version of the neopixels on Amazon.  They appear to be the same thing at 1/4 the price.  So if you need to make multiple sets of ears, this could be a good way to save money.  But I have not tried it so I cannot guarantee anything.