Schleife für Neopixel

Hallo zusammen,

ich schreibe gerade an einem Sketch bei dem 2 Neopixel Strips laufen. Dabei soll neben der Änderung der Farben auch ein Flacker Effekt entstehen und der Wechsel der Farben soll mit einem Fade Effekt ablaufen.

Es müsste doch eine Möglichkeit geben den Flacker Effekt vorher zu schreiben ohne das ich ständig die Zeilen für die Farbe zusammen mit einer anderen Helligkeit aufschreibe..
Das würde ja jeden Speicher sprengen.

Außerdem kann ich bzgl. des Fade Effekts auch keinen Befehl für die Neopixel finden.

Lg Holger

(deleted)

Hallo Peter,

Wenn ich random benutze bekomme ich doch nur eine zufällige Helligkeit, oder?
Dann müsste ich das ganze aber dann trotzdem wiederholen.
Wenn ich die Farbe des jeweiligen Pixels angeben habe folgt ja bei bedarf
strip.setBrightness(); und dann strip.show();
und für die beiden Befehle müsste es doch eine Schleife geben die nach dem Nennen der Farbe zusammen mit einer Häufigkeit nennen kann.
So das er dann in der gewählten Farbe in einer Häufigkeit X flackert bevor er zur nächsten Farbe übergeht.

Momentan sieht der Sketch in etwa so aus:

const uint8_t PROGMEM gamma8[] = {
   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  1,  1,  1,
   1,  1,  1,  1,  1,  1,  1,  1,  1,  2,  2,  2,  2,  2,  2,  2,
   2,  3,  3,  3,  3,  3,  3,  3,  4,  4,  4,  4,  4,  5,  5,  5,
   5,  6,  6,  6,  6,  7,  7,  7,  7,  8,  8,  8,  9,  9,  9, 10,
  10, 10, 11, 11, 11, 12, 12, 13, 13, 13, 14, 14, 15, 15, 16, 16,
  17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22, 23, 24, 24, 25,
  25, 26, 27, 27, 28, 29, 29, 30, 31, 32, 32, 33, 34, 35, 35, 36,
  37, 38, 39, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 50,
  51, 52, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 66, 67, 68,
  69, 70, 72, 73, 74, 75, 77, 78, 79, 81, 82, 83, 85, 86, 87, 89,
  90, 92, 93, 95, 96, 98, 99,101,102,104,105,107,109,110,112,114,
 115,117,119,120,122,124,126,127,129,131,133,135,137,138,140,142,
 144,146,148,150,152,154,156,158,160,162,164,167,169,171,173,175,
 177,180,182,184,186,189,191,193,196,198,200,203,205,208,210,213,
 215,218,220,223,225,228,231,233,236,239,241,244,247,249,252,255 };

#include <Adafruit_NeoPixel.h>

Adafruit_NeoPixel strip_a = Adafruit_NeoPixel(4, 10, NEO_GRB + NEO_KHZ800);
Adafruit_NeoPixel strip_b = Adafruit_NeoPixel(3, 9, NEO_RGB + NEO_KHZ800);



int led = 2;
int led1 = 3;
int led2 = 4;
int led3 = 5;
int led4 = 6;
int led5 = 7;


void setup() {                
 
 pinMode(led, OUTPUT);
 pinMode(led1, OUTPUT);
 pinMode(led2, OUTPUT);
 pinMode(led3, OUTPUT);
 pinMode(led4, OUTPUT);
 pinMode(led5, OUTPUT); 

 strip_a.begin();
 strip_b.begin();
 strip_a.show(); 
 strip_b.show();
   }

void loop() {
 digitalWrite(led, HIGH);   
 delay(5000); 
 digitalWrite(led1, HIGH);
 delay(5000); 
 digitalWrite(led2, HIGH);
 delay(5000); 
 digitalWrite(led3, HIGH);
 delay(5000);
 digitalWrite(led4, HIGH);
 delay(5000);
 digitalWrite(led5, HIGH);
 delay(5000);
 
 strip_a.setPixelColor(0,
   pgm_read_byte(&gamma8[38]),
   pgm_read_byte(&gamma8[198]),
   pgm_read_byte(&gamma8[218]));//Türkis
 strip_a.setPixelColor(1,
   pgm_read_byte(&gamma8[38]),
   pgm_read_byte(&gamma8[198]),
   pgm_read_byte(&gamma8[218]));//Türkis 
 strip_a.setPixelColor(2,
   pgm_read_byte(&gamma8[38]),
   pgm_read_byte(&gamma8[198]),
   pgm_read_byte(&gamma8[218]));//Türkis
 strip_a.setPixelColor(3,
   pgm_read_byte(&gamma8[38]),
   pgm_read_byte(&gamma8[198]),
   pgm_read_byte(&gamma8[218]));//Türkis    
 strip_b.setPixelColor(0,
   pgm_read_byte(&gamma8[213]),
   pgm_read_byte(&gamma8[0]),
   pgm_read_byte(&gamma8[0]));//Rot
 strip_b.setPixelColor(1,
   pgm_read_byte(&gamma8[213]),
   pgm_read_byte(&gamma8[0]),
   pgm_read_byte(&gamma8[0]));//Rot
 strip_b.setPixelColor(2,
   pgm_read_byte(&gamma8[213]),
   pgm_read_byte(&gamma8[0]),
   pgm_read_byte(&gamma8[0]));//Rot
 strip_a.setBrightness(64);
 strip_b.setBrightness(255);
 strip_a.show();
 strip_b.show();
delay(500);
strip_a.setPixelColor(0,
   pgm_read_byte(&gamma8[38]),
   pgm_read_byte(&gamma8[198]),
   pgm_read_byte(&gamma8[218]));//Türkis
 strip_a.setPixelColor(1,
   pgm_read_byte(&gamma8[38]),
   pgm_read_byte(&gamma8[198]),
   pgm_read_byte(&gamma8[218]));//Türkis 
 strip_a.setPixelColor(2,
   pgm_read_byte(&gamma8[38]),
   pgm_read_byte(&gamma8[198]),
   pgm_read_byte(&gamma8[218]));//Türkis
 strip_a.setPixelColor(3,
   pgm_read_byte(&gamma8[38]),
   pgm_read_byte(&gamma8[198]),
   pgm_read_byte(&gamma8[218]));//Türkis    
 strip_b.setPixelColor(0,
   pgm_read_byte(&gamma8[213]),
   pgm_read_byte(&gamma8[0]),
   pgm_read_byte(&gamma8[0]));//Rot
 strip_b.setPixelColor(1,
   pgm_read_byte(&gamma8[213]),
   pgm_read_byte(&gamma8[0]),
   pgm_read_byte(&gamma8[0]));//Rot
 strip_b.setPixelColor(2,
   pgm_read_byte(&gamma8[213]),
   pgm_read_byte(&gamma8[0]),
   pgm_read_byte(&gamma8[0]));//Rot
 strip_a.setBrightness(200);
 strip_b.setBrightness(55);
 strip_a.show();
 strip_b.show();
delay(500);

  digitalWrite(led, LOW);    
  digitalWrite(led1, LOW);
  digitalWrite(led2, LOW);
  digitalWrite(led3, LOW);
  digitalWrite(led4, LOW);
  digitalWrite(led5, LOW);
 }

Und jetzt müsste ich das ganze für die Farbe unzählige male mit jeweils anderer Helligkeit wiederholen. Da brauch ich aber ja ne externe Platte als zusätlichen Speicher um den Code unterzubekommen xD

Setze Deinen Code bitte in Codetags (</>-Button oben links im Forumseditor oder [code] davor und [/code] dahinter ohne *).
Dann ist er auch auf mobilen Geräten besser lesbar.
Das kannst Du auch noch nachträglich ändern.

Auch wäre es besser, wenn der Sketch nicht einfach mittendrin abbricht.

Die Methode setBrightness betrifft immer den gesammten Sketch.

Gruß Tommy

Hallo Tommy,

danke für den Hinweis, ist geändert. Wie meinst du das den gesamten Sketch? Ich kann nach vor jedem show eine andere Helligkeit ausgeben.

Vielleicht hilft das Video das mir den Anstoß gegeben hat, um zu verstehen wo ich hin will. Und zwar geht es dabei um die Sequenz ab 0:23
Lichtsequenz

Ok. Du willst also den Strip mit einer Farbe einfärben und dann die Helligkeit ändern.
Hier als Prinzipstudie (ungetestet):

byte hell = 100;
// Farbe setzen
// z.B. im Setup
pixels.fill(...)
pixels.setBrightness(hell);

void loop() {
  int zu = random(0,21) -10; // Zufall zwischen -10 und +10
  hell +=zu;                         // Helligket berechnen
  pixels.setBrightness(hell);   // verändern
  delay(100);
}

Gruß Tommy

Ja, ich denke das geht so ziemlich in die Richtung die ich haben möchte.
Auf die erste Farbe folgen natürlich noch andere.

Wenn ich bei byte jetzt noch andere Werte eintrage wählt der sich doch einen aus und setzt jetzt noch die Zufälligkeit dazu oder?
Kann ich das ganze dann nicht statt loop sagen wir flackern nennen und dann als Befehl nach der Farbe nennen?

const uint8_t PROGMEM gamma8[] = {
    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  1,  1,  1,
    1,  1,  1,  1,  1,  1,  1,  1,  1,  2,  2,  2,  2,  2,  2,  2,
    2,  3,  3,  3,  3,  3,  3,  3,  4,  4,  4,  4,  4,  5,  5,  5,
    5,  6,  6,  6,  6,  7,  7,  7,  7,  8,  8,  8,  9,  9,  9, 10,
   10, 10, 11, 11, 11, 12, 12, 13, 13, 13, 14, 14, 15, 15, 16, 16,
   17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22, 23, 24, 24, 25,
   25, 26, 27, 27, 28, 29, 29, 30, 31, 32, 32, 33, 34, 35, 35, 36,
   37, 38, 39, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 50,
   51, 52, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 66, 67, 68,
   69, 70, 72, 73, 74, 75, 77, 78, 79, 81, 82, 83, 85, 86, 87, 89,
   90, 92, 93, 95, 96, 98, 99,101,102,104,105,107,109,110,112,114,
  115,117,119,120,122,124,126,127,129,131,133,135,137,138,140,142,
  144,146,148,150,152,154,156,158,160,162,164,167,169,171,173,175,
  177,180,182,184,186,189,191,193,196,198,200,203,205,208,210,213,
  215,218,220,223,225,228,231,233,236,239,241,244,247,249,252,255 };

#include <Adafruit_NeoPixel.h>

Adafruit_NeoPixel strip_a = Adafruit_NeoPixel(4, 10, NEO_GRB + NEO_KHZ800);
Adafruit_NeoPixel strip_b = Adafruit_NeoPixel(3, 9, NEO_RGB + NEO_KHZ800);

byte hell = {180, 30, 89, 23, 255, 200, 90, 150, 60, 230, 180, 45, 90};


void Flackern1() {
  int zu = random(0,21) -10; // Zufall zwischen -10 und +10
  hell +=zu;                         // Helligket berechnen
  strip_a.setBrightness(hell);   // verändern
  strip_a.show();
  delay(100);
}

void Flackern2() {
  int zu = random(0,21) -10; // Zufall zwischen -10 und +10
  hell +=zu;                         // Helligket berechnen
  strip_b.setBrightness(hell);   // verändern
  strip_b.show();
  delay(100);
}

int led = 2;
int led1 = 3;
int led2 = 4;
int led3 = 5;
int led4 = 6;
int led5 = 7;
 

void setup() {                
  
  pinMode(led, OUTPUT);
  pinMode(led1, OUTPUT);
  pinMode(led2, OUTPUT);
  pinMode(led3, OUTPUT);
  pinMode(led4, OUTPUT);
  pinMode(led5, OUTPUT); 

  strip_a.setBrightness(hell);
  strip_b.setBrightness(hell);

  strip_a.begin();
  strip_b.begin();
  strip_a.show(); 
  strip_b.show();
    }

void loop() {
  digitalWrite(led, HIGH);   
  delay(5000); 
  digitalWrite(led1, HIGH);
  delay(5000); 
  digitalWrite(led2, HIGH);
  delay(5000); 
  digitalWrite(led3, HIGH);
  delay(5000);
  digitalWrite(led4, HIGH);
  delay(5000);
  digitalWrite(led5, HIGH);
  delay(5000);
  
  strip_a.setPixelColor(0,
    pgm_read_byte(&gamma8[38]),
    pgm_read_byte(&gamma8[198]),
    pgm_read_byte(&gamma8[218]));//Türkis
  strip_a.setPixelColor(1,
    pgm_read_byte(&gamma8[38]),
    pgm_read_byte(&gamma8[198]),
    pgm_read_byte(&gamma8[218]));//Türkis 
  strip_a.setPixelColor(2,
    pgm_read_byte(&gamma8[38]),
    pgm_read_byte(&gamma8[198]),
    pgm_read_byte(&gamma8[218]));//Türkis
  strip_a.setPixelColor(3,
    pgm_read_byte(&gamma8[38]),
    pgm_read_byte(&gamma8[198]),
    pgm_read_byte(&gamma8[218]));//Türkis    
  strip_b.setPixelColor(0,
    pgm_read_byte(&gamma8[213]),
    pgm_read_byte(&gamma8[0]),
    pgm_read_byte(&gamma8[0]));//Rot
  strip_b.setPixelColor(1,
    pgm_read_byte(&gamma8[213]),
    pgm_read_byte(&gamma8[0]),
    pgm_read_byte(&gamma8[0]));//Rot
  strip_b.setPixelColor(2,
    pgm_read_byte(&gamma8[213]),
    pgm_read_byte(&gamma8[0]),
    pgm_read_byte(&gamma8[0]));//Rot
Flackern1(110);
Flackern2(35);
  
  strip_a.setPixelColor(0,
    pgm_read_byte(&gamma8[33]),
    pgm_read_byte(&gamma8[150]),
    pgm_read_byte(&gamma8[243]));//Hell Blau
  strip_a.setPixelColor(1,
    pgm_read_byte(&gamma8[33]),
    pgm_read_byte(&gamma8[150]),
    pgm_read_byte(&gamma8[243]));//Hell Blau  
  strip_a.setPixelColor(2,
    pgm_read_byte(&gamma8[33]),
    pgm_read_byte(&gamma8[150]),
    pgm_read_byte(&gamma8[243]));//Hell Blau
  strip_a.setPixelColor(3,
    pgm_read_byte(&gamma8[33]),
    pgm_read_byte(&gamma8[150]),
    pgm_read_byte(&gamma8[243]));//Hell Blau   
  strip_b.setPixelColor(0,
    pgm_read_byte(&gamma8[198]),
    pgm_read_byte(&gamma8[44]),
    pgm_read_byte(&gamma8[58]));//Glutrot
  strip_b.setPixelColor(1,
    pgm_read_byte(&gamma8[198]),
    pgm_read_byte(&gamma8[44]),
    pgm_read_byte(&gamma8[58]));//Glutrot
  strip_b.setPixelColor(2,
    pgm_read_byte(&gamma8[198]),
    pgm_read_byte(&gamma8[44]),
    pgm_read_byte(&gamma8[58]));//Glutrot
  Flackern1(90);
  Flackern2(25);

  digitalWrite(led, LOW);    // turn the LED off by making the voltage LOW
  digitalWrite(led1, LOW);
  digitalWrite(led2, LOW);
  digitalWrite(led3, LOW);
  digitalWrite(led4, LOW);
  digitalWrite(led5, LOW);
 }

Wie Du das ganze aufbaust, ob Du nur brightness oder auch die Farbbestandteile zufällig auswählst oder mit einem Array aus Farben arbeitest ist völlig Dir und Deinen Kenntnissen überlassen.

Informiere Dich darüber, welche Methoden die Neopixel-Lib hat, wie man mit Arrays arbeitet und wie man Zeitsteuerungen ohne delay (Du willst ja 2 Stripes unabhängig steuern) mit millis() aufbaut.

Das, was Du willst ist kein C&P-Konstrukt, dazu musst Du einige Grundlagen lernen und alles stückweise (Teilaufgaben) aufbauen, testen, weiterbauen.

Gruß Tommy

Hallo,
warum willst Du die Daten denn ich einem Datendeld ablegen, das kannst Du doch berechnen, oder mit Schleifen laufen lassen und dabei den Farbwert ändern.
Zusätzlich baust Du ein Flackern "Blitzen" auf zufällige LED´s und gibst das auf die Streifen aus. Zeitlich steuerst Du alles mit millis() damt die delay() verschwinden, evetuell auch in zwei unterscheidlichen Zeitrastern.

Heinz

Rentner:
Zusätzlich baust Du ein Flackern "Blitzen" auf zufällige LED´s und gibst das auf die Streifen aus.

Zeige mal, wie Du das machen willst.

Gruß Tommy

Nein, die Farben will ich nicht zufällig auswählen die wähle ich selber aus. es geht mir nur um den Flacker Effeckt und das dieser nicht simultan bei beiden Strips abläuft.
Aus dem Grund habe ich aus dem was du geschrieben hast 2 Funktionen gemacht die ich dann am Ende der gewünschten Farbe anziehe.
Die Frage ist, ob dies so funktioniert…
Ich habe leider keine Ahnung wo ich die Info über die Neopixel Lib herbekomme. Adafruit lässt einen da auch ziemlich im dunkeln. Die sagen einem nur wie man sie einbindet. Und die Beispiele in der Software bringen einen auch nicht weiter.
Da Sache ist die, das wenn sie was erklären, es sich auf die Matrix und Ring Neopixel beziehen. Da ich aber bei einem Strip 3x 8mm Trough-Hole RGB´s und beim anderen 4x Neopixel Mini Buttons verwende ist das nicht einfach zu übertragen.

oothrawnoo:
Ich habe leider keine Ahnung wo ich die Info über die Neopixel Lib herbekomme. Adafruit lässt einen da auch ziemlich im dunkeln.

Wieso? Du hast doch den Quelltext in Deinem Lib-Verzeichnis liegen und der ist ziemlich gut kommentiert (z.B. Adafruit_NeoPixel.h). Lesen und verstehen musst Du selbst.

In Abwandlung eines bekannten Filmzitats: Use the source, Luke

Fange mit ein paar LED an, stelle die Farbe ein und lass sie flackern. Alles, was Du dazu brauchst, hast Du.
Wenn Du versuchst, alles auf einmal zu machen, gehst Du baden.

Gruß Tommy

Super, ich dank dir.
Wie gesagt die Farben sind nicht das Problem.
Wie ich bei einer normalen LED das Flackern auf die Reihe bekomme ist auch nicht das Problem.
Das kann ich im Grunde auch auf die Pixel übertragen. So schreibe ich aber für jedes Flackern eines Strips bis zu 52 Codezeilen.
Ich denke das kann man doch auch simpler lösen...

Wenn ich von den Videos ausgehe, haben alle LED eines Stripes die gleiche Farbe und flackern synchron.
Wenn Du was anderes willst, ist das eine aufwändige Steuerung.
Da schau Dir mal zur Lib FastLed die Beispiele Fire an.

Es sei denn, der Rentner kommt noch mit einem genialen Code zu seiner Aussage in #8 an.

Gruß Tommy

Haha ja das wäre vielleicht ne super Sache.

Nein innerhalb eines Strips können die alle gleich flackern. Damit nicht beide stripes gleich flackern müsste ich die flackern funktion ja nur kopieren, die einstellungen entsprechend anpassen Wenn man die Werte der Funktion über byte macht bekommt die Funktion für den 2. stripe einfach ein byte mit anderen Werten.
Soweit bin ich schon.
Es geht einzig darum die Flacker funktion für einen strip zu bekommen

Ich habe jetzt nen Sketch der keinen Fehler hat, aber die Pixel bleiben dunkel und ich ich verstehe nicht wieso.
Ich vermute das an int i=0 liegt aber was muss ich ändern das er das das byte benutzt und sich daraus eine der zahlen nimmt?

const uint8_t PROGMEM gamma8[] = {
    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  1,  1,  1,
    1,  1,  1,  1,  1,  1,  1,  1,  1,  2,  2,  2,  2,  2,  2,  2,
    2,  3,  3,  3,  3,  3,  3,  3,  4,  4,  4,  4,  4,  5,  5,  5,
    5,  6,  6,  6,  6,  7,  7,  7,  7,  8,  8,  8,  9,  9,  9, 10,
   10, 10, 11, 11, 11, 12, 12, 13, 13, 13, 14, 14, 15, 15, 16, 16,
   17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22, 23, 24, 24, 25,
   25, 26, 27, 27, 28, 29, 29, 30, 31, 32, 32, 33, 34, 35, 35, 36,
   37, 38, 39, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 50,
   51, 52, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 66, 67, 68,
   69, 70, 72, 73, 74, 75, 77, 78, 79, 81, 82, 83, 85, 86, 87, 89,
   90, 92, 93, 95, 96, 98, 99,101,102,104,105,107,109,110,112,114,
  115,117,119,120,122,124,126,127,129,131,133,135,137,138,140,142,
  144,146,148,150,152,154,156,158,160,162,164,167,169,171,173,175,
  177,180,182,184,186,189,191,193,196,198,200,203,205,208,210,213,
  215,218,220,223,225,228,231,233,236,239,241,244,247,249,252,255 };


#include <Adafruit_NeoPixel.h>

Adafruit_NeoPixel strip_a = Adafruit_NeoPixel(2, 9, NEO_GRB + NEO_KHZ800);
Adafruit_NeoPixel strip_b = Adafruit_NeoPixel(4, 10, NEO_GRB + NEO_KHZ800);


byte hell[] = {180, 30, 89, 23, 255, 200, 90, 150, 60, 230, 180, 45, 90};

int i = 0;

void Flackern1() {
  int zu = random(0,21) -10; // Zufall zwischen -10 und +10
  hell[i] +=zu;                         // Helligket berechnen
  strip_b.setBrightness(hell);   // verändern
  strip_b.show();
  delay(100);
  } 

void setup() {

  strip_b.begin();
  strip_b.show(); // Initialize all pixels to 'off'
  
}

// the loop routine runs over and over again forever:
void loop() {

  strip_b.setPixelColor(0,
    pgm_read_byte(&gamma8[213]),
    pgm_read_byte(&gamma8[0]),
    pgm_read_byte(&gamma8[0]));//Rot
  strip_b.setPixelColor(1,
    pgm_read_byte(&gamma8[213]),
    pgm_read_byte(&gamma8[0]),
    pgm_read_byte(&gamma8[0]));//Rot
  strip_b.setPixelColor(2,
    pgm_read_byte(&gamma8[213]),
    pgm_read_byte(&gamma8[0]),
    pgm_read_byte(&gamma8[0]));//Rot
  strip_b.setPixelColor(3,
    pgm_read_byte(&gamma8[213]),
    pgm_read_byte(&gamma8[0]),
    pgm_read_byte(&gamma8[0]));//Rot
 Flackern1;
  
 }
 Flackern1;

Das ist kein Funktionsaufruf. Aktiviere die Warnungen. Dann bekommst du auch mit dass an Stelle etwas nicht stimmt

Bist Du auf Adafruit_NeoPixel festgelegt oder ginge auch FastLED?
Hast Du die LEDs bereits erworben, bist Du auf NeoPixel (WS2812B) festgelegt?
Welchen Arduino verwendest Du?

Ok verstanden und was mache ich da genau falsch?
Sind es die fehlenden Klammern nach der 1? Aber es gibt in der Funktion aber auch noch den Fehler das er nicht das byte benutzt...

Also ich habe ein Nano mit einem Strip 3x 8mm Trough-Hole RGB´s und einem Strip 4x Neopixel Mini Buttons.
Fastled verarbeitet die 8mm nicht richtig. Die werden beim einbinden nicht als NEO_GRB definiert sondern als NEO_RGB und dann leuchten die bei FastLED nur in Blau.

Flackern1;    // Adresse der Funktion
Flackern1(); // Aufruf der Funktion

Woher kennt die Funktion i?
i ist immer 0

Gruß Tommy

ok alles klar und wenn ich die funktion mehrmals aufrufen möchten schreibe ich doch eine zahl in die Klammer, Flackern1(14) zb? Oder stehe ich gerade auf der Leitung?

Was ist denn in der Funktion zu ändern das sich die Funktion aus dem byte einen wert zieht?

byte hell[] = {180, 30, 89, 23, 255, 200, 90, 150, 60, 230, 180, 45, 90};

void Flackern1() {
  int zu = random(0,21) -10; // Zufall zwischen -10 und +10
  hell[i] +=zu;                         // Helligket berechnen
  strip_b.setBrightness(hell);   // verändern
  strip_b.show();
  delay(100);
  }