Subversion Repositories Projects

//*******************************************************************

// Definition of color pattern and sequences

//*******************************************************************

// 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, 127, 50,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-1; 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);

}