Go Down

Topic: Arduino Project (Read 689 times) previous topic - next topic

bhann1

Feb 24, 2012, 08:07 pm Last Edit: Feb 24, 2012, 08:17 pm by CrossRoads Reason: 1
Arduino RGB LED color fade

When the potentiometer is = 0 the light will shine white
When you began to turn it to the right the LED will cycle through all the colors
Once it reaches <899 the LED will continuously cycle through colors


code:

(tags added by moderator)
Code: [Select]

int LEDGreen=9;
int LEDBlue=10;
int LEDRed=11;



int sensorPin=0;
int val;

// Output
int redPin = 9;   // Red LED,   connected to digital pin 9
int grnPin = 10;  // Green LED, connected to digital pin 10
int bluPin = 11;  // Blue LED,  connected to digital pin 11

// Color arrays
int black[3]  = { 0, 0, 0 };
int white[3]  = { 100, 100, 100 };
int red[3]    = { 100, 0, 0 };
int green[3]  = { 0, 100, 0 };
int blue[3]   = { 0, 0, 100 };
int yellow[3] = { 40, 95, 0 };
int dimWhite[3] = { 30, 30, 30 };
// etc.

// Set initial color
int redVal = black[0];
int grnVal = black[1];
int bluVal = black[2];

int wait = 1;      // 10ms internal crossFade delay; increase for slower fades
int hold = 1;       // Optional hold when a color is complete, before the next crossFade
int DEBUG = 1;      // DEBUG counter; if set to 1, will write values back via serial
int loopCount = 0; // How often should DEBUG report?
int repeat = 0;     // How many times should we loop before stopping? (0 for no stop)
int j = 0;          // Loop counter for repeat

// Initialize color variables
int prevR = redVal;
int prevG = grnVal;
int prevB = bluVal;



void setup(){
 Serial.begin(9600);
 pinMode(LEDRed,OUTPUT);
 pinMode(LEDGreen,OUTPUT);
 pinMode(LEDBlue,OUTPUT);  
}

void loop(){
 
 val=map(analogRead(sensorPin),0,1023,0,900);
 Serial.println(val);
 
 if(val>=899)  {
   
  crossFade(red);
 crossFade(green);
 crossFade(blue);
   //cycle colors
 } else if(val==0){
   analogWrite(LEDRed, 0);
   analogWrite(LEDGreen, 0);
   analogWrite(LEDBlue, 0);  

 } else {
 
  if (val < 1){
    analogWrite(LEDRed, 0);
   analogWrite(LEDGreen, 0);
   analogWrite(LEDBlue, 0);
   Serial.println("boo");
 } else if (val<150) {
   analogWrite(LEDRed,0);
   analogWrite(LEDBlue,255);
   analogWrite(LEDGreen,255);
Serial.println("150");  
 } else if (val<300) {
   analogWrite(LEDRed,map(val,150,300,0,255));
   analogWrite(LEDBlue,map(val,150,300,255,0));
   analogWrite(LEDGreen,255);
 } else if (val<450) {
   analogWrite(LEDRed,255);
   analogWrite(LEDBlue,0);
   analogWrite(LEDGreen,255);  
 } else if (val<600) {
   analogWrite(LEDRed,255);
   analogWrite(LEDBlue,map(val,450,600,0,255));
   analogWrite(LEDGreen,map(val,450,600,255,0));
 } else if (val<750) {
   analogWrite(LEDRed,255);
   analogWrite(LEDBlue,255);
   analogWrite(LEDGreen,0);  
 } else if (val<900) {
   analogWrite(LEDRed,map(val,750,900,255,0));
   analogWrite(LEDBlue,255);
   analogWrite(LEDGreen,map(val,750,900,0,255));
 }
   
   //stop cycling colors
 }
 
 
 
 
 delay(10);
}



/* BELOW THIS LINE IS THE MATH -- YOU SHOULDN'T NEED TO CHANGE THIS FOR THE BASICS
*
* The program works like this:
* Imagine a crossfade that moves the red LED from 0-10,
*   the green from 0-5, and the blue from 10 to 7, in
*   ten steps.
*   We'd want to count the 10 steps and increase or
*   decrease color values in evenly stepped increments.
*   Imagine a + indicates raising a value by 1, and a -
*   equals lowering it. Our 10 step fade would look like:
*
*   1 2 3 4 5 6 7 8 9 10
* R + + + + + + + + + +
* G   +   +   +   +   +
* B     -     -     -
*
* The red rises from 0 to 10 in ten steps, the green from
* 0-5 in 5 steps, and the blue falls from 10 to 7 in three steps.
*
* In the real program, the color percentages are converted to
* 0-255 values, and there are 1020 steps (255*4).
*
* To figure out how big a step there should be between one up- or
* down-tick of one of the LED values, we call calculateStep(),
* which calculates the absolute gap between the start and end values,
* and then divides that gap by 1020 to determine the size of the step  
* between adjustments in the value.
*/

int calculateStep(int prevValue, int endValue) {
 int step = endValue - prevValue; // What's the overall gap?
 if (step) {                      // If its non-zero,
   step = 1020/step;              //   divide by 1020
 }
 return step;
}

/* The next function is calculateVal. When the loop value, i,
*  reaches the step size appropriate for one of the
*  colors, it increases or decreases the value of that color by 1.
*  (R, G, and B are each calculated separately.)
*/

int calculateVal(int step, int val, int i) {

 if ((step) && i % step == 0) { // If step is non-zero and its time to change a value,
   if (step > 0) {              //   increment the value if step is positive...
     val += 1;          
   }
   else if (step < 0) {         //   ...or decrement it if step is negative
     val -= 1;
   }
 }
 // Defensive driving: make sure val stays in the range 0-255
 if (val > 255) {
   val = 255;
 }
 else if (val < 0) {
   val = 0;
 }
 return val;
}

/* crossFade() converts the percentage colors to a
*  0-255 range, then loops 1020 times, checking to see if  
*  the value needs to be updated each time, then writing
*  the color values to the correct pins.
*/

void crossFade(int color[3]) {
 // Convert to 0-255
 int R = (color[0] * 255) / 100;
 int G = (color[1] * 255) / 100;
 int B = (color[2] * 255) / 100;

 int stepR = calculateStep(prevR, R);
 int stepG = calculateStep(prevG, G);
 int stepB = calculateStep(prevB, B);

 for (int i = 0; i <= 1020; i++) {
   redVal = calculateVal(stepR, redVal, i);
   grnVal = calculateVal(stepG, grnVal, i);
   bluVal = calculateVal(stepB, bluVal, i);

   analogWrite(redPin, redVal);   // Write current values to LED pins
   analogWrite(grnPin, grnVal);      
   analogWrite(bluPin, bluVal);

   delay(wait); // Pause for 'wait' milliseconds before resuming the loop

   if (DEBUG) { // If we want serial output, print it at the
     if (i == 0 or i % loopCount == 0) { // beginning, and every loopCount times
       Serial.print("Loop/RGB: #");
       Serial.print(i);
       Serial.print(" | ");
       Serial.print(redVal);
       Serial.print(" / ");
       Serial.print(grnVal);
       Serial.print(" / ");  
       Serial.println(bluVal);
     }
     DEBUG += 1;
   }
 }
 // Update current values for next loop
 prevR = redVal;
 prevG = grnVal;
 prevB = bluVal;
 delay(hold); // Pause for optional 'wait' milliseconds before resuming the loop
}



Go Up