Pagina1 van 1
Forum

Welkom bij de Tweaking4All gemeenschapsforums!
Voor je gaat deelnemen, bekijk de Forum Regels!

Specifieke onderwerpen: Start het onderwerp met de naam van het programma of systeem.
Bijvoorbeeld “MacOS X – Jouw vraag“, of bijvoorbeeld “MS Word – Jouw Tip of Truc“.

Merk op: Omschakelen naar een andere taal zal niet werken als je een post aan het lezen bent aangezien er waarschijnlijk geen vertaling beschikbaar is.




Verschillende effec...
 
Deel:
Meldingen
Alles wissen

Verschillende effecten Neopixel, stoppen van Sparkle

Pagina 1 / 3

(@djdeeno)
Eminent Member
Deelgenomen: 2 maanden geleden
Berichten: 21
Topic starter  

Goedendag, ten eerste mijn complimenten voor de mooie uitgebreide site, met name de topic's over neopixels samen met arduino.

Ik ben momenteel bezig om via een arduino verschillende ledstrips aan te sturen (3 stuks in dit geval) gaat om strips met de ws2812 leds, en dat werkt op zich prima. Echter loop ik tegen een probleem aan, de bedoeling is (als het kan) dat er op de 3 datapinnen verschillende neopixel effecten geprogrammeerd worden, wat op zich werkt. Maar er moet een soort tijdschema komen, bijvoorbeeld de 5 seconden moeten op alle 3 strips het effect Sparkle komen en na 5 seconden, op strip1 rainbow effect, strip2 mag doorgaan met Sparkle en strip3 krijgt een 1 vaste kleur. Dat is uiteindelijk de bedoeling, om eerst beetje gevoel te krijgen hoe deze werken heb ik een klein opzetje gemaakt en zoals u kunt zien in de code, word er in loop 3strips met een programma aangeroepen, dat gaat allemaal prima, echter in programmaB word als eerste voor strip2 Sparkle aangeroepen  en na 5 seconden zou hij verder moeten met Rainbow2 , dat doet hij wel maar het lijkt erop als of Sparkle gewoon door gaat op de achtergrond, ik krijg deze niet gestopt.

Misschien zie ik iets over het hoofd of begrijp ik toch niet goed de opbouw hiervan. Kan iemand mij hier in helpen?

Ik heb hiervoor een filmpje gemaakt, zoals u kunt zien is de middelste strip de strip2 waar sparkle lijkt door te gaan.

Er zit overigens nog een delay functie in deze sparkle die de andere 2 strips even in de vertraagmode zet maar dat is een volgende dingetje die ik met millis straks probeer aan te maken.

Sketch is bedoeld voor een Diamant die op mijn modelbouw attractie staat attractie

Nogmaals dank, super leuk en leerzame website en koffie donatie komt in orde.

Filmpje en de code

#include <Adafruit_NeoPixel.h>
#include "FastLED.h"
#include <EEPROM.h>

#define LED_PIN6 6
#define LED_PIN7 7
#define LED_PIN8 8
#define LED_COUNT6 8
#define LED_COUNT7 8
#define LED_COUNT8 8
#define BRIGHTNESS 60
#define LED_TYPE     NEOPIXEL
#define NUM_LEDS    30
CRGB leds[NUM_LEDS];

unsigned long Timer1;


Adafruit_NeoPixel strip1(LED_COUNT6, LED_PIN6);
Adafruit_NeoPixel strip2(LED_COUNT7, LED_PIN7);
Adafruit_NeoPixel strip3(LED_COUNT8, LED_PIN8);

byte selectedEffect = 0;

void setup() {
  FastLED.addLeds<LED_TYPE, LED_PIN8>(leds, LED_COUNT8).setCorrection(TypicalLEDStrip);
  FastLED.addLeds<LED_TYPE, LED_PIN7>(leds, LED_COUNT8).setCorrection(TypicalLEDStrip);

  Timer1 = millis();

  strip1.begin();
  strip1.show();
  strip1.setBrightness(25);

  strip2.begin();
  strip2.show();
  strip2.setBrightness(25);

  strip3.begin();
  strip3.show();
  strip3.setBrightness(25);
}

void loop() {
  // render the first animation into strip
  programmaA();
  // render the second animation into strip3
  programmaB();
  // render the second animation into strip4
  programmaC();
}



// hier begint programma A voor de strip1 op pin 6
void programmaA()
{
  rainbow();
}
void rainbow() {
  static unsigned long firstPixelHue = 0;
  for (int i = 0; i < strip1.numPixels(); i++) {
    int pixelHue = firstPixelHue + (i * 65536L / strip1.numPixels());
    strip1.setPixelColor(i, strip1.gamma32(strip1.ColorHSV(pixelHue)));
  }
  strip1.show();
  firstPixelHue += 256;
  if  (firstPixelHue >= 5 * 65536UL) firstPixelHue = 0;
}


// hier begint programma B voor de strip2 op pin 7
void programmaB()
{
  if (millis() - Timer1 >= 50 )
  {
      Sparkle(0xff, 0xff, 0xff, 5);
  }

  if (millis() - Timer1 >= 5000 )
  {
    rainbowl();
  }
  if (millis() - Timer1 >= 15000 )
  {
    pulse();
  }

  if (millis() - Timer1 >= 20000 )
  {
    Sparkle(0xff, 0xff, 0xff, 5);
  }

}


void Sparkle(byte red, byte green, byte blue, int SpeedDelay) {
  int Pixel = random(LED_COUNT7);
  strip2.setPixelColor(Pixel, red, green, blue);
  strip2.show();
  delay(50);
  strip2.setPixelColor(Pixel, 0, 0, 0);
}

void rainbowl() {

  static unsigned long firstPixelHue = 50;
  for (int i = 0; i < strip2.numPixels(); i++) {
    int pixelHue = firstPixelHue + (i * 65536L / strip2.numPixels());
    strip2.setPixelColor(i, strip2.gamma32(strip2.ColorHSV(pixelHue)));
  }
  strip2.show();
  firstPixelHue += 256;
  if  (firstPixelHue >= 5 * 65536UL) firstPixelHue = 0;
}

void pulse() {
  float MinBrightness = 0;
  float MaxBrightness = 25 - MinBrightness;
  float SpeedFactor = 0.01;
  float wait = 4;

  static unsigned long b = 0;
  {
    float intensity = MaxBrightness / 2.0 * (1.0 + sin(SpeedFactor * b)) + MinBrightness;
    strip2.setBrightness(intensity);
    for (uint8_t i = 0; i < strip2.numPixels(); i++)
    {
      strip2.setPixelColor(i, 0, 200, 200, 255);
    }
    strip2.show();
    b++;
    if (b >= 65535) b = 0;
  }
}



// hier begint programma C voor de strip3 op pin 8
void programmaC()
{
  pulse1();
}
void pulse1() {

  float MinBrightness = 0;
  float MaxBrightness = 25 - MinBrightness;
  float SpeedFactor = 0.01;
  float wait = 8;

  static unsigned long b = 0;
  {
    float intensity = MaxBrightness / 2.0 * (1.0 + sin(SpeedFactor * b)) + MinBrightness;
    strip3.setBrightness(intensity);
    for (uint8_t i = 0; i < strip3.numPixels(); i++)
    {
      strip3.setPixelColor(i, 0, 200, 0, 255);
    }
    strip3.show();
    b++;
    if (b >= 65535) b = 0;
  }
}










// ***************************************
// ** FastLed/NeoPixel Common Functions **
// ***************************************

// Apply LED color changes
void showStrip() {
#ifdef ADAFRUIT_NEOPIXEL_H
  // NeoPixel
  strip1.show();
#endif
#ifndef ADAFRUIT_NEOPIXEL_H
  // FastLED
  FastLED.show();
#endif
}

// Set a LED color (not yet visible)
void setPixel(int Pixel, byte red, byte green, byte blue) {
#ifdef ADAFRUIT_NEOPIXEL_H
  // NeoPixel
  strip1.setPixelColor(Pixel, strip1.Color(red, green, blue));
#endif
#ifndef ADAFRUIT_NEOPIXEL_H
  // FastLED
  leds[Pixel].r = red;
  leds[Pixel].g = green;
  leds[Pixel].b = blue;
#endif
}

// Set all LEDs to a given color and apply it (visible)
void setAll(byte red, byte green, byte blue) {
  for (int i = 0; i < NUM_LEDS; i++ ) {
    setPixel(i, red, green, blue);
  }
  showStrip();
}

 


BeantwoordenCiteren
Onderwerp trefwoorden
 Hans
(@hans)
Noble Member Admin
Deelgenomen: 8 jaar geleden
Berichten: 1890
 

Hallo djdeeno!

Als eerste dank voor het compliment 😊 

Een eerste blijk op jouw code;

1. Je gebruikt de NeoPixel EN de FastLED library door elkaar.

Je hebt maar 1 van de twee nodig. Persoonlijk zou ik FastLED gebruiken omdat het volwassener en sneller is dan NeoPixel.
Aangezien je FastLED al gebruikt, en geen gebruik maakt van de EEPROM, kun je de volgende twee regels verwijderen:

#include <Adafruit_NeoPixel.h>
#include <EEPROM.h>

 

Daarnaast zag ik dat je LED strip definieert voor zowel NeoPixel als FastLED. 1 is genoeg 😉 

Adafruit_NeoPixel strip1(LED_COUNT6, LED_PIN6);
Adafruit_NeoPixel strip2(LED_COUNT7, LED_PIN7);
Adafruit_NeoPixel strip3(LED_COUNT8, LED_PIN8);

 

Daar komt dan nog bij dat de definitie voor FastLED onvolledig is (je mist PIN6), dus ik vermoed dat een deel van jouw problemen komt omdat je 2 bibliotheken door elkaar gebruikt.

FastLED.addLeds<LED_TYPE, LED_PIN6>(leds1, LED_COUNT6).setCorrection(TypicalLEDStrip);
FastLED.addLeds<LED_TYPE, LED_PIN7>(leds2, LED_COUNT7).setCorrection(TypicalLEDStrip);
FastLED.addLeds<LED_TYPE, LED_PIN8>(leds3, LED_COUNT8).setCorrection(TypicalLEDStrip);

 

2. Omdat je FastLED gebruikt kunnen we deze generieke functies, ter ondersteuning van NeoPixel, dus ook weg halen;

// ***************************************
// ** FastLed/NeoPixel Common Functions **
// ***************************************

// Apply LED color changes
void showStrip() {
#ifdef ADAFRUIT_NEOPIXEL_H
  // NeoPixel
  strip1.show();
#endif
#ifndef ADAFRUIT_NEOPIXEL_H
  // FastLED
  FastLED.show();
#endif
}

// Set a LED color (not yet visible)
void setPixel(int Pixel, byte red, byte green, byte blue) {
#ifdef ADAFRUIT_NEOPIXEL_H
  // NeoPixel
  strip1.setPixelColor(Pixel, strip1.Color(red, green, blue));
#endif
#ifndef ADAFRUIT_NEOPIXEL_H
  // FastLED
  leds[Pixel].r = red;
  leds[Pixel].g = green;
  leds[Pixel].b = blue;
#endif
}

// Set all LEDs to a given color and apply it (visible)
void setAll(byte red, byte green, byte blue) {
  for (int i = 0; i < NUM_LEDS; i++ ) {
    setPixel(i, red, green, blue);
  }
  showStrip();
}

 

 

 

Ik zou beginnen met 1 library te kiezen en alles van de andere library te verwijderen.
Een voorschotje voor FastLED (mocht je daarvoor kiezen):

#include "FastLED.h"

#define PIN_STRIP1 6
#define PIN_STRIP2 7
#define PIN_STRIP3 8

#define LED_COUNT_STRIP1 8
#define LED_COUNT_STRIP2 8
#define LED_COUNT_STRIP3 8

#define BRIGHTNESS 60

#define LED_TYPE     NEOPIXEL
#define NUM_LEDS    30

CRGB leds_strip1[LED_COUNT6];
CRGB leds_strip2[LED_COUNT7];
CRGB leds_strip3[LED_COUNT8];

unsigned long Timer1;

byte selectedEffect = 0;

void setup() {
  FastLED.addLeds<LED_TYPE, PIN_STRIP1>(leds_strip1, LED_COUNT_STRIP1).setCorrection(TypicalLEDStrip);
  FastLED.addLeds<LED_TYPE, PIN_STRIP2>(leds_strip2, LED_COUNT_STRIP2).setCorrection(TypicalLEDStrip);
  FastLED.addLeds<LED_TYPE, PIN_STRIP3>(leds_strip3, LED_COUNT_STRIP3).setCorrection(TypicalLEDStrip);
  FastLED.Clear(true); // clear all LEDs
  
  Timer1 = millis();

  leds_strip1.setBrightness(25);
  leds_strip2.setBrightness(25);
  leds_strip3.setBrightness(25);
}

 

Nu zie ik wel dat jouw functies ook aangepast moeten worden.
Ik neem aan dat je de All-effects-in-one al had bekeken.

Als voorbeeld het Sparkle effect in jouw code, wordt dan:

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

 

Nu kent FastLED meerdere methoden om meerdere strips aan te spreken, en ik zag dat je 2x de rainbow functie had, om te kunnen wisselen tussen strips.
En een twee dimensionale array is misschien handig voor jouw opzet.

 

Voor ik er al te veel tijd in ga steken; graag even kijken welke van de twee libraries je wilt gebruiken. Dan kunnen we daarmee verder werken en indien nodig omzetten.


BeantwoordenCiteren
(@djdeeno)
Eminent Member
Deelgenomen: 2 maanden geleden
Berichten: 21
Topic starter  

@hans

Dank je wel voor de update, het klopt inderdaad dat ik 2 verschillende librarys heb gebruikt, eerlijk gezegd dacht ik dat dit wel kon maar ergens snap ik ook dat dit oponthoud kan geven, begrijpelijk, de rest van de code zijn dan inderdaad overbodig. Nu werk ik met de attractie veel met neopixel maar ik las al eerder dat Fastled de overhand neemt, althans sneller is en wat meer aan kan kon, de stap om door te ontwikkelen en verdiepen in Fastled is snel gemaakt, we borduren hier graag op verder.

 

Zoals je al gemeld heb ik de code aangepast, verder met alleen Fastled, gaf eerst nog wat problemen maar hier en daar wat aangepast zoals  FastLED.clear (hoofdletter) en heb ik setBrightness even in een uncomment gezet, deze gaf aan een non-class type van CRGB is, maar deze foutmelding duik ik later op in, dat moet wel uit te zoeken zijn.

 

Nu heb ik voor een snelle test, gewoon om te kijken of de code tot op heden goed werkt, hiervoor heb ik 3 void Sparkle aangemaakt om zo de 3 strip apart aan te roepen en het werkt direct, echter de millis doet zijn werk nog niet helemaal. na elke 5 sec zou de volgende strip moeten starten, hier zit een probleempje waar ik tegen aan loop

#include "FastLED.h"

#define PIN_STRIP1 6
#define PIN_STRIP2 7
#define PIN_STRIP3 8

#define LED_COUNT6 8
#define LED_COUNT7 8
#define LED_COUNT8 8

#define LED_COUNT_STRIP1 8
#define LED_COUNT_STRIP2 8
#define LED_COUNT_STRIP3 8

#define BRIGHTNESS 60

#define LED_TYPE     NEOPIXEL
#define NUM_LEDS    30

CRGB leds_strip1[LED_COUNT6];
CRGB leds_strip2[LED_COUNT7];
CRGB leds_strip3[LED_COUNT8];

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


void setup() {
  FastLED.addLeds<LED_TYPE, PIN_STRIP1>(leds_strip1, LED_COUNT_STRIP1).setCorrection(TypicalLEDStrip);
  FastLED.addLeds<LED_TYPE, PIN_STRIP2>(leds_strip2, LED_COUNT_STRIP2).setCorrection(TypicalLEDStrip);
  FastLED.addLeds<LED_TYPE, PIN_STRIP3>(leds_strip3, LED_COUNT_STRIP3).setCorrection(TypicalLEDStrip);
  FastLED.clear(true); // clear all LEDs

  startMillis = millis(); //start de tijd

  //   leds_strip1.setBrightness(25);
  //   leds_strip2.setBrightness(25);
  //   leds_strip3.setBrightness(25);
}


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

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

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


void loop() {
  // render the first animation into strip1
  programmaA();
  // render the second animation into strip2
  programmaB();
  // render the second animation into strip3
  programmaC();
}



// hier begint programma A voor de strip1 op pin 6
void programmaA()
{
  currentMillis = millis(); // haal de tijd op
  if (currentMillis - startMillis >= 50)
  {
    Sparkle1(0xff, 0xff, 0xff, 0);
  }
}



// hier begint programma B voor de strip1 op pin 7
void programmaB()
{
  currentMillis = millis(); // haal de tijd op
  if (currentMillis - startMillis >= 100)
  {
    Sparkle2(0xff, 0xff, 0xff, 0);
  }
}


// hier begint programma C voor de strip1 op pin 8
void programmaC()
{
  currentMillis = millis(); // haal de tijd op
  if (currentMillis - startMillis >= 100)
  {
    Sparkle3(0xff, 0xff, 0xff, 0);
  }
}





BeantwoordenCiteren
(@djdeeno)
Eminent Member
Deelgenomen: 2 maanden geleden
Berichten: 21
Topic starter  

@hans, ik wilde me reactie even updaten, ik had de timer millis nog niet goed ingesteld, mijn excuus, ik heb deze nu verhoogd naar de juist waardes zodat ze wel elke 5 sec een voor een aan gaan, het gaat nu prima.


BeantwoordenCiteren
 Hans
(@hans)
Noble Member Admin
Deelgenomen: 8 jaar geleden
Berichten: 1890
 

FastLED is inderdaad sneller en veel volwassener dan NeoPixel - heb zelf het vermoeden dat AdaFruit ook niet veel verder ontwikkeld.
De snelheid van FastLED wordt vooral bij veel LED erg duidelijk.
Daarnaast heeft FastLED een hele hoop extra functies die het leven even iets gemakkelijker maakt 😊 

Omdat je met timing werkt is het misschien een idee naar de ingebouwde functies (macros in dit geval) van FastLED te kijken -de zogenaamde event triggers.
Hier een paar voorbeelden: every_n timers, twinkle, demo reel.
Ik heb er zelf niet veel mee gedaan, maar ik denk dat het in jouw project weleens wat code zou kunnen besparen en misschien zelfs wat nauwkeuriger zijn.

Hoewel de documentatie van FastLED erg goed is, kon ik zo 1-2-3 geen uitleg vinden die je op weg helpt hier mee te werken.

Let wel: deze timers "vuren" een event elke x milli/micro/seconde af.
Dus wanneer je een effect start, niet te verwarren met hoe lang een effect moet lopen.

Dus b.v. elke 5 seconden effect X starten. Misschien iets minder geschikt voor dit project bedenk ik me nu.

Ik keek even naar jouw Sparkle functies en ik zie dit: 

if (currentMillis - startMillis >= 50)
  {
    Sparkle1(0xff, 0xff, 0xff, 0);
  }

 

Dit wil zeggen dat Sparkle1 alleen maar wordt afgevuurd als deze functie al 50 or meer milliseconden loopt.

Als je Sparkle1 5 seconden wilt laten lopen dan denk ik dat je dit nodig hebt (geldt ook voor de andere 2).
Overigens werkt het in milliseconden, dus 1 seconde = 1000 milliseconden (als ik me niet vergis).
Dus zolang NU - StartTijd kleiner of gelijk aan 5 seconden: run Sparkle1.

if (currentMillis - startMillis <= 5000)
  {
    Sparkle1(0xff, 0xff, 0xff, 0);
  }

 

Hopelijk helpt dit 😊 


BeantwoordenCiteren


 Hans
(@hans)
Noble Member Admin
Deelgenomen: 8 jaar geleden
Berichten: 1890
 
Geplaatst door: @djdeeno

ik wilde me reactie even updaten

Hebben we elkaar net misgelopen 😉 


BeantwoordenCiteren
(@djdeeno)
Eminent Member
Deelgenomen: 2 maanden geleden
Berichten: 21
Topic starter  

Hans, je bent geweldig!!!

Het werkt super, ik kan nu inderdaad per strip en instelbare millis de juiste programma op de juiste strips zetten, echt heel blij mee. Ik moet zelf even een aantal geschikte effecten zoeken voor op de diamant maar dit gaat me zeker helpen. zodra deze blinkt en knippert maak ik een mooi filmpje. Bakkie Koffies zitten in je rekening hoor, geniet ervan en ik zal in de toekomst wellicht meer schenken wat dit een mooie duidelijk site met goed uitleg, heerlijk.

Misschien dat jij of een andere lezer een tip kan geven over de meerdere Void Sparkle1 , Void Sparkle2 ect, dit is of lijkt mij overbodig maar omdat elke Void zijn eigen strip aanstuurt weet ik dit niet zo makkelijk in de loop te verwerken, dan zou je met eenmalige void klaar zijn, zo staat er nu in een void Sparkle2 

leds_strip2[Pixel] = CRGB(0, 0, 0);

 

Nou dit is in void Sparkle2 om leds_strip2 aan te sturen, in void Sparkle3 staat leds_Strip3 ect, dit lijkt mij overbodig als en beter programmeert.

En ik had nog een vraag aan ieder die mee leest, is er iemand die weet of er een VU meter effect is? Deze hoef niet op geluid te reageren, gaat alleen om het effect.

Super bedankt weer!!!

 


BeantwoordenCiteren
 Hans
(@hans)
Noble Member Admin
Deelgenomen: 8 jaar geleden
Berichten: 1890
 

Geweldig om te horen dat het gelukt is! 👍 
Ik ben benieuwd naar een videootje zodra je er een hebt. 😊 

Voor de void Sparkle kun je eventueel de led array doorgeven als parameter. Ik heb dit zelf niet getest, maar ik denk dat het werkt.
Ik ben er hier vanuit gegaan dat de kans bestaat dat iedere strip een ander aan LEDs kan hebben, dus dat moeten we dan ook even doorgeven.

Aanroep:

Sparkle(leds_strip1, LED_COUNT_STRIP1, 0xff, 0xff, 0xff, 0);

 

In de functie moeten we dan ook even led_stripX en de LED_COUNTX aanpassen.

Functie:

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

 

Je kunt op zo'n manier ook programmaA, programmaB en programmaC veranderen (meer een generieke functie maken).
Maar ik weet niet hoe jou code er op het moment uitziet 😉 

Op basis van de oude code (programmaA,B.,C komen dan te vervallen):

void programmaX(CRGB ledstrip[], int ledcount, int duration)
{
  currentMillis = millis(); // haal de tijd op
  if (currentMillis - startMillis >= duration)
  {
    Sparkle(ledstrip, ledcount, 0xff, 0xff, 0xff, 0);
  }
}

 

Aanroepen:

// ipv programmaA
programmaX(leds_strip1, LED_COUNT_STRIP1, 50);
// ipv programmaB
programmaX(leds_strip2, LED_COUNT_STRIP2, 100);
// ipv programmaC
programmaX(leds_strip3, LED_COUNT_STRIP3, 100);

 

Je zou zelfs nog een stap verder kunnen gaan, waarbij "programmaX" meteen de code voor het effect er in heeft.

Hopelijk helpt dit 😊 


BeantwoordenCiteren
 Hans
(@hans)
Noble Member Admin
Deelgenomen: 8 jaar geleden
Berichten: 1890
 

Vergat ik jouw VU meter vraag te beantwoorden! Woops.

Heb je een voorbeeld video voor een dergelijk effect?
Ik kan me namelijk een aantal varianten voorstellen 😊 


BeantwoordenCiteren
(@djdeeno)
Eminent Member
Deelgenomen: 2 maanden geleden
Berichten: 21
Topic starter  

Hans, hier nog even een update. de diamant is wat aangepast met een extra strip, dus 4 stuks inmiddels, om een idee te krijgen hoe dit werkt en deze aangesloten zit, een plaatje maakt duidelijkheid,

1 zijn stips om en om en zitten op pin 6

2 zijn strips om en om en zitten op pin 7

3 zijn de leds onder de grote kop op pin 8

4 zijn de leds die in de kop zitten, dit zijn 2 rijen die zelfde doen en zitten op 9

 

 Een filmpje hoe het er nu uitziet, eerste effect is dat alle strips de twinkle effect hebben, 2e effect is fire in de eerse 2 strip en strip 3 kleurt alleen rood voor bij effect, daarna nog wat rood wit blauw effecten maar daar ben ik nog mee bezig.

 

wat ik bedoel met VU, ik dacht weet je, hoe leuk is dat, ik bestel een microfoontje en maak een echte vu meter, deze werkende te zien op volgende filmpje

 

Nu moet ik deze nog combineren zodat de VU ook een onderdeel word van de diamant tijdens de leds programma's.

Hier de code van de diamant zoals hij er nu voor staat, moet nog gefinetuned worden

ohja pin 4 en pin 5 sturen de letters breakdance aan boven in de kop, die knipperen aan en uit ect, maar dat gaat prima.

nogmaals dank Hans, koffie al op?

Oja, de leds die boven in de kop zitten zijn 5 mm neopixel, het heeft iets te maken met rgb brg denk ik, want als alle strips blauw moeten zijn, zijn strip 1 en 2 dat wel maar bovenin kleuren ze groen, ook apart. ook daar moet ik nog verder in zoeken, ik dacht hou je op de hoogte

 

#include "FastLED.h"

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

// #define COLOR_ORDER BGR

#define PIN_STRIP1 6 //dit is strip 1 op de diamant
#define PIN_STRIP2 7 //dit is strip 2 op de diamant
#define PIN_STRIP3 8 //dit zijn de leds onder de kop
#define PIN_STRIP4 9 //dit zijn de leds op de kop

#define LED_COUNT1 26 //aantal leds op de diamant in strip 1
#define LED_COUNT2 26 //aantal leds op de diamant in strip 2
#define LED_COUNT3 10 //aantal leds onder de kop
#define LED_COUNT4 31 //aantal leds op de kop

#define LED_TYPE     NEOPIXEL
#define NUM_LEDS    28

CRGBPalette16 firePalette = HeatColors_p;

CRGB leds_strip1[LED_COUNT1];
CRGB leds_strip2[LED_COUNT2];
CRGB leds_strip3[LED_COUNT3];
CRGB leds_strip4[LED_COUNT4];

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

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


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

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

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




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




void loop() {
  // render the first animation into strip1
  programmaA();
  // render the second animation into strip2
  programmaB();
  // render the second animation into strip3
  programmaC();
  // render the second animation into strip3
  programmaD();



}



// hier begint programma A voor de strip1 op pin 5
void programmaA()
{
  currentMillis = millis(); // haal de tijd op
  if ( currentMillis - startMillis > 0 && currentMillis - startMillis < 15000)
  {
    Sparkle(leds_strip1, LED_COUNT1, 0xff, 0xff, 0xff, 50);
  }
  if ( currentMillis - startMillis > 15000 && currentMillis - startMillis < 40000)
  {
    EVERY_N_MILLISECONDS(5) {
      runFire1();
      FastLED.show();
    }
      unsigned long currentMillis = millis();
  if (currentMillis - previousMillis >= interval) {
    previousMillis = currentMillis;
    if (ledState4 == LOW) {
      ledState4 = HIGH;
    } else {
      ledState4 = LOW;
    }
    digitalWrite(ledPin4, ledState4);
  }
  if (ledState4 == LOW) {
    digitalWrite (ledPin5, HIGH);
  } else {
    digitalWrite (ledPin5, LOW);
  }
  }
  if (currentMillis - startMillis >= 40000)
  {
    redWhiteBlue1();
    FastLED.show();
  }
}




// hier begint programma B voor de strip1 op pin 6
void programmaB()
{
  currentMillis = millis(); // haal de tijd op
  if ( currentMillis - startMillis > 0 && currentMillis - startMillis < 15000)
  {
    Sparkle(leds_strip2, LED_COUNT2, 0xff, 0xff, 0xff, 0);
  }
  if ( currentMillis - startMillis > 15000 && currentMillis - startMillis < 40000)
  {
    EVERY_N_MILLISECONDS(5) {
      runFire2();
      FastLED.show();
    }
  }
  if (currentMillis - startMillis >= 40000)
  {
    redWhiteBlue2();
    FastLED.show();
  }
}



// hier begint programma C voor de strip1 op pin 7
void programmaC()
{
  currentMillis = millis(); // haal de tijd op
  if ( currentMillis - startMillis > 0 && currentMillis - startMillis < 15000)
  {
    Sparkle(leds_strip3, LED_COUNT3, 0xff, 0xff, 0xff, 0);
  }

  if ( currentMillis - startMillis > 15000 && currentMillis - startMillis < 40000)
  {
fill_solid( leds_strip3, LED_COUNT3, CRGB(0,255,0)); //Let op NEO_GRB
  }

  if (currentMillis - startMillis >= 40000)
  {
fill_solid( leds_strip3, LED_COUNT3, CRGB(0,0,255)); //Let op NEO_GRB
  }
}



// hier begint programma D voor de strip1 op pin 8
void programmaD()
{
  currentMillis = millis(); // haal de tijd op
  if ( currentMillis - startMillis > 0 && currentMillis - startMillis < 15000)
  {
    Sparkle(leds_strip4, LED_COUNT4, 0xff, 0xff, 0xff, 0);
  }

  if ( currentMillis - startMillis > 15000 && currentMillis - startMillis < 40000)
  {
    //Sparkle(leds_strip4, LED_COUNT4, 0xff, 0xff, 0xff, 0);
  }

  if (currentMillis - startMillis >= 40000)
  {
    //Sparkle(leds_strip4, LED_COUNT4, 0xff, 0xff, 0xff, 0);
  }
}

 


BeantwoordenCiteren


 Hans
(@hans)
Noble Member Admin
Deelgenomen: 8 jaar geleden
Berichten: 1890
 

Dat ziet er goed uit! Ook dank voor het posten van de code.

N.b.: Die truc die we bij Sparkle hebben toegepast, kan ook voor Fire en redWhiteBlue2 gebruikt worden natuurlijk 😉  
Ook ProgrammaA, ProgrammaB en ProgrammaC kunnen zo in een enkele functie gegoten worden.
Maar je gaf zelf al aan dat je nog wat wilde fine-tunen 😉 

 

Geplaatst door: @djdeeno

koffie al op?

😊  Natuurlijk! 😁 

 Wat de kleuren mismatch betreft: Een aantal strips zijn RGB gecodeerd, terwijl er ook strips zijn die GRB gecodeerd zijn. Dus Blauw en Groen verwisselt.

Je kunt dit in de FastLED.addLeds opgeven voor strip nummer 4, b.v.

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

BeantwoordenCiteren
(@djdeeno)
Eminent Member
Deelgenomen: 2 maanden geleden
Berichten: 21
Topic starter  

Hoi Hans, 

Dank je wel voor de update, echter krijg ik een foutmelding als ik de , GRB er aan toe voeg, deze melding luid: no matching function for call to 'CFastLED::addLeds(CRGB [31], int)'

 

Gekke is ook als ik de Brightness per strip wil aanpassen, activeer ik deze regel: leds_strip4.setBrightness(25);

Dan komt hij met de melding: request for member 'setBrightness' in 'leds_strip4', which is of non-class type 'CRGB [31]'

Werkt overigens wel als ik de "standaard" FastLED.setBrightness(25); toe pas maar dan geld het meteen voor alle strips.

 

ik zal de koffiepot ff aanslingeren..


BeantwoordenCiteren
 Hans
(@hans)
Noble Member Admin
Deelgenomen: 8 jaar geleden
Berichten: 1890
 

Kun je misschien jouw huidige sketch posten?
Dat maakt het doorlopen net even iets handiger voor mij ... 😊 


BeantwoordenCiteren
(@djdeeno)
Eminent Member
Deelgenomen: 2 maanden geleden
Berichten: 21
Topic starter  

Natuurlijk, sketch is in principe nog hetzelfde, zijn vele kleine testjes wat ik doe en zoek naar effecten.

Je ziet bijvoorbeeld 2 x een runfire, dit is om de verticale strippen op de diamant iets anders te laten gloeien ten op zichte van elkaar, anders zouden beide strippen exact hetzelfde doen, door ze apart te sturen krijgt het meer een vuur effect maar dat is even om te testen/spelen

 

de code tot nu toe

 

// gaat hier om type leonardo arduino

#include "FastLED.h"

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

// #define COLOR_ORDER BGR

#define PIN_STRIP1 6 //dit is strip 1 op de diamant
#define PIN_STRIP2 7 //dit is strip 2 op de diamant
#define PIN_STRIP3 8 //dit zijn de leds onder de kop
#define PIN_STRIP4 9 //dit zijn de leds op de kop

#define LED_COUNT1 26 //aantal leds op de diamant in strip 1
#define LED_COUNT2 26 //aantal leds op de diamant in strip 2
#define LED_COUNT3 10 //aantal leds onder de kop
#define LED_COUNT4 31 //aantal leds op de kop

#define LED_TYPE     NEOPIXEL
#define NUM_LEDS    28

CRGBPalette16 firePalette = HeatColors_p;

CRGB leds_strip1[LED_COUNT1];
CRGB leds_strip2[LED_COUNT2];
CRGB leds_strip3[LED_COUNT3];
CRGB leds_strip4[LED_COUNT4];

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

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

  FastLED.setBrightness(50);
  //   leds_strip1.setBrightness(25);
  //   leds_strip2.setBrightness(25);
  //   leds_strip3.setBrightness(25);
  //   leds_strip4.setBrightness(25);
}


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

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

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



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




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

    fill_solid( leds_strip3, LED_COUNT3, CRGB(0, 255, 0)); //Let op NEO_GRB
    unsigned long currentMillis = millis();
    if (currentMillis - previousMillis >= interval) {
      previousMillis = currentMillis;
      if (ledState4 == LOW) {
        ledState4 = HIGH;
      } else {
        ledState4 = LOW;
      }
      digitalWrite(ledPin4, ledState4);
    }
    if (ledState4 == LOW) {
      digitalWrite (ledPin5, HIGH);
    } else {
      digitalWrite (ledPin5, LOW);
    }
  }


  if ( currentMillis - startMillis > 20000 && currentMillis - startMillis < 30000)
  {
    //    fill_solid( leds_strip3, LED_COUNT3, CRGB(0, 0, 255)); //Let op NEO_GRB
    redWhiteBlue1();
    redWhiteBlue2();
    FastLED.show();

    unsigned long currentMillis = millis();
    if (currentMillis - previousMillis >= 500) {
      previousMillis = currentMillis;
      if (ledState4 == LOW) {
        ledState4 = HIGH;
        fill_solid( leds_strip3, LED_COUNT3, CRGB(0, 255, 0)); //Let op NEO_GRB
      } else {
        ledState4 = LOW;
        fill_solid( leds_strip3, LED_COUNT3, CRGB(0, 0, 255)); //Let op NEO_GRB
      }
      digitalWrite(ledPin4, ledState4);
    }
    if (ledState4 == LOW) {
      digitalWrite (ledPin5, HIGH);
      fill_solid( leds_strip3, LED_COUNT3, CRGB(0, 255, 0)); //Let op NEO_GRB
      fill_solid( leds_strip4, LED_COUNT4, CRGB(0, 0, 255)); //Let op NEO_GRB
    } else {
      digitalWrite (ledPin5, LOW);
      fill_solid( leds_strip3, LED_COUNT3, CRGB(0, 0, 255)); //Let op NEO_GRB
      fill_solid( leds_strip4, LED_COUNT4, CRGB(0, 255, 0)); //Let op NEO_GRB
    }
  }

  if ( currentMillis - startMillis > 30000 && currentMillis - startMillis < 32000)
  {
    fill_solid( leds_strip1, LED_COUNT1, CRGB(255, 0, 0)); //Let op NEO_GRB
    fill_solid( leds_strip2, LED_COUNT2, CRGB(255, 0, 0)); //Let op NEO_GRB
    fill_solid( leds_strip3, LED_COUNT3, CRGB(0, 255, 0)); //Let op NEO_GRB
    fill_solid( leds_strip4, LED_COUNT4, CRGB(0, 255, 0)); //Let op NEO_GRB
    FastLED.show();
  }
  if ( currentMillis - startMillis > 32000 && currentMillis - startMillis < 34000)
  {
    fill_solid( leds_strip1, LED_COUNT1, CRGB(0, 0, 255)); //Let op NEO_GRB
    fill_solid( leds_strip2, LED_COUNT2, CRGB(0, 0, 255)); //Let op NEO_GRB
    fill_solid( leds_strip3, LED_COUNT3, CRGB(0, 0, 255)); //Let op NEO_GRB
    fill_solid( leds_strip4, LED_COUNT4, CRGB(0, 0, 255)); //Let op NEO_GRB
    FastLED.show();
  }
  if ( currentMillis - startMillis > 34000 && currentMillis - startMillis < 36000)
  {
    fill_solid( leds_strip1, LED_COUNT1, CRGB(0, 255, 0)); //Let op NEO_GRB
    fill_solid( leds_strip2, LED_COUNT2, CRGB(0, 255, 0)); //Let op NEO_GRB
    fill_solid( leds_strip3, LED_COUNT3, CRGB(255, 0, 0)); //Let op NEO_GRB
    fill_solid( leds_strip4, LED_COUNT4, CRGB(255, 0, 0)); //Let op NEO_GRB
    FastLED.show();
  }
  if ( currentMillis - startMillis > 36000 && currentMillis - startMillis < 50000)
  {
    fill_solid( leds_strip1, LED_COUNT1, CRGB(0, 0, 255)); //Let op NEO_GRB
    fill_solid( leds_strip2, LED_COUNT2, CRGB(0, 0, 255)); //Let op NEO_GRB
    fill_solid( leds_strip3, LED_COUNT3, CRGB(255, 255, 255)); //Let op NEO_GRB
    fill_solid( leds_strip4, LED_COUNT4, CRGB(0, 255, 0)); //Let op NEO_GRB
    FastLED.show();
  }
}

BeantwoordenCiteren
 Hans
(@hans)
Noble Member Admin
Deelgenomen: 8 jaar geleden
Berichten: 1890
 

De code compiled zonder foutmeldingen op mijn Arduino. 🤔

Misschien dat je een verouderde FastLED library hebt? (Tools -> Manage Library -> zoek FastLED en kijk of er een update is)
Ik heb versie 3.4.0 geïnstalleerd staan.

Mocht dit allemaal OK zijn, kun je dan misschien de foutmelding hier plakken?

 

Tip: tip om de "pragma" melding van FastLED te muten:
Net voor de #include FastLED regel, deze regel toevoegen:

#define FASTLED_INTERNAL // just used to mute the Pragma messages when compiling

 

 


BeantwoordenCiteren


Pagina 1 / 3

Bevalt je wat je hier ziet, en wil je graag helpen? 

Uiteraard is de beste manier van helpen, door anderen hier te helpen met hun vragen. Maar je kunt ons ook op andere manieren helpen:

- Shop bijvoorbeeld bij Amazon, het kost je niks extra, maar het kan zijn dat wij een kleine commissie ontvangen,
- stuur me een koffie via PayPal ($5, $10, $20, or zelf kiezen),
- je kunt ook een Patreon worden,
- of BitCoin (BTC), of BitCoinCash (BCH) doneren.

Deel: