#include <Adafruit_NeoPixel.h>
#ifdef __AVR__
#include <avr/power.h>

#include <FastLED.h>
#define NUM_LEDS 20
#define BRIGHTNESS 200
CRGB leds[NUM_LEDS];
#define PIN 6
#endif
Adafruit_NeoPixel strip = Adafruit_NeoPixel(NUM_LEDS, PIN, NEO_RGB + NEO_KHZ800);

void setup() {
  strip.setBrightness(BRIGHTNESS);
  LEDS.setBrightness(BRIGHTNESS);
  strip.begin();
  strip.show(); // Initialize all pixels to 'off'
   FastLED.addLeds<WS2811, PIN, RGB>(leds, NUM_LEDS).setCorrection( TypicalLEDStrip );
   FastLED.clear();   
}

void loop() {

  // Some example procedures showing how to display to the pixels:

  knightRider(0XFF, 0X00, 0X23, 7, 100, 50);//PINK
  knightRider(0X00, 0X55, 0XFF, 7, 100, 50);//BLUE
  knightRider(0X00, 0XFF, 0X00, 7, 100, 50);//GREEN
  knightRider(0XFF, 0X23, 0X00, 7, 100, 50);//ORANGE

  rainbow(8, 3);  
  
  colorWipe(strip.Color(255, 5, 180), 100); // Pink
  colorWipe(strip.Color(255, 0, 0), 100); // Red
  colorWipe(strip.Color(0,250,154), 100); // sky blue
  colorWipe(strip.Color(255, 255, 5), 100); // Yellow
  colorWipe(strip.Color(0, 0, 255), 100); // Blue
  colorWipe(strip.Color(0, 255, 0), 100); // Green
  colorWipe(strip.Color(255, 0, 255), 100); // Purple

  rainbow(8, 3);
      
        //theaterChase(strip.Color(0, 255, 255), 100, 5, 10);  // cyan
	//theaterChase(strip.Color(255, 0, 255), 100, 5, 10);  // magenta
	//theaterChase(strip.Color(255, 255, 0), 100, 5, 10);// yelloW


  rainbow(8, 3);

   RunningLights(0XFF, 0X0F, 0X00,  // RED (caution: reverse order!)
                0xFF, 0xFF, 0xFF,  // WHITE 
                0X05, 0XFF, 0X00,  // GREEN
                175);   
   RunningLights(0XFF, 0X0F, 0X00,  // RED (caution: reverse order!)
                0xFF, 0xFF, 0xFF,  // WHITE 
                0X05, 0XFF, 0X00,  // GREEN
                175);   
    RunningLights(0XFF, 0X0F, 0X00,  // RED (caution: reverse order!)
                0xFF, 0xFF, 0xFF,  // WHITE 
                0X05, 0XFF, 0X00,  // GREEN
                175);   
    RunningLights(0XFF, 0X0F, 0X00,  // RED (caution: reverse order!)
                0xFF, 0xFF, 0xFF,  // WHITE 
                0X05, 0XFF, 0X00,  // GREEN
                175);   
    RunningLights (0XFF, 0X0F, 0X00,  // RED (caution: reverse order!)
                0xFF, 0xFF, 0xFF,  // WHITE 
                0X05, 0XFF, 0X00,  // GREEN
                175);   
    RunningLights (0XFF, 0X0F, 0X00,  // RED (caution: reverse order!)
                0xFF, 0xFF, 0xFF,  // WHITE 
                0X05, 0XFF, 0X00,  // GREEN
                175);                                                                           
  
   rainbowCycle(10);

   //theaterChaseRainbow(200);

   rainbowStrip();
 
   alternateColor(strip.Color(234,0,52), strip.Color(0,191,255), 250);
   alternateColor(strip.Color(255,255,0), strip.Color(255,0,0), 250);//yellow-red
   alternateColor(strip.Color(255,0,255), strip.Color(0,255,0), 250);//fuchia-lime

   middleFill(strip.Color(2, 136, 217), 200);

   sideFill(strip.Color(234, 0, 52), 200);


  FadeInOut(0xff, 0x00, 0xe6); // red
  FadeInOut(0xf7, 0xff, 0x03); // yellow 
  FadeInOut(0x00, 0x77, 0xff); // blue
  FadeInOut(0x80, 0x00, 0xff); // purple
  FadeInOut(0x00, 0xff, 0x33); // purple

  Strobe(0xff, 0x77, 0x00, 10, 100, 1000);

  CylonBounce(0x00, 0x80, 0x00, 8, 35, 200);//GREEN
  CylonBounce(0x00, 0xFF, 0xFF, 8, 35, 200);//CYAN
  CylonBounce(0xDC, 0x14, 0x3C, 8, 35, 200); //CRIMSON

  rainbow(8, 3);

  meteorRain(0XFF, 0XFF, 0X00, 7, 200, true, 75);//LIGHT green
  meteorRainReverse(250, 70, 0, 4, 64, true, 70);
  meteorRain(0XFF, 0X00, 0X23, 7, 200, true, 75);//PINK
  meteorRain(0XD2, 0X00, 0XFF, 7, 200, true, 75);//VIOLET
  meteorRain(0X00, 0X80, 0X00, 7, 200, true, 75);//navy blue
  
  RGBLoop();

  NewKITT(0XF5, 0X00, 0X3E, 7, 100, 150);//RED
  NewKITT(0X7F, 0XFF, 0X00, 7, 100, 150);//GREEN
  NewKITT(0X00, 0XBF, 0XFF, 7, 100, 150);//PEACOCK blue
  
 rainbow(8, 3);

}


void knightRider(int red, int green, int blue, int ridingWidth, int delayDuration, int returnDelayDuration){
  for(int i = 0; i < (NUM_LEDS - ridingWidth - 2); i++) {
    FastLED.clear();
    FastLED.show();
    leds[i].setRGB(red/10, green/10, blue/10);
    for(int j = 1; j <= ridingWidth; j++) {
      leds[i + j].setRGB(red, green, blue);
    }
    leds[i + ridingWidth + 1].setRGB(red/10, green/10, blue/10);
    FastLED.show();
    delay(delayDuration);
  }

  delay(returnDelayDuration);

  for(int i = (NUM_LEDS - ridingWidth - 2); i > 0; i--) {
    FastLED.clear();
    FastLED.show();
    leds[i].setRGB(red/10, green/10, blue/10);
    for(int j = 1; j <= ridingWidth; j++) {
      leds[i + j].setRGB(red, green, blue);
    }
    leds[i + ridingWidth + 1].setRGB(red/10, green/10, blue/10);
    FastLED.show();
    delay(delayDuration);
  }
 
  delay(returnDelayDuration);
}

void rainbow(unsigned long wait, unsigned int numLoops) {
	for (unsigned int count = 0; count < numLoops; count++) {
		// iterate through all 8-bit hues, using 16-bit values for granularity
		for (unsigned long firstPixelHue = 0; firstPixelHue < 65536; firstPixelHue += 256) {
			for (unsigned int i = 0; i < strip.numPixels(); i++) {
				unsigned long pixelHue = firstPixelHue + (i * 65536UL / strip.numPixels()); // vary LED hue based on position
				strip.setPixelColor(i, strip.gamma32(strip.ColorHSV(pixelHue)));  // assign color, using gamma curve for a more natural look
			}
			strip.show();
			delay(wait);
		}
	}
}

 // Fill the dots one after the other with a color
void colorWipe(uint32_t c, uint8_t wait) {
  for(uint16_t i=strip.numPixels(); i>0; i--) {
    strip.setPixelColor(i, c);
    strip.show();
    delay(wait);
   
  }
}
//Theatre-style crawling lights.
void theaterChase(uint32_t color, unsigned long wait, unsigned int groupSize, unsigned int numChases) {
	for (unsigned int chase = 0; chase < numChases; chase++) {
		for (unsigned int pos = 0; pos < groupSize; pos++) {
			strip.clear();  // turn off all LEDs
			for (unsigned int i = pos; i < strip.numPixels(); i += groupSize) {
				strip.setPixelColor(i, color);  // turn on the current group
			}
			strip.show();
			delay(wait);
		}
	}
}

void RunningLights(byte red1, byte green1, byte blue1, 
                   byte red2, byte green2, byte blue2,
                   byte red3, byte green3, byte blue3, int WaveDelay) {
                    
  float b1 = 0.01; // brightness LEDs 1 and 5
  float b2 = 0.2;  // brightness LEDs 2 and 4
  
  int Col1Pos = 0;
  for(int start=0; start<15; start++) /// "strip" is 10 leds: 2x5 leds
    {
      for (int i=-15; i < NUM_LEDS+15; i=i+15) {
        Col1Pos = i+start;
        
        setMyPixel(Col1Pos,   red1, green1, blue1);    //turn every third pixel on
        setMyPixel(Col1Pos+1, red1, green1, blue1);
        setMyPixel(Col1Pos+2, red1, green1, blue1);
        setMyPixel(Col1Pos+3, red1, green1, blue1);
        setMyPixel(Col1Pos+4, red1, green1, blue1);
  
        setMyPixel(Col1Pos+5, red2, green2, blue2);    //turn every third pixel on
        setMyPixel(Col1Pos+6, red2, green2, blue2);
        setMyPixel(Col1Pos+7, red2, green2, blue2);
        setMyPixel(Col1Pos+8, red2, green2,blue2);
        setMyPixel(Col1Pos+9, red2, green2, blue2);
  
        setMyPixel(Col1Pos+10, red3, green3, blue3);    //turn every third pixel on
        setMyPixel(Col1Pos+11, red3, green3, blue3);
        setMyPixel(Col1Pos+12, red3, green3, blue3);
        setMyPixel(Col1Pos+13, red3, green3, blue3);
        setMyPixel(Col1Pos+14, red3, green3, blue3);
      }
      
    FastLED.show();
    delay(WaveDelay);
  }
}

void setMyPixel(int Pixel, byte red, byte green, byte blue) {
   if( (Pixel>=0) && (Pixel<=NUM_LEDS) )
   {
     leds[Pixel] = CRGB( red, green, blue);
   }
}




// 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();
    delay(wait);
  }
}



// Rainbow-enhanced theater marquee. Pass delay time (in ms) between frames.
void theaterChaseRainbow(int wait) {
  int firstPixelHue = 0;     // First pixel starts at red (hue 0)
  for(int a=0; a<20; a++) {  // Repeat 30 times...
    for(int b=0; b<3; b++) { //  'b' counts from 0 to 2...
      strip.clear();         //   Set all pixels in RAM to 0 (off)
      // 'c' counts up from 'b' to end of strip in increments of 3...
      for(int c=b; c<strip.numPixels(); c += 3) {
        // hue of pixel 'c' is offset by an amount to make one full
        // revolution of the color wheel (range 65536) along the length
        // of the strip (strip.numPixels() steps):
        int      hue   = firstPixelHue + c * 65536L / strip.numPixels();
        uint32_t color = strip.gamma32(strip.ColorHSV(hue)); // hue -> RGB
        strip.setPixelColor(c, color); // Set pixel 'c' to value 'color'
      }
      strip.show();                // Update strip with new contents
      delay(wait);                 // Pause for a moment
      firstPixelHue += 65536 / 90; // One cycle of color wheel over 90 frames
    }
  }
}

void rainbowStrip() {
  
  int i = 0;
  while(i<NUM_LEDS*4) {     
    strip.setPixelColor(i%NUM_LEDS, strip.Color(255, 255, 255)); //change RGB color value here
    strip.setPixelColor((i+1)%NUM_LEDS, strip.Color(255, 5, 180)); //change RGB color value here
    strip.setPixelColor((i+2)%NUM_LEDS, strip.Color(255, 0, 0)); //change RGB color value here
    strip.setPixelColor((i+3)%NUM_LEDS, strip.Color(255, 150, 0)); //change RGB color value here
    strip.setPixelColor((i+4)%NUM_LEDS, strip.Color(255, 255, 5)); //change RGB color value here
    strip.setPixelColor((i+5)%NUM_LEDS, strip.Color(0, 255, 0)); //change RGB color value here
    strip.setPixelColor((i+6)%NUM_LEDS, strip.Color(0, 0, 255)); //change RGB color value here
    strip.setPixelColor((i+7)%NUM_LEDS, strip.Color(135, 10, 215)); //change RGB color value here
    strip.setPixelColor((i+8)%NUM_LEDS, strip.Color(255, 255, 255)); //change RGB color value here
    i++;
    strip.show();
    delay(100);
  }
}



// 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) {
  WheelPos = 255 - WheelPos;
  if(WheelPos < 85) {
    return strip.Color(255 - WheelPos * 3, 0, WheelPos * 3);
  }
  if(WheelPos < 170) {
    WheelPos -= 85;
    return strip.Color(0, WheelPos * 3, 255 - WheelPos * 3);
  }
  WheelPos -= 170;
  return strip.Color(WheelPos * 3, 255 - WheelPos * 3, 0);
  
}

// alternate between two colors on even and odd LEDs
void alternateColor(uint32_t c1, uint32_t c2, uint8_t wait) {
  for(uint16_t i=0; i<strip.numPixels(); i++) {
    if(i%2 == 0) { // set even LED to color 1
      strip.setPixelColor(i, c1);
    } else { // set odd LED to color 2
      strip.setPixelColor(i, c2);
    }
  }

  strip.show(); // apply the colors
  delay(800);

  for(uint16_t i=0; i<strip.numPixels(); i++) {
    if(i%2 == 0) { // set even LED to color 2
      strip.setPixelColor(i, c2);
    } else { // set odd LED to color 1
      strip.setPixelColor(i, c1);
    }
  }

  strip.show(); // apply the colors
  delay(800);
}

void clearStrip(){
  for(int i=0;i<NUM_LEDS;i++){
      strip.setPixelColor(i, strip.Color(0, 0, 0)); //change RGB color value here
   }
   strip.show();
}



// Light up the strip starting from the middle
void middleFill(uint32_t c, uint8_t wait) {
  clearStrip();
  delay(wait);

  for(uint16_t i=0; i<(strip.numPixels()/2); i++) { // start from the middle, lighting an LED on each side
    strip.setPixelColor(strip.numPixels()/2 + i, c);
    strip.setPixelColor(strip.numPixels()/2 - i, c);
    strip.show();
    delay(wait);
  }
  strip.setPixelColor(0, c);
  strip.show();
  delay(wait);

  for(uint16_t i=0; i<(strip.numPixels()/2); i++) { // reverse
    strip.setPixelColor(i, strip.Color(0, 0, 0));
    strip.setPixelColor(strip.numPixels() - i, strip.Color(0, 0, 0));
    strip.show();
    delay(wait);
  }
  clearStrip();
}

// Light up the strip starting from the sides
void sideFill(uint32_t c, uint8_t wait) {
  clearStrip();
  delay(wait);

  for(uint16_t i=0; i<(strip.numPixels()/2); i++) { // fill strip from sides to middle
    strip.setPixelColor(i, c);
    strip.setPixelColor(strip.numPixels() - i, c);
    strip.show();
    delay(wait);
  }

  strip.setPixelColor(strip.numPixels()/2, c);
  strip.show();
  delay(wait);

  for(uint16_t i=0; i<(strip.numPixels()/2); i++) { // reverse
    strip.setPixelColor(strip.numPixels()/2 + i, strip.Color(0, 0, 0));
    strip.setPixelColor(strip.numPixels()/2 - i, strip.Color(0, 0, 0));
    strip.show();
    delay(wait);
  }
  clearStrip();
}

/*Extra stuff*/
void showStrip() {
 #ifdef ADAFRUIT_NEOPIXEL_H 
   // NeoPixel
   strip.show();
 #endif
 #ifndef ADAFRUIT_NEOPIXEL_H
   // FastLED
   FastLED.show();
 #endif
}

void setPixel(int Pixel, byte red, byte green, byte blue) {
 #ifdef ADAFRUIT_NEOPIXEL_H 
   // NeoPixel
   strip.setPixelColor(Pixel, strip.Color(red, green, blue));
 #endif
 #ifndef ADAFRUIT_NEOPIXEL_H 
   // FastLED
   leds[Pixel].r = red;
   leds[Pixel].g = green;
   leds[Pixel].b = blue;
 #endif
}

void setAll(byte red, byte green, byte blue) {
  for(int i = 0; i < NUM_LEDS; i++ ) {
    setPixel(i, red, green, blue); 
  }
  showStrip();
}



void FadeInOut(byte red, byte green, byte blue){
  float r, g, b;
      
  for(int k = 0; k < 256; k=k+1) { 
    r = (k/256.0)*red;
    g = (k/256.0)*green;
    b = (k/256.0)*blue;
    setAll(r,g,b);
    showStrip();
    delay(4);    
  }  
     
  for(int k = 255; k >= 0; k=k-2) {
    r = (k/256.0)*red;
    g = (k/256.0)*green;
    b = (k/256.0)*blue;
    setAll(r,g,b);
    showStrip();
  }
}


   
void Strobe(byte red, byte green, byte blue, int StrobeCount, int FlashDelay, int EndPause){
  for(int j = 0; j < StrobeCount; j++) {
    setAll(red,green,blue);
    showStrip();
    delay(FlashDelay);
    setAll(0,0,0);
    showStrip();
    delay(FlashDelay);
  }
 
 delay(EndPause);
}

void CylonBounce(byte red, byte green, byte blue, int EyeSize, int SpeedDelay, int ReturnDelay){

  for(int i = 0; i < NUM_LEDS-EyeSize-2; i++) {
    setAll(0,0,0);
    setPixel(i, red/10, green/10, blue/10);
    for(int j = 1; j <= EyeSize; j++) {
      setPixel(i+j, red, green, blue); 
    }
    setPixel(i+EyeSize+1, red/10, green/10, blue/10);
    showStrip();
    delay(SpeedDelay);
  }

  delay(ReturnDelay);

  for(int i = NUM_LEDS-EyeSize-2; i > 0; i--) {
    setAll(0,0,0);
    setPixel(i, red/10, green/10, blue/10);
    for(int j = 1; j <= EyeSize; j++) {
      setPixel(i+j, red, green, blue); 
    }
    setPixel(i+EyeSize+1, red/10, green/10, blue/10);
    showStrip();
    delay(SpeedDelay);
  }
  
  delay(ReturnDelay);
}
void meteorRain(byte red, byte green, byte blue, byte meteorSize, byte meteorTrailDecay, boolean meteorRandomDecay, int SpeedDelay) {  
  setAll(0,0,0);
 
  for(int i = 0; i < NUM_LEDS; i++) {
    // fade brightness all LEDs one step
    for(int j=0; j<NUM_LEDS; j++) {
      if( (!meteorRandomDecay) || (random(10)>5) ) {
        fadeToBlack(j, meteorTrailDecay );        
      }
    }
   
    // draw meteor
    for(int j = 0; j < meteorSize; j++) {
      if( ( i-j <NUM_LEDS) && (i-j>=0) ) {
        setPixel(i-j, red, green, blue);
      }
    }
   
    showStrip();
    delay(SpeedDelay);
  }
}

//Starts at highest number LED and goes to lowest
void meteorRainReverse(byte red, byte green, byte blue, byte meteorSize, byte meteorTrailDecay, boolean meteorRandomDecay, int SpeedDelay) {  
  setAll(0,0,0);
 
  for(int i = 0; i < NUM_LEDS; i++) {
   
   
    // fade brightness all LEDs one step
    for(int j=0; j<NUM_LEDS; j++) {
      if( (!meteorRandomDecay) || (random(10)>5) ) {
        fadeToBlack(j, meteorTrailDecay );        
      }
      
    }
   
    // draw meteor
    for(int j = 0; j < meteorSize; j++) {
      if( ( i-j <NUM_LEDS) && (i-j>=0) ) {
        setPixel(NUM_LEDS-i-j, red, green, blue);
      }
    }
   
    FastLED.show();
    delay(SpeedDelay);
  } 
}

void fadeToBlack(int ledNo, byte fadeValue) {
 #ifdef ADAFRUIT_NEOPIXEL_H
    // NeoPixel
    uint32_t oldColor;
    uint8_t r, g, b;
    int value;
   
    oldColor = strip.getPixelColor(ledNo);
    r = (oldColor & 0x00ff0000UL) >> 12;
    g = (oldColor & 0x0000ff00UL) >> 6;
    b = (oldColor & 0x000000ffUL);
    r=(r<=10)? 0 : (int) r-(r*fadeValue/256);
    g=(g<=10)? 0 : (int) g-(g*fadeValue/256);
    b=(b<=10)? 0 : (int) b-(b*fadeValue/256);
   
    strip.setPixelColor(ledNo, r,g,b);
 #endif
 #ifndef ADAFRUIT_NEOPIXEL_H
   // FastLED
   leds[ledNo].fadeToBlackBy( fadeValue );
 #endif  
}

void RGBLoop(){
  for(int j = 0; j < 3; j++ ) { 
    // Fade IN
    for(int k = 0; k < 256; k++) { 
      switch(j) { 
        case 0: setAll(k,0,0); break;
        case 1: setAll(0,k,0); break;
        case 2: setAll(0,0,k); break;
      }
      showStrip();
      delay(4);
    }
    // Fade OUT
    for(int k = 255; k >= 0; k--) { 
      switch(j) { 
        case 0: setAll(k,0,0); break;
        case 1: setAll(0,k,0); break;
        case 2: setAll(0,0,k); break;
      }
      showStrip();
      delay(4);
    }
  }
}
void NewKITT(byte red, byte green, byte blue, int EyeSize, int SpeedDelay, int ReturnDelay){
  RightToLeft(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
  LeftToRight(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
  OutsideToCenter(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
  CenterToOutside(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
  LeftToRight(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
  RightToLeft(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
  OutsideToCenter(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
  CenterToOutside(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
}

void CenterToOutside(byte red, byte green, byte blue, int EyeSize, int SpeedDelay, int ReturnDelay) {
  for(int i =((NUM_LEDS-EyeSize)/2); i>=0; i--) {
    setAll(0,0,0);
   
    setPixel(i, red/10, green/10, blue/10);
    for(int j = 1; j <= EyeSize; j++) {
      setPixel(i+j, red, green, blue);
    }
    setPixel(i+EyeSize+1, red/10, green/10, blue/10);
   
    setPixel(NUM_LEDS-i, red/10, green/10, blue/10);
    for(int j = 1; j <= EyeSize; j++) {
      setPixel(NUM_LEDS-i-j, red, green, blue);
    }
    setPixel(NUM_LEDS-i-EyeSize-1, red/10, green/10, blue/10);
   
    showStrip();
    delay(SpeedDelay);
  }
  delay(ReturnDelay);
}

void OutsideToCenter(byte red, byte green, byte blue, int EyeSize, int SpeedDelay, int ReturnDelay) {
  for(int i = 0; i<=((NUM_LEDS-EyeSize)/2); i++) {
    setAll(0,0,0);
   
    setPixel(i, red/10, green/10, blue/10);
    for(int j = 1; j <= EyeSize; j++) {
      setPixel(i+j, red, green, blue);
    }
    setPixel(i+EyeSize+1, red/10, green/10, blue/10);
   
    setPixel(NUM_LEDS-i, red/10, green/10, blue/10);
    for(int j = 1; j <= EyeSize; j++) {
      setPixel(NUM_LEDS-i-j, red, green, blue);
    }
    setPixel(NUM_LEDS-i-EyeSize-1, red/10, green/10, blue/10);
   
    showStrip();
    delay(SpeedDelay);
  }
  delay(ReturnDelay);
}

void LeftToRight(byte red, byte green, byte blue, int EyeSize, int SpeedDelay, int ReturnDelay) {
  for(int i = 0; i < NUM_LEDS-EyeSize-2; i++) {
    setAll(0,0,0);
    setPixel(i, red/10, green/10, blue/10);
    for(int j = 1; j <= EyeSize; j++) {
      setPixel(i+j, red, green, blue);
    }
    setPixel(i+EyeSize+1, red/10, green/10, blue/10);
    showStrip();
    delay(SpeedDelay);
  }
  delay(ReturnDelay);
}

void RightToLeft(byte red, byte green, byte blue, int EyeSize, int SpeedDelay, int ReturnDelay) {
  for(int i = NUM_LEDS-EyeSize-2; i > 0; i--) {
    setAll(0,0,0);
    setPixel(i, red/10, green/10, blue/10);
    for(int j = 1; j <= EyeSize; j++) {
      setPixel(i+j, red, green, blue);
    }
    setPixel(i+EyeSize+1, red/10, green/10, blue/10);
    showStrip();
    delay(SpeedDelay);
  }
  delay(ReturnDelay);
}

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();
    delay(wait);
  }
}