Pagina 1 van 1

Arduino – LEDStrip effecten voor NeoPixel en FastLED

Arduino – LEDStrip effecten voor NeoPixel en FastLED
   43

Als je het artikel “Arduino – WS2812 LED strip besturen met NeoPixel of FastLED” al hebt gelezen, dan zul je misschien zelf ook gefascineerd zijn met de LEDStrips en de mogelijke gave effecten.

Met de opkomende feestdagen wil je de LEDStrips misschien wel als aanvulling gaan gebruiken voor de versieringen … misschien wel a-la Griswold (National Lampoon’s Christmas Vacation)! 

Bekijk zeker het vuur-effect eens waarbij WC papier gebruikt wordt voor licht diffusie!

Er wordt wel verondersteld dat je het artikel “Arduino – WS2812 LED strip besturen met NeoPixel of FastLED” hebt gelezen voor wat basis kennis.

Ik hoop dat dit artikeltje een motivatie is voor anderen om hun effecten ook te plaatsen (in de opmerkingen of in het forum).




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.

 

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:

DOWNLOAD - LEDEeffects Sources 

Bestand: LEDEeffects_Sources.zip
Versie: 1.0
Omvang: 33.7 KiB
Datum: 8 nov 2015
 Download Nu 

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 IDE en Library versies 

Voor dit artikel heb ik Arduino IDE 1.6.6 gebruikt, welke (na installatie van FastLED of NeoPixel) meldingen zou kunnen geven dat er updates zijn voor NeoPixel en/of FastLED – voer deze updates uit.

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

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 (magisch WC papier)

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

Halloween Ogen Parameters
 Parameter  Doel  Voorbeeld
 red  Rood waarde  0xFF
 green  Groen waarde  0x00
 blue  Blauw waarde  0x00
 EyeWidth  Aantal LEDs per oog  1
 EyeSpace  Aantal LEDs tussen de 2 ogen  2
 Fade  Fade uit gebruiken of niet  true
false
 Steps  Aantal stappen voor de fade uit  10
 FadeDelay  Vertraging tussen elke fade uit stap  100
 EndPause  Wachttijd als de functie klaar is  1000

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

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

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.

Gebruik maken van Random nummers … 

De Arduino random(Min,Max) functie geeft een willekeurig gekozen nummer tussen “Min” en “Max” terug.

Het aanroepen van randomSeed() zou dit nog eer random moeten maken.

Je kunt de random() functie overigens ook in andere effecten gebruiken – zoals ik soms in wat voorbeelden laat zien.

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

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

 

LEDStrip Effects – 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 Effects – 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 Effects – 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 Effects – 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 Effects – 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);
  }
}

 

Donatie Opties


Donaties worden zeer gewaardeerd, maar zijn zeker niet vereist. Donaties worden gebruikt voor het dekken van kosten voor web-hosting en project materialen, en eventueel voor een drankje of een snack. Voor wie al gedoneerd heeft: Hartelijk dank! Het is werkelijk geweldig om te zien dat men onze artikelen en applicaties waardeert.

Reacties


Er zijn 43 reacties welke je hieronder kunt lezen.
Je kunt jouw eigen opmerkingen plaatsen m.b.v. dit formulier, of een reactie op een opmerking plaatsen door op de "Reageer" knop te klikken.

  • 12 nov 2015 - 11:10 - Wim Hoegaerts Reactie Link

    Net je site voor het eerst gevonden. Geweldig informatief! Maar eh, alsjeblieft, kun je niet fatsoenlijk Nederlands schrijven? “Ik vindt” met dt? “Er wordt veronderstelt” met een t? Vuureffect met een spatie ertussen? Basiskennis met een spatie ertussen? Lichtdiffusie met een spatie ertussen? Haloween-ogen met een spatie ertussen? Kleurentwinkle, sneeuwspark, projectmaterialen, softwareontwikkeling, thuisbioscoop etc. etc. Kan ik voor elke spatie teveel een euro krijgen? Heb geen zin meer om verder te lezen. Jammer. Kijk eens op http://www.spatiegebruik.nl

    Beantwoorden

    Wim Hoegaerts

    • 12 nov 2015 - 15:29 - hans - Auteur: Reactie Link

      Hoi Wim,

      Mijn excuses voor de taal blunders. 

      Helaas ben ik niet iedere dag bezig met de Nederlandse taal, ik spreek hoofdzakelijk Engels. Niet dat mijn Engels nou zo geweldig is overigens. Ik moet dan ook vaak op spellings- en grammatica controle vertrouwen, welke overigens de voorgestelde spatie correcties als fout aangeeft.

      Ik zal een aantal van jouw suggesties zo goed mogelijk proberen te verwerken.

      Beantwoorden

      hans

    • 4 dec 2015 - 23:30 - Philip Reactie Link

      Hallo Wim,

      Wat ben jij een ontzettende LUL om zo een achterlijke reactie te plaatsen!!

      Beantwoorden

      Philip

    • 13 jul 2016 - 17:19 - Tom Reactie Link

      Wim

      Als je geen zin meer had om verder te lezen dan had je beter ook de moeite niet gedaan om zo’n (zielige) reactie te schrijven.

      Taal is een afspraak. Als morgen iedereen “ik vindt” begint te schrijven dan wordt dat de regel. Wees niet zo bekrompen en wees dankbaar voor de moeite die Hans heeft gedaan om je te informeren… Maar hij had dat dan blijkbaar niet moeten doen omwille van wat spelfouten? Komaan, even serieus blijven.

      Tom

      Beantwoorden

      Tom

      • 14 jul 2016 - 11:55 - hans - Auteur: Reactie Link

        Dank je wel Tom, voor de positieve reactie. 

        Ik doe m’n best om correct Nederlands te schrijven, maar dat valt niet altijd mee.
        Het is erg leuk om te horen dat het merendeel van de Nederlandstalige lezers gelukkig meer interesse heeft in de inhoud dan de spelling 

        Beantwoorden

        hans

    • 15 nov 2016 - 20:20 - Passie Reactie Link

      Kijk de een is beter in een programmeertaal dan de ander  

      Beantwoorden

      Passie

  • 23 nov 2015 - 15:08 - Dennis Reactie Link

    hallo meneer,

    mijn vriend en ik zitten in Havo 3 op het van Maerlant lyceum, we doen een project met arduino’s. ons project is een spiegel met diepte door de led licht-snoer.

    graag wil ik u vragen of u ons wilt helpen met een project voor school, we hebben al iets van uw website afgehaald. maar ons doel is nog niet bereikt. we willen graag een bewegingssensor bij ons project toevoegen, zou u voor ons een programma willen maken met daarin een bewegingssensor. (per 50 centimeter andere kleur en dat ie dan aangaat) 

    Beantwoorden

    Dennis

    • 23 nov 2015 - 15:15 - hans - Auteur: Reactie Link

      Hallo Dennis,

      ik wil je best op weg helpen, maar het doel van huiswerk is natuurlijk wel dat je het e.e.a. zelf uitvogelt.

      Start een onderwerp in het Arduino Forum, dan kijk met je mee en kijk ik waar ik kan helpen.
      Overigens, voor detectie van diepte zul je even moeten zoeken naar de juiste soort sensor (een PIR bijvoorbeeld detecteert alleen beweging en geeft geen diepte aan). Zo zou een ultrasoon sensor hier misschien geschikt voor zijn (zie o.a. Ultrasonic Sensor Ping en deze Ultrasonic Ping Library).

      Omdat ik op het moment (voor de komende feestdagen) op vakantie ben, kan het soms wat lastig zijn om het e.e.a. hier uit te proberen. Maar ik zal kijken wat ik voor jullie kan doen. 

      Beantwoorden

      hans

      • 30 nov 2015 - 14:15 - dennis040 Reactie Link

        hallo meneer,
        De docent heeft mij zelf naar u verwezen, Hij weet zelf ook niet veel van arduino’s en de programma’s ervan.En dat met de diepte hebben we al geregeld, het enigste wat we nog moeten doen is er een bewegingsensor aan ons project toevoegen. zodat als je op 1 meter komt hij aan gaat (dat hebben we gewijzigd omdat het iets simpeler is. zou u ons hier mee een beetje kunnen helpen (ik snap het niet van het forum, ik kan niks invullen of toevoegen).
        dank uBatuhan en Dennis.

        Beantwoorden

        dennis040

      • 30 nov 2015 - 19:15 - hans - Auteur: Reactie Link

        Hoi Dennis,

        Nou leuk om te horen dat de docent je hierheen verwezen heeft ….

        Het toevoegen van een sensor zou niet al te moeilijk moeten zijn.
        Je kunt hiervoor een zogenaamde PIR of bewegingssensor gebruiken (zie Spelen met een PIR).
        De uitgang van de PIR kan aangesloten worden op een van de digitale pinnen van de Arduino, welke eenvoudig uit te lezen is, een goed voorbeeld vindt je bij AdaFruit. Daar kun je zien hoe je de PIR aansluit en met een programma kunt uitlezen.

        Voor het gebruik van het forum, moet je jezelf aanmelden – dat is gedaan om te voorkomen dat mensen ongewenste rommel in het forum gaan plaatsen.

        Beantwoorden

        hans

      • 30 nov 2015 - 19:18 - hans - Auteur: Reactie Link

        Even de korte versie in het Nederlands van wat je bij AdaFruit kunt vinden:

        Een PIR heeft 3 aansluitingen:

        • De + gaat naar de 5V van de Arduino
        • De GND (min of aarde) gaat naar de GND van de Arduino
        • De output gaat naar b.v. pin 2 van de Arduino

        PIR aan een Arduino

        De code van AdaFruit:
        int ledPin = 13;                // de "pin" voor het ledje dat op de Arduino zit
        int inputPin = 2; // de input pin (voor de PIR sensor)
        int pirState = LOW; // we beginnen met de aanname dat er nog geen beweging is gedetecteerd
        int val = 0; // variable voor het opslaan van de pin status
         
        void setup() {
          pinMode(ledPin, OUTPUT); // declareer LED als output
          pinMode(inputPin, INPUT); // declareer sensor als input
         
          Serial.begin(9600);
        }
         
        void loop(){
          val = digitalRead(inputPin); // read input value
          if (val == HIGH) { // check if the input is HIGH
            digitalWrite(ledPin, HIGH); // turn LED ON
            if (pirState == LOW) {
              // we have just turned on
              Serial.println("Motion detected!");
              // We only want to print on the output change, not state
              pirState = HIGH;
            }
          } else {
            digitalWrite(ledPin, LOW); // turn LED OFF
            if (pirState == HIGH){
              // we have just turned of
              Serial.println("Motion ended!");
              // We only want to print on the output change, not state
              pirState = LOW;
            }
          }
        }

        Beantwoorden

        hans

  • 10 dec 2015 - 21:00 - Niels Reactie Link

    Leuke effecten! Wat ik me afvraag, hoe kan ik bijvoorbeeld bij de kleurwipe een fade toevoegen? Bijvoorbeeld FadeToBlack, en dan naar de volgende kleur.

    En waar kan ik de lichtsterkte van de leds controleren?

    Beantwoorden

    Niels

    • 10 dec 2015 - 21:35 - hans - Auteur: Reactie Link

      Hallo Niels!

      Fade is niet altijd even makkelijk, en dat komt door het gebruik van RGB waarden voor de LEDs. RGB waarden kennen geen “helderheid” en daarvoor moet een reken truuk worden toegepast. Niet de makkelijkste berekening overigens. Ik heb daarvoor zelf een alternatief in elkaar gedraaid wat er prima uitziet maar technisch misschien niet 100% correct is: langzaam de RGB waarden terug schroeven (zie het fade-in en fade-out voorbeeld);

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

      Deze code moet je dus in het gewenste effect plakken, net na dat een kleur gezet wordt (of aan het einde waar alle LEDs gezet zijn en je b.v. terug naar zwart wilt faden).

      De helderheid van de kleuren kun je, als je NeoPixel gebruikt, als volgt instellen:

      strip.setBrightness( (255 / 100) * BRIGHTNESS );

      Waarbij “BRIGHTNESS” een percentage is.
      Helaas weet ik niet wat het beste antwoord is voor FastLED, zonder al te veel code te gebruiken.

      Het komt er in principe op neer dat je een RGB waarde pakt en iedere waarde (rood, groen, en blauw) met 

      (WAARDE/100)*BRIGHTNESS

      vermenigvuldigd, waarbij “WAARDE” de waarde voor rood, groen en blauw zijn.
      Je zou dat dus als volgt kunnen doen door de “generieke” functie die ik gemaakt had als volgt te definieren:

      void setPixel(int Pixel, byte red, byte green, byte blue) {
       #ifdef ADAFRUIT_NEOPIXEL_H 
         // NeoPixel
         strip.setPixelColor(Pixel, strip.Color((red/100.0)*BRIGHTNESS, (green/100.0)*BRIGHTNESS, (blue/100.0)*BRIGHTNESS));
       #endif
       #ifndef ADAFRUIT_NEOPIXEL_H 
         // FastLED
         leds[Pixel].r = (red/100.0)*BRIGHTNESS;
         leds[Pixel].g = (green/100.0)*BRIGHTNESS;
         leds[Pixel].b = (blue/100.0)*BRIGHTNESS;
       #endif
      }

      Ik heb dit niet kunnen testen (ben op reis). 

      De reden waarom ik 100.0 gebruik is omdat de Arduino anders een integer waarde terug geeft, dus geen getallen achter de komma, wat weer vervelende bij effecten heeft.

      B.v. stel rood = 50. Dan zou de Arduino zeggen 50 / 100 = 0. Als je 50 / 100.0 doet is het antwoord echter 0.5 wat dus wel het juiste antwoord is voor de berekening.

      Overigens, ik ga er vanuit dat je BRIGHTNESS in het begin definieert als b.v.:

      #define BRIGHTNESS 75 // zet helderheid op 75%

      Beantwoorden

      hans

  • 16 dec 2015 - 19:07 - D Reitsma Reactie Link

    Beste arduino strip programmeurs.

    Ik heb voor de kerst een buis gemaakt met 4 strips van 144 leds onder elkaar.

    Nu lijkt mij het leuk om zoveel mogelijk effecten achter elkaar te draaien.

    Wat zijn de mogelijkheden volgens jullie?

    Bij voorbaat dank.

    Beantwoorden

    D Reitsma

    • 16 dec 2015 - 19:31 - hans - Auteur: Reactie Link

      Hoi D Reitsma!

      4 strips van 114 LEDs, dat is nou een leuke strip om mee te spelen 

      Je zou de boven genoemde effecten achter elkaar kunnen zetten – of random laten afspelen.
      Alles een beetje afhankelijk van het Arduino model dat je gebruikt natuurlijk, want geheugen kan mogelijkerwijs een beperking vormen – maar dat merk je vanzelf.

      In de code kun je het aanroepen van een effect gewoon achter elkaar zetten, mits je bijbehorende functie ook in de code kopieert natuurlijk. Als voorbeeld:

      void loop() { 
        RGBLoop();
        theaterChaseRainbow(50);
        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);
        }
      }
      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;
      }
      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);
          }
        }
      }

      In dit voorbeeld (ongetest – heb even geen Arduino en LEDs ter beschikking omdat ik op reis ben), combineer ik RGBLoop, theaterChaseRainbow en BouncingColoredBalls uit bovenstaande voorbeelden.

      Nadat BouncinColorBalls is gestart (dit is 1 van de uitzonderingen), blijft het echter doorgaan met de ballen.
      Zou je die functie niet hebben toegevoegd, dan blijven RGBLoop en TheaterChaseRainbow om beurt afspelen.

      Je moet dus even opletten welke functies eindeloos blijven door gaan, maar dat merk je snel genoeg.

      Beantwoorden

      hans

      • 16 dec 2015 - 20:22 - D Reitsma Reactie Link

        Ik krijg een fout melding bij het comprimeren.

        Eerst maar wat ontspanning Hans.

        Als je weer thuis bent, zou je mij een groot plezier doen om het uit te testen.

        Het ziet er nu buiten ook al kleurrijk uit, alleen wat eentonig.

        Iedereen kan vanaf grote afstand mee genieten.

        Beantwoorden

        D Reitsma

      • 16 dec 2015 - 23:07 - hans - Auteur: Reactie Link

        Het duurt now wel even voor ik weer thuis ben (Januari) haha … 

        Wat bedoel je met comprimeren?

        Beantwoorden

        hans

    • 16 dec 2015 - 19:33 - D Reitsma Reactie Link

      Ik heb alle effecten, hier bovenstaand al bekend.

      Vind ze stuk voor stuk prachtig.

      Is het mogelijk om ze allemaal achter elkaar te zetten?

      Om ze vervolgens te uploaden naar mijn arduino.

      Of schiet daarvoor misschien mijn geheugen tekort van de arduino?

      Beantwoorden

      D Reitsma

      • 16 dec 2015 - 19:39 - hans - Auteur: Reactie Link

        Ik zou proberen alles in een Sketch te zetten – de Arduino IDE applicatie vertelt je wel wanneer je te ver bent gegaan wat geheugen betreft.

        Let wel op dat BouncingBalls (en misschien het vuur effect) eindeloos door blijven lopen. Zou je dit toch willen gebruiken, dan moet je regel 30 (BouncingBalls als voorbeeld) moeten veranderen naar een loop.

        Dus “while(true) {” (eindeloos) vervangen door zoiets als “for (int teller=0; teller<200; teller++) {” waardoor deze loop niet meer eindeloos is, maar naar 200x stopt (je kunt het getal 200 aanpassen naar wens natuurlijk).

        Beantwoorden

        hans

  • 31 mrt 2016 - 12:00 - hans - Auteur: Reactie Link

    Op verzoek in het Engelstalige artikel:

    In het forum kun je de FASTLed en Neopixel files vinden waarin alle effecten staan.

    Beantwoorden

    hans

  • 24 apr 2016 - 13:52 - alexander Reactie Link

    ik ben bezig met een model racebaan te maken van hout 140cm x 80cm. hierin heb ik een sleuf gefreesd van 1.2 mm waarin ik de led’s ws2812b in leg. zelf gesoldeerd.

    ik heb jou programma first led gepakt en die werkt goed. maar nu wil ik 2 leds apart laten branden op 1 strip. deze leds wil ik via een potmeter aansturen. ieder 1 potmeter. zodat ik ze alle twee afzonderlijk sneller en langzamer kan zetten. je moet het zien als een echte race. nu zag ik dat ik in firstled de kleuren en brighnes niet kan inprogrammeren.

    ik ben echt een leek en een beginner in dit…wel ben ik al een heel eind opgeschoten zodat ik de leds al aan de gang hem met jou programma. toch kan ik nog heel veel hulp gebruiken om mij op een goed spoor te krijgen in wat ik wil.eerste project

    Beantwoorden

    alexander

  • 17 jul 2016 - 23:11 - marco kuperus - Auteur: Reactie Link

    hey,

    ik zie dus mooi bij de codes:

    void setup()

    {

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

    }

    // *** REPLACE FROM HERE ***

    void loop() { 

    }

    showStrip(20);

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

    }

    maar als ik dit probeer te uploaden dan geeft hij fouten aan, wat logisch is want er hoort nog wat boven.

    schijnbaar weet ik dus niet hoe het werkt, weet iemand anders dat wel, of kan hij/zei mij even helpen want ik kom er zelf niet uit.

    Beantwoorden

    marco kuperus

    • 17 jul 2016 - 23:14 - marco kuperus - Auteur: Reactie Link

      de foutcode is dus ‘NUM_LEDS’ was not declared in this scope

      Beantwoorden

      marco kuperus

      • 18 jul 2016 - 10:02 - hans - Auteur: Reactie Link

        Ik denk dat je vergeten bent het passende framework er in te kopiëren. 

        Kijk onder Library NeoPixel of FastLED (hierboven). 

        Beantwoorden

        hans

        • 18 jul 2016 - 23:55 - marco kuperus - Auteur: Reactie Link

          nee heb alle geprobeerd(van hoe ik denk hoe het werkt) en het werkte niet

          Beantwoorden

          marco kuperus

          • 19 jul 2016 - 10:37 - hans - Auteur: Reactie Link

            Als je de code van beide delen correct hebt gekopieerd, dan staat NUM_LEDS echt gedefinieerd.

            B.v. bij FastLed:

            #include "FastLED.h"
            #define NUM_LEDS 60 
            CRGB leds[NUM_LEDS];
            #define PIN 6 
            ...

            en bij NeoPixel:

            #include <Adafruit_NeoPixel.h>
            #define PIN 6
            #define NUM_LEDS 60
            // Parameter 1 = number of pixels in strip

            Stel je gebruikt de NeoPixel Library, dan moet je het stukje van 

            // *** REPLACE FROM HERE ***

            tot

            // *** REPLACE TO HERE ***

            vervangen door de code van het gewenste effect.

            hans

  • 10 sep 2016 - 18:50 - marco kuperus Reactie Link

    LEDStrip Effect – Stuiterende Ballen

    ik kopieer en plak de void loop en wat er allemaal nog onder zit in dat arduino programma, en ik wist al dat de setup miste, nu ben ik ook niet de beste in het vinden/maken van codes, dus kan iemand mij vertellen wat de void  setup voor LEDStrip Effect – Stuiterende Ballen is? of kan iemand mij uberhaupt uit leggen hoe void setup werkt?

    Beantwoorden

    marco kuperus

    • 11 sep 2016 - 14:13 - hans - Auteur: Reactie Link

      Hoi Marco,

      Iedere sketch (code) voor een Arduino heeft 2 basis elementen:

      void setup() {
      ...
      }

      en 

      void loop() {
      ...
      }

      In het setup deel worden wat initiële instellingen gedaan – dit stuk wordt maar 1x uitgevoerd en wel zodra je een Arduino aan zet.
      Het loop deel wordt vervolgens steeds herhaald, tot je de Arduino weer uit zet.

      Voor het maken van de “Stuiterende bal”, moet je eerst kiezen welke Library je wilt gaan gebruiken. Het maakt niet uit welke je kiest, ze werken alle twee even goed (voor deze toepassing).

      Dus als we het voorbeeld met de FastLED library gaan doen, dan pakken we eerst het basis framewerk:

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

      Zoals beschreven moeten we het volgende stuk vervangen door de stuiterende bal routines:

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

      Dit stukje tekst moeten we dus vervangen door

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

      Na het plakken van de tekst krijgen we dus:

      #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 );
      } // Nieuw stukje loop begint hier:
      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);
        }
      } // Nieuw stukje loop eindigt hier
      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();
      }

      Merk op dat de betreffende library (bibliotheek) dus wel geinstalleerd moet staan.
      Mocht je NeoPixel gaan gebruiken, dan geldt daarvoor natuurlijk hetzelfde, en werkt de kopieer en plak methode vergelijkbaar.

      Hopelijk helpt je dit op weg …

      p.s. Het kan zinvol zijn om Arduino Programmeren voor Beginners eens door te kijken, om een beter inzicht te krijgen in een aantal basis zaken die het leven net even gemakkelijker maken als je ze door hebt.

      Beantwoorden

      hans

  • 13 dec 2016 - 17:51 - passie Reactie Link

    Ik ben opzoek naar een mooi effect voor de kerst, heeft iemand hier een voorbeeld code voor een “druppelde ijspegel” ? 

    Beantwoorden

    passie

    • 14 dec 2016 - 19:42 - hans - Auteur: Reactie Link

      Hallo Passie!

      Kijk dat lijkt me nou een leuk effect om toe te voegen aan de lijst.
      Ik heb ze weleens gezien bij commerciële kerst verlichting hier in de VS.

      Het lijkt me niet zo moeilijk om te maken, maar daarvoor moeten we eerst even goed beschrijven hoe het druppelen zich gedraagt.
      Heb je een idee of een voorbeeld? 

      Beantwoorden

      hans

      • 14 dec 2016 - 21:03 - passie Reactie Link

        Hallo,

        Ja ik heb wel wat voorbeelden :  

        https://www.youtube.com/watch?v=_wkTtAk2V_k

        https://www.youtube.com/watch?v=nHBImYTDZ9I

        Zelf vindt ik deze 2 wel de mooiste die ik gezien heb.

        Beantwoorden

        passie

        • 15 dec 2016 - 16:12 - hans - Auteur: Reactie Link

          Ik zal proberen ze vandaag te bekijken … (ik woon in de VS dus tijdsverschil is even niet zo handig)

          Beantwoorden

          hans

        • 16 dec 2016 - 15:14 - hans - Auteur: Reactie Link

          Hoi Passie,

          ik zag dat voor die eerste, de source hier gevonden kan worden. Helaas gebruikt de maken objecten wat de leesbaarheid wat minder maakt. Voor die 2de is het blijkbaar lastiger om een source code te vinden.

          Omdat ik nog wat andere projecten op de wachtlijst heb, weet ik niet precies wanneer ik tijd heb om de code om te schrijven. Hierbij is het omschrijven van de code niet het grootste probleem, maar het vinden van een ledstrip en een Arduino is wat lastiger haha – ik ben net klaar met m’n verhuis en m’n Arduino spullen zitten nog in de een of andere doos 

          Ik ga in ieder geval kijken wat ik kan doen!

          Beantwoorden

          hans

          • 20 dec 2016 - 08:16 - Passie Reactie Link

            Nou super, ik wacht het wel af.

            Ga zelf ook wat proberen, die eerste source is voor mij te lastig te lezen.

            Succes.

            Passie

          • 20 dec 2016 - 15:50 - hans - Auteur: Reactie Link

            Even tussen door … Uncles heeft een onderwerp lopen op het Arduino Forum m.b.t. het WaterTorture effect – dit is of lijkt erg sterk op wat jij zoekt … misschien geeft het een goede start. 

            hans

  • 14 dec 2016 - 11:22 - ajm Reactie Link

    Zeer mooi om mee te spelen , veel van geleerd.

    Wat ik mis is om div  effecten achter elkaar te zetten, ik krijg dat niet voor elkaar.

    Ben er al 3 dagen mee aan het vechten, maar kom geen steek verder, kan iemand me een schopje de goede kant op geven ?

    Jos

    Beantwoorden

    ajm

  • 10 jan 2017 - 01:24 - rubenskie547 Reactie Link

    Hey mensen die dit lezen 

    Ben nu net nieuw op dit forum, ik heb een beetje lopen rond neuzen tussen alle geschreven programma’s door Hans hier boven (Dat zijn er een hoop… )
    Nu zag ik in de reacties deze vraag van D. Reitsma. Die eigenlijk de zelfde vraag had als mij toen ik dit allemaal zag, dus bij deze wie (misschien Hans zelf) heeft nog een sketch waar dit min of meer allemaal achter elkaar loopt. Eigenlijk liever nog dat ik met een druk knop kan schakelen tussen alle sketches. Nu kan ik zelf we een beetje programmeren voor de Arduino maar dan met de nadruk op beetje…. Dus eigenlijk als er iemand een loop heeft kan ik daar vast wel een knopje tussen duwen. Zelf heb ik ook al geprobeerd het te laten loopen maar zonder enig succes.

    Hoor graag van jullie.

    /R

    Beantwoorden

    rubenskie547

    • 10 jan 2017 - 21:55 - hans - Auteur: Reactie Link

      Hi Rubenskie547! 

      Je bent niet de eerste die dit vraagt … maar door omstandigheden heb ik zelf ook nog niets in elkaar gedraaid. (net verhuisd naar de Verenigde Staten)
      Een paar forum onderwerpen zijn hier al aan besteedt, maar hoofdzakelijk in de Engelstalige versie van Tweaking4All.com.
      Zie onder andere dit onderwerp

      Helaas zijn het maar delen om het e.e.a. aan de gang te krijgen. Zodra ik wat tijd heb zal ik proberen een sketch hiervoor te maken waar men met een knop kan wisselen … (als ik een meerstanden draai-schakelaar kan vinden dan kan ik dat ook overwegen – maar zo 1-2-3 ligt al dat spul nog in Nederland).

      Beantwoorden

      hans

  • 30 jan 2017 - 16:14 - Stefan Kirk Reactie Link

    Guten Tag,

    ich interessiere mich für Ihre LED-Technik. Sprechen Sie auch deutsch?

    Nur dann können wir komunizieren und ich kann besüchreiben, was genau ich möchte.

    Ich hoffe, Sie melden sich :-)

    Mit freundlichen Grüßen 

    Stefan Kirk 

    Deutschland

    Beantwoorden

    Stefan Kirk

    • 30 jan 2017 - 16:23 - hans - Auteur: Reactie Link

      Hallo Stefan,

      Ich kann in Deutsch schreiben (besser im Deutsch sprechen, und lesen is gar kein Problem), aber da die meiste Besucher English erwarten, bevorzuge ich auf English to schreiben. Im Forum könntest ein Topic starten und können wir Deutsch und English sprechen. Ich kann mir vorstellen das es einfacher is auf Deutsch zu sagen was du bauen willst. Für mich ist es aber bedeutend schwerer auf Deutsch zu schreiben.

      Schönen Gruß …

      Beantwoorden

      hans



Jouw Reactie ...

Vriendelijk verzoek om hier geen lange teksten te plaatsen (zoals source codes, log files of config files). Gebruik daarvoor het Forum.

Deel met anderen:
*
*
Houd me op de hoogte van nieuwe reacties (email).
       Gebruik jouw RSS reader om reacties te volgen.


Tweaking4All uses the free Gravatar service for Avatar display.
Tweaking4All zal nooit jouw email adres met anderen delen.