FastLED Delay problem

Hi I got a problem with delays in my sketch. I have 2 different “effects” in 2 different led strips. These 2 strips are connected to pin 2 and 3. If I try to “slow down” effect number 1, it slows down other aswell. Is it possible to other one to ignore that delay of 1st strip?

here is my code! I am using FastLED.h library and Arduino UNO.

#include "FastLED.h"
#define NUM_LEDS 14 
CRGB leds[NUM_LEDS];
CRGB leds2 [NUM_LEDS];
#define NUM_STRIPS 2
CLEDController *controllers[NUM_STRIPS];
uint8_t gBrightness = 25;
void setup()
{
  controllers[0] = &FastLED.addLeds<WS2812,2, GRB>(leds, NUM_LEDS).setCorrection( TypicalLEDStrip );
  controllers[1] = &FastLED.addLeds<WS2812,3, GRB>(leds, NUM_LEDS).setCorrection( TypicalLEDStrip );
}
//here to ''''''
void loop() {
  SnowSparkle(0x00, 0xFF, 0x00, 20, random(100,1000));
  Fire(55,120,15);
}

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(50);
  setPixel(Pixel,red,green,blue);
  showStrip();
  delay(100);
} 

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

  showStrip2();
  
}

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

//to here '''''''
void showStrip() {
 #ifdef ADAFRUIT_NEOPIXEL_H 
   // NeoPixel
   strip.show();
 #endif
 #ifndef ADAFRUIT_NEOPIXEL_H
   // FastLED
   controllers[0]->showLeds(gBrightness);
 #endif
}
void showStrip2() {
 #ifdef ADAFRUIT_NEOPIXEL_H 
   // NeoPixel
   strip.show();
 #endif
 #ifndef ADAFRUIT_NEOPIXEL_H
   // FastLED
   controllers[1]->showLeds(gBrightness);
 #endif
}

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
}

void setAll(byte red, byte green, byte blue) {
  for(int i = 0; i < NUM_LEDS; i++ ) {
    setPixel(i, red, green, blue); 
  }
  controllers[0]->showLeds(gBrightness);
}

void setAll2(byte red, byte green, byte blue) {
  for(int i = 0; i < NUM_LEDS; i++ ) {
    setPixel(i, red, green, blue); 
  }
  controllers[1]->showLeds(gBrightness);
}

If I try to "slow down" effect number 1, it slows down other aswell. Is it possible to other one to ignore that delay of 1st strip?

The delay() function REALLY should be called the stickYourHeadinTheSandWhileNOTHINGElseHappens(). Then, perhaps, people would not end up writing a sh*tload of code that they have to scrap and start over.

No, it is NOT possible to delay() on part of the code without affecting ALL of the code.

It IS possible to write code that is non-blocking, making events happen on different time lines without affecting other code. There are plenty of examples around. The blink without delay is one such (simple) example.

I checked several different Blink without delay tutorials and examples but I have no clue how do I convert that idea to WS2812 ledstrips..
Is it possible to convert that to the code I have? They used "long" datatype in the code without delay

The concept is simple. You record the time that something starts and on every pass through loop you check that against millis to see if it is time to take another step and do it.

If it was 2:05 and I said meet me at the pub in 20 minutes could you pull that off? Could you figure that out from just the clock without any stopwatch to time the 20 minutes? If so then you can already do what Blink Without Delay is doing.

could you pull that off?

Depends on whether you're buying.