wearables

1-start with plain leds & watch battery…..craft wire???

series & parallel - how many lights each way

Gemma & neopixels

2- find existing projects & just use code

3-tweak code

4-write code


load Arduino IDE  i have 1.6.4

        https://www.arduino.cc/en/Main/Software 

add Adafruit_NeoPixel library  https://github.com/adafruit/Adafruit_NeoPixel 

(download zip file

(unzip

(rename folder to “Adafruit_NeoPixel”

(put in Arduino Libraries folder

Accelerometer LSM303 also needs a library (link on project page at adafruit)


gemma & neopixels

2 example codes in Arduino

File : Examples : Neopixels

- simple, sets neopix to one color

- strand test under examples , does chases & color changes

change pin # & # of neopixels to match controller (gemma vs flora)


gemma & neopixels

https://learn.adafruit.com/space-face-led-galaxy-makeup 

IMG_4035.JPG


gemma & jewel

jewel hairstick project

https://learn.adafruit.com/jewel-hair-stick 

IMG_4029.JPG


a different gemma and jewel code

http://blog.cup-of-joe.me/?p=299 


gemma hoop earrings with ring

https://learn.adafruit.com/gemma-hoop-earrings/overview 

they just use the goggles code

i went with the jewel (7 led) code and added more led’s

IMG_4031.JPG



heart neopixels

gemma neopixels and light sensor

https://learn.adafruit.com/light-activated-pixel-heart/overview

IMG_4040.JPG


tie

microphone neopixels FLora

https://learn.adafruit.com/led-ampli-tie/overview 

IMG_4042.JPG


accelerometer & neopixels

needs Flora

needs LSM303 library

https://learn.adafruit.com/sparkle-skirt/overview

IMG_4054.JPG


accelerometer & neopixel ring (needs LSM303 library

needs Flora

https://learn.adafruit.com/3d-printed-flora-band/overview 

IMG_4049.JPG



goggles project

IMG_4023.JPG

IMG_4024.JPG

IMG_4025.JPG

IMG_4026.JPG

IMG_4027.JPG

IMG_4028.JPG




code for gemma and 4 neopixels

change colors with delay

/*

set pixels to various colors

with various delay times

Based on NeoPixel Library by Adafruit

*/

 

// This section is NeoPixel Variables

 

#include <Adafruit_NeoPixel.h>

 

#define PIN 1

 

// 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)

//   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)

Adafruit_NeoPixel strip = Adafruit_NeoPixel(4, 1, NEO_GRB + NEO_KHZ800);

//You can have fun here changing the colors for the code

uint32_t color1 = strip.Color(236, 79, 100); //Salmon Pink

uint32_t color2 = strip.Color(246, 216, 180); //Cream

uint32_t color3 = strip.Color(174, 113, 208); //Lavendar

uint32_t color4 = strip.Color(182, 31, 40); //Red

uint32_t color5 = strip.Color(91, 44, 86); //Purple

uint32_t color6 = strip.Color(255, 140, 0); //orange

uint32_t color7 = strip.Color(255, 0, 0); //red

uint32_t color8 = strip.Color(0, 255, 0); //green

uint32_t color9 = strip.Color(0, 0, 255); //blue

//add as many colors as desired … RGB code

 

void setup() {

   //This is for Neopixel Setup

  strip.begin();

  strip.show(); // Initialize all pixels to 'off'

}

 

void loop()

{

 

   

  strip.setBrightness(30);

  // the first number is the pixel number, 0 is the first one

 //

  strip.setPixelColor(0, color6);

  strip.setPixelColor(1, color6);

  strip.setPixelColor(2, color6);

  strip.setPixelColor(3, color6);

   

  strip.show();

  delay(3000);

 

 

  strip.setPixelColor(0, color7);  

  strip.setPixelColor(1, color7);

  strip.setPixelColor(2, color7);

  strip.setPixelColor(3, color7);

 

  strip.show();

  delay(3000);

 

 

  strip.setPixelColor(0, color8);

  strip.setPixelColor(1, color8);

  strip.setPixelColor(2, color8);

  strip.setPixelColor(3, color8);

 

   

  strip.show();

  delay(3000);

  strip.setPixelColor(0, color9);  

  strip.setPixelColor(1, color9);

  strip.setPixelColor(2, color9);

  strip.setPixelColor(3, color9);

 

 

  strip.show();

  delay(3000);

 

 

  strip.setPixelColor(0, color6);

  strip.setPixelColor(1, color6);

  strip.setPixelColor(2, color6);

  strip.setPixelColor(3, color6);

   

  strip.show();

  delay(3000);

 

}



tie

flora/neopixels/ microphone

1st code…..

/*

LED VU meter for Arduino and Adafruit NeoPixel LEDs.

Hardware requirements:

 - Most Arduino or Arduino-compatible boards (ATmega 328P or better).

 - Adafruit Electret Microphone Amplifier (ID: 1063)

 - Adafruit Flora RGB Smart Pixels (ID: 1260)

   OR

 - Adafruit NeoPixel Digital LED strip (ID: 1138)

 - Optional: battery for portable use (else power through USB or adapter)

Software requirements:

 - Adafruit NeoPixel library

Connections:

 - 3.3V to mic amp +

 - GND to mic amp -

 - Analog pin to microphone output (configurable below)

 - Digital pin to LED data input (configurable below)

 See notes in setup() regarding 5V vs. 3.3V boards - there may be an

 extra connection to make and one line of code to enable or disable.

Written by Adafruit Industries.  Distributed under the BSD license.

This paragraph must be included in any redistribution.

*/

#include <Adafruit_NeoPixel.h>

#define N_PIXELS  16  // Number of pixels in strand

#define MIC_PIN   A9  // Microphone is attached to this analog pin

#define LED_PIN    6  // NeoPixel LED strand is connected to this pin

#define DC_OFFSET  0  // DC offset in mic signal - if unusure, leave 0

#define NOISE     10  // Noise/hum/interference in mic signal

#define SAMPLES   60  // Length of buffer for dynamic level adjustment

#define TOP       (N_PIXELS + 2) // Allow dot to go slightly off scale

#define PEAK_FALL 40  // Rate of peak falling dot

byte

  peak      = 0,      // Used for falling dot

  dotCount  = 0,      // Frame counter for delaying dot-falling speed

  volCount  = 0;      // Frame counter for storing past volume data

int

  vol[SAMPLES],       // Collection of prior volume samples

  lvl       = 10,      // Current "dampened" audio level

  minLvlAvg = 0,      // For dynamic adjustment of graph low & high

  maxLvlAvg = 512;

Adafruit_NeoPixel

  strip = Adafruit_NeoPixel(N_PIXELS, LED_PIN, NEO_GRB + NEO_KHZ800);

void setup() {

  // This is only needed on 5V Arduinos (Uno, Leonardo, etc.).

  // Connect 3.3V to mic AND TO AREF ON ARDUINO and enable this

  // line.  Audio samples are 'cleaner' at 3.3V.

  // COMMENT OUT THIS LINE FOR 3.3V ARDUINOS (FLORA, ETC.):

//  analogReference(EXTERNAL);

  memset(vol, 0, sizeof(vol));

  strip.begin();

}

void loop() {

  uint8_t  i;

  uint16_t minLvl, maxLvl;

  int      n, height;

 

  n   = analogRead(MIC_PIN);                        // Raw reading from mic

  n   = abs(n - 512 - DC_OFFSET); // Center on zero

  n   = (n <= NOISE) ? 0 : (n - NOISE);             // Remove noise/hum

  lvl = ((lvl * 7) + n) >> 3;    // "Dampened" reading (else looks twitchy)

  // Calculate bar height based on dynamic min/max levels (fixed point):

  height = TOP * (lvl - minLvlAvg) / (long)(maxLvlAvg - minLvlAvg);

  if(height < 0L)       height = 0;      // Clip output

  else if(height > TOP) height = TOP;

  if(height > peak)     peak   = height; // Keep 'peak' dot at top

  // Color pixels based on rainbow gradient

  for(i=0; i<N_PIXELS; i++) {

    if(i >= height)               strip.setPixelColor(i,   0,   0, 0);

    else strip.setPixelColor(i,Wheel(map(i,0,strip.numPixels()-1,30,150)));

   

  }

  // Draw peak dot  

  if(peak > 0 && peak <= N_PIXELS-1) strip.setPixelColor(peak,Wheel(map(peak,0,strip.numPixels()-1,30,150)));

 

   strip.show(); // Update strip

// Every few frames, make the peak pixel drop by 1:

    if(++dotCount >= PEAK_FALL) { //fall rate

     

      if(peak > 0) peak--;

      dotCount = 0;

    }

  vol[volCount] = n;                      // Save sample for dynamic leveling

  if(++volCount >= SAMPLES) volCount = 0; // Advance/rollover sample counter

  // Get volume range of prior frames

  minLvl = maxLvl = vol[0];

  for(i=1; i<SAMPLES; i++) {

    if(vol[i] < minLvl)      minLvl = vol[i];

    else if(vol[i] > maxLvl) maxLvl = vol[i];

  }

  // minLvl and maxLvl indicate the volume range over prior frames, used

  // for vertically scaling the output graph (so it looks interesting

  // regardless of volume level).  If they're too close together though

  // (e.g. at very low volume levels) the graph becomes super coarse

  // and 'jumpy'...so keep some minimum distance between them (this

  // also lets the graph go to zero when no sound is playing):

  if((maxLvl - minLvl) < TOP) maxLvl = minLvl + TOP;

  minLvlAvg = (minLvlAvg * 63 + minLvl) >> 6; // Dampen min/max levels

  maxLvlAvg = (maxLvlAvg * 63 + maxLvl) >> 6; // (fake rolling average)

}

// Input a value 0 to 255 to get a color value.

// The colors are a transition r - g - b - back to r.

uint32_t Wheel(byte WheelPos) {

  if(WheelPos < 85) {

   return strip.Color(WheelPos * 3, 255 - WheelPos * 3, 0);

  } else if(WheelPos < 170) {

   WheelPos -= 85;

   return strip.Color(255 - WheelPos * 3, 0, WheelPos * 3);

  } else {

   WheelPos -= 170;

   return strip.Color(0, WheelPos * 3, 255 - WheelPos * 3);

  }

}


2nd code…

/*

LED VU meter for Arduino and Adafruit NeoPixel LEDs.

 

 Hardware requirements:

 - Most Arduino or Arduino-compatible boards (ATmega 328P or better).

 - Adafruit Electret Microphone Amplifier (ID: 1063)

 - Adafruit Flora RGB Smart Pixels (ID: 1260)

 OR

 - Adafruit NeoPixel Digital LED strip (ID: 1138)

 - Optional: battery for portable use (else power through USB or adapter)

 Software requirements:

 - Adafruit NeoPixel library

 

 Connections:

 - 3.3V to mic amp +

 - GND to mic amp -

 - Analog pin to microphone output (configurable below)

 - Digital pin to LED data input (configurable below)

 See notes in setup() regarding 5V vs. 3.3V boards - there may be an

 extra connection to make and one line of code to enable or disable.

 

 Written by Adafruit Industries.  Distributed under the BSD license.

 This paragraph must be included in any redistribution.

 

 fscale function:

 Floating Point Autoscale Function V0.1

 Written by Paul Badger 2007

 Modified from code by Greg Shakar

 

 */

#include <Adafruit_NeoPixel.h>

#include <math.h>

#define N_PIXELS  16  // Number of pixels in strand

#define MIC_PIN   A9  // Microphone is attached to this analog pin

#define LED_PIN    6  // NeoPixel LED strand is connected to this pin

#define SAMPLE_WINDOW   10  // Sample window for average level

#define PEAK_HANG 24 //Time of pause before peak dot falls

#define PEAK_FALL 4 //Rate of falling peak dot

#define INPUT_FLOOR 10 //Lower range of analogRead input

#define INPUT_CEILING 300 //Max range of analogRead input, the lower the value the more sensitive (1023 = max)

byte peak = 16;      // Peak level of column; used for falling dots

unsigned int sample;

byte dotCount = 0;  //Frame counter for peak dot

byte dotHangCount = 0; //Frame counter for holding peak dot

Adafruit_NeoPixel strip = Adafruit_NeoPixel(N_PIXELS, LED_PIN, NEO_GRB + NEO_KHZ800);

void setup()

{

  // This is only needed on 5V Arduinos (Uno, Leonardo, etc.).

  // Connect 3.3V to mic AND TO AREF ON ARDUINO and enable this

  // line.  Audio samples are 'cleaner' at 3.3V.

  // COMMENT OUT THIS LINE FOR 3.3V ARDUINOS (FLORA, ETC.):

  //  analogReference(EXTERNAL);

  // Serial.begin(9600);

  strip.begin();

  strip.show(); // Initialize all pixels to 'off'

}

void loop()

{

  unsigned long startMillis= millis();  // Start of sample window

  float peakToPeak = 0;   // peak-to-peak level

  unsigned int signalMax = 0;

  unsigned int signalMin = 1023;

  unsigned int c, y;

  // collect data for length of sample window (in mS)

  while (millis() - startMillis < SAMPLE_WINDOW)

  {

    sample = analogRead(MIC_PIN);

    if (sample < 1024)  // toss out spurious readings

    {

      if (sample > signalMax)

      {

        signalMax = sample;  // save just the max levels

      }

      else if (sample < signalMin)

      {

        signalMin = sample;  // save just the min levels

      }

    }

  }

  peakToPeak = signalMax - signalMin;  // max - min = peak-peak amplitude

 

  // Serial.println(peakToPeak);

  //Fill the strip with rainbow gradient

  for (int i=0;i<=strip.numPixels()-1;i++){

    strip.setPixelColor(i,Wheel(map(i,0,strip.numPixels()-1,30,150)));

  }

  //Scale the input logarithmically instead of linearly

  c = fscale(INPUT_FLOOR, INPUT_CEILING, strip.numPixels(), 0, peakToPeak, 2);

 

  if(c < peak) {

    peak = c;        // Keep dot on top

    dotHangCount = 0;    // make the dot hang before falling

  }

  if (c <= strip.numPixels()) { // Fill partial column with off pixels

    drawLine(strip.numPixels(), strip.numPixels()-c, strip.Color(0, 0, 0));

  }

  // Set the peak dot to match the rainbow gradient

  y = strip.numPixels() - peak;

 

  strip.setPixelColor(y-1,Wheel(map(y,0,strip.numPixels()-1,30,150)));

  strip.show();

  // Frame based peak dot animation

  if(dotHangCount > PEAK_HANG) { //Peak pause length

    if(++dotCount >= PEAK_FALL) { //Fall rate

      peak++;

      dotCount = 0;

    }

  }

  else {

    dotHangCount++;

  }

}

//Used to draw a line between two points of a given color

void drawLine(uint8_t from, uint8_t to, uint32_t c) {

  uint8_t fromTemp;

  if (from > to) {

    fromTemp = from;

    from = to;

    to = fromTemp;

  }

  for(int i=from; i<=to; i++){

    strip.setPixelColor(i, c);

  }

}

float fscale( float originalMin, float originalMax, float newBegin, float

newEnd, float inputValue, float curve){

  float OriginalRange = 0;

  float NewRange = 0;

  float zeroRefCurVal = 0;

  float normalizedCurVal = 0;

  float rangedValue = 0;

  boolean invFlag = 0;

  // condition curve parameter

  // limit range

  if (curve > 10) curve = 10;

  if (curve < -10) curve = -10;

  curve = (curve * -.1) ; // - invert and scale - this seems more intuitive - postive numbers give more weight to high end on output

  curve = pow(10, curve); // convert linear scale into lograthimic exponent for other pow function

  /*

   Serial.println(curve * 100, DEC);   // multply by 100 to preserve resolution  

   Serial.println();

   */

  // Check for out of range inputValues

  if (inputValue < originalMin) {

    inputValue = originalMin;

  }

  if (inputValue > originalMax) {

    inputValue = originalMax;

  }

  // Zero Refference the values

  OriginalRange = originalMax - originalMin;

  if (newEnd > newBegin){

    NewRange = newEnd - newBegin;

  }

  else

  {

    NewRange = newBegin - newEnd;

    invFlag = 1;

  }

  zeroRefCurVal = inputValue - originalMin;

  normalizedCurVal  =  zeroRefCurVal / OriginalRange;   // normalize to 0 - 1 float

  // Check for originalMin > originalMax  - the math for all other cases i.e. negative numbers seems to work out fine

  if (originalMin > originalMax ) {

    return 0;

  }

  if (invFlag == 0){

    rangedValue =  (pow(normalizedCurVal, curve) * NewRange) + newBegin;

  }

  else     // invert the ranges

  {  

    rangedValue =  newBegin - (pow(normalizedCurVal, curve) * NewRange);

  }

  return rangedValue;

}

// 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) {

  if(WheelPos < 85) {

    return strip.Color(WheelPos * 3, 255 - WheelPos * 3, 0);

  }

  else if(WheelPos < 170) {

    WheelPos -= 85;

    return strip.Color(255 - WheelPos * 3, 0, WheelPos * 3);

  }

  else {

    WheelPos -= 170;

    return strip.Color(0, WheelPos * 3, 255 - WheelPos * 3);

  }

}


accelerometer & flora & neopixels

 

#include <Wire.h>

#include <Adafruit_LSM303.h>

#include <Adafruit_NeoPixel.h>

// Parameter 1 = number of pixels in strip

// 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

//   NEO_KHZ400  400 KHz bitstream (e.g. FLORA pixels)

//   NEO_KHZ800  800 KHz bitstream (e.g. High Density LED strip)

Adafruit_NeoPixel strip = Adafruit_NeoPixel(6, 6, NEO_GRB + NEO_KHZ800);

Adafruit_LSM303 lsm;

// 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 myFavoriteColors[][3] = {{200,   0, 200},   // purple

                                 {200,   0,   0},   // red

                                 {200, 200, 200},   // white

                               };

// don't edit the line below

#define FAVCOLORS sizeof(myFavoriteColors) / 3

// mess with this number to adjust TWINklitude :)

// lower number = more sensitive

#define MOVE_THRESHOLD 45

void setup()

{

  Serial.begin(9600);

 

  // Try to initialise and warn if we couldn't detect the chip

  if (!lsm.begin())

  {

    Serial.println("Oops ... unable to initialize the LSM303. Check your wiring!");

    while (1);

  }

  strip.begin();

  strip.show(); // Initialize all pixels to 'off'

}

void loop()

{

  // Take a reading of accellerometer data

  lsm.read();

  Serial.print("Accel X: "); Serial.print(lsm.accelData.x); Serial.print(" ");

  Serial.print("Y: "); Serial.print(lsm.accelData.y);       Serial.print(" ");

  Serial.print("Z: "); Serial.print(lsm.accelData.z);     Serial.print(" ");

  // Get the magnitude (length) of the 3 axis vector

  // http://en.wikipedia.org/wiki/Euclidean_vector#Length

  double storedVector = lsm.accelData.x*lsm.accelData.x;

  storedVector += lsm.accelData.y*lsm.accelData.y;

  storedVector += lsm.accelData.z*lsm.accelData.z;

  storedVector = sqrt(storedVector);

  Serial.print("Len: "); Serial.println(storedVector);

 

  // wait a bit

  delay(100);

 

  // get new data!

  lsm.read();

  double newVector = lsm.accelData.x*lsm.accelData.x;

  newVector += lsm.accelData.y*lsm.accelData.y;

  newVector += lsm.accelData.z*lsm.accelData.z;

  newVector = sqrt(newVector);

  Serial.print("New Len: "); Serial.println(newVector);

 

  // are we moving

  if (abs(newVector - storedVector) > MOVE_THRESHOLD) {

    Serial.println("Twinkle!");

    flashRandom(5, 1);  // first number is 'wait' delay, shorter num == shorter twinkle

    flashRandom(5, 3);  // second number is how many neopixels to simultaneously light up

    flashRandom(5, 2);

  }

}

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 = myFavoriteColors[c][0];

    int green = myFavoriteColors[c][1];

    int blue = myFavoriteColors[c][2];

    // get a random pixel from the list

    int j = random(strip.numPixels());

    //Serial.print("Lighting up "); Serial.println(j);

   

    // 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)

}



accelerometer & neopixel ring

#include <Wire.h>

#include <Adafruit_LSM303.h>

#include <Adafruit_NeoPixel.h>

// Parameter 1 = number of pixels in strip

// 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

//   NEO_KHZ400  400 KHz bitstream (e.g. FLORA pixels)

//   NEO_KHZ800  800 KHz bitstream (e.g. High Density LED strip)

Adafruit_NeoPixel strip = Adafruit_NeoPixel(12, 10, NEO_GRB + NEO_KHZ800);

Adafruit_LSM303 lsm;

// 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 myFavoriteColors[][3] = {{200,   0, 200},   // purple

                                 {0,   117,   255},   // blue

                                 {200, 200, 200},   // white

                               };

// don't edit the line below

#define FAVCOLORS sizeof(myFavoriteColors) / 3

// mess with this number to adjust TWINklitude :)

// lower number = more sensitive

#define MOVE_THRESHOLD 300

void setup()

{

  Serial.begin(9600);

 

  // Try to initialise and warn if we couldn't detect the chip

  if (!lsm.begin())

  {

    Serial.println("Oops ... unable to initialize the LSM303. Check your wiring!");

    while (1);

  }

  strip.begin();

  strip.show(); // Initialize all pixels to 'off'

}

void loop()

{

  // Take a reading of accellerometer data

  lsm.read();

  Serial.print("Accel X: "); Serial.print(lsm.accelData.x); Serial.print(" ");

  Serial.print("Y: "); Serial.print(lsm.accelData.y);       Serial.print(" ");

  Serial.print("Z: "); Serial.print(lsm.accelData.z);     Serial.print(" ");

  // Get the magnitude (length) of the 3 axis vector

  // http://en.wikipedia.org/wiki/Euclidean_vector#Length

  double storedVector = lsm.accelData.x*lsm.accelData.x;

  storedVector += lsm.accelData.y*lsm.accelData.y;

  storedVector += lsm.accelData.z*lsm.accelData.z;

  storedVector = sqrt(storedVector);

  Serial.print("Len: "); Serial.println(storedVector);

 

  // wait a bit

  delay(100);

 

  // get new data!

  lsm.read();

  double newVector = lsm.accelData.x*lsm.accelData.x;

  newVector += lsm.accelData.y*lsm.accelData.y;

  newVector += lsm.accelData.z*lsm.accelData.z;

  newVector = sqrt(newVector);

  Serial.print("New Len: "); Serial.println(newVector);

 

  // are we moving

  if (abs(newVector - storedVector) > MOVE_THRESHOLD) {

    Serial.println("Twinkle!");

    flashRandom(5, 1);  // first number is 'wait' delay, shorter num == shorter twinkle

    flashRandom(5, 3);  // second number is how many neopixels to simultaneously light up

    flashRandom(5, 2);

  }

}

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 = myFavoriteColors[c][0];

    int green = myFavoriteColors[c][1];

    int blue = myFavoriteColors[c][2];

    // get a random pixel from the list

    int j = random(strip.numPixels());

    //Serial.print("Lighting up "); Serial.println(j);

   

    // 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)

}