Hi Timbaland,

sorry voor de late reactie ... ik ben op vakantie, en dan gaat alles soms even niet zo vlot als gebruikelijk 

Gave video! Ik vindt het er nu al stoer uit zien!

Gezien de hoeveelheid LEDs die je hebt, is de vertraging waarschijnlijk te wijten aan de fadeToBlack() loop:

    // fade brightness all LEDs one step
    for (int j = 0; j < NUM_LEDS; j++)
    {
      fadeToBlack(j, meteorTrailDecay);
    }

Ik heb helaas m'n Arduino en LED strips niet bij de hand, maar we zouden de functie wat kunnen optimaliseren;

void meteorRain(byte red, byte green, byte blue, byte meteorSize, byte meteorTrailDecay, boolean meteorRandomDecay, int SpeedDelay)
{
  for (int i = 0; i < NUM_LEDS + NUM_LEDS; i++)
  {
    // fade brightness all LEDs one step
    for (int j = 0; j < NUM_LEDS; j++) // <- optimaliseer hier!
    {
      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();
  }
}

De "for (int j = 0; j < NUM_LEDS; j++)" loop zou wat korter kunnen, maar uiteraard is dat wat lastig omdat we niet 100% zeker weten welke LEDs nog niet zwart (uit) zijn ... 
Omdat de meteoor vooruit beweegt, zou je dit kunnen proberen:

    // fade brightness all LEDs one step
    for (int j = 0; j < i; j++) // <- optimaliseer hier!
    {
      fadeToBlack(j, meteorTrailDecay);
    }

("i" in plaats van NUM_LEDS)

Maar ook dat gaat natuurlijk steeds meer tijd kosten.
Je zou ook kunnen proberen om het zo te doen:

    // fade brightness all LEDs one step
    for (int j = max(0, i-meteorSize); j < i; j++) // <- optimaliseer hier!
    {
      fadeToBlack(j, meteorTrailDecay);
    }

Je moet dan aan het begin van de code wel het volgende toevoegen omdat het een functie is die in de math.h bibliotheek staat:

#include "math.h"

Zoals gezegd; ik kan het e.e.a. nu even niet testen, dus het resultaat kon ook weleens tegen vallen.

Ik zou zelf ook het volgende proberen, met de for-loop zoals deze voorheen was:

    // fade brightness all LEDs one step
    for (int j = 0; j < NUM_LEDS; j++)
    {
      fadeToBlack(j, meteorTrailDecay);
    }

 en de fadeToBlack() functie wat aan te passen zodat niet alle LEDs uit gaan:

void fadeToBlack(int ledNo, byte fadeValue)
{
  uint8_t r, g, b;
  r = (r <= 50) ? 50 : (int)r – (r * fadeValue / 256);
  g = (g <= 50) ? 50 : (int)g – (g * fadeValue / 256);
  b = (b <= 50) ? 50 : (int)b – (b * fadeValue / 256);
  // FastLED
  leds[ledNo].fadeToBlackBy(fadeValue);
}

Door de waarde "10" en "0" te vervangen door "50" gaat een LED wat vlotter naar "donker" met een minimale helderheid van 50. Het zou kunnen zijn dat het hier door meer lijkt op meerdere meteoren die tegelijk lopen. Nu kan het zijn dat "50" nog te helder is, dus je zou dat ook kunnen testen met "10", dus:

void fadeToBlack(int ledNo, byte fadeValue)
{
  uint8_t r, g, b;
  r = (r <= 10) ? 10 : (int)r – (r * fadeValue / 256);
  g = (g <= 10) ? 10 : (int)g – (g * fadeValue / 256);
  b = (b <= 10) ? 10 : (int)b – (b * fadeValue / 256);
  // FastLED
  leds[ledNo].fadeToBlackBy(fadeValue);
}

Meerdere meteoren tegelijk doen is lastig, maar we kunnen wel proberen het effect te laten lijken op meerdere meteoren.

Hi Hans,

Sorry voor de late reactie, ik ben erg druk de laatste tijd dus het programmeren stond even op een laag pitje.

Ik ben de code een stuk gaan vereenvoudigen. Hierdoor ben ik de vertraging kwijt geraakt bij het opnieuw beginnen van de meteor. 
Hierdoor is de led strip nu snel genoeg. 

mijn code op dit moment

#include "FastLED.h"
#define NUM_LEDS 430 //350
#define PIN 6
CRGB leds[NUM_LEDS];
int myCounter = 0;
int mySwitchPin = 12;
int pinvalue = 0;
void showStrip() {
  FastLED.show();
}
void setPixel(int Pixel, byte red, byte green, byte blue) {
  leds[Pixel].r = red;
  leds[Pixel].g = green;
  leds[Pixel].b = blue;
}
void setup()
{
  pinMode(mySwitchPin, INPUT_PULLUP);
  FastLED.addLeds<WS2812B, PIN, GRB>(leds, NUM_LEDS).setCorrection(TypicalLEDStrip);
}
void loop()
{
  pinvalue = digitalRead(mySwitchPin);
    if (pinvalue == 1)  
  meteorRain(0xff, 0xff, 0xff, 20, 20, false, 1);
  else FastLED.clear();
}
void meteorRain(byte red, byte green, byte blue, byte meteorSize, byte meteorTrailDecay, boolean meteorRandomDecay, int SpeedDelay) 
   {
      for (int i = 0; i < NUM_LEDS /*+ NUM_LEDS*/; i++) 
      {
        // fade brightness all LEDs one step
        for (int j = 0; j < NUM_LEDS; j++) 
        {
            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();
      }
    }
void fadeToBlack(int ledNo, byte fadeValue) 
{
  leds[ledNo].fadeToBlackBy(fadeValue);

Het enige dat ik nu nog wel toevoegen is dat de meteor nog in tegengestelde richting kan bewegen. 

Ik ben stap voor stap gaan testen waarom dit nu niet werkt.
Ik ben er achter gekomen dat de fadetoblack functie niet de andere kant op wil werken. 
Wanneer ik deze code gebruik lopen de leds inderdaad de andere kant op alleen gaan ze nooit uit omdat ik fadetoblack heb uitstaan.

void meteorRain(byte red, byte green, byte blue, byte meteorSize, byte meteorTrailDecay, boolean meteorRandomDecay, int SpeedDelay)
{
  for (int i = NUM_LEDS; i > 0; i--)
  {
    // fade brightness all LEDs one step
    for (int j = NUM_LEDS; j > 0; j--)
  //  {
//      fadeToBlack(j, meteorTrailDecay);
   // }
    // draw meteor
    for (int j = meteorSize; j > 0; j--)
    {
      if ((i < NUM_LEDS))
      {
        setPixel(i, red, green, blue);
      }
    }
    showStrip();
  }
}
/*void fadeToBlack(int ledNo, byte fadeValue)
{
  // FastLED
  fadeToBlackBy(0, 25, fadeValue);
}*/

na wat google werk ben ik erachter dat de fadetoblack functie gewoon de andere kant op kan werken. alleen zie ik nog niet helemaal waarom het niet werkt bij mij.

Hoi Timbaland,

ik weet hoe het gaat met het druk hebben haha. Precies hetzelfde probleem hier! Dus eigenlijk ben ik al blij dat er af en toe wat ruimte tussen zitten 

Als ik naar jouw code kijk:

void meteorRain(byte red, byte green, byte blue, byte meteorSize, byte meteorTrailDecay, boolean meteorRandomDecay, int SpeedDelay)
{
  for (int i = NUM_LEDS; i > 0; i--)
  {
    // fade brightness all LEDs one step
    for (int j = NUM_LEDS; j > 0; j--)
  //  {
//      fadeToBlack(j, meteorTrailDecay);
   // }
    // draw meteor
    for (int j = meteorSize; j > 0; j--)
    {
      if ((i < NUM_LEDS))
      {
        setPixel(i, red, green, blue);
      }
    }
    showStrip();
  }
}
/*void fadeToBlack(int ledNo, byte fadeValue)
{
  // FastLED
  fadeToBlackBy(0, 25, fadeValue);
}*/

en deze een beetje opruim:

void meteorRain(byte red, byte green, byte blue, byte meteorSize, byte meteorTrailDecay, boolean meteorRandomDecay, int SpeedDelay)

{
  for (int i = NUM_LEDS; i > 0; i--)
  {
    for (int j = NUM_LEDS; j > 0; j--)   /// <---- hier gaat het fout
    for (int j = meteorSize; j > 0; j--)
    {
      if ((i < NUM_LEDS))
      {
        setPixel(i, red, green, blue);
      }
    }
    showStrip();
  }
}

dan zie ik dat de 2de loop niet voorzien is van "//" is en dus actief is.
Of dit een negatief effect heeft weet ik niet 100% zeker (kan het nu niet testen).
Of het doet helemaal niks, of je krijgt een compiler error, of het doet de andere "j" loop teniet.