Ok, I am down to the last piece of the puzzle.
I have now added a switch and 5 more functions.
What I am looking to make it do is ...
At power up all ls off.
Press Button : All RGB on to make white.
Press Button : only RED
Press Button : only Green
Press Button : only Blue
Press Button : Transition.
Press Button : All off.
I got it to work up until the transition.
Once it is in transition mode I cant turn it off. It also does not Loop once it is in Transition Mode
Now I know it has to do with the Delays in the code, And I looked at the blink with out Delay example to see if I could figure it out, but had no luck.
//RGB w/Tarnistion
#define RED 4
#define GREEN 0
#define BLUE 1
#define delayTime 70
int switchPin = 3;
long previousMillis = 0;
long interval = 0;
int val;
int val2;
int buttonState;
int mode = 0;
/*
RGB LED - Automatic Smooth Color Cycling
Marco Colli
April 2012
Uses the properties of the RGB Colour Cube
The RGB colour space can be viewed as a cube of colour. If we assume a cube of dimension 1, then the
coordinates of the vertices for the cubve will range from (0,0,0) to (1,1,1) (all black to all white).
The transitions between each vertex will be a smooth colour flow and we can exploit this by using the
path coordinates as the LED transition effect.
*/
// Tranistion Setup
// Constants for readability are better than magic numbers
// Used to adjust the limits for the LED, especially if it has a lower ON threshold
#define MIN_RGB_VALUE 10 // no smaller than 0.
#define MAX_RGB_VALUE 255 // no bigger than 255.
// Slowing things down we need ...
#define TRANSITION_DELAY 70 // in milliseconds, between individual light changes
#define WAIT_DELAY 500 // in milliseconds, at the end of each traverse
//
// Total traversal time is ((MAX_RGB_VALUE - MIN_RGB_VALUE) * TRANSITION_DELAY) + WAIT_DELAY
// eg, ((255-0)*70)+500 = 18350ms = 18.35s
// Structure to contain a 3D coordinate
typedef struct
{
byte x, y, z;
}
coord;
static coord v; // the current rgb coordinates (colour) being displayed
const coord vertex[] =
{
//x y z name
{
0, 0, 0 }
, // A or 0
{
0, 1, 0 }
, // B or 1
{
0, 1, 1 }
, // C or 2
{
0, 0, 1 }
, // D or 3
{
1, 0, 0 }
, // E or 4
{
1, 1, 0 }
, // F or 5
{
1, 1, 1 }
, // G or 6
{
1, 0, 1 } // H or 7
};
const byte path[] =
{
0x01, 0x23, 0x76, 0x54, 0x03, 0x21, 0x56, 0x74, // trace the edges
0x13, 0x64, 0x16, 0x02, 0x75, 0x24, 0x35, 0x17, 0x25, 0x70, // do the diagonals
};
#define MAX_PATH_SIZE (sizeof(path)/sizeof(path[0])) // size of the array
void setup() {
pinMode(switchPin, INPUT);
digitalWrite(switchPin, HIGH);
pinMode(GREEN, OUTPUT);
pinMode(BLUE, OUTPUT);
pinMode(RED, OUTPUT);
digitalWrite(GREEN, HIGH);
digitalWrite(BLUE, HIGH);
digitalWrite(RED, HIGH);
buttonState = digitalRead(switchPin);
}
void Red(){
digitalWrite(GREEN, HIGH);
digitalWrite(BLUE, HIGH);
digitalWrite(RED, LOW);
}
void Green(){
digitalWrite(GREEN, LOW);
digitalWrite(BLUE, HIGH);
digitalWrite(RED, HIGH);
}
void Blue(){
digitalWrite(GREEN, HIGH);
digitalWrite(BLUE, LOW);
digitalWrite(RED, HIGH);
}
void White(){
digitalWrite(GREEN, LOW);
digitalWrite(BLUE, LOW);
digitalWrite(RED, LOW);
}
void off(){
digitalWrite(GREEN, HIGH);
digitalWrite(BLUE, HIGH);
digitalWrite(RED, HIGH);
}
void traverse(int dx, int dy, int dz)
// Move along the colour line from where we are to the next vertex of the cube.
// The transition is achieved by applying the 'delta' value to the coordinate.
// By definition all the coordinates will complete the transition at the same
// time as we only have one loop index.
{
if ((dx == 0) && (dy == 0) && (dz == 0)) // no point looping if we are staying in the same spot!
return;
for (int i = 0; i < MAX_RGB_VALUE-MIN_RGB_VALUE; i++, v.x += dx, v.y += dy, v.z += dz)
{
// set the colour in the LED
analogWrite(RED, 255-v.x);
analogWrite(GREEN, 255-v.y);
analogWrite(BLUE, 255-v.z);
delay(TRANSITION_DELAY); // wait fot the transition delay
}
delay(WAIT_DELAY); // give it an extra rest at the end of the traverse
}
void RGB()
{
int v1, v2=0; // the new vertex and the previous one
// initialise the place we start from as the first vertex in the array
v.x = (vertex[v2].x ? MAX_RGB_VALUE : MIN_RGB_VALUE);
v.y = (vertex[v2].y ? MAX_RGB_VALUE : MIN_RGB_VALUE);
v.z = (vertex[v2].z ? MAX_RGB_VALUE : MIN_RGB_VALUE);
// Now just loop through the path, traversing from one point to the next
for (int i = 0; i < 2*MAX_PATH_SIZE; i++)
{
// !! loop index is double what the path index is as it is a nybble index !!
v1 = v2;
if (i&1) // odd number is the second element and ...
v2 = path[i>>1] & 0xf; // ... the bottom nybble (index /2) or ...
else // ... even number is the first element and ...
v2 = path[i>>1] >> 4; // ... the top nybble
traverse(vertex[v2].x-vertex[v1].x,
vertex[v2].y-vertex[v1].y,
vertex[v2].z-vertex[v1].z);
}
}
void loop(){
val = digitalRead(switchPin); // read input value and store it in val
delay(10); // 10 milliseconds
val2 = digitalRead(switchPin);
if (val == val2){
if (val != buttonState){
if (val == LOW){
if (mode == 0){
White ();
mode = 1;
}
else if (mode == 1){
Red();
mode = 2;
}
else if (mode == 2){
Green();
mode = 3;
}
else if (mode == 3){
Blue();
mode = 4;
}
else if (mode == 4){
RGB ();
mode = 5;
}
else if (mode == 5){
off();
mode = 0;
}
}
buttonState = val;
}
}
}