Subversion Repositories Projects

Rev

Blame | Last modification | View Log | RSS feed

//*******************************************************************
// Definition of color pattern and sequences
//*******************************************************************
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);
        strip.show();
        delay ( wait/2 );
         
  }
}

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);
        strip.show();
        delay ( wait/2 );
         
  }
}

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

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


// Fade In
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);
 }  
  strip.show();
  delay(wait);
 }
}

// Fade Out
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);
 }  
  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
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);
    }
   strip.show();
   delay(wait);
  }
  }
}

// Two colors flashing on left and right.
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);
    }
   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);
     }
   strip.show();
   delay(wait);
   }
 }
}

// Cycle through two colors, equally spaced around the Strip
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;
    strip.show(); // write all the pixels out
  }
 clearstrip ();
}


// fill strip dots by dot with selected color
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);
 strip.show();
 delay(wait);
 }
}

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

 clearstrip ();

 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)
 }
 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;

 clearstrip ();

 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)
 }
 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);
 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, strip.Color(r/8, g/8, b/8),ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8);
 strip.setPixelColor(pos, strip.Color(r, g, b),ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8);
 strip.setPixelColor(pos + 1, strip.Color(r/8, g/8, b/8),ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8);

 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, strip.Color(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
#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);
 }
 strip.show();
 delay(wait);
 }
}

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;

 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 / strip.numPixels() 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);
 }
}
/* Helper functions */

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

 // Clear strip
 void clearstrip (){
   for (int i=0; i < stripSize; i++) {
     strip.setPixelColor(i, 0);
   }
 }

// Set single LED
void setLED(uint16_t n, uint8_t r, uint8_t g, uint8_t b, uint8_t r1, uint8_t r2, uint8_t r3, uint8_t r4, uint8_t r5, uint8_t r6, uint8_t r7, uint8_t r8){
 n=n-1;
 strip.setPixelColor(n, strip.Color(r, g, b), r1, r2, r3, r4, r5, r6, r7, r8);
}