LEDStrip Effecten

Overzicht

Hieronder een overzicht van dit artikel.

Alle deze effecten werken voor zowel NeoPixel als FastLED, en bij elk effect heb ik een korte video geplaatst.

Overzicht

• 1Overzicht
• 2Arduino en LED strip voorbereiden
• 3Hulpmiddel: Kleur Kiezer
• 4Maak gavere effecten: Lichtdiffusie (de WC papier truuk)
• 5Library - NeoPixel of FastLED ?
• Basis framewerk
• FastLED Framewerk
• NeoPixel Framewerk
• 6LEDStrip Effect - Fade In en Fade Out: Rood, Groen en Blauw
• 7LEDStrip Effect - Fade In en Fade met Jouw Eigen Kleur(en)
• 8LEDStrip Effect - Strobe
• 9LEDStrip Effect - Knipperende Halloween-Ogen
• 10LEDStrip Effect - Cylon
• 11LEDStrip Effect - De nieuwe KITT
• 12LEDStrip Effect - Twinkle
• 13LEDStrip Effect - Willekeurige Kleuren-Twinkle
• 14LEDStrip Effect - Sparkle
• 15LEDStrip Effect - Sneeuw-Sparkle
• 16LEDStrip Effect - Lopende Lichten
• 17LEDStrip Effect - Kleur Wipe
• 18LEDStrip Effect - Regenboog Cycle
• 19LEDStrip Effect - Theatre Chase
• 20LEDStrip Effect - Theatre Chase Regenboog
• 21LEDStrip Effect - Vuur
• 22LEDStrip Effect - Stuiterende Ballen
• 23LEDStrip Effect - Multi Color Stuiterende Ballen
• 24LEDStrip Effect - Meteor Regen

Arduino en LED strip voorbereiden

Vergeet niet jouw eigen effecten hieronder in de opmerkingen te plaatsen, ik hoop dat deze effecten motiverend zijn … 

De sources van alle effecten kun je overigens hier downloaden:

De effecten in dit artikel gaan uit van de volgende opstelling (zoals beschreven staat in “Arduino – WS2812 LED strip besturen met NeoPixel of FastLED“).
Lees en volg dit zorgvuldig!

Arduino Aangesloten op de PC

De volgende schakeling heb ik gebruikt terwijl de Arduino is aangesloten op mijn PC:

Arduino & WS2812 – USB en Extra Voeding

Arduino Standalone

Als je een bepaald effect wilt laten lopen terwijl de Arduino niet is aangesloten op de PC, dan zul je de Arduino zelf moeten voeden met behulp van de externe voeding. Als de Arduino namelijk is aangesloten op de PC, dan voedt deze zich via de USB poort en die hebben we dus niet als we geen PC gebruiken.

 Dit is dus ALLEEN voor stand-alone gebruiken, dus wanneer de Arduino NIET met de PC is verbonden!

Arduino & WS2812 – Zonder computer

Hulpmiddel: Kleur Kiezer

Dit hulpmiddel kan handig zijn bij het kiezen van kleuren:
LED kleuren zijn immers opgebouwd uit 3 nummers: rood, groen en blauw (RGB).
Elke nummer is een byte en elk nummer kan dus een waarde hebben van 0 … 255 (in hexadecimaal: 00 … FF).

Nu werken onze grijze cellen (meestal) niet met RGB nummers, en dat is waarbij deze kleur kiezer handig kan zijn.
Je kunt hier een kleur kiezen welke de nummers in hexadecimaal terug geeft.
Merk op dat LED strips kleuren net een beetje anders kunnen zijn – ze zijn immers niet gekalibreerd.

Kleur Kiezer:

Gebruik:
Klik op het input veld en een popup zal verschijnen waar je een kleur kunt kiezen. Na het aan klikken van een kleur zal de hexadecimale waarde verschijnen.
We gebruiken deze hexadecimale waarde als volgt in een Arduino Sketch:

De eerste 2 karakters representeren ROOD,
de tweede set van twee karakters zijn voor GROEN en
de laatste 2 karakters voor BLAUW.

We moeten ‘0x‘ voor de waarden typen om aan te geven dat het hexadecimale nummers betreft.

Voorbeeld:
Voor paars is de hexadecimale waarde B700FE.
Dus rood is B7, groen is 00 en blauw is FE.

Als we dit in onze Arduino code willen gebruiken, moeten we dus “0x” voor het nummer typen, en dan krijgen we (als voorbeeld) de volgende aanroep voor b.v. de NeoPixel strip.Color() functie:

strip.Color( 0xB7, 0x00, 0xFE );

Maak gavere effecten: Lichtdiffusie (de WC papier truuk)

Ik vind het altijd erg leuk om met LEDStrips te spelen, maar soms ziet het er net even niet zo uit als ik zou willen. Bij bepaalde effecten wil je niet de individuele LEDs zien, of ben je geneigd om meerder LEDs naast elkaar te zetten.

Een mooie oplossing kan dan lichtdiffusie zijn wat het licht wat meer verspreid en vervaagd.

Er zijn verschillende technieken. Zo kun je ping-pong ballen gebruiken, wat vooral goed werkt met maar een klein aantal LEDS, of at glas of plastic, of zelfs witte stof (katoen of zo).

Nu had ik geen van allen beschikbaar, en de ping-pong ballen zijn letterlijk door m’n lieve hond gesloopt, dus moest ik even snel iets anders verzinnen.

En tot mijn grote vreugde vond ik iets simpels: gewoon WC papier (jazeker!). Het geeft een mooi diffuus effect, je hebt het vaak al ergens in huis (hoop ik) en het is spot goedkoop. Helaas had ik alleen maar WC papier met een print erop, egaal WC papier is mooier.

Let er wel op dat je het WC papier een klein beetje van de LEDs vandaan houdt, zeg een centimeter of 2 tot 3. WC papier moet zeker niet de LEDs aanraken want dan zien we toch nog de individuele LEDs.

Merk op: Beide voorbeelden zien er het beste uit als je de LEDStrip verticaal plaatst.

Zelf vind ik het vuur-effect het mooiste en meest indrukwekkend, en meteen het mooiste voorbeeld van diffuus licht!

De stuiterende rood, wit en blauwe ballen zien er ook een stuk beter/leuker uit met diffuus licht.

Library – NeoPixel of FastLED ?

Omdat ik beide Libraries erg goed vindt, heb ik besloten de functies op zo’n manier in elkaar te zetten, zodat ze met beiden prima werken (en dus ook voor alle LED Strips die deze libraries ondersteunen).

Ik heb dat gedaan door een paar generieke functies te maken en deze in een mini framewerk te gooien.

Beide libraries werken dus met deze effecten!

Uiteraad moet je eerste NeoPixel en/of FastLED installeren. Hiervoor verwijs ik je naar het artikel “Arduino – WS2812 LED strip besturen met NeoPixel of FastLED“.

 N.b. : FastLED lijkt iets sneller. In test met erg veel LEDs (300+) merk ik dat FastLED net even sneller is dan NeoPixel, somes tot 15% sneller – iets wat je bij kleien strips niet echt zult merken. Aan de andere kant, gebruikt NeoPixel minder geheugen van de Arduino.

Hieronder laat ik je zien hoe de kleine “wrappers” werken – er is vast ruimte voor een beter aanpak, en suggesties zijn dus welkom.

Basis framewerk

Voor elke van de LEDStrip effecten, gebruiken we een stukje basis code.
In dit basis stukje doe je de specifieke instellingen voor jouw LEDStrip en library! Vergeet dit niet!

Om de effecten generiek te maken, heb ik 3 basis functies gedefinieerd, welke automatisch tijden compileren de juiste code pakt voor NeoPixel of FastLED.

showStrip();

Deze functie maakt de LEDs zichtbaar en roept de functie strip.show (NeoPixel) of FastLED.show (FastLED) aan.

setPixel(Pixel, red, green, blue);

Met deze functie, stellen de kleur van een individuele LED (pixel) in.
We moeten daarbij aangeven om wel LED nummer het gaat (start bij nul) en de gewenste RGB waarden.
Voor NeoPixel roept het setPixelColor aan, en voor FastLED wijst het waarden toe aan de leds array.

setAll(red, green, blue);

Deze functie zet de hele strip in een gegeven kleur – d.w.z. dat setAll(0,0,0) de hele strip dus op zwart (uit) zet.

Bij elk van de effecten plaatsen we hier alleen maar een stukje van de totale code, welke in het framewerk geplakt dient te worden tussen “// *** REPLACE FROM HERE” en “// *** REPLACE TO HERE” (sorry, vertalen werd een beetje te bewerkelijk):

1
2
3
4
5
6
7
// *** REPLACE FROM HERE ***

void loop() { 

  // ---> here we call the effect function <---

}



// ---> here we define the effect function <---

// *** REPLACE TO HERE ***

Dus in de effect voorbeelden laten we alleen maar de loop() en de effect functie zien.
Instellingen en de 3 generieke functie definitie worden dus niet weergegeven maar zijn zeer zeker wel nodig!

FastLED Framewerk

Dit is het basis framewerk voor gebruik met de FastLED library.

We includen de gewenste library (regel 1), definiëren het aantal LEDs (regel 2), en welke Arduino pin gebruikt gaat worden (regel 4), en een aantal strip specifieke instellingen (regel 8) zoals kleur volgorde etc (RGB, GRB etc.).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
#include "FastLED.h"

#define NUM_LEDS 60 

CRGB leds[NUM_LEDS];

#define PIN 6 



void setup()

{

  FastLED.addLeds<WS2811, PIN, GRB>(leds, NUM_LEDS).setCorrection( TypicalLEDStrip );

}



// *** REPLACE FROM HERE ***
void loop() { 
  // ---> here we call the effect function <---
}

// ---> here we define the effect function <---
// *** REPLACE TO HERE ***


void showStrip() {

 #ifdef ADAFRUIT_NEOPIXEL_H 

   // NeoPixel

   strip.show();

 #endif

 #ifndef ADAFRUIT_NEOPIXEL_H

   // FastLED

   FastLED.show();

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

  }

  showStrip();

}

NeoPixel Framewerk

Voor NeoPixel gebruiken we een soort gelijk framewerk voor de effecten.

Regel 1 include de NeoPixel library, regel 2 definieert de Arduino pin (6), de opmerking regels vertellen wat over regel 10, en in regel 10 definiëren we strip specifieke instellingen.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
#include <Adafruit_NeoPixel.h>

#define PIN 6

#define NUM_LEDS 60

// Parameter 1 = number of pixels in strip

// Parameter 2 = pin number (most are valid)

// Parameter 3 = pixel type flags, add together as needed:

//   NEO_KHZ800  800 KHz bitstream (most NeoPixel products w/WS2812 LEDs)

//   NEO_KHZ400  400 KHz (classic 'v1' (not v2) FLORA pixels, WS2811 drivers)

//   NEO_GRB     Pixels are wired for GRB bitstream (most NeoPixel products)

//   NEO_RGB     Pixels are wired for RGB bitstream (v1 FLORA pixels, not v2)

Adafruit_NeoPixel strip = Adafruit_NeoPixel(NUM_LEDS, PIN, NEO_GRB + NEO_KHZ800);



void setup() {

  strip.begin();

  strip.show(); // Initialize all pixels to 'off'

}



// *** REPLACE FROM HERE ***
void loop() { 
 // ---> here we call the effect function <---
}

// ---> here we define the effect function <---
// *** REPLACE TO HERE ***


void showStrip() {

 #ifdef ADAFRUIT_NEOPIXEL_H 

   // NeoPixel

   strip.show();

 #endif

 #ifndef ADAFRUIT_NEOPIXEL_H

   // FastLED

   FastLED.show();

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

  }

  showStrip();

}

LEDStrip Effect – Fade In en Fade Out: Rood, Groen en Blauw

Met dit effect gebruiken we voorgedefinieerde kleuren: Rood, Groen en Blauw. De hele strip wordt om beurten een van deze kleuren welke we in en uit faden. Dus langzaam naar helder en dan weer langzaam naar donker,

Omdat de functie in de loop() staat, blijft zich dit oneindig herhalen.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
void loop() { 

  RGBLoop();

}



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

    }

  }

}

LEDStrip Effect – Fade In en Fade met Jouw Eigen Kleur(en)

Nou zijn voorgedefinieerde kleuren allemaal wel leuk en aardig, maar het is toch leuker als we onze eigen kleuren kunnen gebruiken.

Hierbij is definiëren we onze eigen kleur, en daarbij kun je de Kleur Kiezer gebruiken.

Zoals met de meeste van deze effecten, kun je ze combineren. Als je dus Rood, Wit en Blauw wilt gebruiken, dan doen we dat gewoon door de functie 3x aan te roepen, elk met hun eigen kleur:

1
2
3
4
5
6
7
8
9
...



void loop() { 

  FadeInOut(0xff, 0x00, 0x00); // red

  FadeInOut(0xff, 0xff, 0xff); // white 

  FadeInOut(0x00, 0x00, 0xff); // blue

}



...

De effect code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
void loop() { 

  FadeInOut(0xff, 0x77, 0x00);

}



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

  }

}

LEDStrip Effect – Strobe

Deze functie, die we weleens bij een kermis o.i.d. zien, zet alle LEDs snel aan en wer uit waardoor je een “flitsend” effect kunt krijgen, ook wel strobe genoemd.

Ik heb de functie een beetje meer flexibel gemaakt, zodat je kunt bepalen hoe veel milliseconden er gewacht wordt tussen de individuele flitsen, en hoe lang er gewacht wordt aan het einde van de functie.

De functie gebruikt 6 parameters.

De eerste 3 zijn de kleur, of te wel rood, groen en blauw (zie ook Kleur Kiezer)en n het voorbeeld gebruik ik wit.

De volgende parameter (StrobeCount) geeft aan hoeveel flitsen we willen zien.
Parameter 5 (FlashDelay) en 6 (EndPause) geven de vertraging aan tussen twee flitsen, en de pauze als het gegeven aantal flitsen afgerond is.

  Pas op met Strobe effecten – het kan bij bepaalde mensen epileptische aanvallen veroorzaken!

Effect code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
void loop() { 

  // Slower:

  // Strobe(0xff, 0x77, 0x00, 10, 100, 1000);

  // Fast:

  Strobe(0xff, 0xff, 0xff, 10, 50, 1000);

}



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

}

LEDStrip Effect – Knipperende Halloween-Ogen

Dit effect is voor de Halloween fans onder ons … het laat twee rode ogen op een willekeurige plek zien, welke dan langzaam weer verdwijnen.

Ook deze functie heb ik wat flexibiliteit gegeven, zodat je het kunt instellen naar wens.

Ook hier kunnen we weer onze gewenste kleur opgeven, welke typisch rood is (0xff, 0x00, 0x00).

Je kunt de functie dus redelijk statisch aanroepen met b.v.:

Maar het wordt toch leuker als we een wat geavanceerder aanroep doen, zoals b.v.:

1
2
3
4
HalloweenEyes(0xff, 0x00, 0x00, 

              1, 4, 

              true, random(5,50), random(50,150), 

              random(1000, 10000));

In dat voorbeeld gebruiken we de random functie zodat het verschijnen en verdwijnen van de ogen wat willekeuriger is.

Leuk om mee te experimenteren …. 

De effect code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
void loop() {

  // Fixed:

  // HalloweenEyes(0xff, 0x00, 0x00, 1,4, true, 10, 80, 3000);

  // or Random:

  HalloweenEyes(0xff, 0x00, 0x00, 

                1, 4, 

                true, random(5,50), random(50,150), 

                random(1000, 10000));

}



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

}

LEDStrip Effect – Cylon

Ik ben opgegroeid met Battlestar Galactica en Knight Rrider, waarbij een zogenaamde Larson scanner gebruikt wordt voor de Cylon robots en de auto van Michael Knight (KITT). Dit effect doet een soort gelijk effect.

Overigens wordt dit type “scanner” vaak een Larson scanner genoemd naar Glen Larson, de man achter de originele Battlestar Galactica en Knight Rider TV shows.

Het effect is relatief eenvoudig: Het rode “oog” beweegt van links naar recht en dan weer van rechts naar links, een soort eindeloze stuiter bal

De Cylon() functie heeft 6 parameters, waarbij de eerste 3 kleur bepalend zijn (een Cylon heeft een rood “oog”, maar je kunt dus je eigen kleur kiezen). De 4e parameter (EyeSize) bepaald hoe groot het “oog” is, dus hoeveel LEDs we voor het oog gebruiken (de twee buitenste, vagere LEDs, niet meegerekend).

De 5e parameter (SpeedDelay) bepaald hoeveel milliseconden de beweging vertraagd wordt (hoger = trager).
De laatste parameter (ReturnDelay) geeft aan hoeveel vertraging er gebruikt wordt als het oog “stuitert” tegen de rand.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
void loop() {

  CylonBounce(0xff, 0, 0, 4, 10, 50);

}



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

}

LEDStrip Effect – De nieuwe KITT

We hebben het al over KITT gehad in het Cylon effect, en dit effect is gebaseerd op de mislukte comeback van de Knight Rider TV show (zie ook deze KITT-duino Instructables).

In deze comeback is de scanner van KITT aangepast en maakt de volgende beweging:

KITT’s nieuwe scanner

Ik had hier eerlijk gezegd geen idee van tot ik het eerder genoemde KITT-duino Instructable had gelezen.

Omdat zich een aantal functie herhalen, ziet het er wat complexer uit omdat ik elke beweging als aparte functie heb gedefinieerd, welke ook individueel gebruikt kunnen worden.

Uiteraard geven we weer de kleur definitie door (rood, groen en blauw), maar ook de grootte van het bewegend “oog” en de vertragingen die we in het Cylon effect zagen.

Zoals eerder gezegd, NewKITT() roept een aantal losse functies aan: CenterToOutside() (midden naar buiten), OutsideToCenter() (buiten naar midden), LeftToRight() (links naar rechts) en RightToLeft() (rechts naar links), welke los aan te roepen zijn.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
void loop() {

  NewKITT(0xff, 0, 0, 8, 10, 50);

}



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

}



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

}



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

}



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

}



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

}

LEDStrip Effect – Twinkle

Dit effect laat 1 of meer LEDs willekeurig oplichten op de strip in opgegeven kleur.

Natuurlijk hebben we weer 3 parameters voor de kleur definitie.
De 4e parameter (Count) bepaalde hoeveel LEDs we willen zien oplichten, en de 5e parameter de vertraging tussen het verschijnen van twee LEDs (speed).

De 6e parameter (OnlyOne) wordt op true gezet als je maar 1 LED tegelijk wilt zien, en op false als je uiteindelijk alle “Count” LEDs zichtbaar wilt hebben.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
void loop() {

  Twinkle(0xff, 0, 0, 10, 100, false);

}



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

}

LEDStrip Effect – Willekeurige Kleuren-Twinkle

Dit is een variant op het Twinkle() effect, waarbij de kleuren willekeurig gekozen worden en dus geen kleur definitie hoeft worden meegegeven aan de functie.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
void loop() {

  TwinkleRandom(20, 100, false);

}



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

}

LEDStrip Effect – Sparkle

Ook dit is weer een Twinkle() variant, en deze keer had ik Kerstmis in gedachten.

De functie licht maar 1 LED op en schakelt deze daarna weer uit.

Ook hier weer de gebruikelijk parameters: Kleur en vertraging.

Als je liever willekeurige kleuren ziet, gebruik dan:

Sparkle(random(255), random(255), random(255), 0);

De effect code, waarbij ik wit als kleur heb gekozen:

1
2
3
4
5
6
7
8
9
10
11
void loop() {

  Sparkle(0xff, 0xff, 0xff, 0);

}



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

}

LEDStrip Effect – Sneeuw-Sparkle

Ik vindt deze elegante variant op Sparkle, waarbij we de achtergrond kleur kunnen instellen. Het deed me denken aan sneeuw waar je af en toe een zon reflectie ziet glimmen.

De glimmer kleur is vast: wit. Maar de achtergrond kleur kun je aangeven. Ik vond bij mijn opstelling dat een donkere wit (10 10 10) het mooiste effect gaf.

De 4e parameter, SparkleDelay, geeft aan hoe lang een “glim” zichtbaar is. Zet dit net te kort anders merk je nauwelijks dat er iets gebeurt.

De laatste parameter geeft aan hoe lang te wachten voor de volgende “glim”.

Ook hier kun je weer een vaste interval gebruiken:

SnowSparkle(0x10, 0x10, 0x10, 20, 200);

Maar gebruik maken van de random() functie maakt dit effect leuker.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
void loop() {

  SnowSparkle(0x10, 0x10, 0x10, 20, random(100,1000));

}



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

}

LEDStrip Effect – Lopende Lichten

Dit effect laat meerder groepen LEDs elkaar achter volgen – een soort effect dat je vroeger weleens tijdens de feestdagen in de etalages van winkels zag.

We hebben hier 4 parameters, waarvan de eerste 3 weer de kleur bepalen en de 4de parameter die de vertraging bepaald.

Je kunt deze functie wat creatiever gebruiken, bijvoorbeeld op een thema avond, waardoor we eerste een rode band zien lopen, dan een witte en dan een blauwe. Omdat het in de loop() staat herhaald zich dit natuurlijk oneindig:

1
2
3
4
5
void loop() {

  RunningLights(0xff,0,0, 50);        // rood

  RunningLights(0xff,0xff,0xff, 50);  // wit

  RunningLights(0,0,0xff, 50);        // blauw

}

Het effect:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
void loop() {

  RunningLights(0xff,0xff,0x00, 50);

}



void RunningLights(byte red, byte green, byte blue, int WaveDelay) {

  int Position=0;

  

  for(int j=0; j<NUM_LEDS*2; j++)

  {

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

  }

}

LEDStrip Effect – Kleur Wipe

Dit voorbeeld is een aangepaste versie van een voorbeeld van de NeoPixel library. Het zet steeds het volgende LED aan in een gegeven kleur, tot de hele strip de opgegeven kleur is. In het voorbeeld roep ik de functie 2x aan. De eerste keer om alles op groen te zetten, en de tweede keer om alles op zwart te zetten.

De functie neemt weer de gebruikelijke kleur als parameter, en een vertraging welke aangeeft hoe snel de volgende LED aangezet wordt.

1
2
3
4
5
6
7
8
9
10
11
12
void loop() {

  colorWipe(0x00,0xff,0x00, 50);

  colorWipe(0x00,0x00,0x00, 50);

}



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

  }

}

LEDStrip Effect – Regenboog Cycle

Ook weer een aangpast NeoPixel voorbeeld.
Deze functie geeft een regenboog aan kleuren weer en verschuift deze kleuren langzaam.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
void loop() {

  rainbowCycle(20);

}



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

  }

}



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;

}

LEDStrip Effect – Theatre Chase

Weer een aangepast NeoPixel voorbeeld. Hier volgen LEDs elkaar op, net zoals je in oude film theaters kon zien.

De parameters zijn weer kleur en vertraging.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
void loop() {

  theaterChase(0xff,0,0,50);

}



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

      }

    }

  }

}

LEDStrip Effect – Theatre Chase Regenboog

En weer een aangepast NeoPixel voorbeeld. Dit is in principe hetzelfde als de TheatreChase, maar nu met alle kleuren van de regenboog (technisch gezien natuurlijk niet ALLE kleuren van de regenboog).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
void loop() {

  theaterChaseRainbow(50);

}



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

        }

    }

  }

}



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;

}

LEDStrip Effect – Vuur

Dit effect ziet er het beste uit als de strip verticaal staat. Het emuleert het gedrag van vuur, wat een aanpassing is van een FastLED library voorbeeld wwat weer een aanpassing is van werk van Mark Kriegsman (genaamd “Fire2012”).

Overigens is dit effect erg mooi als je diffuuslicht gebruikt!

We gebruiken hier 3 parameters.

De eerste (Cooling) geeft aan hoe snel het vuur afkoelt – meer koeling betekend kortere vlammen. Een waarde tussen 20 en 100 is aanbevolen. 50 leek me een nette waarde.

De tweede parameter (Sparking), geeft aan hoe groot de kans is op een extra vonk om het vuur aan te wakkeren (kans uit 0 … 255). Een hogere waarde maakt het vuur actiever, en een waarde tussen 50 en 200 wordt gesuggereerd, met 120 als mijn voorkeur.

De laatste parameter (SpeedDelay) staat het toe om het vuur wat te vertragen. Een hogere waarde maakt het verschijnen van de vlammen wat trager – mijn voorkeur is ergens tussen 0 en 20.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
void loop() {

  Fire(55,120,15);

}



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

  }

}

LEDStrip Effect – Stuiterende Ballen

Ook dit effect ziet er het beste uit als de LEDStrip verticaal staat.
Het geeft een stuiterende bal effect, op basis van een gegeven kleur. Dit is gebaseerd op werk van Danny Wilson.

Uiteraard geven we als parameters weer de kleur, en de 4de parameter geeft aan hoeveel ballen er gaan stuiteren.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
void loop() {

  BouncingBalls(0xff,0,0, 3);

}



void BouncingBalls(byte red, byte green, byte blue, int BallCount) {

  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];

  

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

  }



  while (true) {

    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 ) {

          ImpactVelocity[i] = ImpactVelocityStart;

        }

      }

      Position[i] = round( Height[i] * (NUM_LEDS - 1) / StartHeight);

    }

  

    for (int i = 0 ; i < BallCount ; i++) {

      setPixel(Position[i],red,green,blue);

    }

    

    showStrip();

    setAll(0,0,0);

  }

}

LEDStrip Effect – Multi Color Stuiterende Ballen

Dit is een wat complexere variant van de eerder genoemde stuiterende ballen – in deze variant kunnen we namelijk de kleur van iedere bal instellen.

Helaas komt dat met een wat complex manier om de kleur aan de functie door te geven.
We hebben namelijk een zogenaamde multi-dimensionale array nodig – en dat klinkt best moeilijk he? No worries: ik probeer uit te leggen hoe dat in z’n werk gaat.

Als eerste even de basis van de functie: we gegeven op hoeveel ballen we gaan gebruiken, en we geven de kleur(en) van de individuele ballen door. Dat laatste is het lastige stuk, omdat ik van te voren niet weet of jij nu 1, 2 of 12 ballen gaat gebruiken.

Dus we definiëren een array (zie het als een tabel) voor de kleuren.
Stel we hebben 3 ballen; een rode, een witte en een blauwe. Dus 3 ballen en 3 kleuren.

We weten al dat een kleur op zichzelf al uit 3 waarden bestaat.
Als we dat nu in een multi-dimensionale array gooien, dan zien we zoiets als dit:

1
2
3
byte colors[3][3] = { {0xff, 0,0}, 

                      {0xff, 0xff, 0xff}, 

                      {0, 0, 0xff} };

De eerste regel definieert de variabel “colors” als een 3 x 3 array van bytes: byte colors[3][3] (nadeel: je kunt maar 255 ballen gebruiken)
Omdat we 3 ballen hebben, met elke een kleur welke elk weer 3 waarden hebben, zetten we de eerste waarde op 3 (ballen).
Omdat de kleuren ieder ook weer 3 waarden hebben, zetten we de tweed waarde ook op 3.

Stom voorbeeld ik weet het … ik geef zo voorbeelden met andere hoeveelheden.

In de taal C kunnen we waarden meteen toewijzen aan een variabele, ook al is het een array.
Voor een gewone enkelvoudige array doe je dat als volgt { value1, value2, ... valuen } …. dus met 3 waarden kan dat er zo uit zien { 1, 2, 3 } , met accolades ( { en } ) .

Omdat we een multi dimensionale array hebben moeten we een array doorgeven als een waarde voor de elementen van een array, wat er zoiets uit ziet: { { value1, value2, value2 }, { value1, value2, value2 }, { value1, value2, value2 } } .

Herken je al een patroon? { value1, value2, value2 } is ieder een set van 3 waarden (bytes) … ideaal voor een kleur.

Hier en voorbeeld met 2 ballen … een rode en een groene:

1
2
byte colors[2][3] = { {0xff, 0, 0},  

                      {0, 0xdd, 0} };

2 Ballen, elke met een kleur definitie van rood, groen en blauw (3).

Nu moeten we wel opletten bij het aanroepen van de functie. Het aantal ballen in de array (eerste nummer) moet dus hetzelfde zijn als het aantal ballen wat we aan de functie doorgeven. Dus:

1
2
3
4
5
6
void loop() {

  byte colors[2][3] = { {0xff, 0,0}, 

                        {0, 0xff, 0} };



  BouncingBalls(2, colors);

}

Ik hoop dat ik het een beetje OK heb uitgelegd …

Nog maar eens een voorbeeld, nu met 5 ballen (rood, groen, blauw, wit en geel):

1
2
3
4
5
6
7
8
9
void loop() {

  byte colors[5][3] = { {0xff, 0,0},       // red

                        {0, 0xff, 0},      // green

                        {0, 0, 0xff},      // blue

                        {0xff, 0xff, 0xff},// white 

                        {0xff, 0xff, 0} }; // yellow



  BouncingBalls(5, colors);

}

Hier dan de code voor het effect:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
void loop() {

  byte colors[3][3] = { {0xff, 0,0}, 

                        {0xff, 0xff, 0xff}, 

                        {0   , 0   , 0xff} };



  BouncingColoredBalls(3, colors);

}



void BouncingColoredBalls(int BallCount, byte colors[][3]) {

  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];

  

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

  }



  while (true) {

    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 ) {

          ImpactVelocity[i] = ImpactVelocityStart;

        }

      }

      Position[i] = round( Height[i] * (NUM_LEDS - 1) / StartHeight);

    }

  

    for (int i = 0 ; i < BallCount ; i++) {

      setPixel(Position[i],colors[i][0],colors[i][1],colors[i][2]);

    }

    

    showStrip();

    setAll(0,0,0);

  }

}

LEDStrip Effect – Meteor Regen

Dit effect, op basis van een verzoek van Hendrik, heb ik 2 jaar na dato (1 Januarit 2018) nog toegevoegd. De video is niet de beste en moet eigenlijk vertikaal bekeken worden. Dit is een effect wat met een leuke uitdaging kwam: FastLED heeft namelijk een dim functie voor LEDs, maar NeoPixel niet.

Zoals je ziet moet het een beetje lijken op een vallende ster of meteoor.

Je roept het effect als volgt aan:

meteorRain(0xff,0xff,0xff,10, 64, true, 30);

Zoals in eerder effecten gebruiken we rood, groen en blauw om de kleur te bepalen – in dit geval van de meteoor dus.

De 4de parameter wordt gebruikt om aan te geven hoe groot de meteoor moet zijn – in aantal LEDS, en de staart niet meegerekend.

De volgende, 5de, parameter geeft aan hoe snel de staart verdwijnt. Een hoger nummer wil dus zeggen sneller, en dus ziet de staart er dan ook korter uit. Theoretisch zou een waarde van 64 de helderheid steeds met een kwart moeten verlagen (64/256 = 1/4).

Omdat een normale meteoor niet perfect is, kan de 6de parameter gebruikt worden om aan te geven dat er wat rommel in de staart te zien is. Zet deze waarde op “true” en je ziet dat de staart er wat natuurlijker uit ziet. Als je deze waarde op “false” zet dan is de staart smooth.

Ook hier weer een snelheid beprekende parameter, zoals we die ook bij andere effecten zagen. Dit is de tijd in milliseconden waarmee de tekentijd wordt afegremd (1000 milli seconden = 1 seconde).

De effect code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
void loop() {

  meteorRain(0xff,0xff,0xff,10, 64, true, 30);

}



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

  }

}



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  

}