Subversion Repositories Projects

Rev

Blame | Last modification | View Log | RSS feed

//*******************************************************************
// Definition of color pattern and sequences
//*******************************************************************


// ------------------------------------------------------------------
// Move a  flashing circle from inner to outer
// ------------------------------------------------------------------
void flashingCircle( uint8_t r, uint8_t g, uint8_t b, uint8_t wait) { 
  uint8_t ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8;
  
  for (uint8_t j=0; j< riggerSize ; j++){
        strip.setPixelColor(j, r, g, b, 1, 1, 1, 1, 1, 1, 1, 1);
        strip.show();
        delay ( wait );
        strip.setPixelColor(j, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1);
remoteControl();
if (counter1 != counter2) {
   return;}
        strip.show();
        delay ( wait/2 );
         
  }
}

// ------------------------------------------------------------------
// Move a  flashing circle from outer to inner
// ------------------------------------------------------------------
void flashingCircleRev( uint8_t r, uint8_t g, uint8_t b, uint8_t wait) { 
  uint8_t ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8;
  
  for (uint8_t j = riggerSize; j > 0 ; j--){
        strip.setPixelColor(j-1, r, g, b, 1, 1, 1, 1, 1, 1, 1, 1);
        strip.show();
        delay ( wait );
        strip.setPixelColor(j-1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1);
remoteControl();
if (counter1 != counter2) {
   return;}
        strip.show();
        delay ( wait/2 );
         
  }
}

// ------------------------------------------------------------------
// Move a single circling LED from inner to outer
// ------------------------------------------------------------------
void spiral( uint8_t r, uint8_t g, uint8_t b, uint8_t wait) { 
  uint8_t ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8;
  
  for (uint8_t j=0; j< riggerSize ; j++){
     for (uint8_t i=1; i<= rigger ; i++){
        if (i == 1){
        strip.setPixelColor(j, r, g, b, 1, 0, 0, 0, 0, 0, 0, 0);
        strip.show();
        delay ( wait );
        strip.setPixelColor(j, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0);
remoteControl();
if (counter1 != counter2) {
   return;}
        strip.show();
        delay ( wait );
        }
        
        if (i == 2){
        strip.setPixelColor(j, r, g, b, 0, 1, 0, 0, 0, 0, 0, 0);
        strip.show();
        delay ( wait );
        strip.setPixelColor(j, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0);
remoteControl();
if (counter1 != counter2) {
   return;}
        strip.show();
        delay ( wait );
        }
        
        if (i == 3){
        strip.setPixelColor(j, r, g, b, 0, 0, 1, 0, 0, 0, 0, 0);
        strip.show();
        delay ( wait );
        strip.setPixelColor(j, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0);
remoteControl();
if (counter1 != counter2) {
    return;}
       strip.show();
        delay ( wait );
        }
        
        if (i == 4){
        strip.setPixelColor(j, r, g, b, 0, 0, 0, 1, 0, 0, 0, 0);
        strip.show();
        delay ( wait );
        strip.setPixelColor(j, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0);
remoteControl();
if (counter1 != counter2) {
   return;}
        strip.show();
        delay ( wait );
        }
        
        if (i == 5){
        strip.setPixelColor(j, r, g, b, 0, 0, 0, 0, 1, 0, 0, 0);
        strip.show();
        delay ( wait );
        strip.setPixelColor(j, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0);
remoteControl();
if (counter1 != counter2) {
   return;}
        strip.show();
        delay ( wait );
        }
        
        if (i == 6){
        strip.setPixelColor(j, r, g, b, 0, 0, 0, 0, 0, 1, 0, 0);
        strip.show();
        delay ( wait );
        strip.setPixelColor(j, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0);
remoteControl();
if (counter1 != counter2) {
   return;}
        strip.show();
        delay ( wait );
        }
        
        if (i == 7){
        strip.setPixelColor(j, r, g, b, 0, 0, 0, 0, 0, 0, 1, 0);
        strip.show();
        delay ( wait );
        strip.setPixelColor(j, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0);
remoteControl();
if (counter1 != counter2) {
   return;}
        strip.show();
        delay ( wait );
        }
        
         if (i == 8){
        strip.setPixelColor(j, r, g, b, 0, 0, 0, 0, 0, 0, 0, 1);
        strip.show();
        delay ( wait );
        strip.setPixelColor(j, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1);
remoteControl();
if (counter1 != counter2) {
   return;}
        strip.show();
        delay ( wait );
         }
     }
  }
}

// ------------------------------------------------------------------
// Move a single circling LED from outer to inner
// ------------------------------------------------------------------
void spiralRev( uint8_t r, uint8_t g, uint8_t b, uint8_t wait) { 
  uint8_t ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8;
  
  for (uint8_t j = riggerSize; j > 0 ; j--){
     for (uint8_t i = 1 ; i <= rigger ; i++){
        if (i == 1){
        strip.setPixelColor(j-1, r, g, b, 1, 0, 0, 0, 0, 0, 0, 0);
        strip.show();
        delay ( wait );
        strip.setPixelColor(j-1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0);
remoteControl();
if (counter1 != counter2) {
   return;}
        strip.show();
        delay ( wait );
        }
        
        if (i == 2){
        strip.setPixelColor(j-1, r, g, b, 0, 1, 0, 0, 0, 0, 0, 0);
        strip.show();
        delay ( wait );
        strip.setPixelColor(j-1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0);
remoteControl();
if (counter1 != counter2) {
   return;}
        strip.show();
        delay ( wait );
        }
        
        if (i == 3){
        strip.setPixelColor(j-1, r, g, b, 0, 0, 1, 0, 0, 0, 0, 0);
        strip.show();
        delay ( wait );
        strip.setPixelColor(j-1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0);
remoteControl();
if (counter1 != counter2) {
   return;}
        strip.show();
        delay ( wait );
        }
        
        if (i == 4){
        strip.setPixelColor(j-1, r, g, b, 0, 0, 0, 1, 0, 0, 0, 0);
        strip.show();
        delay ( wait );
        strip.setPixelColor(j-1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0);
remoteControl();
if (counter1 != counter2) {
   return;}
        strip.show();
        delay ( wait );
        }
        
        if (i == 5){
        strip.setPixelColor(j-1, r, g, b, 0, 0, 0, 0, 1, 0, 0, 0);
        strip.show();
        delay ( wait );
        strip.setPixelColor(j-1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0);
remoteControl();
if (counter1 != counter2) {
   return;}
        strip.show();
        delay ( wait );
        }
        
        if (i == 6){
        strip.setPixelColor(j-1, r, g, b, 0, 0, 0, 0, 0, 1, 0, 0);
        strip.show();
        delay ( wait );
        strip.setPixelColor(j-1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0);
remoteControl();
if (counter1 != counter2) {
   return;}
        strip.show();
        delay ( wait );
        }
        
        if (i == 7){
        strip.setPixelColor(j-1, r, g, b, 0, 0, 0, 0, 0, 0, 1, 0);
        strip.show();
        delay ( wait );
        strip.setPixelColor(j-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0);
remoteControl();
if (counter1 != counter2) {
   return;}
        strip.show();
        delay ( wait );
        }
        
         if (i == 8){
        strip.setPixelColor(j-1, r, g, b, 0, 0, 0, 0, 0, 0, 0, 1);
        strip.show();
        delay ( wait );
        strip.setPixelColor(j-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1);
remoteControl();
if (counter1 != counter2) {
   return;}
        strip.show();
        delay ( wait );
         }
     }
  }
}


// ------------------------------------------------------------------
// Fade In: Fades selected color from dark to full bright
// ------------------------------------------------------------------
void fadein( uint8_t r, uint8_t g, uint8_t b, uint8_t wait, uint8_t ri1, uint8_t ri2, uint8_t ri3, uint8_t ri4, uint8_t ri5, uint8_t ri6, uint8_t ri7, uint8_t ri8) { 

 uint8_t r2, g2, b2;

for (uint8_t j = 127; j > 10; j--){
  uint8_t rh = r-(j*r/127);
   if((r || rh) && rh <= r) r2 = rh;
   if(rh > r) r2 = r;
   if(r == 0) r2 = 0;
  uint8_t gh = g-(j*g/127);
   if((g || gh) && gh <= g) g2 = gh;
   if(gh > g) g2 = g;
   if(g == 0) g2 = 0;
  uint8_t bh = b-(j*b/127);
   if((b || bh) && bh <= b) b2 = bh;
   if(bh > b) b2 = b;
   if(b == 0) b2 = 0;
 for(uint8_t i=0; i<riggerSize; i++) {
 strip.setPixelColor(i, r2, g2, b2, ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8);
 }  
remoteControl();
if (counter1 != counter2) {
   return;}
  strip.show();
  delay(wait);
 }
}

// ------------------------------------------------------------------
// Fade Out: Fades selected color from full bright to dark
// ------------------------------------------------------------------
void fadeout(uint8_t r, uint8_t g, uint8_t b, uint8_t wait, uint8_t ri1, uint8_t ri2, uint8_t ri3, uint8_t ri4, uint8_t ri5, uint8_t ri6, uint8_t ri7, uint8_t ri8) { 

 uint8_t r2, g2, b2;

for (uint8_t j = 10; j < 127; j++){
  uint8_t rh = r-(j*r/127);
   if((r || 0) && rh < r) r2 = rh;
   if(r == 0) r2 = 0;
  uint8_t gh = g-(j*g/127);
   if((g || 0) && gh < g) g2 = gh;
   if(g == 0) g2 = 0;
  uint8_t bh = b-(j*b/127);
   if((b || 0) && bh < b) b2 = bh;
   if(b == 0) b2 = 0;
for(int i=0; i<riggerSize; i++) {
 strip.setPixelColor(i, r2, g2, b2,ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8);
 }  
remoteControl();
if (counter1 != counter2) {
   return;}
  strip.show();
  delay(wait);
 }
for(int i=0; i<riggerSize; i++) {
 strip.setPixelColor(i, 0,ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8);
 }  
}

// ------------------------------------------------------------------
// Flashing Light: Blink full rigger 
// ------------------------------------------------------------------
void flashLight(uint8_t wait, uint8_t cyl, uint8_t ri1, uint8_t ri2, uint8_t ri3, uint8_t ri4, uint8_t ri5, uint8_t ri6, uint8_t ri7, uint8_t ri8) {

  for (int j=0; j < cyl; j++) { 
  for (int x = 0; x<2; x++){
    for (int i = 0; i < riggerSize; i++){
     strip.setPixelColor(i, 0, 127,0,ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8);
    }
   strip.show();
   delay(wait);
    for (int i = 0; i < riggerSize; i++){
     strip.setPixelColor(i, 0,ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8);
    }
remoteControl();
if (counter1 != counter2) {
   return;}
   strip.show();
   delay(wait);
  }
  }
}

// ------------------------------------------------------------------
// Police Light :Two colors flashing on left and right of selected rigger.
// ------------------------------------------------------------------
void police(uint8_t wait, uint8_t cyl, uint8_t ri1, uint8_t ri2, uint8_t ri3, uint8_t ri4, uint8_t ri5, uint8_t ri6, uint8_t ri7, uint8_t ri8) {

  for (int j=0; j < cyl; j++) { 
  for (int x = 0; x<2; x++){
    for (int i = 0; i < (riggerSize/2); i++){
     strip.setPixelColor(i, 127,0,0,ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8);
    }
   strip.show();
   delay(wait);
    for (int i = 0; i < (riggerSize/2); i++){
     strip.setPixelColor(i, 0, 0,0,ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8);
    }
remoteControl();
if (counter1 != counter2) {
   return;}
   strip.show();
   delay(wait);
  }
  for (int x = 0; x<2; x++){
    for (int i = (riggerSize/2); i < riggerSize; i++){
     strip.setPixelColor(i, 0, 0,127,ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8);
     } 
   strip.show();
    delay(wait);
  for (int i = (riggerSize/2); i < riggerSize; i++){
     strip.setPixelColor(i, 0,ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8);
     }
remoteControl();
if (counter1 != counter2) {
   return;}
   strip.show();
   delay(wait);
   }
 }
}

// ------------------------------------------------------------------
// Cycle through two colors, equally spaced around the Strip ( one left, on right )
// Like Nightrider, but with two colors.
// ------------------------------------------------------------------
void circlinglights(uint8_t wait, uint8_t cyl, uint8_t ri1, uint8_t ri2, uint8_t ri3, uint8_t ri4, uint8_t ri5, uint8_t ri6, uint8_t ri7, uint8_t ri8) {
 uint16_t b=0;
 uint16_t r=riggerSize-1;

 for (int j=0; j < stripSize * cyl; j++) { 
    strip.setPixelColor(b%riggerSize,0,2,0,ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8);
    strip.setPixelColor((b+1)%riggerSize,1,16,0,ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8);
    strip.setPixelColor((b+2)%riggerSize,0,55,0,ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8);
    strip.setPixelColor((b+3)%riggerSize,0,127,0,ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8);
    strip.setPixelColor(r%riggerSize,2,1,0,ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8);
    strip.setPixelColor((r+riggerSize-1)%riggerSize,16,3,0,ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8);
    strip.setPixelColor((r+riggerSize-2)%riggerSize,55,15,0,ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8);
    strip.setPixelColor((r+riggerSize-3)%riggerSize,127,20,0,ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8);
    strip.show();
    delay(wait);
    strip.setPixelColor(b%riggerSize,0,ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8);
    strip.setPixelColor(r%riggerSize,0,ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8);
    strip.show();
    if (b++==riggerSize) b=0;
    if (r--==0) r=riggerSize;
remoteControl();
if (counter1 != counter2) {
   return;}
    strip.show(); // write all the pixels out
  }
}


// ------------------------------------------------------------------
// Fill hole rigger dot by dot with selected color from inner to outer
// ------------------------------------------------------------------
void colorWipe( uint8_t r, uint8_t g, uint8_t b, uint8_t wait, uint8_t ri1, uint8_t ri2, uint8_t ri3, uint8_t ri4, uint8_t ri5, uint8_t ri6, uint8_t ri7, uint8_t ri8) {
 int i;

 for (i=0; i < riggerSize; i++) {
 strip.setPixelColor(i , r, g, b ,ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8);
remoteControl();
if (counter1 != counter2) {
   return;}
 strip.show();
 delay(wait);
 }
}

// ------------------------------------------------------------------
// Fill hole rigger dot by dot with selected color from outer to inner 
// ------------------------------------------------------------------
void colorWipeREV( uint8_t r, uint8_t g, uint8_t b, uint8_t wait, uint8_t ri1, uint8_t ri2, uint8_t ri3, uint8_t ri4, uint8_t ri5, uint8_t ri6, uint8_t ri7, uint8_t ri8) {
 int i;

 for (i = riggerSize-1; i >= 0 ; i--) {
 strip.setPixelColor(i , r, g, b ,ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8);
remoteControl();
if (counter1 != counter2) {
   return;}
 strip.show();
 delay(wait);
 }
}

// ------------------------------------------------------------------
// Fill hole rigger with selected color in one step
// ------------------------------------------------------------------
void colorFill( uint8_t r, uint8_t g, uint8_t b, uint8_t ri1, uint8_t ri2, uint8_t ri3, uint8_t ri4, uint8_t ri5, uint8_t ri6, uint8_t ri7, uint8_t ri8) {
 int i;

 for (i=0; i < riggerSize; i++) {
 strip.setPixelColor(i , r, g, b ,ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8);
 }
remoteControl();
if (counter1 != counter2) {
   return;}
 strip.show();
}

// ------------------------------------------------------------------
// Chase a dot down the strip
// good for testing purposes
// ------------------------------------------------------------------
void colorChase( uint8_t r, uint8_t g, uint8_t b, uint8_t wait, uint8_t ri1, uint8_t ri2, uint8_t ri3, uint8_t ri4, uint8_t ri5, uint8_t ri6, uint8_t ri7, uint8_t ri8) {
 int pix;

 for (pix=0; pix < riggerSize; pix++) {
 strip.setPixelColor(pix , r, g, b ,ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8); // set one pixel
 strip.show(); // refresh strip display
 delay(wait); // hold image for a moment
 strip.setPixelColor(pix,0,0, 0, ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8); // erase pixel (but don't refresh yet)
 }
remoteControl();
if (counter1 != counter2) {
   return;}
 strip.show(); // for last erased pixel
}

// ------------------------------------------------------------------
// Chase a dot reverse up the strip
// good for testing purposes
// ------------------------------------------------------------------
void colorChaseRev( uint8_t r, uint8_t g, uint8_t b, uint8_t wait, uint8_t ri1, uint8_t ri2, uint8_t ri3, uint8_t ri4, uint8_t ri5, uint8_t ri6, uint8_t ri7, uint8_t ri8) {
 int i;
 for (i=riggerSize-1; i >= 0; i--) {
 strip.setPixelColor(i,  r, g, b ,ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8); // set one pixel
 strip.show(); // refresh strip display
 delay(wait); // hold image for a moment
 strip.setPixelColor(i,0,0, 0,ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8); // erase pixel (but don't refresh yet)
 }
remoteControl();
if (counter1 != counter2) {
   return;}
 strip.show(); // for last erased pixel
}

// ------------------------------------------------------------------
// An "ordered dither" fills every pixel in a sequence that looks
// sparkly and almost random, but actually follows a specific order.
// ------------------------------------------------------------------
void dither(uint8_t r, uint8_t g, uint8_t b, uint8_t wait, uint8_t ri1, uint8_t ri2, uint8_t ri3, uint8_t ri4, uint8_t ri5, uint8_t ri6, uint8_t ri7, uint8_t ri8) {

 // Determine highest bit needed to represent pixel index
 int hiBit = 0;
 int n = (riggerSize/3)+1;
 for(int bit=1; bit < 0x8000; bit <<= 1) {
 if(n & bit) hiBit = bit;
 }

 int bit, reverse;
 for(int i=0; i<(hiBit << 1); i++) {
 // Reverse the bits in i to create ordered dither:
 reverse = 0;
 for(bit=1; bit <= hiBit; bit <<= 1) {
 reverse <<= 1;
 if(i & bit) reverse |= 1;
 }
 strip.setPixelColor(reverse, r,g,b,ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8);
remoteControl();
if (counter1 != counter2) {
   return;}
 strip.show();
 delay(wait);
 }
 delay(250); // Hold image for 1/4 sec
}

// ------------------------------------------------------------------
// "Larson scanner" = Cylon/KITT bouncing light effect
// ------------------------------------------------------------------
void scanner(uint8_t r, uint8_t g, uint8_t b, uint8_t wait, uint8_t ri1, uint8_t ri2, uint8_t ri3, uint8_t ri4, uint8_t ri5, uint8_t ri6, uint8_t ri7, uint8_t ri8) {
 int i, j, pos, dir;

 pos = 1;
 dir = 1;

 for(i=1; i<(riggerSize)*8; i++) {
 strip.setPixelColor(pos - 1, r/8, g/8, b/8,ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8);
 strip.setPixelColor(pos, r, g, b,ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8);
 strip.setPixelColor(pos + 1, r/8, g/8, b/8,ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8);

remoteControl();
if (counter1 != counter2) {
   return;}
 strip.show();
 delay(wait);
 // If we wanted to be sneaky we could erase just the tail end
 // pixel, but it's much easier just to erase the whole thing
 // and draw a new one next time.
 for(j=-1; j<= 1; j++) strip.setPixelColor(pos+j,0,0,0,ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8); // Bounce off ends of strip

 pos += dir;
 if(pos < 1) {
 pos = 1;
 dir = -dir;
 } else if(pos >= riggerSize-2) {
 pos = riggerSize - 2;
 dir = -dir;
 }
 }
}

// ------------------------------------------------------------------
// Sine wave effect (Selcted color and white)
// ------------------------------------------------------------------
#define PI 3.14159265
void wave( uint8_t r, uint8_t g, uint8_t b, uint8_t wait, int stp, uint8_t ri1, uint8_t ri2, uint8_t ri3, uint8_t ri4, uint8_t ri5, uint8_t ri6, uint8_t ri7, uint8_t ri8) {
 float y;
 uint8_t r2, g2, b2;

 for(int x=0; x<(riggerSize*5); x++)
 {
 for(int i=0; i<riggerSize; i++) {
 y = sin(PI * (float)stp * (float)(x + i) / (float)riggerSize);
 if(y >= 0.0) {
 // Peaks of sine wave are white
 y = 1.0 - y; // Translate Y to 0.0 (top) to 1.0 (center)
 r2 = 127 - (byte)((float)(127 - r) * y);
 g2 = 127 - (byte)((float)(127 - g) * y);
 b2 = 127 - (byte)((float)(127 - b) * y);
 } else {
 // Troughs of sine wave are black
 y += 1.0; // Translate Y to 0.0 (bottom) to 1.0 (center)
 r2 = (byte)((float)r * y);
 g2 = (byte)((float)g * y);
 b2 = (byte)((float)b * y);
 }
 strip.setPixelColor(i, r2, g2, b2,ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8);
 }
remoteControl();
if (counter1 != counter2) {
   return;}
 strip.show();
 delay(wait);
 }
}

// ------------------------------------------------------------------
// Cycling thru the colors of RGB color the wheel (outer to inner)
// ------------------------------------------------------------------
void rainbowCycle(uint8_t wait, uint8_t cyl, uint8_t ri1, uint8_t ri2, uint8_t ri3, uint8_t ri4, uint8_t ri5, uint8_t ri6, uint8_t ri7, uint8_t ri8) {
 uint16_t i, j;
remoteControl();
if (counter1 != counter2) {
   return;}
 for (j=0; j < 384 * cyl; j++) { // 5 cycles of all 384 colors in the wheel
 for (i=0; i < riggerSize; i++) {
 // tricky math! we use each pixel as a fraction of the full 384-color
 // wheel (thats the i * 384 / riggerSize part)
 // Then add in j which makes the colors go around per pixel
 // the % 384 is to make the wheel cycle around
 strip.setPixelColor(i, Wheel(((i * 384 / riggerSize) + j) % 384),ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8);
 }
 strip.show(); // write all the pixels out
 delay(wait);
 }
}

// ------------------------------------------------------------------
// Cycling thru the colors of RGB color the wheel (all LEDs at same time)
// ------------------------------------------------------------------
void rainbowCycleAll(uint8_t wait, uint8_t cyl, uint8_t ri1, uint8_t ri2, uint8_t ri3, uint8_t ri4, uint8_t ri5, uint8_t ri6, uint8_t ri7, uint8_t ri8) {
 uint16_t i, j, w;
remoteControl();
if (counter1 != counter2) {
   return;}
 for (j=0; j < 384*cyl; j++) { // cyl * cycles of all 384 colors in the wheel
 for (i=0; i < riggerSize; i++) {
       strip.setPixelColor(i, Wheel((j) % 384),ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8);
     }
   strip.show(); // write all the pixels out
    for (w=0; w < wait; w++){
        delay(5);
        }
   }
}


// ------------------------------------------------------------------
/* Helper function for Rainbow */
// ------------------------------------------------------------------

//Input a value 0 to 384 to get a color value.
//The colours are a transition r - g - b - back to r
uint32_t Wheel(uint16_t WheelPos)
{
 byte r, g, b;
 switch(WheelPos / 128)
 {
 case 0:
        r = 127 - WheelPos % 128; // red down
        g = WheelPos % 128; // green up
        b = 0; // blue off
 break;
 case 1:
        g = 127 - WheelPos % 128; // green down
        b = WheelPos % 128; // blue up
        r = 0; // red off
 break;
 case 2:
        b = 127 - WheelPos % 128; // blue down
        r = WheelPos % 128; // red up
        g = 0; // green off
 break;
 }
 return(strip.Color(r,g,b));
}