User:BrittanyJ/ENES-100/Project 2/Operate/Cross Color Fade Blink

/* Cross Color Fade Blink combining code */ void setup{ setupCrossColor; setupBlink; } void loop{ loopCrossColor; setupBlink; } /*
 * Code for cross-fading 3 LEDs, red, green and blue (RGB)
 * To create fades, you need to do two things:
 * 1. Describe the colors you want to be displayed
 * 2. List the order you want them to fade in
 * DESCRIBING A COLOR:
 * A color is just an array of three percentages, 0-100,
 * controlling the red, green and blue LEDs
 * Red is the red LED at full, blue and green off
 * int red = { 100, 0, 0 }
 * Dim white is all three LEDs at 30%
 * int dimWhite = {30, 30, 30}
 * etc.
 * Some common colors are provided below, or make your own
 * LISTING THE ORDER:
 * In the main part of the program, you need to list the order
 * you want to colors to appear in, e.g.
 * crossFade(red);
 * crossFade(green);
 * crossFade(blue);
 * Those colors will appear in that order, fading out of
 * one color and into the next
 * In addition, there are 5 optional settings you can adjust:
 * 1. The initial color is set to black (so the first color fades in), but
 * you can set the initial color to be any other color
 * 2. The internal loop runs for 1020 interations; the 'wait' variable
 * sets the approximate duration of a single crossfade. In theory,
 * a 'wait' of 10 ms should make a crossFade of ~10 seconds. In
 * practice, the other functions the code is performing slow this
 * down to ~11 seconds on my board. YMMV.
 * 3. If 'repeat' is set to 0, the program will loop indefinitely.
 * if it is set to a number, it will loop that number of times,
 * then stop on the last color in the sequence. (Set 'return' to 1,
 * and make the last color black if you want it to fade out at the end.)
 * 4. There is an optional 'hold' variable, which pasues the
 * program for 'hold' milliseconds when a color is complete,
 * but before the next color starts.
 * 5. Set the DEBUG flag to 1 if you want debugging output to be
 * sent to the serial monitor.
 * The internals of the program aren't complicated, but they
 * are a little fussy -- the inner workings are explained
 * below the main loop.
 * April 2007, Clay Shirky 
 * 5. Set the DEBUG flag to 1 if you want debugging output to be
 * sent to the serial monitor.
 * The internals of the program aren't complicated, but they
 * are a little fussy -- the inner workings are explained
 * below the main loop.
 * April 2007, Clay Shirky 
 * April 2007, Clay Shirky 
 * April 2007, Clay Shirky 

// 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 = 10;     // 10ms internal crossFade delay; increase for slower fades int hold = 0;      // 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 = 60; // How often should DEBUG report? int repeat = 3;    // 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;

// Set up the LED outputs void setupCrossColor { pinMode(redPin, OUTPUT);   // sets the pins as output pinMode(grnPin, OUTPUT); pinMode(bluPin, OUTPUT);

if (DEBUG) {          // If we want to see values for debugging... Serial.begin(9600); // ...set up the serial ouput } }

// Main program: list the order of crossfades void loopCrossColor { crossFade(red); crossFade(green); crossFade(blue); crossFade(yellow);

if (repeat) { // Do we loop a finite number of times? j += 1; if (j >= repeat) { // Are we there yet? exit(j);        // If so, stop. } } }

/* 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.
 * 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 }

/* Blink Turns on an LED on for one second, then off for one second, repeatedly. This example code is in the public domain. */ // Pin 13 has an LED connected on most Arduino boards. // give it a name: int led = 13;

// the setup routine runs once when you press reset: void setupBlink { // initialize the digital pin as an output. pinMode(led, OUTPUT); }

// the loop routine runs over and over again forever: void loopBlink { digitalWrite(led, HIGH);  // turn the LED on (HIGH is the voltage level) delay(1000);              // wait for a second digitalWrite(led, LOW);   // turn the LED off by making the voltage LOW delay(1000);              // wait for a second }