How to create "Auto switch case"

Question

I am new to programming. I want to modify this sketch and I really need help. I have a switch case in this sketch, and what I want is an auto change effect.

In this sketch 18 color effects for WS2812B led strip. To change effects you have to press ta button. How do I make it change effect automatically, for example 8-10 seconds. I don't know how to do this. So please help me, huge thanks!

#include "FastLED.h"
#include <EEPROM.h>
#define NUM_LEDS 60 
CRGB leds[NUM_LEDS];
#define PIN 6 
#define BUTTON 2
byte selectedEffect=0;
void setup()
{
 FastLED.addLeds<WS2811, PIN, GRB>(leds, NUM_LEDS).setCorrection( TypicalLEDStrip );
 digitalWrite (BUTTON, HIGH); // internal pull-up resistor
 attachInterrupt (digitalPinToInterrupt (BUTTON), changeEffect, CHANGE); // pressed
}
// *** REPLACE FROM HERE ***
void loop() { 
 EEPROM.get(0,selectedEffect); 
 if(selectedEffect>18) { 
 selectedEffect=0;
 EEPROM.put(0,0);
 } 
 switch(selectedEffect) {
 case 0 : {
 // RGBLoop - no parameters
 RGBLoop();
 break;
 }
 case 1 : {
 // FadeInOut - Color (red, green. blue)
 FadeInOut(0xff, 0x00, 0x00); // red
 FadeInOut(0xff, 0xff, 0xff); // white 
 FadeInOut(0x00, 0x00, 0xff); // blue
 break;
 }
 case 2 : {
 // Strobe - Color (red, green, blue), number of flashes, flash speed, end pause
 Strobe(0xff, 0xff, 0xff, 10, 50, 1000);
 break;
 }
 case 3 : {
 // HalloweenEyes - Color (red, green, blue), Size of eye, space between eyes, fade (true/false), steps, fade delay, end pause
 HalloweenEyes(0xff, 0x00, 0x00, 
 1, 4, 
 true, random(5,50), random(50,150), 
 random(1000, 10000));
 HalloweenEyes(0xff, 0x00, 0x00, 
 1, 4, 
 true, random(5,50), random(50,150), 
 random(1000, 10000));
 break;
 }
 case 4 : {
 // CylonBounce - Color (red, green, blue), eye size, speed delay, end pause
 CylonBounce(0xff, 0x00, 0x00, 4, 10, 50);
 break;
 }
 case 5 : {
 // NewKITT - Color (red, green, blue), eye size, speed delay, end pause
 NewKITT(0xff, 0x00, 0x00, 8, 10, 50);
 break;
 }
 case 6 : {
 // Twinkle - Color (red, green, blue), count, speed delay, only one twinkle (true/false) 
 Twinkle(0xff, 0x00, 0x00, 10, 100, false);
 break;
 }
 case 7 : { 
 // TwinkleRandom - twinkle count, speed delay, only one (true/false)
 TwinkleRandom(20, 100, false);
 break;
 }
 case 8 : {
 // Sparkle - Color (red, green, blue), speed delay
 Sparkle(0xff, 0xff, 0xff, 0);
 break;
 }
 case 9 : {
 // SnowSparkle - Color (red, green, blue), sparkle delay, speed delay
 SnowSparkle(0x10, 0x10, 0x10, 20, random(100,1000));
 break;
 }
 case 10 : {
 // Running Lights - Color (red, green, blue), wave dealy
 RunningLights(0xff,0x00,0x00, 50); // red
 RunningLights(0xff,0xff,0xff, 50); // white
 RunningLights(0x00,0x00,0xff, 50); // blue
 break;
 }
 case 11 : {
 // colorWipe - Color (red, green, blue), speed delay
 colorWipe(0x00,0xff,0x00, 50);
 colorWipe(0x00,0x00,0x00, 50);
 break;
 }
 case 12 : {
 // rainbowCycle - speed delay
 rainbowCycle(20);
 break;
 }
 case 13 : {
 // theatherChase - Color (red, green, blue), speed delay
 theaterChase(0xff,0,0,50);
 break;
 }
 case 14 : {
 // theaterChaseRainbow - Speed delay
 theaterChaseRainbow(50);
 break;
 }
 case 15 : {
 // Fire - Cooling rate, Sparking rate, speed delay
 Fire(55,120,15);
 break;
 }
 // simple bouncingBalls not included, since BouncingColoredBalls can perform this as well as shown below
 // BouncingColoredBalls - Number of balls, color (red, green, blue) array, continuous
 // CAUTION: If set to continuous then this effect will never stop!!! 
 case 16 : {
 // mimic BouncingBalls
 byte onecolor[1][3] = { {0xff, 0x00, 0x00} };
 BouncingColoredBalls(1, onecolor, false);
 break;
 }
 case 17 : {
 // multiple colored balls
 byte colors[3][3] = { {0xff, 0x00, 0x00}, 
 {0xff, 0xff, 0xff}, 
 {0x00, 0x00, 0xff} };
 BouncingColoredBalls(3, colors, false);
 break;
 }
 case 18 : {
 // meteorRain - Color (red, green, blue), meteor size, trail decay, random trail decay (true/false), speed delay 
 meteorRain(0xff,0xff,0xff,10, 64, true, 30);
 break;
 }
 }
}
void changeEffect() {
 if (digitalRead (BUTTON) == HIGH) {
 selectedEffect++;
 EEPROM.put(0, selectedEffect);
 asm volatile (" jmp 0");
 }
}
// *************************
// ** LEDEffect Functions **
// *************************
void RGBLoop(){
 for(int j = 0; j < 3; j++ ) { 
 // Fade IN
 for(int k = 0; k < 256; k++) { 
 switch(j) { 
 case 0: setAll(k,0,0); break;
 case 1: setAll(0,k,0); break;
 case 2: setAll(0,0,k); break;
 }
 showStrip();
 delay(3);
 }
 // Fade OUT
 for(int k = 255; k >= 0; k--) { 
 switch(j) { 
 case 0: setAll(k,0,0); break;
 case 1: setAll(0,k,0); break;
 case 2: setAll(0,0,k); break;
 }
 showStrip();
 delay(3);
 }
 }
}
void FadeInOut(byte red, byte green, byte blue){
 float r, g, b;
 for(int k = 0; k < 256; k=k+1) { 
 r = (k/256.0)*red;
 g = (k/256.0)*green;
 b = (k/256.0)*blue;
 setAll(r,g,b);
 showStrip();
 }
 for(int k = 255; k >= 0; k=k-2) {
 r = (k/256.0)*red;
 g = (k/256.0)*green;
 b = (k/256.0)*blue;
 setAll(r,g,b);
 showStrip();
 }
}
void Strobe(byte red, byte green, byte blue, int StrobeCount, int FlashDelay, int EndPause){
 for(int j = 0; j < StrobeCount; j++) {
 setAll(red,green,blue);
 showStrip();
 delay(FlashDelay);
 setAll(0,0,0);
 showStrip();
 delay(FlashDelay);
 }
 delay(EndPause);
}
void HalloweenEyes(byte red, byte green, byte blue, 
 int EyeWidth, int EyeSpace, 
 boolean Fade, int Steps, int FadeDelay,
 int EndPause){
 randomSeed(analogRead(0));
 int i;
 int StartPoint = random( 0, NUM_LEDS - (2*EyeWidth) - EyeSpace );
 int Start2ndEye = StartPoint + EyeWidth + EyeSpace;
 for(i = 0; i < EyeWidth; i++) {
 setPixel(StartPoint + i, red, green, blue);
 setPixel(Start2ndEye + i, red, green, blue);
 }
 showStrip();
 if(Fade==true) {
 float r, g, b;
 for(int j = Steps; j >= 0; j--) {
 r = j*(red/Steps);
 g = j*(green/Steps);
 b = j*(blue/Steps);
 for(i = 0; i < EyeWidth; i++) {
 setPixel(StartPoint + i, r, g, b);
 setPixel(Start2ndEye + i, r, g, b);
 }
 showStrip();
 delay(FadeDelay);
 }
 }
 setAll(0,0,0); // Set all black
 delay(EndPause);
}
void CylonBounce(byte red, byte green, byte blue, int EyeSize, int SpeedDelay, int ReturnDelay){
 for(int i = 0; i < NUM_LEDS-EyeSize-2; i++) {
 setAll(0,0,0);
 setPixel(i, red/10, green/10, blue/10);
 for(int j = 1; j <= EyeSize; j++) {
 setPixel(i+j, red, green, blue); 
 }
 setPixel(i+EyeSize+1, red/10, green/10, blue/10);
 showStrip();
 delay(SpeedDelay);
 }
 delay(ReturnDelay);
 for(int i = NUM_LEDS-EyeSize-2; i > 0; i--) {
 setAll(0,0,0);
 setPixel(i, red/10, green/10, blue/10);
 for(int j = 1; j <= EyeSize; j++) {
 setPixel(i+j, red, green, blue); 
 }
 setPixel(i+EyeSize+1, red/10, green/10, blue/10);
 showStrip();
 delay(SpeedDelay);
 }
 delay(ReturnDelay);
}
void NewKITT(byte red, byte green, byte blue, int EyeSize, int SpeedDelay, int ReturnDelay){
 RightToLeft(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
 LeftToRight(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
 OutsideToCenter(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
 CenterToOutside(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
 LeftToRight(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
 RightToLeft(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
 OutsideToCenter(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
 CenterToOutside(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
}
// used by NewKITT
void CenterToOutside(byte red, byte green, byte blue, int EyeSize, int SpeedDelay, int ReturnDelay) {
 for(int i =((NUM_LEDS-EyeSize)/2); i>=0; i--) {
 setAll(0,0,0);
 setPixel(i, red/10, green/10, blue/10);
 for(int j = 1; j <= EyeSize; j++) {
 setPixel(i+j, red, green, blue); 
 }
 setPixel(i+EyeSize+1, red/10, green/10, blue/10);
 setPixel(NUM_LEDS-i, red/10, green/10, blue/10);
 for(int j = 1; j <= EyeSize; j++) {
 setPixel(NUM_LEDS-i-j, red, green, blue); 
 }
 setPixel(NUM_LEDS-i-EyeSize-1, red/10, green/10, blue/10);
 showStrip();
 delay(SpeedDelay);
 }
 delay(ReturnDelay);
}
// used by NewKITT
void OutsideToCenter(byte red, byte green, byte blue, int EyeSize, int SpeedDelay, int ReturnDelay) {
 for(int i = 0; i<=((NUM_LEDS-EyeSize)/2); i++) {
 setAll(0,0,0);
 setPixel(i, red/10, green/10, blue/10);
 for(int j = 1; j <= EyeSize; j++) {
 setPixel(i+j, red, green, blue); 
 }
 setPixel(i+EyeSize+1, red/10, green/10, blue/10);
 setPixel(NUM_LEDS-i, red/10, green/10, blue/10);
 for(int j = 1; j <= EyeSize; j++) {
 setPixel(NUM_LEDS-i-j, red, green, blue); 
 }
 setPixel(NUM_LEDS-i-EyeSize-1, red/10, green/10, blue/10);
 showStrip();
 delay(SpeedDelay);
 }
 delay(ReturnDelay);
}
// used by NewKITT
void LeftToRight(byte red, byte green, byte blue, int EyeSize, int SpeedDelay, int ReturnDelay) {
 for(int i = 0; i < NUM_LEDS-EyeSize-2; i++) {
 setAll(0,0,0);
 setPixel(i, red/10, green/10, blue/10);
 for(int j = 1; j <= EyeSize; j++) {
 setPixel(i+j, red, green, blue); 
 }
 setPixel(i+EyeSize+1, red/10, green/10, blue/10);
 showStrip();
 delay(SpeedDelay);
 }
 delay(ReturnDelay);
}
// used by NewKITT
void RightToLeft(byte red, byte green, byte blue, int EyeSize, int SpeedDelay, int ReturnDelay) {
 for(int i = NUM_LEDS-EyeSize-2; i > 0; i--) {
 setAll(0,0,0);
 setPixel(i, red/10, green/10, blue/10);
 for(int j = 1; j <= EyeSize; j++) {
 setPixel(i+j, red, green, blue); 
 }
 setPixel(i+EyeSize+1, red/10, green/10, blue/10);
 showStrip();
 delay(SpeedDelay);
 }
 delay(ReturnDelay);
}
void Twinkle(byte red, byte green, byte blue, int Count, int SpeedDelay, boolean OnlyOne) {
 setAll(0,0,0);
 for (int i=0; i<Count; i++) {
 setPixel(random(NUM_LEDS),red,green,blue);
 showStrip();
 delay(SpeedDelay);
 if(OnlyOne) { 
 setAll(0,0,0); 
 }
 }
 delay(SpeedDelay);
}
void TwinkleRandom(int Count, int SpeedDelay, boolean OnlyOne) {
 setAll(0,0,0);
 for (int i=0; i<Count; i++) {
 setPixel(random(NUM_LEDS),random(0,255),random(0,255),random(0,255));
 showStrip();
 delay(SpeedDelay);
 if(OnlyOne) { 
 setAll(0,0,0); 
 }
 }
 delay(SpeedDelay);
}
void Sparkle(byte red, byte green, byte blue, int SpeedDelay) {
 int Pixel = random(NUM_LEDS);
 setPixel(Pixel,red,green,blue);
 showStrip();
 delay(SpeedDelay);
 setPixel(Pixel,0,0,0);
}
void SnowSparkle(byte red, byte green, byte blue, int SparkleDelay, int SpeedDelay) {
 setAll(red,green,blue);
 int Pixel = random(NUM_LEDS);
 setPixel(Pixel,0xff,0xff,0xff);
 showStrip();
 delay(SparkleDelay);
 setPixel(Pixel,red,green,blue);
 showStrip();
 delay(SpeedDelay);
}
void RunningLights(byte red, byte green, byte blue, int WaveDelay) {
 int Position=0;
 for(int i=0; i<NUM_LEDS*2; i++)
 {
 Position++; // = 0; //Position + Rate;
 for(int i=0; i<NUM_LEDS; i++) {
 // sine wave, 3 offset waves make a rainbow!
 //float level = sin(i+Position) * 127 + 128;
 //setPixel(i,level,0,0);
 //float level = sin(i+Position) * 127 + 128;
 setPixel(i,((sin(i+Position) * 127 + 128)/255)*red,
 ((sin(i+Position) * 127 + 128)/255)*green,
 ((sin(i+Position) * 127 + 128)/255)*blue);
 }
 showStrip();
 delay(WaveDelay);
 }
}
void colorWipe(byte red, byte green, byte blue, int SpeedDelay) {
 for(uint16_t i=0; i<NUM_LEDS; i++) {
 setPixel(i, red, green, blue);
 showStrip();
 delay(SpeedDelay);
 }
}
void rainbowCycle(int SpeedDelay) {
 byte *c;
 uint16_t i, j;
 for(j=0; j<256*5; j++) { // 5 cycles of all colors on wheel
 for(i=0; i< NUM_LEDS; i++) {
 c=Wheel(((i * 256 / NUM_LEDS) + j) & 255);
 setPixel(i, *c, *(c+1), *(c+2));
 }
 showStrip();
 delay(SpeedDelay);
 }
}
// used by rainbowCycle and theaterChaseRainbow
byte * Wheel(byte WheelPos) {
 static byte c[3];
 if(WheelPos < 85) {
 c[0]=WheelPos * 3;
 c[1]=255 - WheelPos * 3;
 c[2]=0;
 } else if(WheelPos < 170) {
 WheelPos -= 85;
 c[0]=255 - WheelPos * 3;
 c[1]=0;
 c[2]=WheelPos * 3;
 } else {
 WheelPos -= 170;
 c[0]=0;
 c[1]=WheelPos * 3;
 c[2]=255 - WheelPos * 3;
 }
 return c;
}
void theaterChase(byte red, byte green, byte blue, int SpeedDelay) {
 for (int j=0; j<10; j++) { //do 10 cycles of chasing
 for (int q=0; q < 3; q++) {
 for (int i=0; i < NUM_LEDS; i=i+3) {
 setPixel(i+q, red, green, blue); //turn every third pixel on
 }
 showStrip();
 delay(SpeedDelay);
 for (int i=0; i < NUM_LEDS; i=i+3) {
 setPixel(i+q, 0,0,0); //turn every third pixel off
 }
 }
 }
}
void theaterChaseRainbow(int SpeedDelay) {
 byte *c;
 for (int j=0; j < 256; j++) { // cycle all 256 colors in the wheel
 for (int q=0; q < 3; q++) {
 for (int i=0; i < NUM_LEDS; i=i+3) {
 c = Wheel( (i+j) % 255);
 setPixel(i+q, *c, *(c+1), *(c+2)); //turn every third pixel on
 }
 showStrip();
 delay(SpeedDelay);
 for (int i=0; i < NUM_LEDS; i=i+3) {
 setPixel(i+q, 0,0,0); //turn every third pixel off
 }
 }
 }
}
void Fire(int Cooling, int Sparking, int SpeedDelay) {
 static byte heat[NUM_LEDS];
 int cooldown;
 // Step 1. Cool down every cell a little
 for( int i = 0; i < NUM_LEDS; i++) {
 cooldown = random(0, ((Cooling * 10) / NUM_LEDS) + 2);
 if(cooldown>heat[i]) {
 heat[i]=0;
 } else {
 heat[i]=heat[i]-cooldown;
 }
 }
 // Step 2. Heat from each cell drifts 'up' and diffuses a little
 for( int k= NUM_LEDS - 1; k >= 2; k--) {
 heat[k] = (heat[k - 1] + heat[k - 2] + heat[k - 2]) / 3;
 }
 // Step 3. Randomly ignite new 'sparks' near the bottom
 if( random(255) < Sparking ) {
 int y = random(7);
 heat[y] = heat[y] + random(160,255);
 //heat[y] = random(160,255);
 }
 // Step 4. Convert heat to LED colors
 for( int j = 0; j < NUM_LEDS; j++) {
 setPixelHeatColor(j, heat[j] );
 }
 showStrip();
 delay(SpeedDelay);
}
void setPixelHeatColor (int Pixel, byte temperature) {
 // Scale 'heat' down from 0-255 to 0-191
 byte t192 = round((temperature/255.0)*191);
 // calculate ramp up from
 byte heatramp = t192 & 0x3F; // 0..63
 heatramp <<= 2; // scale up to 0..252
 // figure out which third of the spectrum we're in:
 if( t192 > 0x80) { // hottest
 setPixel(Pixel, 255, 255, heatramp);
 } else if( t192 > 0x40 ) { // middle
 setPixel(Pixel, 255, heatramp, 0);
 } else { // coolest
 setPixel(Pixel, heatramp, 0, 0);
 }
}
void BouncingColoredBalls(int BallCount, byte colors[][3], boolean continuous) {
 float Gravity = -9.81;
 int StartHeight = 1;
 float Height[BallCount];
 float ImpactVelocityStart = sqrt( -2 * Gravity * StartHeight );
 float ImpactVelocity[BallCount];
 float TimeSinceLastBounce[BallCount];
 int Position[BallCount];
 long ClockTimeSinceLastBounce[BallCount];
 float Dampening[BallCount];
 boolean ballBouncing[BallCount];
 boolean ballsStillBouncing = true;
 for (int i = 0 ; i < BallCount ; i++) { 
 ClockTimeSinceLastBounce[i] = millis();
 Height[i] = StartHeight;
 Position[i] = 0; 
 ImpactVelocity[i] = ImpactVelocityStart;
 TimeSinceLastBounce[i] = 0;
 Dampening[i] = 0.90 - float(i)/pow(BallCount,2);
 ballBouncing[i]=true; 
 }
 while (ballsStillBouncing) {
 for (int i = 0 ; i < BallCount ; i++) {
 TimeSinceLastBounce[i] = millis() - ClockTimeSinceLastBounce[i];
 Height[i] = 0.5 * Gravity * pow( TimeSinceLastBounce[i]/1000 , 2.0 ) + ImpactVelocity[i] * TimeSinceLastBounce[i]/1000;
 if ( Height[i] < 0 ) { 
 Height[i] = 0;
 ImpactVelocity[i] = Dampening[i] * ImpactVelocity[i];
 ClockTimeSinceLastBounce[i] = millis();
 if ( ImpactVelocity[i] < 0.01 ) {
 if (continuous) {
 ImpactVelocity[i] = ImpactVelocityStart;
 } else {
 ballBouncing[i]=false;
 }
 }
 }
 Position[i] = round( Height[i] * (NUM_LEDS - 1) / StartHeight);
 }
 ballsStillBouncing = false; // assume no balls bouncing
 for (int i = 0 ; i < BallCount ; i++) {
 setPixel(Position[i],colors[i][0],colors[i][1],colors[i][2]);
 if ( ballBouncing[i] ) {
 ballsStillBouncing = true;
 }
 }
 showStrip();
 setAll(0,0,0);
 }
}
void meteorRain(byte red, byte green, byte blue, byte meteorSize, byte meteorTrailDecay, boolean meteorRandomDecay, int SpeedDelay) { 
 setAll(0,0,0);
 for(int i = 0; i < NUM_LEDS+NUM_LEDS; i++) {
 // fade brightness all LEDs one step
 for(int j=0; j<NUM_LEDS; j++) {
 if( (!meteorRandomDecay) || (random(10)>5) ) {
 fadeToBlack(j, meteorTrailDecay ); 
 }
 }
 // draw meteor
 for(int j = 0; j < meteorSize; j++) {
 if( ( i-j <NUM_LEDS) && (i-j>=0) ) {
 setPixel(i-j, red, green, blue);
 } 
 }
 showStrip();
 delay(SpeedDelay);
 }
}
// used by meteorrain
void fadeToBlack(int ledNo, byte fadeValue) {
 #ifdef ADAFRUIT_NEOPIXEL_H 
 // NeoPixel
 uint32_t oldColor;
 uint8_t r, g, b;
 int value;
 oldColor = strip.getPixelColor(ledNo);
 r = (oldColor & 0x00ff0000UL) >> 16;
 g = (oldColor & 0x0000ff00UL) >> 8;
 b = (oldColor & 0x000000ffUL);
 r=(r<=10)? 0 : (int) r-(r*fadeValue/256);
 g=(g<=10)? 0 : (int) g-(g*fadeValue/256);
 b=(b<=10)? 0 : (int) b-(b*fadeValue/256);
 strip.setPixelColor(ledNo, r,g,b);
 #endif
 #ifndef ADAFRUIT_NEOPIXEL_H
 // FastLED
 leds[ledNo].fadeToBlackBy( fadeValue );
 #endif 
}
// *** REPLACE TO HERE ***
// ***************************************
// ** FastLed/NeoPixel Common Functions **
// ***************************************
// Apply LED color changes
void showStrip() {
 #ifdef ADAFRUIT_NEOPIXEL_H 
 // NeoPixel
 strip.show();
 #endif
 #ifndef ADAFRUIT_NEOPIXEL_H
 // FastLED
 FastLED.show();
 #endif
}
// Set a LED color (not yet visible)
void setPixel(int Pixel, byte red, byte green, byte blue) {
 #ifdef ADAFRUIT_NEOPIXEL_H 
 // NeoPixel
 strip.setPixelColor(Pixel, strip.Color(red, green, blue));
 #endif
 #ifndef ADAFRUIT_NEOPIXEL_H 
 // FastLED
 leds[Pixel].r = red;
 leds[Pixel].g = green;
 leds[Pixel].b = blue;
 #endif
}
// Set all LEDs to a given color and apply it (visible)
void setAll(byte red, byte green, byte blue) {
 for(int i = 0; i < NUM_LEDS; i++ ) {
 setPixel(i, red, green, blue); 
 }
 showStrip();
}

Answer 1

use millis to check

static unsigned long lastChange = millis();
if(auto_changing && millis()-lastChange > 10*1000){
 selectedEffect++;
 EEPROM.put(0,selectedEffect);
 lastChange = millis();
}

Put this before the if(selectedEffect>18) and it will cycle each effect for at least 10 seconds before going to the next effect.

---

BTW I suggest that you rejig your code like blinkWithoutDelay so you don't need to use interrupts the flash memory and jmp 0 and can instead avoid that.

It'll require quite a bit of refactoring though but will allow you to fade from one effect to the next smoothly.

• VanderAGSN: I got error when put your part of code after if(selectedEffect>18), that says next : 'auto_changing' was not declared in this scope That's screenshot ( dl.dropboxusercontent.com/s/1l1342opvq43n6x/… )
• ratchet freak: @VanderAGSN forgot to add that auto_changing is the enable variable for the auto changing mode. When true it will cycle the states if false the current state will remain active. How you change that is up to you
• VanderAGSN: Code successfully accepted in arduino, but effects not switched, have any ideas? Also thanks for help!
• chrisl: Please post the updated code in your question, so that we can see how you followed ratchet freaks instructions