Page 1 of 1

Combining pattern codes FastLED & Adafruit_NeoPixel

combining pattern codes FastLED & Adafruit_NeoPixel

Welcome to the Tweaking4All community forums!
When participating, please keep the Forum Rules in mind!

Topics for particular software or systems: Start your topic link with the name of the application or system.
Examples: "MacOS X - Your question", "MS Word - Your Tip or Trick".

Please note that switching to another language when reading a post will not work!
Posts will not have a translated counterpart.




RSS Feed

Home Forums Hardware Arduino combining pattern codes FastLED & Adafruit_NeoPixel

This topic contains 7 replies, has 2 voices, and was last updated by  jayanath 2 days, 2 hours ago.

Viewing 8 posts - 1 through 8 (of 8 total)
  • Author
    Posts
  • 12428

    jayanath
    Participant

    CODE COMBINING, WANT TO COMBINE CODE A AND B TOGETHER FOR MORE PATTERNS IN ONE STRIP. REQUEST GUIDANCE.

    CODE A IS WORKING PERFECTLY ONE AFTER ANOTHER BUT IN CODE B  WORKING ONLY UP TO 

     if( secondHand == 250) { currentPalette = HeatColors_p; currentBlending = NOBLEND; } 

    REQUEST INSTRUCTIONS TO COMBINE BOTH A AND B TOGETHER. THANKS.

    CODE A……………………………………. 

    #include <Adafruit_NeoPixel.h>
    #include <EEPROM.h>
    #define NUM_LEDS 150
    #define PIN 5
    Adafruit_NeoPixel strip = Adafruit_NeoPixel(NUM_LEDS, PIN, NEO_GRB + NEO_KHZ800);
    #define BUTTON 2
    byte selectedEffect=0;
    void setup()
    {
    strip.begin();
    strip.show(); // Initialize all pixels to ‘off’
    digitalWrite (BUTTON, HIGH); // internal pull-up resistor
    attachInterrupt (digitalPinToInterrupt (BUTTON), changeEffect, CHANGE); // pressed
    selectedEffect=0;
    }
    // *** REPLACE FROM HERE ***
    void loop() {
    selectedEffect++;
    if(selectedEffect>18) {
    selectedEffect=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();
    }

    CODE B………………………………………………………

    #include <FastLED.h>

    #define LED_PIN 5

    #define NUM_LEDS 150

    #define BRIGHTNESS 255

    #define LED_TYPE WS2811

    #define COLOR_ORDER RGB

    CRGB leds[NUM_LEDS];

    #define UPDATES_PER_SECOND 100

    CRGBPalette16 currentPalette;

    TBlendType currentBlending;

    extern CRGBPalette16 myRedWhiteBluePalette;

    extern CRGBPalette16 myAPalette;

    extern const TProgmemPalette16 myRedWhiteBluePalette_p PROGMEM;

    extern const TProgmemPalette16 myAPalette_p PROGMEM;

    void setup() {

        delay( 3000 ); 

        FastLED.addLeds<LED_TYPE, LED_PIN, COLOR_ORDER>(leds, NUM_LEDS).setCorrection( TypicalLEDStrip );

        FastLED.setBrightness( BRIGHTNESS );

        

        currentPalette = RainbowColors_p;

        currentBlending = LINEARBLEND;

         currentPalette = RainbowStripeColors_p;

         currentBlending = NOBLEND;

         currentPalette = RainbowStripeColors_p;

         currentBlending = LINEARBLEND;

         currentPalette = RainbowStripeColors_p;

         currentBlending = NOBLEND;

         currentPalette = CloudColors_p;

          currentBlending = LINEARBLEND;

          currentPalette = CloudColors_p;

          currentBlending = NOBLEND;

          currentPalette = PartyColors_p;

          currentBlending = LINEARBLEND;

           currentPalette = PartyColors_p;

          currentBlending = NOBLEND;

          currentPalette = ForestColors_p;

          currentBlending = LINEARBLEND;

          currentPalette = ForestColors_p;

          currentBlending = NOBLEND;

          currentPalette = LavaColors_p;

          currentBlending = LINEARBLEND;

          currentPalette = LavaColors_p;

          currentBlending = NOBLEND;

          currentPalette = OceanColors_p; 

           currentBlending = LINEARBLEND;

           currentPalette = OceanColors_p; 

           currentBlending = NOBLEND;

            currentPalette = myAPalette_p;  

           currentBlending = NOBLEND;

            currentPalette = myAPalette_p;  

           currentBlending = LINEARBLEND;

           

    }

    void loop()

    {

        ChangePalettePeriodically();

        

        static uint8_t startIndex = 0;

        startIndex = startIndex + 1; /* motion speed */

        

        FillLEDsFromPaletteColors( startIndex);

        

        FastLED.show();

        FastLED.delay(1000 / UPDATES_PER_SECOND);

    }

    void FillLEDsFromPaletteColors( uint8_t colorIndex)

    {

        uint8_t brightness = 255;

        

        //for( int i = 0; i < NUM_LEDS; i++) 

       for( int i = (NUM_LEDS-1); i>=0; i–) 

        

        

        {

            leds[i] = ColorFromPalette( currentPalette, colorIndex, brightness, currentBlending);

            colorIndex += 3;

        }

    }

    void ChangePalettePeriodically()

    {

        uint8_t secondHand = (millis() / 2000) % 500;

        static uint8_t lastSecond = 1000;

        

        if( lastSecond != secondHand) {

            lastSecond = secondHand;

            if( secondHand == 0) { currentPalette = RainbowColors_p; currentBlending = LINEARBLEND; }

             if( secondHand == 10) { currentPalette = RainbowColors_p; currentBlending = NOBLEND; }

            if( secondHand == 20) { currentPalette = RainbowStripeColors_p; currentBlending = LINEARBLEND; }

             if( secondHand == 30) { currentPalette = RainbowStripeColors_p; currentBlending = NOBLEND; }

            if( secondHand == 40) { SetupPurpleAndGreenPalette(); currentBlending = LINEARBLEND; }

            if( secondHand == 50) { SetupPurpleAndGreenPalette(); currentBlending = NOBLEND; }

            if( secondHand == 60) { SetupTotallyRandomPalette(); currentBlending = LINEARBLEND; }

            if( secondHand == 70) { SetupTotallyRandomPalette(); currentBlending = NOBLEND; }

            if( secondHand == 80) { SetupBlackAndWhiteStripedPalette(); currentBlending = LINEARBLEND; }

             if( secondHand == 90) { SetupBlackAndWhiteStripedPalette(); currentBlending = NOBLEND; }

            if( secondHand == 100) { SetupBlackAndWhiteStripedPalette(); currentBlending = LINEARBLEND; }

             if( secondHand == 110) { SetupBlackAndWhiteStripedPalette(); currentBlending = NOBLEND; }

            if( secondHand == 120) { currentPalette = CloudColors_p; currentBlending = LINEARBLEND; }

            if( secondHand == 130) { currentPalette = CloudColors_p; currentBlending = NOBLEND; }

            if( secondHand == 140) { currentPalette = PartyColors_p; currentBlending = LINEARBLEND; }

            if( secondHand == 150) { currentPalette = PartyColors_p; currentBlending = NOBLEND; }

            if( secondHand == 160) { currentPalette = myRedWhiteBluePalette_p; currentBlending = LINEARBLEND; }

             if( secondHand == 170) { currentPalette = myRedWhiteBluePalette_p; currentBlending = NOBLEND; }

             if( secondHand == 180) { currentPalette = ForestColors_p; currentBlending = LINEARBLEND; }

               if( secondHand == 190) { currentPalette = ForestColors_p; currentBlending = NOBLEND; }

             if( secondHand == 200) { currentPalette = LavaColors_p; currentBlending = LINEARBLEND; }

              if( secondHand == 210) { currentPalette = LavaColors_p; currentBlending = NOBLEND; }

              if( secondHand == 220) { currentPalette = OceanColors_p; currentBlending = LINEARBLEND; }

              if( secondHand == 230) { currentPalette = OceanColors_p; currentBlending = NOBLEND; }

                if( secondHand == 240) { currentPalette = HeatColors_p; currentBlending = LINEARBLEND; }

              if( secondHand == 250) { currentPalette = HeatColors_p; currentBlending = NOBLEND; }

               if( secondHand == 260) {SetupRedAndBluePalette(); currentBlending = NOBLEND; }

                if( secondHand == 270) {SetupRedAndBluePalette(); currentBlending = LINEARBLEND; }

                if( secondHand == 280) {SetupYellowAndPurplePalette(); currentBlending = NOBLEND; }

                if( secondHand == 290) {SetupYellowAndPurplePalette(); currentBlending = LINEARBLEND; }

                  if( secondHand == 300) {SetupOrangeAndPinkPalette(); currentBlending = NOBLEND; }

                if( secondHand == 310) {SetupOrangeAndPinkPalette(); currentBlending = LINEARBLEND; }

                 if( secondHand == 320) {SetupBlueAndGreenStripedPalette(); currentBlending = NOBLEND; }

                if( secondHand == 330) {SetupBlueAndGreenStripedPalette(); currentBlending = LINEARBLEND; }

                  if( secondHand == 340) { currentPalette = myAPalette_p; currentBlending = LINEARBLEND; }

             if( secondHand == 350) { currentPalette = myAPalette_p; currentBlending = NOBLEND; }

            

        }

    }

    void SetupTotallyRandomPalette()

    {

        for( int i = 0; i < 16; i++)

         

        {

           // currentPalette[i] = CHSV( random8(), 255, random8());

             currentPalette[i] = CHSV( random(), 255, random());

        }

    }

    void SetupBlackAndWhiteStripedPalette()

    {

        // ‘black out’ all 16 palette entries…

        fill_solid( currentPalette, 16, CRGB::Black);

        // and set every fourth one to white.

        currentPalette[0] = CRGB::Red;

        currentPalette[4] = CRGB::Green;

        currentPalette[8] = CRGB::Blue;

        currentPalette[12] = CRGB::Pink;  

    }

    void SetupBlueAndGreenStripedPalette()

    {

        // ‘black out’ all 16 palette entries…

        fill_solid( currentPalette, 16, CRGB::Black);

        // and set every fourth one to white.

        currentPalette[0] = CRGB::Orange;

        currentPalette[4] = CRGB::Purple;

        currentPalette[8] = CRGB::Blue;

        currentPalette[12] = CRGB::Yellow;

        

    }

    void SetupPurpleAndGreenPalette()

    {

        CRGB purple = CHSV( HUE_PURPLE, 255, 255);

        CRGB green = CHSV( HUE_GREEN, 255, 255);

        CRGB black = CRGB::Black;

      

        currentPalette = CRGBPalette16(

                                       green, green, black, black,

                                       purple, purple, black, black,

                                       green, green, black, black,

                                       purple, purple, black, black );

                                       

    }

    void SetupRedAndBluePalette()

    {

        CRGB red = CHSV( HUE_RED, 255, 255);

        CRGB blue = CHSV( HUE_BLUE, 255, 255);

        CRGB black = CRGB::Black;

      

        currentPalette = CRGBPalette16(

                                       red, red, black, black,

                                       blue, blue, black, black,

                                       red, red, black, black,

                                       blue, blue, black, black );                        

    }

    void SetupYellowAndPurplePalette()

    {

        CRGB yellow = CHSV( HUE_YELLOW, 255, 255);

        CRGB purple = CHSV( HUE_PURPLE, 255, 255);

        CRGB black = CRGB::Black;

      

        currentPalette = CRGBPalette16(

                                       yellow, yellow, black, black,

                                       purple, purple, black, black,

                                       yellow, yellow, black, black,

                                       purple, purple, black, black );                        

    }

    void SetupOrangeAndPinkPalette()

    {

        CRGB orange = CHSV( HUE_ORANGE, 255, 255);

        CRGB pink = CHSV( HUE_PINK, 255, 255);

        CRGB black = CRGB::Black;

      

        currentPalette = CRGBPalette16(

                                       orange, orange, black, black,

                                       pink, pink, black, black,

                                        orange, orange, black, black,

                                       pink, pink, black, black);                       

    }

    const TProgmemPalette16 myRedWhiteBluePalette_p PROGMEM =

    {

        CRGB::Red,

        CRGB::Gray, // ‘white’ is too bright compared to red and blue

        CRGB::Blue,

        CRGB::Black,

        CRGB::Red,

        CRGB::Gray,

        CRGB::Blue,

        CRGB::Black,

        CRGB::Red,

        CRGB::Red,

        CRGB::Gray,

        CRGB::Gray,

        CRGB::Blue,

        CRGB::Blue,

        CRGB::Black,

        CRGB::Black

    };

    const TProgmemPalette16 myAPalette_p PROGMEM =

    {

        CRGB::Green,

        CRGB::Orange, 

        CRGB::Pink,

        CRGB::Black,

       CRGB::Green,

        CRGB::Orange, 

        CRGB::Pink,

        CRGB::Black,

        CRGB::Orange,

        CRGB::Orange,

        CRGB::Pink,

        CRGB::Pink,

        CRGB::Green,

        CRGB::Green,

        CRGB::Black,

        CRGB::Black

    };

    12430

    hans
    Keymaster

    Hi Jayanath,

    I really don’t want to sound rude, but you should really pay more attention to netiquette.

    Writing in all capital characters is considered shouting, and commonly seen as rude.
    I know this is probably not what you intend to do.

    Second of all, if you post code;

    1) Make sure you do this in the appropriate place,
    2) If you post the code, make sure it is formatted as such (select the code and press the “code” formatting button),
    3) I’d recommend posting your code as two separate attachments, instead of pasting a long and unformatted piece of code.

    Since I don’t know what you have tried so far;
    If the posted code is what you’ve been trying, then I can only say that combining code this way will never work.

    For one the start section of the code (with the includes and the #define’s and such) can appear only once.
    The functions void setup() and void loop() can appear only once as well.

    12432

    jayanath
    Participant

    Dear sir, i understood. Sorry Again. Below is the my code. The problem is Case 0: is not functioning only just flash once and starting from case 1:.

    #include <Adafruit_NeoPixel.h>
    #include <FastLED.h>
    #include <EEPROM.h>
    #define NUM_LEDS 150
    #define LED_PIN 5
    #define BRIGHTNESS 255
    #define LED_TYPE WS2811
    #define COLOR_ORDER RGB
    Adafruit_NeoPixel strip = Adafruit_NeoPixel(NUM_LEDS, LED_PIN, NEO_GRB + NEO_KHZ800);
    CRGB leds[NUM_LEDS];
    #define UPDATES_PER_SECOND 100
    #define BUTTON 2
    byte selectedEffect=0;
    CRGBPalette16 currentPalette;
    TBlendType currentBlending;
    extern CRGBPalette16 myRedWhiteBluePalette;
    extern const TProgmemPalette16 myRedWhiteBluePalette_p PROGMEM;
    void setup()
    {
    delay( 3000 ); // power-up safety delay
    FastLED.addLeds<LED_TYPE, LED_PIN, COLOR_ORDER>(leds, NUM_LEDS).setCorrection( TypicalLEDStrip );
    FastLED.setBrightness( BRIGHTNESS );
    currentPalette = RainbowColors_p;
    currentBlending = LINEARBLEND;
    strip.begin();
    strip.show(); // Initialize all pixels to 'off'
    digitalWrite (BUTTON, HIGH); // internal pull-up resistor
    attachInterrupt (digitalPinToInterrupt (BUTTON), changeEffect, CHANGE); // pressed
    selectedEffect=0;
    }
    // *** REPLACE FROM HERE ***
    void loop() {
    static uint8_t startIndex = 0;
    startIndex = startIndex + 1; /* motion speed */
    FillLEDsFromPaletteColors( startIndex);
    FastLED.show();
    FastLED.delay(1000 / UPDATES_PER_SECOND);
    selectedEffect++;
    if(selectedEffect>12) {
    selectedEffect=0;
    }
    switch(selectedEffect) {
    case 0 : {
    ChangePalettePeriodically();
    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 : {
    // NewKITT - Color (red, green, blue), eye size, speed delay, end pause
    NewKITT(0xff, 0x00, 0x00, 8, 10, 50);
    break;
    }
    case 4 : {
    // Sparkle - Color (red, green, blue), speed delay
    Sparkle(0xff, 0xff, 0xff, 0);
    break;
    }
    case 5 : {
    // SnowSparkle - Color (red, green, blue), sparkle delay, speed delay
    SnowSparkle(0x10, 0x10, 0x10, 20, random(100,1000));
    break;
    }
    case 6 : {
    // 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 7 : {
    // colorWipe - Color (red, green, blue), speed delay
    colorWipe(0x00,0xff,0x00, 50);
    colorWipe(0x00,0x00,0x00, 50);
    break;
    }
    case 8 : {
    // rainbowCycle - speed delay
    rainbowCycle(20);
    break;
    }
    case 9 : {
    // theatherChase - Color (red, green, blue), speed delay
    theaterChase(0xff,0,0,50);
    break;
    }
    case 10 : {
    // theaterChaseRainbow - Speed delay
    theaterChaseRainbow(50);
    break;
    }
    case 11 : {
    // Fire - Cooling rate, Sparking rate, speed delay
    Fire(55,120,15);
    break;
    }
    case 12 : {
    // 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");
    }
    }


    void FillLEDsFromPaletteColors( uint8_t colorIndex)
    {
    uint8_t brightness = 255;
    for( int i = 0; i < NUM_LEDS; i++) {
    leds[i] = ColorFromPalette( currentPalette, colorIndex, brightness, currentBlending);
    colorIndex += 3;
    }
    }
    void ChangePalettePeriodically()
    {
    uint8_t secondHand = (millis() / 1000) % 60;
    static uint8_t lastSecond = 99;
    if( lastSecond != secondHand) {
    lastSecond = secondHand;
    if( secondHand == 0) { currentPalette = RainbowColors_p; currentBlending = LINEARBLEND; }
    if( secondHand == 10) { currentPalette = RainbowStripeColors_p; currentBlending = NOBLEND; }
    if( secondHand == 15) { currentPalette = RainbowStripeColors_p; currentBlending = LINEARBLEND; }
    if( secondHand == 20) { SetupPurpleAndGreenPalette(); currentBlending = LINEARBLEND; }
    if( secondHand == 25) { SetupTotallyRandomPalette(); currentBlending = LINEARBLEND; }
    if( secondHand == 30) { SetupBlackAndWhiteStripedPalette(); currentBlending = NOBLEND; }
    if( secondHand == 35) { SetupBlackAndWhiteStripedPalette(); currentBlending = LINEARBLEND; }
    if( secondHand == 40) { currentPalette = CloudColors_p; currentBlending = LINEARBLEND; }
    if( secondHand == 45) { currentPalette = PartyColors_p; currentBlending = LINEARBLEND; }
    if( secondHand == 50) { currentPalette = myRedWhiteBluePalette_p; currentBlending = NOBLEND; }
    if( secondHand == 55) { currentPalette = myRedWhiteBluePalette_p; currentBlending = LINEARBLEND; }
    }
    }
    void SetupTotallyRandomPalette()
    {
    for( int i = 0; i < 16; i++) {
    currentPalette[i] = CHSV( random8(), 255, random8());
    }
    }
    void SetupBlackAndWhiteStripedPalette()
    {
    // 'black out' all 16 palette entries...
    fill_solid( currentPalette, 16, CRGB::Black);
    // and set every fourth one to white.
    currentPalette[0] = CRGB::Red;
    currentPalette[4] = CRGB::Green;
    currentPalette[8] = CRGB::Blue;
    currentPalette[12] = CRGB::Pink;
    }
    void SetupPurpleAndGreenPalette()
    {
    CRGB purple = CHSV( HUE_PURPLE, 255, 255);
    CRGB green = CHSV( HUE_GREEN, 255, 255);
    CRGB black = CRGB::Black;
    currentPalette = CRGBPalette16(
    green, green, black, black,
    purple, purple, black, black,
    green, green, black, black,
    purple, purple, black, black );
    }
    const TProgmemPalette16 myRedWhiteBluePalette_p PROGMEM =
    {
    CRGB::Red,
    CRGB::Gray,
    CRGB::Blue,
    CRGB::Black,
    CRGB::Red,
    CRGB::Gray,
    CRGB::Blue,
    CRGB::Black,
    CRGB::Red,
    CRGB::Red,
    CRGB::Gray,
    CRGB::Gray,
    CRGB::Blue,
    CRGB::Blue,
    CRGB::Black,
    CRGB::Black
    };


    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 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 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 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();
    }
    12435

    hans
    Keymaster

    Looks like that is what you’ve told it to do.

    In your code, you’ve placed the change of the selectedEffect in the loop(). Meaning; it will run this over and over again.
    So your code increases the selectedEffect, runs one effect once, and then starts the loop again (increase effect, run effect).

    So when your Arduino starts, it will run effect 1, effect 2 ,… last effect, and then reset to effect 0, and continue again with effect 1, effect 2 ,… last effect.

    The bold part of the code:

    void loop() {
       static uint8_t startIndex = 0;
        startIndex = startIndex + 1; /* motion speed */
        FillLEDsFromPaletteColors( startIndex);
        FastLED.show();
        FastLED.delay(1000 / UPDATES_PER_SECOND);
      selectedEffect++;
      if(selectedEffect>12) {
        selectedEffect=0;

      }
      switch(selectedEffect) {
        case 0 : {
                    ChangePalettePeriodically();
                    break;
                  }

    1) This code make it start with effect 1 (and not 0).

    A few changes would make it start actually at zero.
    In the beginning of your code, you see:

    byte selectedEffect=0;

    Replace this with

    byte selectedEffect=250; // arbitrary value

    With this, the bold code, will reset selectedEffect to zero, and your loop will indeed start with effect zero.

    2) I have no idea what the function “ChangePalettePeriodically()” does. It seems to do nothing (effectwise).
    I suspect it works with the “FillLEDsFromPaletteColors()” function.

    12439

    jayanath
    Participant

    Dear sir i have made changes taught by you but still only rainbow colurs appearing no pattern moving sir. i have changed delay values  ad speeds also but nothing happens. please instruct me. thank you

    #include <Adafruit_NeoPixel.h>
    #include <FastLED.h>
    #include <EEPROM.h>
    #define NUM_LEDS 150 
    #define LED_PIN 5 
    #define BRIGHTNESS 255
    #define LED_TYPE WS2811
    #define COLOR_ORDER RGB
    Adafruit_NeoPixel strip = Adafruit_NeoPixel(NUM_LEDS, LED_PIN, NEO_GRB + NEO_KHZ800);
    CRGB leds[NUM_LEDS];
    #define UPDATES_PER_SECOND 100
    #define BUTTON 2
    byte selectedEffect=250;
    CRGBPalette16 currentPalette;
    TBlendType currentBlending;
    extern CRGBPalette16 myRedWhiteBluePalette;
    extern const TProgmemPalette16 myRedWhiteBluePalette_p PROGMEM;
    void setup()
    {
      delay( 3000 ); // power-up safety delay
        FastLED.addLeds<LED_TYPE, LED_PIN, COLOR_ORDER>(leds, NUM_LEDS).setCorrection( TypicalLEDStrip );
        FastLED.setBrightness( BRIGHTNESS );
        currentPalette = RainbowColors_p;
        currentBlending = LINEARBLEND;
        
      strip.begin();
      strip.show(); // Initialize all pixels to 'off'
      digitalWrite (BUTTON, HIGH); // internal pull-up resistor
      attachInterrupt (digitalPinToInterrupt (BUTTON), changeEffect, CHANGE); // pressed
    selectedEffect=0;
    }
    // *** REPLACE FROM HERE ***
    void loop() {
       FillLEDsFromPaletteColors();
        
        static uint8_t startIndex = 0;
        startIndex = startIndex + 1; /* motion speed */
        
        FillLEDsFromPaletteColors( startIndex);
        
     FastLED.show();
     FastLED.delay(1000/ UPDATES_PER_SECOND); 
      
      selectedEffect++;
      if(selectedEffect>12) { 
        selectedEffect=0;
      }
     
      
      switch(selectedEffect) {
        
        case 0 : {
                  
                    FillLEDsFromPaletteColors();
                   
                    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 : {
                    // NewKITT - Color (red, green, blue), eye size, speed delay, end pause
                    NewKITT(0xff, 0x00, 0x00, 8, 10, 50);
                    break;
                  }
                  
      
                  
        case 4 : {
                    // Sparkle - Color (red, green, blue), speed delay
                    Sparkle(0xff, 0xff, 0xff, 0);
                    break;
                  }
                   
        case 5 : {
                    // SnowSparkle - Color (red, green, blue), sparkle delay, speed delay
                    SnowSparkle(0x10, 0x10, 0x10, 20, random(100,1000));
                    break;
                  }
                  
        case 6 : {
                    // 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 7 : {
                    // colorWipe - Color (red, green, blue), speed delay
                    colorWipe(0x00,0xff,0x00, 50);
                    colorWipe(0x00,0x00,0x00, 50);
                    break;
                  }
        case 8 : {
                    // rainbowCycle - speed delay
                    rainbowCycle(20);
                    break;
                  }
        case 9 : {
                    // theatherChase - Color (red, green, blue), speed delay
                    theaterChase(0xff,0,0,50);
                    break;
                  }
        case 10 : {
                    // theaterChaseRainbow - Speed delay
                    theaterChaseRainbow(50);
                    break;
                  }
        case 11 : {
                    // Fire - Cooling rate, Sparking rate, speed delay
                    Fire(55,120,15);
                    break;
                  }
      
        case 12 : {
                    // 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 FillLEDsFromPaletteColors( uint8_t colorIndex)
    {
        uint8_t brightness = 255;
        
        for( int i = 0; i < NUM_LEDS; i++) {
            leds[i] = ColorFromPalette( currentPalette, colorIndex, brightness, currentBlending);
            colorIndex += 3;
        }
    }
    void FillLEDsFromPaletteColors()
    {
        uint8_t secondHand = (millis() / 1000) % 60;
        static uint8_t lastSecond = 99;
        
        if( lastSecond != secondHand) {
            lastSecond = secondHand;
            if( secondHand == 0) { currentPalette = RainbowColors_p; currentBlending = LINEARBLEND; }
            if( secondHand == 10) { currentPalette = RainbowStripeColors_p; currentBlending = NOBLEND; }
            if( secondHand == 15) { currentPalette = RainbowStripeColors_p; currentBlending = LINEARBLEND; }
            if( secondHand == 20) { SetupPurpleAndGreenPalette(); currentBlending = LINEARBLEND; }
            if( secondHand == 25) { SetupTotallyRandomPalette(); currentBlending = LINEARBLEND; }
            if( secondHand == 30) { SetupBlackAndWhiteStripedPalette(); currentBlending = NOBLEND; }
            if( secondHand == 35) { SetupBlackAndWhiteStripedPalette(); currentBlending = LINEARBLEND; }
            if( secondHand == 40) { currentPalette = CloudColors_p; currentBlending = LINEARBLEND; }
            if( secondHand == 45) { currentPalette = PartyColors_p; currentBlending = LINEARBLEND; }
            if( secondHand == 50) { currentPalette = myRedWhiteBluePalette_p; currentBlending = NOBLEND; }
            if( secondHand == 55) { currentPalette = myRedWhiteBluePalette_p; currentBlending = LINEARBLEND; }
        }
       
    }

    void SetupTotallyRandomPalette()
    {
        for( int i = 0; i < 16; i++) {
            currentPalette[i] = CHSV( random8(), 255, random8());
        }
    }

    void SetupBlackAndWhiteStripedPalette()
    {
        // 'black out' all 16 palette entries...
        fill_solid( currentPalette, 16, CRGB::Black);
        // and set every fourth one to white.
        currentPalette[0] = CRGB::Red;
        currentPalette[4] = CRGB::Green;
        currentPalette[8] = CRGB::Blue;
        currentPalette[12] = CRGB::Pink;
        
    }

    void SetupPurpleAndGreenPalette()
    {
        CRGB purple = CHSV( HUE_PURPLE, 255, 255);
        CRGB green = CHSV( HUE_GREEN, 255, 255);
        CRGB black = CRGB::Black;
        
        currentPalette = CRGBPalette16(
                                       green, green, black, black,
                                       purple, purple, black, black,
                                       green, green, black, black,
                                       purple, purple, black, black );
    }

    const TProgmemPalette16 myRedWhiteBluePalette_p PROGMEM =
    {
        CRGB::Red,
        CRGB::Gray, 
        CRGB::Blue,
        CRGB::Black,
        
        CRGB::Red,
        CRGB::Gray,
        CRGB::Blue,
        CRGB::Black,
        
        CRGB::Red,
        CRGB::Red,
        CRGB::Gray,
        CRGB::Gray,
        CRGB::Blue,
        CRGB::Blue,
        CRGB::Black,
        CRGB::Black
    };
    void changeEffect() {
      if (digitalRead (BUTTON) == HIGH) {
        selectedEffect++;
        EEPROM.put(0, selectedEffect);
        asm volatile (" jmp 0");
      }
    }





    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 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 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 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  
    }








    // ***************************************
    // ** 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();
    }
    12441

    hans
    Keymaster

    In your new code, I see the same function defined twice?

    ...
     void FillLEDsFromPaletteColors( uint8_t colorIndex)
    {
        uint8_t brightness = 255;
        
        for( int i = 0; i < NUM_LEDS; i++) {
            leds[i] = ColorFromPalette( currentPalette, colorIndex, brightness, currentBlending);
            colorIndex += 3;
        }
    }
    void FillLEDsFromPaletteColors()
    {
        uint8_t secondHand = (millis() / 1000) % 60;
        static uint8_t lastSecond = 99;
    ...

    This is probably not a good thing … not saying it will resolve the issue, but it’s not the way it should be …

    12445

    jayanath
    Participant

    dear sir thanks for the early reply. below i posted original second code and this is well working. request instructions to combine with yours ‘ case ‘ code.

    #include <FastLED.h>
    #define LED_PIN 5
    #define NUM_LEDS 150
    #define BRIGHTNESS 255
    #define LED_TYPE WS2811
    #define COLOR_ORDER RGB
    CRGB leds[NUM_LEDS];
    #define UPDATES_PER_SECOND 100

    CRGBPalette16 currentPalette;
    TBlendType currentBlending;
    extern CRGBPalette16 myRedWhiteBluePalette;
    extern const TProgmemPalette16 myRedWhiteBluePalette_p PROGMEM;

    void setup() {
        delay( 3000 ); // power-up safety delay
        FastLED.addLeds<LED_TYPE, LED_PIN, COLOR_ORDER>(leds, NUM_LEDS).setCorrection( TypicalLEDStrip );
        FastLED.setBrightness( BRIGHTNESS );
        
        currentPalette = RainbowColors_p;
        currentBlending = LINEARBLEND;
    }

    void loop()
    {
        ChangePalettePeriodically();
        
        static uint8_t startIndex = 0;
        startIndex = startIndex + 1; /* motion speed */
        
        FillLEDsFromPaletteColors( startIndex);
        
        FastLED.show();
        FastLED.delay(1000 / UPDATES_PER_SECOND);
    }
    void FillLEDsFromPaletteColors( uint8_t colorIndex)
    {
        uint8_t brightness = 255;
        
        for( int i = 0; i < NUM_LEDS; i++) {
            leds[i] = ColorFromPalette( currentPalette, colorIndex, brightness, currentBlending);
            colorIndex += 3;
        }
    }
    void ChangePalettePeriodically()
    {
        uint8_t secondHand = (millis() / 1000) % 60;
        static uint8_t lastSecond = 99;
        
        if( lastSecond != secondHand) {
            lastSecond = secondHand;
            if( secondHand == 0) { currentPalette = RainbowColors_p; currentBlending = LINEARBLEND; }
            if( secondHand == 10) { currentPalette = RainbowStripeColors_p; currentBlending = NOBLEND; }
            if( secondHand == 15) { currentPalette = RainbowStripeColors_p; currentBlending = LINEARBLEND; }
            if( secondHand == 20) { SetupPurpleAndGreenPalette(); currentBlending = LINEARBLEND; }
            if( secondHand == 25) { SetupTotallyRandomPalette(); currentBlending = LINEARBLEND; }
            if( secondHand == 30) { SetupBlackAndWhiteStripedPalette(); currentBlending = NOBLEND; }
            if( secondHand == 35) { SetupBlackAndWhiteStripedPalette(); currentBlending = LINEARBLEND; }
            if( secondHand == 40) { currentPalette = CloudColors_p; currentBlending = LINEARBLEND; }
            if( secondHand == 45) { currentPalette = PartyColors_p; currentBlending = LINEARBLEND; }
            if( secondHand == 50) { currentPalette = myRedWhiteBluePalette_p; currentBlending = NOBLEND; }
            if( secondHand == 55) { currentPalette = myRedWhiteBluePalette_p; currentBlending = LINEARBLEND; }
        }
    }

    void SetupTotallyRandomPalette()
    {
        for( int i = 0; i < 16; i++) {
            currentPalette[i] = CHSV( random8(), 255, random8());
        }
    }

    void SetupBlackAndWhiteStripedPalette()
    {
        // 'black out' all 16 palette entries...
        fill_solid( currentPalette, 16, CRGB::Black);
        // and set every fourth one to white.
        currentPalette[0] = CRGB::Red;
        currentPalette[4] = CRGB::Green;
        currentPalette[8] = CRGB::Blue;
        currentPalette[12] = CRGB::Pink;
        
    }

    void SetupPurpleAndGreenPalette()
    {
        CRGB purple = CHSV( HUE_PURPLE, 255, 255);
        CRGB green = CHSV( HUE_GREEN, 255, 255);
        CRGB black = CRGB::Black;
        
        currentPalette = CRGBPalette16(
                                       green, green, black, black,
                                       purple, purple, black, black,
                                       green, green, black, black,
                                       purple, purple, black, black );
    }

    const TProgmemPalette16 myRedWhiteBluePalette_p PROGMEM =
    {
        CRGB::Red,
        CRGB::Gray, 
        CRGB::Blue,
        CRGB::Black,
        
        CRGB::Red,
        CRGB::Gray,
        CRGB::Blue,
        CRGB::Black,
        
        CRGB::Red,
        CRGB::Red,
        CRGB::Gray,
        CRGB::Gray,
        CRGB::Blue,
        CRGB::Blue,
        CRGB::Black,
        CRGB::Black
    };
    12473

    jayanath
    Participant

    dear sir. are you busy these days? requesting instructions to combine the two codes please?

Viewing 8 posts - 1 through 8 (of 8 total)



You must be logged in to reply to this topic.