#define FASTLED_INTERNAL
#include <FastLED.h>
#include <Adafruit_NeoPixel.h>
//#include <EEPROM.h>
#define PIN 5
#define N_PIXELS  32
#define BG 0
#define COLOR_ORDER GRB  // Try mixing up the letters (RGB, GBR, BRG, etc) for a whole new world of color combinations
#define BRIGHTNESS 64   // 0-255, higher number is brighter.
#define LED_TYPE WS2812B
#define MIC_PIN    A0  // Microphone is attached to this analog pin
#define MIC_PIN_2  A1
#define DC_OFFSET  0  // DC offset in mic signal - if unusure, leave 0
#define NOISE     10  // Noise/hum/interference in mic signal
#define SAMPLES   64  // Length of buffer for dynamic level adjustment
#define SAMPLES2  64
#define TOP       (N_PIXELS + 2) // Allow dot to go slightly off scale
#define PEAK_FALL 20  // Rate of peak falling dot
#define N_PIXELS_HALF (N_PIXELS/2)
#define GRAVITY           -9.81              // Downward (negative) acceleration of gravity in m/s^2
#define h0                1                  // Starting height, in meters, of the ball (strip length)
#define NUM_BALLS         3                  // Number of bouncing balls you want (recommend < 7, but 20 is fun in its own way)
#define SPEED .20       // Amount to increment RGB color by each cycle
#define ARRAY_SIZE(A) (sizeof(A) / sizeof((A)[0]))

//config for balls
float h[NUM_BALLS] ;                         // An array of heights
float vImpact0 = sqrt( -2 * GRAVITY * h0 );  // Impact velocity of the ball when it hits the ground if "dropped" from the top of the strip
float vImpact[NUM_BALLS] ;                   // As time goes on the impact velocity will change, so make an array to store those values
float tCycle[NUM_BALLS] ;                    // The time since the last time the ball struck the ground
int   pos[NUM_BALLS] ;                       // The integer position of the dot on the strip (LED index)
long  tLast[NUM_BALLS] ;                     // The clock time of the last ground strike
float COR[NUM_BALLS] ;                       // Coefficient of Restitution (bounce damping)

float
greenOffset = 30,
blueOffset = 150;

byte
peakLeft      = 0,      // Used for falling dot
peakRight     = 0,
dotCountLeft  = 0,      // Frame counter for delaying dot-falling speed
dotCountRight = 0,
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;

uint8_t volCountLeft = 0;
int volLeft[SAMPLES];
int lvlLeft = 10;
int minLvlAvgLeft = 0;
int maxLvlAvgLeft = 512;

uint8_t volCountRight = 0;
int volRight[SAMPLES2];
int lvlRight = 10;
int minLvlAvgRight = 0;
int maxLvlAvgRight = 512;

int brightnessValue, prevBrightnessValue;
int sensorDeviationBrightness = 1;
int sensitivityValue = 128;                               // 0 - 255, initial value (value read from the potentiometer if useSensorValues = true)
int maxSensitivity = 2 * 255;                             // let the 'volume' go up to 200%!
int ledBrightness = 64;                                   // 0 - 255, initial value (value read from the potentiometer if useSensorValues = true)
int nPatterns = 1;
int Pattern = 1;

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

// FOR SYLON ETC
uint8_t thisbeat =  23;
uint8_t thatbeat =  28;
uint8_t thisfade =   2;                                     // How quickly does it fade? Lower = slower fade rate.
uint8_t thissat = 255;                                     // The saturation, where 255 = brilliant colours.
uint8_t thisbri = 64;

//FOR JUGGLE
uint8_t numdots = 4;                                          // Number of dots in use.
uint8_t faderate = 2;                                         // How long should the trails be. Very low value = longer trails.
uint8_t hueinc = 16;                                          // Incremental change in hue between each dot.
uint8_t thishue = 0;                                          // Starting hue.
uint8_t curhue = 0;
uint8_t thisbright = 64;                                     // How bright should the LED/display be.
uint8_t basebeat = 5;
uint8_t max_bright = 64;

// Twinkle
float redStates[N_PIXELS];
float blueStates[N_PIXELS];
float greenStates[N_PIXELS];
float Fade = 0.96;

// Vu meter 4
const uint32_t Red = strip.Color(128, 0, 0);
const uint32_t Yellow = strip.Color(128, 128, 0);
const uint32_t Green = strip.Color(0, 128, 0);
const uint32_t Blue = strip.Color(0, 0, 128);
const uint32_t White = strip.Color(255, 255, 255);
const uint32_t Dark = strip.Color(0, 0, 0);
unsigned int sample;

CRGB leds[N_PIXELS];

int          myhue =   0;
// Modes
enum
{
} MODE;
bool reverse = true;



//Ripple variables
int color;
int center = 0;
int step = -1;
int maxSteps = 8;
float fadeRate = 0.80;
int diff;

//background color
uint32_t currentBg = random(256);
uint32_t nextBg = currentBg;

byte peak = 16;
byte dotCount = 0;
byte dotHangCount = 0;


//************************************************************************
void setup() {
  delay( 2000 ); // power-up safety delay
  FastLED.addLeds<WS2812B, PIN, COLOR_ORDER>(leds, N_PIXELS).setCorrection( TypicalLEDStrip );
  FastLED.setBrightness(  BRIGHTNESS );
  //  analogReference(EXTERNAL);
  memset(vol, 0, sizeof(vol));
  LEDS.addLeds<LED_TYPE, PIN, COLOR_ORDER>(leds, N_PIXELS);
  strip.setBrightness(ledBrightness);
  strip.begin();
  strip.show(); // Initialize all pixels to 'off'
  for (int i = 0 ; i < NUM_BALLS ; i++) {    // Initialize variables
    tLast[i] = millis();
    h[i] = h0;
    pos[i] = 0;                              // Balls start on the ground
    vImpact[i] = vImpact0;                   // And "pop" up at vImpact0
    tCycle[i] = 0;
    COR[i] = 0.90 - float(i) / pow(NUM_BALLS, 2);
  }
}

void loop() {

  //for mic
  uint8_t  i;
  uint16_t minLvlLeft, maxLvlLeft;
  uint16_t minLvlRight, maxLvlRight;
  int      n, n1, height;
  // end mic

  Pattern = Pattern + 1;
  if ( Pattern > nPatterns ) Pattern = 1;


  switch (Pattern) {

    case 1:
      All();
      break;
  }
}

void colorWipe(uint32_t c, uint8_t wait) {
  for (uint16_t i = 0; i < strip.numPixels(); i++) {
    strip.setPixelColor(i, c);
    strip.show();
    if (Pattern != nPatterns)  // <------------- add this
      return;         // <------------ and this
    delay(wait);
  }
}

void Vu4() {
  uint8_t  i;
  uint16_t minLvlLeft, maxLvlLeft;
  uint16_t minLvlRight, maxLvlRight;
  int      n, n1, 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
  lvlLeft = ((lvlLeft * 7) + n) >> 3;    // "Dampened" reading (else looks twitchy)

  // Calculate bar height based on dynamic min/max levels (fixed point):
  height = TOP * (lvlLeft - minLvlAvgLeft) / (long)(maxLvlAvgLeft - minLvlAvgLeft);

  if (height < 0L)       height = 0;     // Clip output
  else if (height > TOP) height = TOP;
  if (height > peakLeft)     peakLeft   = height; // Keep 'peak' dot at top
  greenOffset += SPEED;
  blueOffset += SPEED;
  if (greenOffset >= 255) greenOffset = 0;
  if (blueOffset >= 255) blueOffset = 0;

  // Color pixels based on rainbow gradient
  for (i = 0; i < N_PIXELS_HALF; i++) {
    if (i >= height) {
      strip.setPixelColor(N_PIXELS_HALF + i,   0,   0, 0);
    }
    else {
      uint32_t color = Wheel(map(N_PIXELS_HALF + i, 0, strip.numPixels() - 1, (int)greenOffset, (int)blueOffset));
      strip.setPixelColor(N_PIXELS_HALF + i, color);
    }

  }

  // Draw peak dot
  if (peakLeft > 0 && peakLeft <= N_PIXELS_HALF - 1) {
    uint32_t color = Wheel(map(N_PIXELS_HALF + peakLeft, 0, strip.numPixels() - 1, 30, 150));
    strip.setPixelColor(N_PIXELS_HALF + peakLeft, color);
  }

  strip.show(); // Update strip

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

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

    if (peakLeft > 0) peakLeft--;
    dotCountLeft = 0;
  }


  volLeft[volCountLeft] = n;                      // Save sample for dynamic leveling
  if (++volCountLeft >= SAMPLES) volCountLeft = 0; // Advance/rollover sample counter

  // Get volume range of prior frames
  minLvlLeft = maxLvlLeft = vol[0];
  for (i = 1; i < SAMPLES; i++) {
    if (volLeft[i] < minLvlLeft)      minLvlLeft = volLeft[i];
    else if (volLeft[i] > maxLvlLeft) maxLvlLeft = volLeft[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 ((maxLvlLeft - minLvlLeft) < TOP) maxLvlLeft = minLvlLeft + TOP;
  minLvlAvgLeft = (minLvlAvgLeft * 63 + minLvlLeft) >> 6; // Dampen min/max levels
  maxLvlAvgLeft = (maxLvlAvgLeft * 63 + maxLvlLeft) >> 6; // (fake rolling average)

  n1   = analogRead(MIC_PIN_2);                        // Raw reading from mic
  n1   = abs(n1 - 512 - DC_OFFSET); // Center on zero
  n1   = (n1 <= NOISE) ? 0 : (n1 - NOISE);             // Remove noise/hum
  lvlRight = ((lvlRight * 7) + n1) >> 3;    // "Dampened" reading (else looks twitchy)

  // Calculate bar height based on dynamic min/max levels (fixed point):
  height = TOP * (lvlRight - minLvlAvgRight) / (long)(maxLvlAvgRight - minLvlAvgRight);

  if (height < 0L)       height = 0;     // Clip output
  else if (height > TOP) height = TOP;
  if (height > peakRight)     peakRight   = height; // Keep 'peak' dot at top
  greenOffset += SPEED;
  blueOffset += SPEED;
  if (greenOffset >= 255) greenOffset = 0;
  if (blueOffset >= 255) blueOffset = 0;

  // Color pixels based on rainbow gradient
  for (i = 0; i < N_PIXELS_HALF; i++) {
    if (i >= height) {
      strip.setPixelColor(N_PIXELS_HALF - i - 1,   0,   0, 0);
    }
    else {
      uint32_t color = Wheel(map(i, 0, strip.numPixels() - 1, (int)greenOffset, (int)blueOffset));
      strip.setPixelColor(N_PIXELS_HALF - i - 1, color);
    }
  }

  // Draw peak dot
  if (peakRight > 0 && peakRight <= N_PIXELS_HALF - 1) {
    uint32_t color = Wheel(map(N_PIXELS_HALF - peakRight - 1, 0, strip.numPixels() - 1, 30, 150));
    strip.setPixelColor(N_PIXELS_HALF - peakRight - 1, color);
  }

  strip.show(); // Update strip

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

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

    if (peakRight > 0) peakRight--;
    dotCountRight = 0;
  }


  volRight[volCountRight] = n;                      // Save sample for dynamic leveling
  if (++volCountRight >= SAMPLES2) volCountRight = 0; // Advance/rollover sample counter

  // Get volume range of prior frames
  minLvlRight = maxLvlRight = vol[0];
  for (i = 1; i < SAMPLES2; i++) {
    if (volRight[i] < minLvlRight)      minLvlRight = volRight[i];
    else if (volRight[i] > maxLvlRight) maxLvlRight = volRight[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 ((maxLvlRight - minLvlRight) < TOP) maxLvlRight = minLvlRight + TOP;
  minLvlAvgRight = (minLvlAvgRight * 63 + minLvlRight) >> 6; // Dampen min/max levels
  maxLvlAvgRight = (maxLvlAvgRight * 63 + maxLvlRight) >> 6; // (fake rolling average)

}


void Vu3() {
  uint8_t i;
  uint16_t minLvlLeft, maxLvlLeft;
  uint16_t minLvlRight, maxLvlRight;
  int n, n1, 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
  lvlLeft = ((lvlLeft * 7) + n) >> 3;    // "Dampened" reading (else looks twitchy)

  // Calculate bar height based on dynamic min/max levels (fixed point):
  height = TOP * (lvlLeft - minLvlAvgLeft) / (long)(maxLvlAvgLeft - minLvlAvgLeft);

  if (height < 0L)       height = 0;      // Clip output
  else if (height > TOP) height = TOP;
  if (height > peakLeft)     peakLeft   = height; // Keep 'peak' dot at top

  greenOffset += SPEED;
  blueOffset += SPEED;
  if (greenOffset >= 255) greenOffset = 0;
  if (blueOffset >= 255) blueOffset = 0;

  // Color pixels based on rainbow gradient
  for (i = 0; i < N_PIXELS_HALF / 2; i++) {
    if (i >= height) {
      strip.setPixelColor(N_PIXELS_HALF / 2 - i - 1, 0, 0, 0);
    } else {
      uint32_t color = Wheel(map(N_PIXELS_HALF / 2 - i - 1, 1, strip.numPixels() - 1, (int)greenOffset, (int)blueOffset));
      strip.setPixelColor(N_PIXELS_HALF / 2 - i - 1, color);
    }
  }
  // Draw peak dot
  if (peakLeft > 0 && peakLeft <= N_PIXELS_HALF / 2 - 1) {
    uint32_t color = Wheel(map(N_PIXELS_HALF / 2 - peakLeft - 1, 0, strip.numPixels() - 1, 30, 150));
    strip.setPixelColor(N_PIXELS_HALF / 2 - peakLeft - 1, color);
  }

  strip.show(); // Update strip

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

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

    if (peakLeft > 0) peakLeft--;
    dotCountLeft = 0;
  }
  strip.show();  // Update strip

  volLeft[volCountLeft] = n;
  if (++volCountLeft >= SAMPLES) {
    volCountLeft = 0;
  }

  // Get volume range of prior frames
  minLvlLeft = maxLvlLeft = vol[0];
  for (i = 1; i < SAMPLES; i++) {
    if (volLeft[i] < minLvlLeft) {
      minLvlLeft = volLeft[i];
    } else if (volLeft[i] > maxLvlLeft) {
      maxLvlLeft = volLeft[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 ((maxLvlLeft - minLvlLeft) < TOP) {
    maxLvlLeft = minLvlLeft + TOP;
  }
  minLvlAvgLeft = (minLvlAvgLeft * 63 + minLvlLeft) >> 6; // Dampen min/max levels
  maxLvlAvgLeft = (maxLvlAvgLeft * 63 + maxLvlLeft) >> 6; // (fake rolling average)

  n1 = analogRead(MIC_PIN_2);             // Raw reading from mic
  n1 = abs(n1 - 512 - DC_OFFSET);        // Center on zero
  n1 = (n1 <= NOISE) ? 0 : (n1 - NOISE);  // Remove noise/hum
  lvlRight = ((lvlRight * 7) + n1) >> 3;    // "Dampened" reading (else looks twitchy)

  // Calculate bar height based on dynamic min/max levels (fixed point):
  height = TOP * (lvlRight - minLvlAvgRight) / (long)(maxLvlAvgRight - minLvlAvgRight);

  if (height < 0L)       height = 0;      // Clip output
  else if (height > TOP) height = TOP;
  if (height > peakRight)     peakRight   = height; // Keep 'peak' dot at top

  greenOffset += SPEED;
  blueOffset += SPEED;
  if (greenOffset >= 255) greenOffset = 0;
  if (blueOffset >= 255) blueOffset = 0;

  // Color pixels based on rainbow gradient
  for (i = 0; i < N_PIXELS_HALF / 2; i++) {
    if (i >= height) {
      strip.setPixelColor(N_PIXELS_HALF / 2 + i, 0, 0, 0);
    } else {
      uint32_t color = Wheel(map(N_PIXELS_HALF + i, 1, strip.numPixels(), (int)greenOffset, (int)blueOffset));
      strip.setPixelColor(N_PIXELS_HALF / 2 + i, color);
    }
  }
  // Draw peak dot
  if (peakRight > 0 && peakRight <= N_PIXELS_HALF / 2) {
    uint32_t color =  Wheel(map(N_PIXELS_HALF + peakLeft, 1, strip.numPixels(), 30, 150));
    strip.setPixelColor(N_PIXELS_HALF + peakLeft, color);
  }

  strip.show(); // Update strip

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

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

    if (peakRight > 0) peakRight--;
    dotCountRight = 0;
  }
  strip.show();  // Update strip

  volRight[volCountRight] = n1;
  if (++volCountRight >= SAMPLES2) {
    volCountRight = 0;
  }

  // Get volume range of prior frames
  minLvlRight = maxLvlRight = vol[0];
  for (i = 1; i < SAMPLES2; i++) {
    if (volRight[i] < minLvlRight) {
      minLvlRight = volRight[i];
    } else if (volRight[i] > maxLvlRight) {
      maxLvlRight = volRight[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 ((maxLvlRight - minLvlRight) < TOP) {
    maxLvlRight = minLvlRight + TOP;
  }
  minLvlAvgRight = (minLvlAvgRight * 63 + minLvlRight) >> 6; // Dampen min/max levels
  maxLvlAvgRight = (maxLvlAvgRight * 63 + maxLvlRight) >> 6; // (fake rolling average)

}


void Balls() {
  for (int i = 0 ; i < NUM_BALLS ; i++) {
    tCycle[i] =  millis() - tLast[i] ;     // Calculate the time since the last time the ball was on the ground

    // A little kinematics equation calculates positon as a function of time, acceleration (gravity) and intial velocity
    h[i] = 0.5 * GRAVITY * pow( tCycle[i] / 1000 , 2.0 ) + vImpact[i] * tCycle[i] / 1000;

    if ( h[i] < 0 ) {
      h[i] = 0;                            // If the ball crossed the threshold of the "ground," put it back on the ground
      vImpact[i] = COR[i] * vImpact[i] ;   // and recalculate its new upward velocity as it's old velocity * COR
      tLast[i] = millis();

      if ( vImpact[i] < 0.01 ) vImpact[i] = vImpact0;  // If the ball is barely moving, "pop" it back up at vImpact0
    }
    pos[i] = round( h[i] * (N_PIXELS - 1) / h0);       // Map "h" to a "pos" integer index position on the LED strip
  }

  //Choose color of LEDs, then the "pos" LED on
  for (int i = 0 ; i < NUM_BALLS ; i++) leds[pos[i]] = CHSV( uint8_t (i * 40) , 255, 255);
  FastLED.show();
  //Then off for the next loop around
  for (int i = 0 ; i < NUM_BALLS ; i++) {
    leds[pos[i]] = CRGB::Black;
  }
}



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

  for (j = 0; j < 256 * 5; 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();
    if (Pattern != nPatterns)  // <------------- add this
      return;         // <------------ and this
    delay(wait);
  }
}
// HERE


void vu() {

  uint8_t  i;
  uint16_t minLvlLeft, maxLvlLeft;
  uint16_t minLvlRight, maxLvlRight;
  int      n, n1, 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
  lvlLeft = ((lvlLeft * 7) + n) >> 3;    // "Dampened" reading (else looks twitchy)

  // Calculate bar height based on dynamic min/max levels (fixed point):
  height = TOP * (lvlLeft - minLvlAvgLeft) / (long)(maxLvlAvgLeft - minLvlAvgLeft);

  if (height < 0L)       height = 0;     // Clip output
  else if (height > TOP) height = TOP;
  if (height > peakLeft)     peakLeft   = height; // Keep 'peak' dot at top


  // Color pixels based on rainbow gradient
  for (i = 0; i < N_PIXELS_HALF; i++) {
    if (i >= height) {
      strip.setPixelColor(N_PIXELS_HALF - i - 1,   0,   0, 0);
    } else {
      uint32_t color = Wheel(map(i, 0, strip.numPixels() - 1, 30, 150));
      strip.setPixelColor(N_PIXELS_HALF - i - 1, color);
    }

  }


  // Draw peak dot
  if (peakLeft > 0 && peakLeft <= N_PIXELS_HALF - 1) {
    uint32_t color = Wheel(map(N_PIXELS_HALF - peakLeft - 1, 0, strip.numPixels() - 1, 30, 150));
    strip.setPixelColor(N_PIXELS_HALF - peakLeft - 1, color);
  }

  strip.show(); // Update strip

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

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

    if (peakLeft > 0) peakLeft--;
    dotCountLeft = 0;
  }



  volLeft[volCountLeft] = n;                      // Save sample for dynamic leveling
  if (++volCountLeft >= SAMPLES) volCountLeft = 0; // Advance/rollover sample counter

  // Get volume range of prior frames
  minLvlLeft = maxLvlLeft = vol[0];
  for (i = 1; i < SAMPLES; i++) {
    if (volLeft[i] < minLvlLeft)      minLvlLeft = volLeft[i];
    else if (volLeft[i] > maxLvlLeft) maxLvlLeft = volLeft[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 ((maxLvlLeft - minLvlLeft) < TOP) maxLvlLeft = minLvlLeft + TOP;
  minLvlAvgLeft = (minLvlAvgLeft * 63 + minLvlLeft) >> 6; // Dampen min/max levels
  maxLvlAvgLeft = (maxLvlAvgLeft * 63 + maxLvlLeft) >> 6; // (fake rolling average)

  n1   = analogRead(MIC_PIN_2);                        // Raw reading from mic
  n1   = abs(n1 - 512 - DC_OFFSET); // Center on zero
  n1   = (n1 <= NOISE) ? 0 : (n1 - NOISE);             // Remove noise/hum
  lvlRight = ((lvlRight * 7) + n1) >> 3;    // "Dampened" reading (else looks twitchy)

  // Calculate bar height based on dynamic min/max levels (fixed point):
  height = TOP * (lvlRight - minLvlAvgRight) / (long)(maxLvlAvgRight - minLvlAvgRight);

  if (height < 0L)       height = 0;     // Clip output
  else if (height > TOP) height = TOP;
  if (height > peakRight)     peakRight   = height; // Keep 'peak' dot at top


  // Color pixels based on rainbow gradient
  for (i = 0; i < N_PIXELS_HALF; i++) {
    if (i >= height)  {
      strip.setPixelColor(N_PIXELS_HALF + i,   0,   0, 0);
    }
    else {
      uint32_t color =  Wheel(map(N_PIXELS_HALF + i, 0, strip.numPixels(), 30, 150));
      strip.setPixelColor(N_PIXELS_HALF + i, color);
    }
  }


  // Draw peak dot
  if (peakRight > 0 && peakRight <= N_PIXELS_HALF) strip.setPixelColor(N_PIXELS_HALF + peakRight, Wheel(map(N_PIXELS_HALF + peakRight, 0, strip.numPixels(), 30, 150)));

  strip.show(); // Update strip

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

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

    if (peakRight > 0) peakRight--;
    dotCountRight = 0;
  }



  volRight[volCountRight] = n1;                      // Save sample for dynamic leveling
  if (++volCountRight >= SAMPLES2) volCountRight = 0; // Advance/rollover sample counter

  // Get volume range of prior frames
  minLvlRight = maxLvlRight = vol[0];
  for (i = 1; i < SAMPLES2; i++) {
    if (volRight[i] < minLvlRight)      minLvlRight = volRight[i];
    else if (volRight[i] > maxLvlRight) maxLvlRight = volRight[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 ((maxLvlRight - minLvlRight) < TOP) maxLvlRight = minLvlRight + TOP;
  minLvlAvgRight = (minLvlAvgRight * 63 + minLvlRight) >> 6; // Dampen min/max levels
  maxLvlAvgRight = (maxLvlAvgRight * 63 + maxLvlRight) >> 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);
  }
}


void vu2() {

  uint8_t  i;
  uint16_t minLvlLeft, maxLvlLeft;
  uint16_t minLvlRight, maxLvlRight;
  int      n, n1, 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
  lvlLeft = ((lvlLeft * 7) + n) >> 3;    // "Dampened" reading (else looks twitchy)

  // Calculate bar height based on dynamic min/max levels (fixed point):
  height = TOP * (lvlLeft - minLvlAvgLeft) / (long)(maxLvlAvgLeft - minLvlAvgLeft);

  if (height < 0L)       height = 0;     // Clip output
  else if (height > TOP) height = TOP;
  if (height > peakLeft)     peakLeft   = height; // Keep 'peak' dot at top

  // Color pixels based on rainbow gradient
  for (i = 0; i < N_PIXELS_HALF; i++) {
    if (i >= height) {
      strip.setPixelColor(N_PIXELS_HALF - i - 1,   0,   0, 0);
    }
    else {
      uint32_t color = Wheel(map(i, 2, strip.numPixels() - 1, 30, 150));
      strip.setPixelColor(N_PIXELS_HALF - i - 1, color);
    }
  }

  // Draw peak dot
  if (peakLeft > 0 && peakLeft <= N_PIXELS_HALF - 1) {
    uint32_t color = Wheel(map(N_PIXELS_HALF - peakLeft - 1, 2, strip.numPixels() - 1, 30, 150));
    strip.setPixelColor(N_PIXELS_HALF - peak - 1, color);
  }

  strip.show(); // Update strip

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

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

    if (peakLeft > 0) peakLeft--;
    dotCountLeft = 0;
  }

  volLeft[volCountLeft] = n;                      // Save sample for dynamic leveling
  if (++volCountLeft >= SAMPLES) volCountLeft = 0; // Advance/rollover sample counter

  // Get volume range of prior frames
  minLvlLeft = maxLvlLeft = vol[0];
  for (i = 1; i < SAMPLES; i++) {
    if (volLeft[i] < minLvlLeft)      minLvlLeft = volLeft[i];
    else if (volLeft[i] > maxLvlLeft) maxLvlLeft = volLeft[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 ((maxLvlLeft - minLvlLeft) < TOP) maxLvlLeft = minLvlLeft + TOP;
  minLvlAvgLeft = (minLvlAvgLeft * 63 + minLvlLeft) >> 6; // Dampen min/max levels
  maxLvlAvgLeft = (maxLvlAvgLeft * 63 + maxLvlLeft) >> 6; // (fake rolling average)

  n1   = analogRead(MIC_PIN_2);                        // Raw reading from mic
  n1   = abs(n - 512 - DC_OFFSET); // Center on zero
  n1   = (n1 <= NOISE) ? 0 : (n1 - NOISE);             // Remove noise/hum
  lvlRight = ((lvlRight * 7) + n1) >> 3;    // "Dampened" reading (else looks twitchy)

  // Calculate bar height based on dynamic min/max levels (fixed point):
  height = TOP * (lvlRight - minLvlAvgRight) / (long)(maxLvlAvgRight - minLvlAvgRight);

  if (height < 0L)       height = 0;     // Clip output
  else if (height > TOP) height = TOP;
  if (height > peakRight)     peakRight   = height; // Keep 'peak' dot at top

  // Color pixels based on rainbow gradient
  for (i = 0; i < N_PIXELS_HALF; i++) {
    if (i >= height) {
      strip.setPixelColor(N_PIXELS_HALF + i,   0,   0, 0);
    }
    else {
      uint32_t color = Wheel(map(N_PIXELS_HALF + i, 2, strip.numPixels() , 30, 150));
      strip.setPixelColor(N_PIXELS_HALF + i, color);
    }
  }

  // Draw peak dot
  if (peakRight > 0 && peakRight <= N_PIXELS_HALF) {
    uint32_t color = Wheel(map(N_PIXELS_HALF + peakRight, 2, strip.numPixels() , 30, 150));
    strip.setPixelColor(N_PIXELS_HALF + peakRight, color);
  }

  strip.show(); // Update strip

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

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

    if (peakRight > 0) peakRight--;
    dotCountRight = 0;
  }

  volRight[volCountRight] = n1;                      // Save sample for dynamic leveling
  if (++volCountRight >= SAMPLES2) volCountRight = 0; // Advance/rollover sample counter

  // Get volume range of prior frames
  minLvlRight = maxLvlRight = vol[0];
  for (i = 1; i < SAMPLES2; i++) {
    if (volRight[i] < minLvlRight)      minLvlRight = volRight[i];
    else if (volRight[i] > maxLvlRight) maxLvlRight = volRight[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 ((maxLvlRight - minLvlRight) < TOP) maxLvlRight = minLvlRight + TOP;
  minLvlAvgRight = (minLvlAvgRight * 63 + minLvlRight) >> 6; // Dampen min/max levels
  maxLvlAvgRight = (maxLvlAvgRight * 63 + maxLvlRight) >> 6; // (fake rolling average)

}

//here................

void ripple() {

  if (currentBg == nextBg) {
    nextBg = random(256);
  }
  else if (nextBg > currentBg) {
    currentBg++;
  } else {
    currentBg--;
  }
  for (uint16_t l = 0; l < N_PIXELS; l++) {
    leds[l] = CHSV(currentBg, 255, 50);         // strip.setPixelColor(l, Wheel(currentBg, 0.1));
  }

  if (step == -1) {
    center = random(N_PIXELS);
    color = random(256);
    step = 0;
  }

  if (step == 0) {
    leds[center] = CHSV(color, 255, 255);         // strip.setPixelColor(center, Wheel(color, 1));
    step ++;
  }
  else {
    if (step < maxSteps) {

      leds[wrap(center + step)] = CHSV(color, 255, pow(fadeRate, step) * 255);     //   strip.setPixelColor(wrap(center + step), Wheel(color, pow(fadeRate, step)));
      leds[wrap(center - step)] = CHSV(color, 255, pow(fadeRate, step) * 255);     //   strip.setPixelColor(wrap(center - step), Wheel(color, pow(fadeRate, step)));
      if (step > 3) {
        leds[wrap(center + step - 3)] = CHSV(color, 255, pow(fadeRate, step - 2) * 255);   //   strip.setPixelColor(wrap(center + step - 3), Wheel(color, pow(fadeRate, step - 2)));
        leds[wrap(center - step + 3)] = CHSV(color, 255, pow(fadeRate, step - 2) * 255);   //   strip.setPixelColor(wrap(center - step + 3), Wheel(color, pow(fadeRate, step - 2)));
      }
      step ++;
    }
    else {
      step = -1;
    }
  }
  LEDS.show();
  delay(50);
}


int wrap(int step) {
  if (step < 0) return N_PIXELS + step;
  if (step > N_PIXELS - 1) return step - N_PIXELS;
  return step;
}


void one_color_allHSV(int ahue, int abright) {                // SET ALL LEDS TO ONE COLOR (HSV)
  for (int i = 0 ; i < N_PIXELS; i++ ) {
    leds[i] = CHSV(ahue, 255, abright);
  }
}


void ripple2() {
  if (BG) {
    if (currentBg == nextBg) {
      nextBg = random(256);
    }
    else if (nextBg > currentBg) {
      currentBg++;
    } else {
      currentBg--;
    }
    for (uint16_t l = 0; l < N_PIXELS; l++) {
      strip.setPixelColor(l, Wheel(currentBg, 0.1));
    }
  } else {
    for (uint16_t l = 0; l < N_PIXELS; l++) {
      strip.setPixelColor(l, 0, 0, 0);
    }
  }


  if (step == -1) {
    center = random(N_PIXELS);
    color = random(256);
    step = 0;
  }



  if (step == 0) {
    strip.setPixelColor(center, Wheel(color, 1));
    step ++;
  }
  else {
    if (step < maxSteps) {
      strip.setPixelColor(wrap(center + step), Wheel(color, pow(fadeRate, step)));
      strip.setPixelColor(wrap(center - step), Wheel(color, pow(fadeRate, step)));
      if (step > 3) {
        strip.setPixelColor(wrap(center + step - 3), Wheel(color, pow(fadeRate, step - 2)));
        strip.setPixelColor(wrap(center - step + 3), Wheel(color, pow(fadeRate, step - 2)));
      }
      step ++;
    }
    else {
      step = -1;
    }
  }
  strip.show();
  delay(50);
}

// 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, float opacity) {

  if (WheelPos < 85) {
    return strip.Color((WheelPos * 3) * opacity, (255 - WheelPos * 3) * opacity, 0);
  }
  else if (WheelPos < 170) {
    WheelPos -= 85;
    return strip.Color((255 - WheelPos * 3) * opacity, 0, (WheelPos * 3) * opacity);
  }
  else {
    WheelPos -= 170;
    return strip.Color(0, (WheelPos * 3) * opacity, (255 - WheelPos * 3) * opacity);
  }
}


void pattern2() {

  sinelon();                                                  // Call our sequence.
  show_at_max_brightness_for_power();                         // Power managed display of LED's.
} // loop()


void sinelon() {
  // a colored dot sweeping back and forth, with fading trails
  fadeToBlackBy( leds, N_PIXELS, thisfade);
  int pos1 = beatsin16(thisbeat, 0, N_PIXELS);
  int pos2 = beatsin16(thatbeat, 0, N_PIXELS);
  leds[(pos1 + pos2) / 2] += CHSV( myhue++ / 64, thissat, thisbri);
}
// Pattern 3 - JUGGLE
void pattern3() {
  ChangeMe();
  juggle();
  show_at_max_brightness_for_power();                         // Power managed display of LED's.
} // loop()


void juggle() {                                               // Several colored dots, weaving in and out of sync with each other
  curhue = thishue;                                          // Reset the hue values.
  fadeToBlackBy(leds, N_PIXELS, faderate);
  for ( int i = 0; i < numdots; i++) {
    leds[beatsin16(basebeat + i + numdots, 0, N_PIXELS)] += CHSV(curhue, thissat, thisbright); //beat16 is a FastLED 3.1 function
    curhue += hueinc;
  }
} // juggle()


void ChangeMe() {                                             // A time (rather than loop) based demo sequencer. This gives us full control over the length of each sequence.
  uint8_t secondHand = (millis() / 1000) % 30;                // IMPORTANT!!! Change '30' to a different value to change duration of the loop.
  static uint8_t lastSecond = 99;                             // Static variable, means it's only defined once. This is our 'debounce' variable.
  if (lastSecond != secondHand) {                             // Debounce to make sure we're not repeating an assignment.
    lastSecond = secondHand;
    if (secondHand ==  0)  {
      numdots = 1;  // You can change values here, one at a time , or altogether.
      faderate = 2;
    }
    if (secondHand == 10)  {
      numdots = 4;
      thishue = 128;
      faderate = 8;
    }
    if (secondHand == 20)  {
      hueinc = 48;  // Only gets called once, and not continuously for the next several seconds. Therefore, no rainbows.
      thishue = random8();
    }
  }
} // ChangeMe()

void Twinkle () {
  if (random(25) == 1) {
    uint16_t i = random(N_PIXELS);
    if (redStates[i] < 1 && greenStates[i] < 1 && blueStates[i] < 1) {
      redStates[i] = random(256);
      greenStates[i] = random(256);
      blueStates[i] = random(256);
    }
  }

  for (uint16_t l = 0; l < N_PIXELS; l++) {
    if (redStates[l] > 1 || greenStates[l] > 1 || blueStates[l] > 1) {
      strip.setPixelColor(l, redStates[l], greenStates[l], blueStates[l]);

      if (redStates[l] > 1) {
        redStates[l] = redStates[l] * Fade;
      } else {
        redStates[l] = 0;
      }

      if (greenStates[l] > 1) {
        greenStates[l] = greenStates[l] * Fade;
      } else {
        greenStates[l] = 0;
      }

      if (blueStates[l] > 1) {
        blueStates[l] = blueStates[l] * Fade;
      } else {
        blueStates[l] = 0;
      }
    } else {
      strip.setPixelColor(l, 0, 0, 0);
    }
  }
  strip.show();
  delay(10);
}

// TOO HERE

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();
    // check if a button pressed
    if (Pattern != nPatterns)  // <------------- add this
      return;         // <------------ and this
    delay(wait);
  }
}

// List of patterns to cycle through.  Each is defined as a separate function below.
typedef void (*SimplePatternList[])();
SimplePatternList qPatterns = {vu, vu2, Vu3, Vu4, Twinkle, pattern3, pattern2, ripple2, ripple, Balls};
uint8_t qCurrentPatternNumber = 0; // Index number of which pattern is current

void nextPattern()
{
  // add one to the current pattern number, and wrap around at the end
  qCurrentPatternNumber = (qCurrentPatternNumber + 1) % ARRAY_SIZE( qPatterns);
}
void All()
{
  // Call the current pattern function once, updating the 'leds' array
  qPatterns[qCurrentPatternNumber]();
  EVERY_N_MINUTES( 1 ) {
    nextPattern();  // change patterns periodically
  }
}