Led Fading sketch crashes after a few loops

i've had few people @ code now, , cant figure out why program seems crash after few loops through program.  i'm running ardweeny off usb power.  with code below, runs pattern 12 times or so, , stops.  

code: [select]

// data definitions

#define max_color 255 // defined make math easier later can changed if need arises

struct patterns // defines pattern state
{
 int red;
 int green;
 int blue;
 int time;
 int steps;
};

enum state  // defines current led run state
{
 run,
 done,
 ptrn
};

//  order in led run through patterns before looping
//byte led1pattern[] = {0,1,2,3,1,1,4,4,5,6,5,5,6,6,4,4,4,1,1,254};
//const byte led1pattern[] = {1,1,4,4,4,4,4,4,5,254};
const byte led1pattern[] = {4,4,4,4,4,4,4,4,4,254};
// pattern data

// available patterns run
// ,{0,0,0,0,40}  is termination value, indicating end of pattern
const patterns patternmain[][7] =
{
 {  
   {255,0,0,2000,8},
   {0,250,0,2000,8},
   {0,0,250,2000,8},
   {255,0,0,2000,15},
   {0,250,0,2000,15},
   {0,0,250,2000,15},
   {0,0,0,0,40}
 },// red-green-blue x2 0
 {  
   {255,0,0,1000,8},
   {0,0,0,1000,8},
   {255,0,0,1000,8},
   {0,0,0,1000,8},
   {0,0,0,0,40}
 }, //flash red twice 1
 {
   {0,250,0,1000,8},
   {0,0,0,1000,8},
   {0,250,0,1000,8},
   {0,0,0,1000,8},
   {0,0,0,0,40}
 }, //flash green twice 2
 {
   {0,0,250,1000,8},
   {0,0,0,1000,8},
   {0,0,250,1000,8},
   {0,0,0,1000,8},
   {0,0,0,0,40}
 },  //flash red twice 3
 {
   {255,0,0,50,1},
   {0,0,0,100,1},
   {0,0,0,0,40}
 }, //flash red once quick 4
 {
   {0,250,0,50,1},
   {0,0,0,100,1},
   {0,0,0,0,40}
 }, //flash green once quick 5
 {
   {0,0,250,50,1},
   {0,0,0,100,1},
   {0,0,0,0,40}
 } //flash blue once quick 6
};

class led // led class definition
{
 public:
   led(int, int, int, int);
   void transition_to(int, int, int, int, int);
   void update();
   void lerp();
   void transition_complete();
   void patterngroupselect();
   
   state ledstate;    // status of led
   
 private:
   int redpin;      // should in led constructor
   int greenpin;    // same above
   int bluepin;     // same above

   int startred;    // colors @ start of transition
   int startgreen;
   int startblue;
   
   int redval;      // current color during transition
   int greenval;
   int blueval;
   
   int dstred;      // color @ end of transition
   int dstgreen;
   int dstblue;
   
   unsigned long transition_start;    // ticks @ start of transition
   unsigned long transition_end;      // ticks @ end      
   
   unsigned long previousmillis;
   unsigned long currenttime;
   unsigned int increment;
   
   int pattern;
   int patterngroup;
   int lednum;
   int patternindex;
   float progress;
   int stepamt;
   int stepchk;
};    // end of led class

led::led(int red, int green, int blue, int num)
{
 lednum = num;
 ledstate = run;
 
 redpin   = red;
 greenpin = green;
 bluepin  = blue;
 
 pattern = 0;
 patternindex = 0;
 
 analogwrite(redpin, 0);
 analogwrite(greenpin, 0);
 analogwrite(bluepin, 0);
 patterngroup = led1pattern[patternindex];
}

void led::transition_to(int r, int g, int b, int length, int i)
{
   dstred   = r;
   dstblue  = b;
   dstgreen = g;

   startred   = redval;
   startblue  = blueval;
   startgreen = greenval;

   increment = i;

   transition_start = millis();
   transition_end = transition_start + length;
   ledstate = run;
   previousmillis = currenttime;
}

void led::update()
{
 analogwrite(redpin, redval);
 analogwrite(greenpin, greenval);
 analogwrite(bluepin, blueval);
}

void led::lerp()
{
 if (ledstate == run)
 {
   currenttime = millis();  
   // linear interpolation
   progress = 1.0 - (float)(transition_end - currenttime)/(transition_end - transition_start);
   
    // gets value color based on progress
   redval   = startred   + (dstred - startred) * progress;
   greenval = startgreen + (dstgreen - startgreen) * progress;
   blueval  = startblue  + (dstblue - startblue) * progress;

     if (increment <= 1) // if increment value set 1 or 0, update , smooth
     {                   // fade
         update();
     }
     else if(increment >1) // updates leds specified amount of times
     {                     // allows low frame rate type transition (looks cool, ok?!)
         stepamt = 100 / increment;

         for( int z = 0; z <= increment; z++)
         {
            stepchk = stepamt * z;
            if (stepchk == (int)(progress * 100))
            {
               update();
            }
         }
     }
     
     if ( progress >= 1.0 )
     {
         redval   = dstred;  // progress finished, set color values should be.
         greenval = dstgreen;
         blueval  = dstblue;
         pattern++;  // advances pattern
         ledstate = done;
     }
   }
} // end of lerp()

// runs through given pattern
void led::transition_complete()
{
 if (patternmain[patterngroup][pattern].steps < 30) // 30+ eol value
 { // sets next transition
   transition_to(
                   patternmain[patterngroup][pattern].red,
                   patternmain[patterngroup][pattern].green,
                   patternmain[patterngroup][pattern].blue,
                   patternmain[patterngroup][pattern].time,
                   patternmain[patterngroup][pattern].steps
                   );
 }
 else
 {
   ledstate = ptrn;  
 }

}

void led::patterngroupselect()
{
 pattern = 0;  //when selecting new pattern, resets beginning
 switch(lednum) // each led number have own set pattern
 {
   case 1:
     //advances pattern index
     patternindex++;
     //resets pattern start
     if (led1pattern[patternindex] == 254)
     {
       patternindex = 0;
     }
     //retrieves pattern group number
     patterngroup = led1pattern[patternindex];
   break;

 }
}

// global variables , constants

unsigned int timer = 0;

led led1(9, 10, 11, 1);

void setup()
{
 led1.transition_complete(); //gets going
 
}

void loop()
{
 switch(led1.ledstate)
 {
   case run:
     led1.lerp();
     break;
   case done: // finishes transition
     led1.transition_complete();
     break;
   case ptrn: //pattern finished
     led1.patterngroupselect();
     led1.ledstate = run;
     led1.transition_complete();
     break;
 }
}


if can see problems, let me know.  some people have said floats , division no good, cant figure out way without progress line , variable.

so bloat fade 3 leds?
awesome!!!!

Arduino Forum > Forum 2005-2010 (read only) > Software > Syntax & Programs > Led Fading sketch crashes after a few loops

arduino