Neopixelstripe.c

gehe zur Dokumentation dieser Datei

/****************************************************************************/
/****************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <p18cxxx.h>
#include <xc.h>
#include "system.h"      // use "" for Includes in aktive Projectdirectory
#include <stdint.h>

/****************************************************************************/
#define LED_TRIS TRISAbits.RA0
#define LED LATAbits.LATA0

#define NEOPIXEL_TRIS TRISBbits.RB0
#define NEOPIXEL_OUT LATBbits.LATB0


#define TRUE = 1
#define FALSE = 0

/****************************************************************************/
uint8_t gbyte ;
uint8_t rbyte ;
uint8_t bbyte ;
uint8_t bytetosend ;
uint8_t pixel;
uint8_t j;
uint8_t limit;
uint8_t colorvalue;
uint8_t stripelength = 30; // Number of pixels in Stripe

uint16_t i;
uint16_t runs;
uint16_t loops;

/****************************************************************************/
uint8_t greens[30];
uint8_t reds[30];
uint8_t blues[30];

/*******************************************************************/
uint8_t stripe[30][3];

/*******************************************************************/
struct pixelcolor{
  uint8_t gbyte;
  uint8_t rbyte;
  uint8_t bbyte;
}Pixelcolors[30];

struct temp_pixelcolor{
  uint8_t gbyte;
  uint8_t rbyte;
  uint8_t bbyte;
}temp_pixelcolors;

/*******************************************************************/
struct pxcolor
{
  uint8_t pxgbyte;
  uint8_t pxrbyte;
  uint8_t pxbbyte;
}pxcolors[30] = {{0,0,0},{1,1,1},{2,2,2},{3,3,3},{4,4,4},{5,5,5},{6,6,6},
                 {7,7,7},{8,8,8},{9,9,9},{10,10,10},{11,11,11},{12,12,12},
                 {13,13,13},{14,14,14},{15,15,15},{16,16,16},{0,0,0},
                 {0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},
                 {0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},},
                 pxred    ={0x00,0xff,0x00},
                 pxgreen  ={0xff,0x00,0x00},
                 pxyellow ={0xff,0xff,0x00},
                 pxpink   ={0x00,0xff,0xff},
                 pxturkis ={0xff,0x00,0xff},
                 pxdark   ={0x00,0x00,0x00},
                 pxwhite  ={0xff,0xff,0xff},
                 pxblue   ={0x00,0x00,0xff};

 /* TODO write stripe rewrite with predefined colors and pointer to it  */

// Struct of Pointers ptr.gbyte,ptr.rbyte,ptr.bbyte
// declare Pointer of type struct PXColor  : struct PXColor *ptr
// Pointer points to PXColors first element: = PXColors
struct pxcolor *wr_ptr = &pxcolors ;          // declare write pointer
struct pxcolor *rd_ptr = &pxcolors ;          // declare read pointer
struct pxcolor *end_ptr = &pxcolors ;         // declare end pointer
static struct pxcolor *strt_ptr = &pxcolors ; // declare strt pointer

/*******************************************************************/
void Low(void);
void High(void);
void Res(void);
void Warte(uint16_t);

void Init_Stripe(void);
void Init_PXColors(uint8_t,uint8_t,uint8_t);
void Init_Pixelcolors(uint8_t);
void NeoInit (uint8_t);

void Prepare_Pixel(uint8_t);

void Write_Byte(uint8_t);
void Write_Pixel(uint8_t,uint8_t,uint8_t);
void Write_Stripe(uint8_t,uint8_t,uint8_t);
void Write_Stripe_Mono(struct pxcolor *rd_ptr);
void Write_PXColors2Pixel(void);
void Write_PXColors2pixel2(void);

void Moving_Bloc(void);

 /* TODO Add Prototypes.  */

/*******************************************************************/
void Warte(uint16_t loops)
{
  for (i=0;i<loops;i++)
   {
   __delay_ms(10);
   }
}

/*******************************************************************/
void Low()
{
   NEOPIXEL_OUT = 1;         // set High
   _delay(2);                // 2 = 336ns
   NEOPIXEL_OUT = 0;         // set Low
   _delay(5);
}

/*******************************************************************/
void High()
{
   NEOPIXEL_OUT = 1;          // set High
   _delay(7);                 // 5=582ns 7=748 ns
   NEOPIXEL_OUT = 0;          // set Low
   _delay(1)   ;              // 1=580ns
}

/*******************************************************************/
void Res()
{
   NEOPIXEL_OUT = 0;          // set Low
   _delay(600)   ;
}

/*******************************************************************/
void Write_Stripe(uint8_t gbyte,uint8_t rbyte,uint8_t bbyte)
{
  limit =1;
  for (runs =0; runs<limit;runs++)
    {
    for (pixel =0 ; pixel<runs;pixel++)
      {
      Write_Byte(gbyte);
      Write_Byte(rbyte);
      Write_Byte(bbyte);
      }
    Res();
    __delay_ms(5);

    if (limit<31) limit++ ;
    else limit =1 ;
    }
    Warte(50);
 }

/*******************************************************************/
void Write_Stripe_New(struct pxcolor *rd_ptr)
{
  uint8_t a ;
  for (a=0;a< stripelength ;a++)
  {
    Write_Byte(rd_ptr -> pxgbyte);  // Pointer to PXGbyte
    Write_Byte(rd_ptr -> pxrbyte);
    Write_Byte(rd_ptr -> pxbbyte);
    rd_ptr++ ;
  }
}

/*******************************************************************/
void Write_Stripe_Mono(struct pxcolor *rd_ptr)
{
  uint8_t a ;
  for (a=0;a< stripelength ;a++)
  {
    Write_Byte(rd_ptr -> pxgbyte);  // Pointer to PXGbyte
    Write_Byte(rd_ptr -> pxrbyte);
    Write_Byte(rd_ptr -> pxbbyte);
  }
}

/*******************************************************************/
void Write_Pixel(uint8_t gbyte,uint8_t rbyte,uint8_t bbyte)
{
  Write_Byte(gbyte);
  Write_Byte(rbyte);
  Write_Byte(bbyte);
}

/*******************************************************************/
void Write_Byte(uint8_t bytetosend)
{
  uint8_t i;
  uint8_t mask = 128 ;

  for (i=0 ; i<8 ; i++)
    {
    if (bytetosend & mask) High();
    else Low();
    mask = mask>>1;
    }
}// write_byte

/*******************************************************************/
void Init_Stripe(void)
{
uint8_t a=0;

// for (a=0;a<7;a++)
a=0;
   stripe[a][0] = 0xFF ;
   stripe[a][1] = 0x00 ;
   stripe[a][2] = 0x00 ;
   
   a=1;
   stripe[a][0] = 0x00 ;
   stripe[a][1] = 0xFF ;
   stripe[a][2] = 0x00 ;
   
   a=2;
   stripe[a][0] = 0x00 ;
   stripe[a][1] = 0x00 ;
   stripe[a][2] = 0xFF ;
   
   a=3;
   stripe[a][0] = 0xFF ;
   stripe[a][1] = 0x00 ;
   stripe[a][2] = 0xFF ;
   
   a=4;
   stripe[a][0] = 0xFF ;
   stripe[a][1] = 0xFF ;
   stripe[a][2] = 0x00 ;
   
   a=5;
   stripe[a][0] = 0x00 ;
   stripe[a][1] = 0xFF ;
   stripe[a][2] = 0xFF ;
   
   a=6;
   stripe[a][0] = 0x00 ;
   stripe[a][1] = 0x00 ;
   stripe[a][2] = 0x00 ;
   }
// Init_stripe

/*******************************************************************/
void Init_PXColors(uint8_t g,uint8_t r,uint8_t b)
{
uint8_t a=0;
wr_ptr = pxcolors ;              // pointer back to Start
for (a=0;a<5;a++)
  {
    wr_ptr -> pxgbyte = g;      // first 5 Fields RGB Value
    wr_ptr -> pxrbyte = r;
    wr_ptr -> pxbbyte = b;
    wr_ptr++ ;
  }
for (a=5;a< stripelength ;a++)
  {
    wr_ptr -> pxgbyte = 0x00;   // Fields above 5 0x00 dark
    wr_ptr -> pxrbyte = 0x00;
    wr_ptr -> pxbbyte = 0x00;
    wr_ptr++ ;
  }
}

/*******************************************************************/
void Init_Pixelcolors_New(uint8_t brightness)
{
uint8_t a=0, b=0, g=0, r=0;
wr_ptr = pxcolors ;              // pointer back to Start

for (a=0;a<stripelength;a++)
  {
  if (a < 4)
    {b=0x00 ;g= brightness;r= 0x00; } // rot
  else if ((a > 4)&(a<8) )
    {b= 0x00;g=brightness;r=0x00 ;}   // orange
  else if ((a > 8)&(a<12) )
    {b= brightness;g=brightness;r=0x00;}    // gelb
  else if ((a > 12)&(a<16) )
    {b= brightness;g=0x00;r=0x00;}   //grün
  else if ((a > 20)&(a<24) )
    {b= 0x00;g=brightness;r=brightness;}   //türkis
  else if ((a > 24)&(a<28) )
    {b= 0x00;g=0x00;r=brightness;}   //blau
  else if ((a > 28)&(a< stripelength))
    {b= 0x00;   g=brightness;  r=brightness;} //lila

  wr_ptr -> pxgbyte = b;
  wr_ptr -> pxrbyte = g;
  wr_ptr -> pxbbyte = r;
  wr_ptr++ ;

  }
}

/*******************************************************************/
void Write_PXColors2Pixel(void)
{
uint8_t a;
for (a=0;a<240;a++)
  {
    Write_Byte(rd_ptr -> pxgbyte);  // Pointer to PXGbyte
    Write_Byte(rd_ptr -> pxrbyte);
    Write_Byte(rd_ptr -> pxbbyte);
    rd_ptr++ ;                      // next Pixel
    if (rd_ptr >= end_ptr) rd_ptr = pxcolors ;
  }
}

/*******************************************************************/
void Write_PXColors2Pixel2(void)
{
uint8_t a;
for (a=0;a<stripelength;a++)
  {
    Write_Byte(rd_ptr -> pxgbyte);  // Pointer to PXGbyte
    Write_Byte(rd_ptr -> pxrbyte);
    Write_Byte(rd_ptr -> pxbbyte);
    rd_ptr-- ;                      // next Pixel
    if (rd_ptr <= strt_ptr) rd_ptr = end_ptr ;
  }
}
/*******************************************************************/
void Init_Pixelcolors(uint8_t brightness)
{
uint8_t a=0, b=0, g=0, r=0;
for (a=0;a<stripelength;a++)
  {
  if (a < 5)
    {b= brightness;g= 0x00;r= 0x00; }
  else if ((a > 5)&(a<10) )
    {b= 0x00;g=brightness;r=0x00 ;}
  else if ((a > 10)&(a<15) )
    {b= 0x00;g=0x00;r=brightness;}
  else if ((a > 15)&(a<20) )
    {b= brightness;g=0x00;r=0x00;}
  else if ((a > 20)&(a<25) )
    {b= 0x00;g=brightness;r=0x00;}
  else if ((a > 25)&(a<stripelength))
    {b= 0x00;   g=0x00;  r=brightness;}

  Pixelcolors[a].gbyte = b ;
  Pixelcolors[a].rbyte = g ;
  Pixelcolors[a].bbyte = r ;
  }
}

/*******************************************************************/
void NeoInit (uint8_t colorvalue)
{
   uint8_t NeoPixel;
for (NeoPixel = 0; NeoPixel < stripelength ; NeoPixel++)
   {
      if (NeoPixel < 5)
         { greens[NeoPixel] = 0; blues[NeoPixel] = 0; reds[NeoPixel] = colorvalue; }
      else if ((NeoPixel >= 5) & (NeoPixel < 10))
         { greens[NeoPixel] = 0; blues[NeoPixel] = colorvalue; reds[NeoPixel] = 0; }
      else if ((NeoPixel >= 10) & (NeoPixel < 15))
         { greens[NeoPixel] = 0; blues[NeoPixel] = colorvalue; reds[NeoPixel] = colorvalue; }
      else if ((NeoPixel >= 15) & (NeoPixel < 20))
         { greens[NeoPixel] = colorvalue; blues[NeoPixel] = 0; reds[NeoPixel] = 0; }
      else if ((NeoPixel >= 20) & (NeoPixel < 25))
         { greens[NeoPixel] = colorvalue; blues[NeoPixel] = 0; reds[NeoPixel] = colorvalue; }
      else if ((NeoPixel >= 25) & (NeoPixel < stripelength ))
         { greens[NeoPixel] = colorvalue; blues[NeoPixel] = colorvalue; reds[NeoPixel] = 0; }
   }
}

/*******************************************************************/
void NeoInit_New (uint8_t colorvalue)
{
   uint8_t a,b,r,g ;
   wr_ptr = pxcolors ;              // pointer back to Start
   for (a = 0; a < stripelength ; a++)
   {
      if (a < 5)
         {g =0;b=0;r=colorvalue;}
      else if ((a >= 5) & (a < 10))
         {g =0;b=colorvalue;r=0;}
      else if ((a >= 10) & (a < 15))
         {g =0;b=colorvalue;r=colorvalue;}
      else if ((a >= 15) & (a < 20))
         {g =colorvalue;b=0;r=0;}
      else if ((a >= 20) & (a < 25))
         {g =colorvalue;b=0;r=colorvalue;}
      else if ((a >= 25) & (a < stripelength ))
         {g =colorvalue;b=colorvalue;r=0;}

     wr_ptr -> pxgbyte = g;
     wr_ptr -> pxrbyte = r;
     wr_ptr -> pxbbyte = b;
     wr_ptr++ ;
   }
}

/*******************************************************************/
void Prepare_Pixel(uint8_t j)
{
uint8_t b=0;
for (b=0;b<3;b++)
  {
  gbyte = stripe[j][b];
  rbyte = stripe[j][b];
  bbyte = stripe[j][b];
  }
}
// prepare_pixel



//void increase(unsigned char G,unsigned char R,unsigned char B)
/*{
  for (c=0;c<255;c=c+5)
    {
    for (a=0;a<stripelenght;a++)
      {
      colorvalue = c;
      gbyte=G;
      rbyte=R;
      bbyte=colorvalue;
      Write_Pixel(gbyte,rbyte,bbyte);
      }
    warte(1);
    }
}*/

/*******************************************************************/
void Moving_Bloc(void)
{
  uint8_t a,c;
  for (a=0;a<10;a++)
  {
    Init_PXColors(0xFF,0x00,0x00);
    for (c=0;c< stripelength ;c++)
    {
      rd_ptr = pxcolors ; // pointer back to Start
      rd_ptr = rd_ptr + c ;
      Write_PXColors2Pixel();
      Res();
      Warte(2);
    }    
  }
  for (a=0;a<10;a++)
  {
    Init_PXColors(0x00,0xff,0xff);
    for (c=0;c< stripelength ;c++)
    {
      rd_ptr = pxcolors ; // pointer back to Start
      rd_ptr = rd_ptr + c ;
      Write_PXColors2Pixel2();
      Res();
      Warte(2);
    }    
  }
}

/*******************************************************************/
void Moving_Bloc2(void)
{
  uint8_t a,c;
  for (a=0;a<10;a++)
  {
    Init_Pixelcolors_New(0x7f);
    for (c=0;c< stripelength ;c++)
    {
      rd_ptr = pxcolors ; // pointer back to Start
      rd_ptr = rd_ptr + c ;
      Write_PXColors2Pixel();
      Res();
      Warte(2);
    }  
  }
  for (a=0;a<10;a++)
  {
    Init_Pixelcolors_New(0xff);
    for (c=0;c< stripelength ;c++)
    {
      rd_ptr = pxcolors ; // pointer back to Start
      rd_ptr = rd_ptr + c ;
      Write_PXColors2Pixel2();
      Res();
      Warte(2);
    }
  }
}

/*******************************************************************/
void init_uart()
{
    RCSTAbits.SPEN = 1;
    TRISCbits.TRISC7 = 1;
    TRISCbits.TRISC6 = 1;
    TXSTA = 0b00100000;
    RCSTA = 0b10000000;
    BAUDCON = 0b00000000;
    SPBRG = 77;
}

/*******************************************************************/
void uart_send(char ch)
{
    TXREG = ch;
    while(!TXSTAbits.TRMT);
}

/*******************************************************************/
 /* TODO cleanup  */
 main()
{
    ConfigureOscillator();
    NEOPIXEL_TRIS = 0;       // Output
    LED_TRIS = 0;
    Init_Stripe();
    NeoInit(64);
    end_ptr = rd_ptr + stripelength ;  // adjust end_ptr to Stripelength

  // init_uart();
  // uart_send("555V");
    
    while(1)
    {

    unsigned char a,c;

      //dark
    rd_ptr  =  &pxdark  ;              //Load adress struct pxdark
    Write_Stripe_Mono(rd_ptr);

/*/ printf("The variable rd_ptr is located at address 0x%X\n", &rd_ptr);
    printf("The value of x is %d\n", x);
    printf("The pointer p is located at address 0x%X\n", &p);
    printf("The value of p is 0x%X\n", p);
    printf("The value pointed to by *p = %d\n", *p); */

    Moving_Bloc();
    Warte(50);
    Moving_Bloc2();

    NeoInit_New(64);
    rd_ptr = pxcolors ;                // adjust Pointer
    Write_Stripe_New(rd_ptr);
    Warte(50);
    NeoInit_New(10);
    rd_ptr = pxcolors;
    Write_Stripe_New(rd_ptr);
    Warte(50);
    NeoInit_New(255);
    rd_ptr = pxcolors ;
    Write_Stripe_New(rd_ptr);
    Warte(50);

    /* TODO Find way to modify value in predefined Pixel  */
    for (a=0;a< stripelength ;a++)
      {
      Write_Byte(greens[a]);
      Write_Byte(reds[a]);
      Write_Byte(blues[a]);
      }
    Warte(50);
    NeoInit(10);

    for (a=0;a< stripelength ;a++)
      {
      Write_Byte(greens[a]);
      Write_Byte(reds[a]);
      Write_Byte(blues[a]);
      }

    NeoInit(255);
    Warte(50);

    for (a=0;a< stripelength ;a++)
      {
      Write_Byte(greens[a]);
      Write_Byte(reds[a]);
      Write_Byte(blues[a]);
      }

    for (c=0;c<6;c++)
      {
      for (a=0;a<5;a++)
        {
        Write_Byte(stripe[c][0]) ;
        Write_Byte(stripe[c][1]) ;
        Write_Byte(stripe[c][2]) ;
        }
      }
    Warte(50);

    for (c=0;c<6;c++)
      {
      for (a=0;a<5;a++)
        {
        Write_Byte(stripe[c][0]) ;
        Write_Byte(stripe[c][1]) ;
        Write_Byte(stripe[c][2]) ;
        }
      }

    Warte(50);

    //dark
    rd_ptr  =  &pxdark  ;              //Load adress struct pxdark
    Write_Stripe_Mono(rd_ptr);

    Warte(50);

//******************************************
    for (a=2;a<252;a=a+25)
      {
      Init_Pixelcolors(a);
      for (c=0;c< stripelength ;c++)
        {
        Write_Byte(Pixelcolors[c].gbyte);
        Write_Byte(Pixelcolors[c].rbyte);
        Write_Byte(Pixelcolors[c].bbyte);
        }

      Warte(25);
      }

    Warte(50);

    colorvalue=128;

    for (c=0;c<255;c++)
      {
      colorvalue =c;
      for (a=0;a<10;a++)
        {
        //green
        gbyte =colorvalue  ;//128;
        rbyte=0;
        bbyte=0;
        Write_Pixel(gbyte,rbyte,bbyte);
  //    Write_Pixel(gbyte,rbyte,bbyte);
        //red
        gbyte=0;
        rbyte=colorvalue ; //128;
        bbyte=0;
        Write_Pixel(gbyte,rbyte,bbyte);
  //    Write_Pixel(gbyte,rbyte,bbyte);
        //blue
        gbyte=0;
        rbyte=0;
        bbyte=colorvalue ;//128;
        Write_Pixel(gbyte,rbyte,bbyte);
 //     Write_Pixel(gbyte,rbyte,bbyte);
        }

      Warte(10);

      for (a=0;a<10;a++)
        {
        //blue
        gbyte=0;
        rbyte=0;
        bbyte=colorvalue ; //255;
        Write_Pixel(gbyte,rbyte,bbyte);
  //    Write_Pixel(gbyte,rbyte,bbyte);
        //green
        gbyte=colorvalue; //255;
        rbyte=0;
        bbyte=0;
        Write_Pixel(gbyte,rbyte,bbyte);
  //    Write_Pixel(gbyte,rbyte,bbyte);
        //red
        gbyte=0;
        rbyte=colorvalue;//255;
        bbyte=0;
        Write_Pixel(gbyte,rbyte,bbyte);
 //     Write_Pixel(gbyte,rbyte,bbyte);
        }

      Warte(10);

      for (a=0;a<10;a++)
        {
        //red
        gbyte=0;
        rbyte=colorvalue;//255;
        bbyte=0;
        Write_Pixel(gbyte,rbyte,bbyte);
        //blue
        gbyte=0;
        rbyte=0;
        bbyte=colorvalue;//255;
        Write_Pixel(gbyte,rbyte,bbyte);
        //green
        gbyte=colorvalue;//255;
        rbyte=0;
        bbyte=0;
        Write_Pixel(gbyte,rbyte,bbyte);
        }

      Warte(10);
  //  colorvalue = colorvalue -1;
    }

//blue on
    rd_ptr  =  &pxblue  ;              //Load adress struct pxbluek
    Write_Stripe_Mono(rd_ptr);

//blue fading
    for (c=0;c<255;c=c+5)  // Helligkeit
      {
       colorvalue = c;
       gbyte=0;
       rbyte=0;
       bbyte=colorvalue;
       for (a=0;a< stripelength ;a++)
         {
         Write_Pixel(gbyte,rbyte,bbyte);  //
         }
         Warte(1);
       }

       for (c=255;c>0;c=c-5)
         {
         colorvalue = c;
         gbyte=0;
         rbyte=0;
         bbyte=colorvalue;
         for (a=0;a< stripelength ;a++)
           {
           Write_Pixel(gbyte,rbyte,bbyte);
           }
         Warte(1);
         }

 //red on
    rd_ptr  =  &pxred  ;              //Load adress struct pxred
    Write_Stripe_Mono(rd_ptr);

// red fading
    for (c=0;c<255;c=c+5)  // Helligkeit
      {
      colorvalue = c;
      gbyte=0;
      rbyte=colorvalue;
      bbyte=0;
      for (a=0;a< stripelength ;a++)
        {
        Write_Pixel(gbyte,rbyte,bbyte);  //
        }
      Warte(1);
      }

    for (c=255;c>0;c=c-5)
      {
      colorvalue = c;
      gbyte=0;
      rbyte=colorvalue;
      bbyte=0;
      for (a=0;a< stripelength ;a++)
        {
        Write_Pixel(gbyte,rbyte,bbyte);
        }
      Warte(1);
      }
         
 //green on
    rd_ptr  =  &pxgreen  ;              //Load adress struct pxgreen
    Write_Stripe_Mono(rd_ptr);

    for (c=0;c<255;c=c+5)  // Helligkeit
      {
      colorvalue = c;
      gbyte=colorvalue;
      rbyte=0;
      bbyte=0;
      for (a=0;a< stripelength ;a++)
        {
        Write_Pixel(gbyte,rbyte,bbyte);  //
        }
      Warte(1);
      }

    for (c=255;c>0;c=c-5)
      {
      colorvalue = c;
      gbyte=colorvalue;
      rbyte=0;
      bbyte=0;
      for (a=0;a< stripelength ;a++)
        {
        Write_Pixel(gbyte,rbyte,bbyte);
        }
      Warte(1);
    }

 //yellow
    rd_ptr  =  &pxyellow  ;              //Load adress struct pxyellow
    Write_Stripe_Mono(rd_ptr);

    for (c=0;c<255;c=c+5)  // Helligkeit
      {
      colorvalue = c;
      gbyte=colorvalue;
      rbyte=colorvalue;
      bbyte=0;
      for (a=0;a< stripelength ;a++)
        {
        Write_Pixel(gbyte,rbyte,bbyte);  //
        }
      Warte(1);
      }

    for (c=255;c>0;c=c-5)
      {
      colorvalue = c;
      gbyte=colorvalue;
      rbyte=colorvalue;
      bbyte=0;
      for (a=0;a< stripelength ;a++)
        {
        Write_Pixel(gbyte,rbyte,bbyte);
        }
      Warte(1);
      }

  //pink
   rd_ptr  =  &pxpink  ;              //Load adress struct pxpink
   Write_Stripe_Mono(rd_ptr);

     for (c=0;c<255;c=c+5)  // Helligkeit
       {
       colorvalue = c;
       gbyte=0;
       rbyte=colorvalue;
       bbyte=colorvalue;
       for (a=0;a< stripelength ;a++)
         {
         Write_Pixel(gbyte,rbyte,bbyte);  //
         }
       Warte(1);
       }

     for (c=255;c>0;c=c-5)
       {
       colorvalue = c;
       gbyte=0;
       rbyte=colorvalue;
       bbyte=colorvalue;
       for (a=0;a< stripelength ;a++)
         {
         Write_Pixel(gbyte,rbyte,bbyte);
         }
       Warte(1);
       }

   //tuerkis
   rd_ptr  =  &pxturkis  ;              //Load adress struct pxturkis
   Write_Stripe_Mono(rd_ptr);

     for (c=0;c<255;c=c+5)  // Helligkeit
     {
     colorvalue = c;
          gbyte=colorvalue;
          rbyte=0;
          bbyte=colorvalue;
          for (a=0;a< stripelength ;a++)
          {
          Write_Pixel(gbyte,rbyte,bbyte);  //
          }
          Warte(1);
        }

        for (c=255;c>0;c=c-5)
        {
          colorvalue = c;
          gbyte=colorvalue;
          rbyte=0;
          bbyte=colorvalue;
          for (a=0;a< stripelength ;a++)
          {
          Write_Pixel(gbyte,rbyte,bbyte);
          }
           Warte(1);
        }
//dark
      rd_ptr  =  &pxdark  ;              //Load adress struct pxdark
      Write_Stripe_Mono(rd_ptr);

// white fading
      for (c=0;c<255;c=c+5)  // Helligkeit
        {
          colorvalue = c;
          gbyte=colorvalue;
          rbyte=colorvalue;
          bbyte=colorvalue;
          for (a=0;a< stripelength ;a++)
          {
          Write_Pixel(gbyte,rbyte,bbyte);  //
          }
          Warte(1);
        }

        for (c=255;c>0;c=c-5)
        {
          colorvalue = c;
          gbyte=colorvalue;
          rbyte=colorvalue;
          bbyte=colorvalue;
          for (a=0;a< stripelength ;a++)
          {
          Write_Pixel(gbyte,rbyte,bbyte);
          }
           Warte(1);
        }

//dark
      rd_ptr  =  &pxdark  ;              //Load adress struct pxdark
      Write_Stripe_Mono(rd_ptr);

        LED = ~LED;
    }
}
//main

// no code behind this line