Saturday, May 16, 2015

Twinkling Daffodils Based on Adafruit Neopixel Tiara (As Seen On Adafruit Show-and-Tell)

This was a fun project.  The final tiara project its for my granddaughter's pre-school graduation. I would have done a mortar board, but I think it might be unseemly for a 5-year old to wear a tricked-out costume in her procession, so I decided on a tiara that should could wear at family events to celebrate her accomplishment.

Rather than the headband plus wires in the tutorial, I decided to buy a tiara and add the neopixels to it.  I looked all over Michael's, AC Moore, ToysRUs, Itzaparty, etc, and found nothing suitable, but I found this online and bought 2 so I'd have one for backup.

Meanwhile, I was preparing for our local "in-Bloom" festival and decided to see what I could do with fake daffodils. That same day (but I had the idea first) Wearable Wednesday had a floral bouquet project, so I knew I was on the right track. It turns out fake daffodils are hard to find, but AC Moore had a fake potted plant.

Here's what I bought to add neopixels to

I'm in this to learn, and I was not disappointed by this project.

What I learned (or at least some of it...some things re-learned)

Screen shot from video re tiara on a breadboard
That's a 3V Trinket with 4 neopixels connected to 3V pin on Trinket via breadboard
Powered by a DIY 5V regulated power supply
  1. See my post on setting up the neopixels on a breadboard...that was the initial test. I got it going with 4 neopixels, both a Gemma and a 3V Trinket, and some alligator clips
  2. I wanted to add colors to the code supplied.  The comments are pretty clear:  
    // Here is where you can put in your favorite colors that will appear!
    // just add new {nnn, nnn, nnn}, lines. They will be picked out randomly
    //                          R   G   B
    uint8_t myColors[][3] = {{232, 100, 255},   // purple
                             {200, 200, 20},   // yellow
                             {30, 200, 200},   // blue
                              };                   
    // don't edit the line below
    #define FAVCOLORS sizeof(myColors) / 3
    However, I was not sure about the  [][3] construct (i.e., not specifying one dimension of the array).  Some Googling revealed that if the array is initialized, the dimension can be omitted. This one is initialized, so all I had to do was  more colors (more rows of {R,G,B}). The comments in the example code say that, but not why.  I have been programming for 40 years in a variety of languages, so arrays are very familiar--sometimes I just have to learn the details to apply them with understanding. So, I added 5 colors.  
  3. The tiara example shows the neopixels powered from the 3.3V pin on the Gemma, and that works with both a Gemma and a 3V Trinket. The Adafruit Neopixel Uberguide says to always power neopixels separately from the power pin on the microcontroller, and that they need 5V. As far as I can tell the guide is accurate, but for projects using a few neopixels from a Gemma or 3V Trinket, powering from the 3.3V pin works. The guide also says not to use alligator clips, but I didn't have any trouble with them for testing.
  4. The Uberguide says to add a 1000uf capacitor across the + and - pins of the power supply, and also a 300-500Ohm Resistor between the data pin and the first neopixel.  I will reserve that knowledge for future projects. Becky's tiara tutorial does not mention this, and the circuit works without them. Just for grins, I will add the cap and resistor to the daffodil circuit.
  5. Further, the guide says that if you're using a 3V microcontroller and power the neopixels from a 5V supply, you need a logic level shifter. I decided to stick with the tutorial for the tiara (3V Gemma with neopixels connected to 3.3V and GND on the Gemma), but for the daffodils I will use a 5V Trinket to avoid the need for a level shifter, and power the neopixels from power rail. not the 5V pin on the Trinket. I was going to power the circuit from  my 5V regulated power supply, but that adds an extra component, so I'll just solder a barrel jack on the perma-proto and use a 5V wall wart (I'd need power anyway to power the 5V supply). I'm using the Adafruit Compact Switching Power Supply.
  6. After fussing with ideas about an enclosure, I decided that I didn't need one. The circuit is very simple, and I don't need a lot of internal connections. So, I'm putting it on a small mint tin size perma-proto, with a barrel jack for the connection to power. Since the power rails are down the center, I can place the trinket horizontally across the board, with the BAT and GND pins over the power rails, supplied by the barrel jack.  Since pin #4 is next to GND, I can modify the data pin in the code and connect DATA, GND, and Vcc to header pins to connect to the 3-wire connector and on to the daffodils.  That's it.  I will put 3/4" standoffs on the 4 corners of the perma proto to provide clearance.I don't need to solder anything other than the 3 wires to the Trinket...that will make it easier to reuse.
  7. Speaking of the 3-wire connector, I found some, labeled B2-2832, that I ordered a while back, I don't remember from where. Googling the number doesn't yield anything useful. Anyway, it simplified the wiring a lot.  I'll cut it in half, use the receptacle end to attached to  the Trinket pin and power rails, and solder the other ends to data. power and ground coming from the circuit.  I'll put the resistor in the connection on the data wire. 
  8. I had originally planned to put the neopixels inside the corona (trumpet part of daffodil). My wife, who understands crafty stuff better than I, suggested just positioning the neopixels outside of the flowers, to let flowers diffuse the light. This turned out to look better, and also simplify the project.  I would have had to clip out the flowery stuff inside the corona (fake pistil, stigma, and anther), poke holes in the corona for wires, and solder the inter-flower data wires and heat shrink on the flower.I made more work for myself because I started out with the original design in mind, but the tutorial reflects the improved process.

Finished Product

Parts, Supplies, and Tools

  1. Barrel Jack
  2. 5V Trinket
  3. 1000uf Capacitor
  4. 470 Ohm Resistor
  5. Breadboard (size not important, I used a half-size)
  6. Silicone-Coated stranded wire
  7. 22-gauge solid core hookup wire
  8. Heat shrink tubing
  9. 3-wire connector (optional, here's an example for illustration--or use what you have)
  10. header pins (also optional, but it made it easier for me)
  11. flora neopixels V2 (6) (I bought this sheet of 20--they also come in quantities of 4)
  12. small mint tin size perma proto-board
  13. 3/4 inch nylon standoffs & screws (4)
  14. 5V or switchable wall adapter
  15. Short alligator clips
  16. In-line power switch
  17. Fake daffodils in fake flower pot (you're on your own here--I found mine at AC Moore, try Michael's, etc.)
  18. Green florist's tape 
  19. Soldering Iron and requisite accessories--solder, stand, sucker, helping hands, etc
  20. Multimeter
  21. Flush Clippers
  22. Heat gun 
  23. If you really want to finish it off, put it in a suitable encosure and drill holes for power input and output to flowers--I did not do that

Construction/testing process

Note: this project could be accomplished without soldering, but it would not be as tidy, and you would need clips, and/or solderless wire connectors and/or a larger Arduio (like an Uno) to make connections via jumber wires. Making reliable connections to neopizels without soldering is tough. It's easy soldering, though.

1st neopixel soldered
Red to power, black to ground, white to data pin, yellow to next neopixel
Neopixels wired and ready for test

  1. See Fritzing diagram above.  The circuit is really simple, but the construction has a lot of steps, so...the first thing I did was verify that the above circuit works with a 5V Trinket, external power, and one neopixel.  (Note, this requires modifying the Adafruit NeoPixel_Tiara sketch to use just 1 neopixel.  See above for other possible changes--colors and timing, for example).
    That was fine, so I added the cap and resistor and that was also fine. As expected, but it's good to start with something that has been proven to work. Note that I recommend a lot of testing as you go through the project. It's a lot easier to find and fix problems as you build, rather than trying to figure out where you went wrong after the project is all put together.
  2. Next step, build up to a pre-assembly test.
    Solder + and - leads to neopixels in the lengths we'll need to go from the flowers to the circuit. Watch the data arrows on the neopixels--take care to match output of one to input of the next.
    Solder leads to BAT, GND, and pin 4 on the Trinket, in the lengths you'll need to connect to the perma-proto when you're ready.
    Using alligator clips, connect all the + wires to the power rail, all the - wires to the GND rail, the data wire to the resistor, and the other data wires to each other, and also to connect the Trinket pins to the + and - rails and to the resistor
  3. Fire up the circuit for a test (still on the breadboard). Make sure all the neopixels light up. If you want different colors, more or less colors, or different speed, change the code (see below). If it doesn't work, there are probably some missed connections or bad soldering.connections.  Check the direction of the arrows on the neopixel data pins. Keep the Trinket connected for the next test. Here's a video of this step.
  4. Now we're ready for the flowers.I had orginally planned to put the neopixels in then corona (the trumpet part).  My wife convinced me that the flowers diffusing the light would be a better effect, so I changed the design.
    Run the power wires, and the data wire to the 1st neopixel, down the stems and secure the wires to the stems temporarily. I used plastic twist ties. Continue the wires down the pot to join together in a common location at the bottom.Twist the + wires together for a power connection and the - wires together for the GND connection.
  5. Test
    Connect the flowers to the circuit on the breadboard again using alligator clips. If you left the Trinket connected it should be all set. Power it up verify and correct as before.
  6. Final Assembly
    a) Remove the alligator clips. [Making sure to check that the out arrow from one neopixel will be wired to to the in arrow of the next, put heat shrink wrap on one side of the data connection between flowers, solder the two sides together, move the head shrink over the connection and shrink with a lighter or heat gun.  Repeat for all 5 inter-flower connections. ] Not necessary if you connect directly, per new design.
    b) Solder the barrel jack to the perma-proto board. Plug the wall wart into the barrel jack and test the pins of the jack with a multimeter to be sure a) that the connections are sound and b) that you know which pin is + and which is -. With the multimeter on DC voltage, the reading should be about +5V. If it is not, there is a bad connection. If it says -5V, the meter leads are reversed.  Solder the + pin of the jack to the + rail (the one with the red line on it) on the perma-proto, and the - to the GND rail (blue line) using a short insulated wire.  The jack should be connected to holes that are part of the rail (i.e. with vertical interconnections--the first holes are not connected to the rail. (see photo)
    c) Solder a 3-pin header to horizontally across the power rails. One pin will be +, one -, and the one to the side of the rail will be connected to a perma proto row (holes horizontally interconnected).
    d) Solder one side of the 470Ohm resistor to the row the header pin is connected to, and the other side to the row to which you will connect the data wire (pin 4) from the Trinket.
    e) Solder the 1000uf capacitor across the power rail (watch the polarity: +pin to +rail, -pin to -rail)
    f) For stability, I attached a five pin long header with the plastic stopper above the perma proto through to female headers.  The holes that the top of the perma-proto are not connected to anything, and I did not solder this--it's just to hold the Trinket in place so I can reuse it easily.
    g) Place the top row of holes on the Trinket over the header pins from the last step. Solder the Trinket leads: BAT to + rail, GND to - rail, Pin 4 to the row the resistor is on.
    h) If the 3-wire connector has plugs.jacks at two ends, cut it in two pieces. You want the jack (female) end, so it will fit over the 3-pin header. Using alligator clips, connect the data, power, and ground connections to the 3-wire connector. Plug the connector to the header, and test. If there are problems, check all connections (and that you have powered the circuit).
    i) Using heat shrink wrap as with the inter-flower connections, solder and heat shrink the flowers to the 3-wire connector (taking care that the correct wires are connected).
    Here's a video of the circuit working from the perma proto...I just need to hide the wires and position the neopixels and finish soldering.
  7. Finish
    Test
    the final connection, and correct any problems.
    Remove the temporary twist ties, or whatever, from the stems, and wrap the wires and stems together with green florists tape.
    I wanted to be able to power on/off without unplugging, so I added the in-line power switch. I also added a second 3-wire connector as an extension.
    You're done

Bottom of perma-proto
Note vertical and horizontal connections

Top of perma-proto
Notte power rails in center

Perma-proto bottom, after soldering
Top view after soldering










Code (NeoPixel_Tiara by Adafruit, as modified by Virgil Machine)


/Random Flash animation for Neopixel circuits
//by Dano Wall and Becky Stern for Adafruit Industries
//based on the Sparkle Skirt, minus the accelerometer
/*2015-05-10 vm Daffodil project
Nneopixels in 6 of 11 fake daffodils in fake pot.
Designed for "Brewster in Bloom", advised by Becky's LED Bouquet project.based on the neopixel tiara project.
Uses 5V Trinket with pixels powered directly from power rails (not 5V pin on Trinket).
Powered by 5V Regulated power supply, which can be powered by wall wart or battery.
2015-05-10 */
#include <Adafruit_NeoPixel.h>

#define PIN 4  //2015-05-11 changed from pin 1 to pin 4 for ease of connection

// Parameter 1 = number of pixels in strip
// Parameter 2 = pin number (most are valid)
// Parameter 3 = pixel type flags, add together as needed:
//   NEO_KHZ800  800 KHz bitstream (most NeoPixel products w/WS2812 LEDs) 2015-05-10 vm we're using Flora neopixels v2
//   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)
//2015-05-10  changed parameter 1 to 6 for 6 neopixels in daffodils
Adafruit_NeoPixel strip = Adafruit_NeoPixel(6, PIN, NEO_GRB + NEO_KHZ800);

// Here is where you can put in your favorite colors that will appear!
// just add new {nnn, nnn, nnn}, lines. They will be picked out randomly
/*2015-05-09 vm note the [][3] specifying the dimensions of this 2-D array
1st dimension (number of rows--colors in this case--is empty, which is legal
as long as the array is initialized in-line, which this is.  The second dimension, the columns,
is the RGB components. We can add a row (color) without changing anything else. I added 5 clors
to the purple, yellow, blue that were supplied in the example.
Line 40, declaring FAVCOLORS, calculates the # of colors using the size of the initialized array.
Line 58 gets a random number between 1 and FAVCOLORs do decide which color to use, at random
2015-05-09*/
//                          R   G   B
uint8_t myColors[][3] = {{232, 100, 255},  // purple
                         {200, 200, 20},   // yellow
                         {30, 200, 200},   // blue
                         {(0,255,255)},    // cyan
                         {(255,69,0)},     // orange red
                         {(0,255,0)},      // lime
                         {(255,0,255)},    // magenta
                         {(255,0,0)},      // red
                          };
                             
// don't edit the line below
#define FAVCOLORS sizeof(myColors) / 3

void setup() {
  strip.begin();
  strip.setBrightness(40);
  strip.show(); // Initialize all pixels to 'off'
}

void loop() {
flashRandom(15, 2);  // first number is 'wait' delay, shorter num == shorter twinkle 2015-05-08 vm changed this to 15 from 5--better for flowers
flashRandom(15, 4);  // second number is how many neopixels to simultaneously light up 2015-05-08 vm changed this to 2-4-3 from 1-3-2 for grins
flashRandom(15, 3);
}

void flashRandom(int wait, uint8_t howmany) {

  for(uint16_t i=0; i<howmany; i++) {
    // pick a random favorite color!
    int c = random(FAVCOLORS);
    int red = myColors[c][0];
    int green = myColors[c][1];
    int blue = myColors[c][2];

    // get a random pixel from the list
    int j = random(strip.numPixels());
 
    // now we will 'fade' it in 5 steps
    for (int x=0; x < 5; x++) {
      int r = red * (x+1); r /= 5;
      int g = green * (x+1); g /= 5;
      int b = blue * (x+1); b /= 5;
   
      strip.setPixelColor(j, strip.Color(r, g, b));
      strip.show();
      delay(wait);
    }
    // & fade out in 5 steps
    for (int x=5; x >= 0; x--) {
      int r = red * x; r /= 5;
      int g = green * x; g /= 5;
      int b = blue * x; b /= 5;
   
      strip.setPixelColor(j, strip.Color(r, g, b));
      strip.show();
      delay(wait);
    }
  }
  // LEDs will be off when done (they are faded to 0)

}