Posted by: @djdeeno

vele kleine testjes wat ik doe en zoek naar effecten

Dat is de beste manier 😁 -- zo doe ik het ook. 👍 

Hey Hans, koffie pruttelt trouwens ha.

Oke ik heb de regel toegevoegd en bibliotheek gecontroleerd en deze draait op de laatste versie, 3.4.0

Deze regel staat erin: // leds_strip1.setBrightness(25);

Als ik deze regel uncomment maakt dus : leds_strip1.setBrightness(25);

Komt volgende foutmelding:

Dit geld overigens voor alle 4 de strippen (leds_strip1, leds_strip2, leds_strip3, leds_strip4)

Voor andere probleem, kleuren wisseling van rood en groen (heeft geen prio, zoals nu weet is kwestie van kleur bij houden, wetende dat deze omgedraaid zit maar voor mooie zou deze gelijk moeten zijn)

Deze regel: FastLED.addLeds<LED_TYPE, PIN_STRIP4>(leds_strip4, LED_COUNT4).setCorrection(TypicalLEDStrip);

aanpassen naar: FastLED.addLeds<LED_TYPE, PIN_STRIP4, GRB>(leds_strip4, LED_COUNT4).setCorrection(TypicalLEDStrip);

Geeft de volgende foutmelding:

diamand-test1:42:69: error: wrong number of template arguments (3, should be 1)

FastLED.addLeds<LED_TYPE, PIN_STRIP4, GRB>(leds_strip4, LED_COUNT4).setCorrection(TypicalLEDStrip);

^

exit status 1
no matching function for call to 'CFastLED::addLeds(CRGB [31], int)'

Van wat ik uit de documentatie haal, werkt dit inderdaad niet per strip, maar voor alles wat op FastLED draait.
De foutmelding kan ik nu ook reproduceren. Het zegt eigenlijk dat "leds_strip1" geen Class (non-class type CRGB), en dus geen methode (member) kent die "setBrightness" heet. 🤔 

Maar goed, dus FastLED.setBrightness(25) doet wat die 4 regels hadden moeten doen - had misschien beter geweest als dit inderdaad per strip had gekund.
Ik heb zelf nog nooit met meerdere strips tegelijk gespeeld.

Wat de kleur volgorde betreft; dat koste me even wat moeite om te vinden. Het lijkt aan het LED TYPE te liggen.
Als ik die namelijk baar WS2812 verander, dan compiled het wel correct

// #define LED_TYPE    NEOPIXEL
#define LED_TYPE    WS2812

Asl ik me niet vergis zijn de Neopixel LEDs gewoon WS2811 of WS2812 LEDs.

p.s. afbeeldingen kun je gewoon in de berichten plaatsen met Copy en Paste (ik weet niet precies hoe jij ze geplaatst had)

aha, ja dna houd de brightness een beetje op, scheelt gelukkig niet zoveel.

nou ik maak een printscreen en save hem eerst en dan upload ik het plaatje, kan wellicht Copy Paste ook even proberen, net zo handig.

Dan denk ik dat ik er bijna ben, ik wacht nog even op een microfoontje om 2 strips van geluid te kunnen voorzien voor de VU meter effect, hoop dat dat gaat werken anders is misschien iets om deze waardes te simuleren? 

Oja , als programma klaar is dan mag hij het rieteltje opnieuw afspelen, nu zit aan de timer millis seconden gekoppeld en kunnen we de millis niet zomaar op 0 zetten, kunnen we hier een startover van maken of iets van dat? had nog koffie overgemaakt, weet nie of gezien is, had wat problemen met paypall

Ik heb zelf wat lopen prullen (nooit afgemaakt) met microfoontjes en liep wel tegen wat problemen aan.
Microfoontje werkt overigens wel, maar soms heb je een klein versterkertje nodig.

Omdat microfoons ook geluid van de omgeving meenemen, heb ik ook met RCA en 3.5mm stekkers (direct op de geluidsbron) gespeeld, maar dat liep niet naar wens (RCA heeft een versterkertje nodig, en de 3.5mm koptelefoon jack zet meteen het geluid uit, dus dat was ook niet handig).

En zo is dat op de hoop "projecten die ik nog wil afmaken" belandt 😁 

Hans, Als ik de loop opnieuw wil laten lopen, meende aan einde van de skecth dit op te kunnen lossen door een 0 waarde mee te geven in de startMillis, echter reageert hij daar niet op.

is dat omdat hij in alle tijden doorloopt?

if ( currentMillis - startMillis > 80000 && currentMillis - startMillis < 810000)
  {
    startMillis = 0; //start opnieuw
  }

Het is een beetje lastig te bepalen wat er fout gaat ... de context van de code is me niet helemaal duidelijk.

Kan het zijn dat je nadat je "startMillis=0;" terug moet keren naar de functie die dit aanriep (met return)? Dus b.v. zo:
(het is maar een gok omdat ik de volledige code niet zie - terug kijken in eerdere code maakte het wat onduidelijk voor me)

if ( currentMillis - startMillis > 80000 && currentMillis - startMillis < 810000)
  {
    startMillis = 0; //start opnieuw
    return; // toegevoegd
  }

Daarbij moet ik dan wel zeggen dat de code dan verder gaat na de regel waar de functie werd aangeroepen en het kan zijn dat ook dit niet wenselijk is.

Omdat je in de void loop een aantal if-then constructies hebt, kan het nodig zijn een break toe te voegen om de if-then af te breken, wat iets lastiger (maar niet onmogelijk) is.

Ik zie (code op de vorige pagina is het enige wat ik als referentie heb) dat startMillis nergens veranderd, en startMillis in de setup opgeven, wil niet zeggen dat dit nul gaat zijn.
Dus ik weet niet hoe dit dan de effecten zou moeten gaan beïnvloeden.

@Hans ja het klopt hoor, de sketch is niet veranderd, wat hij eigenlijk moet doen is aan het einde van de loop, weer opnieuw moet beginnen, dus als millis bij punt 8000 komt, zou hij gewoon weer met de eerste Sparkle effect te starten.

// gaat hier om type leonardo arduino
#define FASTLED_INTERNAL // just used to mute the Pragma messages when compiling
#include "FastLED.h"

const int ledPin4 =  4;// pin nummer voor breakdance leds1
const int ledPin5 =  5;// pin nummer voor breakdance leds2
int ledState4 = LOW;
int ledState5 = LOW;
unsigned long previousMillis = 0;
const long interval = 1500;


#define PIN_STRIP1 6 //dit is strip 1 op de diamant
#define PIN_STRIP2 7 //dit is strip 2 op de diamant
#define PIN_STRIP3 8 //dit zijn de leds onder de kop
#define PIN_STRIP4 9 //dit zijn de leds op de kop
#define LED_COUNT1 26 //aantal leds op de diamant in strip 1
#define LED_COUNT2 26 //aantal leds op de diamant in strip 2
#define LED_COUNT3 10 //aantal leds onder de kop
#define LED_COUNT4 31 //aantal leds op de kop
#define LED_TYPE     WS2812
#define NUM_LEDS    28

CRGBPalette16 firePalette = HeatColors_p;
CRGB leds_strip1[LED_COUNT1];
CRGB leds_strip2[LED_COUNT2];
CRGB leds_strip3[LED_COUNT3];
CRGB leds_strip4[LED_COUNT4];

unsigned long currentMillis = 0;
unsigned long startMillis = 0;

void setup() {
  FastLED.addLeds<LED_TYPE, PIN_STRIP1, GRB>(leds_strip1, LED_COUNT1).setCorrection(TypicalLEDStrip);
  FastLED.addLeds<LED_TYPE, PIN_STRIP2, GRB>(leds_strip2, LED_COUNT2).setCorrection(TypicalLEDStrip);
  FastLED.addLeds<LED_TYPE, PIN_STRIP3, RGB>(leds_strip3, LED_COUNT3).setCorrection(TypicalLEDStrip);
  FastLED.addLeds<LED_TYPE, PIN_STRIP4, RGB>(leds_strip4, LED_COUNT4).setCorrection(TypicalLEDStrip);
  FastLED.clear(true); // clear alle LEDs
  startMillis = millis(); //start de tijd
  pinMode(ledPin4, OUTPUT);
  pinMode(ledPin5, OUTPUT);

}


void purpleBlackGreen() {
  uint16_t sinBeat   = beatsin16(20, 0, LED_COUNT1 - 1, 0, 0);
  uint16_t sinBeat2  = beatsin16(20, 0, LED_COUNT1 - 1, 0, 21845);
  uint16_t sinBeat3  = beatsin16(20, 0, LED_COUNT1 - 1, 0, 43690);
  leds_strip1[sinBeat]   = CRGB::Purple;
  leds_strip1[sinBeat2]  = CRGB::Black;
  leds_strip1[sinBeat3]  = CRGB::Green;
  fadeToBlackBy(leds_strip1, LED_COUNT1, 12);
}

void purpleBlackGreen1() {
  uint16_t sinBeat   = beatsin16(20, 0, LED_COUNT2 - 0, 0, 0);
  uint16_t sinBeat2  = beatsin16(20, 0, LED_COUNT2 - 1, 0, 21845);
  uint16_t sinBeat3  = beatsin16(20, 0, LED_COUNT2 - 1, 0, 43690);
  leds_strip2[sinBeat]   = CRGB::Purple;
  leds_strip2[sinBeat2]  = CRGB::Black;
  leds_strip2[sinBeat3]  = CRGB::Green;
  fadeToBlackBy(leds_strip2, LED_COUNT2, 12);
}

void Sparkle(CRGB ledstrip[], int ledcount, byte red, byte green, byte blue, int SpeedDelay) {
  int Pixel = random(ledcount);
  ledstrip[Pixel] = CRGB(red, green, blue);
  FastLED.show();
  delay(70);
  ledstrip[Pixel] = CRGB(0, 0, 0);
}

void juggle() {
  // eight colored dots, weaving in and out of sync with each other
  fadeToBlackBy( leds_strip4, LED_COUNT4, 20);
  byte dothue = 0;
  for ( int i = 0; i < 8; i++) {
    leds_strip4[beatsin16( i + 7, 0, LED_COUNT4 - 1 )] |= CHSV(dothue, 200, 255);
    dothue += 32;
  }
}

void juggle1() {
  // eight colored dots, weaving in and out of sync with each other
  fadeToBlackBy( leds_strip1, LED_COUNT1, 20);
  byte dothue = 0;
  for ( int i = 0; i < 10; i++) {
    leds_strip1[beatsin16( i + 7, 0, LED_COUNT1 - 1 )] |= CHSV(dothue, 200, 255);
    dothue += 32;
  }
}

void juggle2() {
  // eight colored dots, weaving in and out of sync with each other
  fadeToBlackBy( leds_strip2, LED_COUNT2, 22);
  byte dothue = 0;
  for ( int i = 0; i < 5; i++) {
    leds_strip2[beatsin16( i + 7, 0, LED_COUNT2 - 1 )] |= CHSV(dothue, 200, 255);
    dothue += 32;
  }
}

void runFire1() {
  int  a = millis();
  for (int i = 0; i < NUM_LEDS; i++) {
    uint8_t noise = inoise8 (0 , i * 70 - a , a / 3);
    uint8_t math = abs8(i - (NUM_LEDS - 26)) * 255 / (NUM_LEDS - 0);
    uint8_t index = qsub8 (noise, math);
    leds_strip1[i] = ColorFromPalette (firePalette, index, 255);
  }
}

void runFire2() {
  int  a = millis();
  for (int i = 0; i < NUM_LEDS; i++) {
    uint8_t noise = inoise8 (0 , i * 30 - a , a / 3);
    uint8_t math = abs8(i - (NUM_LEDS - 26)) * 255 / (NUM_LEDS - 0);
    uint8_t index = qsub8 (noise, math);
    leds_strip2[i] = ColorFromPalette (firePalette, index, 255);
  }
}

void redWhiteBlue1() {
  uint16_t sinBeat   = beatsin16(30, 0, LED_COUNT1 - 1, 0, 0);
  uint16_t sinBeat2  = beatsin16(30, 0, LED_COUNT1 - 1, 0, 21845);
  uint16_t sinBeat3  = beatsin16(30, 0, LED_COUNT1 - 1, 0, 43690);
  leds_strip1[sinBeat]   = CRGB::Blue;
  leds_strip1[sinBeat2]  = CRGB::Red;
  leds_strip1[sinBeat3]  = CRGB::White;
  fadeToBlackBy(leds_strip1, LED_COUNT1, 5);
}

void redWhiteBlue2() {
  uint16_t sinBeat   = beatsin16(20, 0, LED_COUNT2 - 1, 0, 0);
  uint16_t sinBeat2  = beatsin16(20, 0, LED_COUNT2 - 1, 0, 21845);
  uint16_t sinBeat3  = beatsin16(20, 0, LED_COUNT2 - 1, 0, 43690);
  leds_strip2[sinBeat]   = CRGB::Blue;
  leds_strip2[sinBeat2]  = CRGB::Red;
  leds_strip2[sinBeat3]  = CRGB::White;
  fadeToBlackBy(leds_strip2, LED_COUNT2, 5);
}

void loop()
{
  currentMillis = millis(); // haal de tijd op
  if ( currentMillis - startMillis > 0 && currentMillis - startMillis < 10000)
  {
    Sparkle(leds_strip1, LED_COUNT1, 0xff, 0xff, 0xff, 180);
    Sparkle(leds_strip2, LED_COUNT2, 0xff, 0xff, 0xff, 0);
    Sparkle(leds_strip3, LED_COUNT3, 0xff, 0xff, 0xff, 0);
    Sparkle(leds_strip4, LED_COUNT4, 0xff, 0xff, 0xff, 0);
    FastLED.setBrightness(250);
    FastLED.show();
  }


  if ( currentMillis - startMillis > 10000 && currentMillis - startMillis < 20000)
  {
    EVERY_N_MILLISECONDS(50) {
      runFire1();
      runFire2();
      FastLED.setBrightness(100);
      FastLED.show();
    }
    fill_solid( leds_strip3, LED_COUNT3, CRGB(225, 0, 0));
    fill_solid( leds_strip4, LED_COUNT4, CRGB(255, 112, 0));
    unsigned long currentMillis = millis();
    if (currentMillis - previousMillis >= interval) {
      previousMillis = currentMillis;
      if (ledState4 == LOW) {
        ledState4 = HIGH;
      } else {
        ledState4 = LOW;
      }
      digitalWrite(ledPin4, ledState4);
    }
    if (ledState4 == LOW) {
      digitalWrite (ledPin5, HIGH);
    } else {
      digitalWrite (ledPin5, LOW);
    }
  }


  if ( currentMillis - startMillis > 20000 && currentMillis - startMillis < 30000)
  {
    purpleBlackGreen();
    purpleBlackGreen1();
    unsigned long currentMillis = millis();
    if (currentMillis - previousMillis >= 1500) {
      previousMillis = currentMillis;
      if (ledState4 == LOW) {
        ledState4 = HIGH;
        fill_solid( leds_strip3, LED_COUNT3, CRGB (0, 255, 0));
      } else {
        ledState4 = LOW;
        fill_solid( leds_strip3, LED_COUNT3, CRGB(255, 0, 255));
      }
      digitalWrite(ledPin4, ledState4);
    }
    if (ledState4 == LOW) {
      digitalWrite (ledPin5, HIGH);
      fill_solid( leds_strip3, LED_COUNT3, CRGB(0, 255, 0));
      fill_solid( leds_strip4, LED_COUNT4, CRGB(255, 0, 255));
    } else {
      digitalWrite (ledPin5, LOW);
      fill_solid( leds_strip3, LED_COUNT3, CRGB(255, 0, 255));
      fill_solid( leds_strip4, LED_COUNT4, CRGB(0, 255, 0));
    }
    FastLED.setBrightness(100);
    FastLED.show();
  }


  if ( currentMillis - startMillis > 30000 && currentMillis - startMillis < 40000)
  {
    digitalWrite (ledPin4, LOW);
    digitalWrite (ledPin5, LOW);
    juggle();
    juggle1();
    juggle2();
    fill_solid( leds_strip3, LED_COUNT3, CRGB(0, 0, 0));
    FastLED.setBrightness(150);
    FastLED.show();
  }


  if ( currentMillis - startMillis > 40000 && currentMillis - startMillis < 50000)
  {
    redWhiteBlue1();
    redWhiteBlue2();
    FastLED.setBrightness(100);
    FastLED.show();
    unsigned long currentMillis = millis();
    if (currentMillis - previousMillis >= 1000) {
      previousMillis = currentMillis;
      if (ledState4 == LOW) {
        ledState4 = HIGH;
        fill_solid( leds_strip3, LED_COUNT3, CRGB(255, 0, 0));
      } else {
        ledState4 = LOW;
        fill_solid( leds_strip3, LED_COUNT3, CRGB(0, 0, 255));
      }
      digitalWrite(ledPin4, ledState4);
    }
    if (ledState4 == LOW) {
      digitalWrite (ledPin5, HIGH);
      fill_solid( leds_strip3, LED_COUNT3, CRGB(255, 0, 0));
      fill_solid( leds_strip4, LED_COUNT4, CRGB(0, 0, 255));
    } else {
      digitalWrite (ledPin5, LOW);
      fill_solid( leds_strip3, LED_COUNT3, CRGB(0, 0, 255));
      fill_solid( leds_strip4, LED_COUNT4, CRGB(255, 0, 0));
    }
  }


  if ( currentMillis - startMillis > 50000 && currentMillis - startMillis < 53000)
  {
    digitalWrite (ledPin4, LOW);
    digitalWrite (ledPin5, LOW);
    fill_solid( leds_strip1, LED_COUNT1, CRGB(255, 0, 0)); //Let op NEO_GRB
    fill_solid( leds_strip2, LED_COUNT2, CRGB(255, 0, 0)); //Let op NEO_GRB
    fill_solid( leds_strip3, LED_COUNT3, CRGB(255, 0, 0)); //Let op NEO_GRB
    fill_solid( leds_strip4, LED_COUNT4, CRGB(255, 0, 0)); //Let op NEO_GRB
    FastLED.setBrightness(100);
    FastLED.show();
  }
  if ( currentMillis - startMillis > 53000 && currentMillis - startMillis < 56000)
  {
    fill_solid( leds_strip1, LED_COUNT1, CRGB(0, 0, 255)); //Let op NEO_GRB
    fill_solid( leds_strip2, LED_COUNT2, CRGB(0, 0, 255)); //Let op NEO_GRB
    fill_solid( leds_strip3, LED_COUNT3, CRGB(0, 0, 255)); //Let op NEO_GRB
    fill_solid( leds_strip4, LED_COUNT4, CRGB(0, 0, 255)); //Let op NEO_GRB
    FastLED.setBrightness(100);
    FastLED.show();
  }
  if ( currentMillis - startMillis > 56000 && currentMillis - startMillis < 59000)
  {
    fill_solid( leds_strip1, LED_COUNT1, CRGB(0, 255, 0)); //Let op NEO_GRB
    fill_solid( leds_strip2, LED_COUNT2, CRGB(0, 255, 0)); //Let op NEO_GRB
    fill_solid( leds_strip3, LED_COUNT3, CRGB(0, 255, 0)); //Let op NEO_GRB
    fill_solid( leds_strip4, LED_COUNT4, CRGB(0, 255, 0)); //Let op NEO_GRB
    FastLED.setBrightness(100);
    FastLED.show();
  }
  if ( currentMillis - startMillis > 59000 && currentMillis - startMillis < 62000)
  {
    fill_solid( leds_strip1, LED_COUNT1, CRGB(255, 255, 0)); //Let op NEO_GRB
    fill_solid( leds_strip2, LED_COUNT2, CRGB(255, 255, 0)); //Let op NEO_GRB
    fill_solid( leds_strip3, LED_COUNT3, CRGB(255, 255, 0)); //Let op NEO_GRB
    fill_solid( leds_strip4, LED_COUNT4, CRGB(255, 255, 0)); //Let op NEO_GRB
    FastLED.setBrightness(100);
    FastLED.show();
  }
  if ( currentMillis - startMillis > 62000 && currentMillis - startMillis < 65000)
  {
    fill_solid( leds_strip1, LED_COUNT1, CRGB(0, 255, 255)); //Let op NEO_GRB
    fill_solid( leds_strip2, LED_COUNT2, CRGB(0, 255, 255)); //Let op NEO_GRB
    fill_solid( leds_strip3, LED_COUNT3, CRGB(0, 255, 255)); //Let op NEO_GRB
    fill_solid( leds_strip4, LED_COUNT4, CRGB(0, 255, 255)); //Let op NEO_GRB
    FastLED.setBrightness(100);
    FastLED.show();
  }
  if ( currentMillis - startMillis > 65000 && currentMillis - startMillis < 68000)
  {
    fill_solid( leds_strip1, LED_COUNT1, CRGB(255, 0, 255)); //Let op NEO_GRB
    fill_solid( leds_strip2, LED_COUNT2, CRGB(255, 0, 255)); //Let op NEO_GRB
    fill_solid( leds_strip3, LED_COUNT3, CRGB(255, 0, 255)); //Let op NEO_GRB
    fill_solid( leds_strip4, LED_COUNT4, CRGB(255, 0, 255)); //Let op NEO_GRB
    FastLED.setBrightness(100);
    FastLED.show();
  }
  if ( currentMillis - startMillis > 68000 && currentMillis - startMillis < 71000)
  {
    fill_solid( leds_strip1, LED_COUNT1, CRGB(0, 0, 255)); //Let op NEO_GRB
    fill_solid( leds_strip2, LED_COUNT2, CRGB(0, 0, 255)); //Let op NEO_GRB
    fill_solid( leds_strip3, LED_COUNT3, CRGB(255, 255, 255)); //Let op NEO_GRB
    fill_solid( leds_strip4, LED_COUNT4, CRGB(255, 0, 0)); //Let op NEO_GRB
    FastLED.setBrightness(100);
    FastLED.show();
  }
  if (millis >= 71000)
  {
    fill_solid( leds_strip1, LED_COUNT1, CRGB(0, 0, 0)); //Let op NEO_GRB
    fill_solid( leds_strip2, LED_COUNT2, CRGB(0, 0, 0)); //Let op NEO_GRB
    fill_solid( leds_strip3, LED_COUNT3, CRGB(0, 0, 0)); //Let op NEO_GRB
    fill_solid( leds_strip4, LED_COUNT4, CRGB(0, 0, 0)); //Let op NEO_GRB
    FastLED.setBrightness(100);
    FastLED.show();
    startMillis = 0; //start opnieuw
    currentMillis = 0; //start opnieuw
    return; // toegevoegd
  }

}

Ah OK - duidelijk 😊 

Ik denk dat ik de aanpak een beetje zou veranderen.
Je kunt millis namelijk niet resetten.

Wat je wel kunt doen;

  startMillis = millis();

Zodat de telling vanaf dat punt gebeurt.

Dus in de laatste if-then:

if (millis >= 71000)
  {
    fill_solid( leds_strip1, LED_COUNT1, CRGB(0, 0, 0)); //Let op NEO_GRB
    fill_solid( leds_strip2, LED_COUNT2, CRGB(0, 0, 0)); //Let op NEO_GRB
    fill_solid( leds_strip3, LED_COUNT3, CRGB(0, 0, 0)); //Let op NEO_GRB
    fill_solid( leds_strip4, LED_COUNT4, CRGB(0, 0, 0)); //Let op NEO_GRB
    FastLED.setBrightness(100);
    FastLED.show();
    startMillis = millis(); //start opnieuw
  }

Na het toewijzen van de nieuwe tijd, gaat het programma verder met void loop opnieuw doorlopen.
De vergelijking currentMillis-startMillis blijft dan een valide vergelijking.

(ik hoop dat ik het goed lees 😉 )

Ja wat hij eigenlijk moet doen is gewoon weer opnieuw beginnen, na de 71000 mag hij weer opnieuw de loop gaan doorlopen, dus met sprakle beginnen.

ik heb het zojuist geprobeerd maar na 71000 gebeurd er niets, wellicht dat de aanpak niet goed is geweest hoor.

Ik zou zelf ook een iets andere aanpak gebruiken.

Zoiets als:

void loop()
{
  currentMillis = millis(); // haal de tijd op
  unsigned long SinceStartTime = currentMillis - startMillis;
  
  if(SinceStartTime<10000) 
  {
    ...
  }
  else if(SinceStartTime<20000) 
  { 
    ...
  }
  else if(SinceStartTime<30000)
  {
    ...
  }
  else if(SinceStartTime<40000)
  {
    ...
  }
  //
  // ... etc ...
  //
  else if(SinceStartTime<71000)
  {
    ...
  }
  else // >= 71000
  {
    ...
    startIme = millis(); //start opnieuw door de start tijd op nu te zetten
  }
}

Voordeel is dat het aantal berekeningen en vergelijkingen minder wordt (snellere en efficiëntere code).
De if-then-else loop wordt verlaten zodra een gevonden conditie waar is (en de bijbehorende code werd uitgevoerd),

Dus als het tijdsverschil (SinceStartTime) b.v. 31.000 is dan falen de eerste 3 condities.
De 4de conditie is waar en wordt dus uitgevoerd, en daarna wordt void loop weer opnieuw uitgevoerd.
De vergelijkingen na de 4de conditie worden dus overgeslagen.

Door startMilis op "nu" te zetten, wordt het tijdsverschil effectief weer op nul gezet.

Ik heb even niet de middelen om me heen om het te testen.

Aha, dit werk inderdaad prima, althans, hij start weer bij het begin dus dat gaat goed, echter hij sluit dan de lopende lichteffect, bijvoorbeeld Sparkle, niet meer af, hij gaat dan door naar de 2e (runfire) maar de sparkle blijft dan ook door draaien.

Hmm, dat is apart ... misschien dat dit veroorzaakt wordt door EVERY_N_MILLISECONDS ?
Deze FastLED macro is soms moeilijk te bevatten, ook ik heb er moeite mee.
Dat is het enige wat ik nu zo snel kan bedenken ... 🤔

Kun je de gewijzigde code posten?

p.s. je zou dat stukje code bij EVERY_N_MILLISECONDS even uit kunnen commenteren, kijken of het probleem zich dan nog voordoet.