[aide] Neopixel

Salut tous le monde!

Je suis encore débutant et j'ai beaucoup de mal à gérer une variable (j'ai pas encore la logique ^^)

Je joue pas mal avec des leds néopixels en ce moment et la je voulais faire des leds allumé fixe et des leds randoms en fading pour faire un effet de fluctuation d'énergie.
Le truc , et ça me parait logique, c'est que je fais varier le setBrightness, et forcément en faisant ça je fais tous varier.
En isolant mes leds autrement dans le programme, dans le loop ou même dans le setup, les leds ne restent pas allumé en fixe, le programme de fading "écrase" la commande que j'essaye d'imposer.

Je vous montre une esquisse de ce que j'essaye de faire.

// Appel de la librairie Adafruit NeoPixel
#include <Adafruit_NeoPixel.h>

//Initialisation de la bande led utilisée avec son nombre et la sortie.
Adafruit_NeoPixel ArcReactorMk50(12, 9, NEO_GRB + NEO_KHZ800);

uint32_t cyan = ArcReactorMk50.Color(0,255,255);

void setup() {

  ArcReactorMk50.begin();
  ArcReactorMk50.show();
}

void loop() {
  
  // ici les leds que je voudrai garder fixent durant tous le programme.
  ArcReactorMk50.setPixelColor(11,cyan);
  ArcReactorMk50.setPixelColor(10,cyan);
  ArcReactorMk50.setPixelColor(9,cyan); 
  show();


  // une boucle de fading que voudrai rendre random avec 3 leds en même temps par la suite.
  for (int fadeValue3 = 0 ; fadeValue3 <= 255; fadeValue3 += 5) {
    ArcReactorMk50.setPixelColor(3,cyan);
    ArcReactorMk50.show();
    ArcReactorMk50.setBrightness(fadeValue3);
    delay(30);
  }
  for (int fadeValue3 = 255 ; fadeValue3 >= 0; fadeValue3 -= 5) {

    ArcReactorMk50.setPixelColor(3,cyan);
    ArcReactorMk50.show();
    ArcReactorMk50.setBrightness(fadeValue3); 
    delay(30);
  }
}

Je pense que je devrai utiliser des variables, mais je ne sais pas comment m'y prendre, ça ne me saute pas encore aux yeux.

Merci pour votre aide.

Cette fonction gère la luminosité de manière globale.
Pour gérer la luminosité d'une LED, il faut le faire avec setPixelColor()

ArcReactorMk50.setPixelColor(i, ArcReactorMk50.Color(R, G , B));

Par exemple, pour CYAN tu as défini R=0, G=255, B=255
Si tu veux faire pulser une LED en conservant la couleur CYAN, il faut maintenir l'égalité R = G et faire varier la valeur que tu affectes à ces 2 variables.

Merci beaucoup fdufnews!!
En fait j'aurai du y penser, c'est tellement évidement maintenant que tu le soulignes ^^.

La j'essaye de varier le programme avec millis (ça me permet d'apprendre à l'utiliser déjà)
Et par la suite se sera une meilleur habitude que delay je pense.

la j'ai réussi la première variation du fading mais la deuxième ne s'exécute pas, je pense que je dois mettre une condition avec une valeur booléenne pour valider la première partie et passer à la suivante..
Je vais plancher sur le sujet.

// Appel de la librairie Adafruit NeoPixel
#include <Adafruit_NeoPixel.h>

//Initialisation de la bande led utilisée avec son nombre et la sortie.
Adafruit_NeoPixel ArcReactorMk50(12, 9, NEO_GRB + NEO_KHZ800);

uint32_t cyan = ArcReactorMk50.Color(0,255,255);

int fluctuation = 0; //j'initialise le tableau qui contiendra les leds, elles seront appelé pour executer leurs propres effets.

// ici je vais tenter de travailler sans le delay, le but serai d'enchainer les effets des leds qui seront sur une base de temps aléatoires pour tenter l'effet de fluctuationd d'énergie.
unsigned long ChronoTemp = 0;
unsigned long tempAttente = 5000;

void setup() {

  ArcReactorMk50.begin();
  ArcReactorMk50.show();
  ChronoTemp = millis();
}

void loop() {
  
  // ici les leds que je voudrai garder fixent durant tous le programme.
  ArcReactorMk50.setPixelColor(11,cyan);
  ArcReactorMk50.setPixelColor(10,cyan);
  ArcReactorMk50.setPixelColor(9,cyan); 
  ArcReactorMk50.show();

  if( millis()-ChronoTemp > tempAttente) {   
    for (int i0 = 0 ; i0 <= 255; i0 += 1) {
    ArcReactorMk50.setPixelColor(0,ArcReactorMk50.Color(0,i0,i0));
    ArcReactorMk50.show();  
    ChronoTemp = millis();
    }
    }
  
  if( millis()-ChronoTemp > tempAttente) { 
    for (int i0 = 255 ; i0 >= 0; i0 -= 1) {
    ArcReactorMk50.setPixelColor(0,ArcReactorMk50.Color(0,i0,i0));
    ArcReactorMk50.show();   
    ChronoTemp = millis();
  }
  }
  }

J'ai testé ça comme et visiblement ça ne fonctionne pas ^^.

// Appel de la librairie Adafruit NeoPixel
#include <Adafruit_NeoPixel.h>

//Initialisation de la bande led utilisée avec son nombre et la sortie.
Adafruit_NeoPixel ArcReactorMk50(12, 9, NEO_GRB + NEO_KHZ800);

uint32_t cyan = ArcReactorMk50.Color(0,255,255);

//Je fais des variables pour les conditions et l'employer en symbiose avec millis
bool condition0 = true;
int i0 = 0;


int fluctuation = 0; //j'initialise le tableau qui contiendra les leds, elles seront appelé pour executer leurs propres effets.

// ici je vais tenter de travailler sans le delay, le but serai d'enchainer les effets des leds qui seront sur une base de temps aléatoires pour tenter l'effet de fluctuationd d'énergie.
unsigned long ChronoTemp = 0;
unsigned long tempAttente = 5000;

void setup() {

  ArcReactorMk50.begin();
  ArcReactorMk50.show();
  ChronoTemp = millis();
}

void loop() {
  
  // ici les leds que je voudrai garder fixent durant tous le programme.
  ArcReactorMk50.setPixelColor(11,cyan);
  ArcReactorMk50.setPixelColor(10,cyan);
  ArcReactorMk50.setPixelColor(9,cyan); 
  ArcReactorMk50.show();

  if(condition0 = true){
  if( millis()-ChronoTemp > tempAttente) {   
    for (i0 = 0 ; i0 <= 255; i0 += 1) {
    ArcReactorMk50.setPixelColor(0,ArcReactorMk50.Color(0,i0,i0));
    ArcReactorMk50.show();  
    ChronoTemp = millis();
    if(i0=255){
      condition0 = false;
    }
    }
    }
    }
  if(condition0 = false){
  if( millis()-ChronoTemp > tempAttente) { 
    for (i0 = 255 ; i0 >= 0; i0 -= 1) {
    ArcReactorMk50.setPixelColor(0,ArcReactorMk50.Color(0,i0,i0));
    ArcReactorMk50.show();   
    ChronoTemp = millis();
    if(i0=0){
      condition0 = true;
    }
  }
  }
  }
  }

Ici une erreur

Je pense que tu voulais faire
if(condition0 == true){
Même chose dans le test suivant

Pense à faire un ctrl+t dans la fenêtre de l'IDE avant de copier ton code pour qu'il soit correctement indenté cela facilite la lecture.

Bonjour pheonix59540

Moi aussi, c'est un excellent jouet :wink:.

Le problème de ton fadeIn/out est que tu n'as pas de temps entre les paliers de ta boucle d'incrémentation/décrémentation, donc tu ne vois pas la progression.

			ArcReactorMk50.setPixelColor(0,ArcReactorMk50.Color(0,i0,i0));
			ArcReactorMk50.show();
			delay(10);

Cette méthode de fadeIn/fad est trop rigide puisque ne fonctionne qu'avec ta couleur cyan.
Pour faire un fadeIn/out avec n'importe quelle couleur il faut faire une fonction. Si tu le veux, je t'explique ça dans un prochain post.

#include <Adafruit_NeoPixel.h>

//Initialisation de la bande led utilisée avec son nombre et la sortie.
Adafruit_NeoPixel ArcReactorMk50(12, 9, NEO_GRB + NEO_KHZ800);

uint32_t cyan = ArcReactorMk50.Color(0,255,255);

//Je fais des variables pour les conditions et l'employer en symbiose avec millis
bool condition0 = true;
//int i0 = 0;


int fluctuation = 0; //j'initialise le tableau qui contiendra les leds, elles seront appelé pour executer leurs propres effets.

// ici je vais tenter de travailler sans le delay, le but serai d'enchainer les effets des leds qui seront sur une base de temps aléatoires pour tenter l'effet de fluctuationd d'énergie.
unsigned long ChronoTemp = 0;
unsigned long tempAttente = 5000;

void setup() {

	ArcReactorMk50.begin();
	ArcReactorMk50.show();
	ChronoTemp = millis();
}

void loop() {
	
	// ici les leds que je voudrai garder fixent durant tous le programme.
	ArcReactorMk50.setPixelColor(11,cyan);
	ArcReactorMk50.setPixelColor(10,cyan);
	ArcReactorMk50.setPixelColor(9,cyan);
	ArcReactorMk50.show();

	if( millis()-ChronoTemp > tempAttente && condition0) {
		for (int i0 = 0 ; i0 <= 255; i0 += 1) {
			ArcReactorMk50.setPixelColor(0,ArcReactorMk50.Color(0,i0,i0));
			ArcReactorMk50.show();
			delay(10);
		}
		condition0 = false;
		ChronoTemp = millis();
	}
	
	if( millis()-ChronoTemp > tempAttente && !condition0) {
		for (int i0 = 255 ; i0 >= 0; i0 -= 1) {
			ArcReactorMk50.setPixelColor(0,ArcReactorMk50.Color(0,i0,i0));
			ArcReactorMk50.show();
			delay(10);
		}
		condition0 = true;
		ChronoTemp = millis();
	}
}

Cordialement
jpbbricole

effectivement , ça fonctionne mieux.

Comme tu dis jpbbricole, je ne vois pas de progression , le temps d'attente correspond en fin de compte à un délais d'allumage donc bof, pas de progression. faut que je réfléchisse à ça.

De plus je n'arrive pas à faire la décrémentation (surement du fait que la première partie est mal interprété.

Pour la couleur Cyan, c'est absolument volontaire! c'est pour un réacteur arc dans iron man pour ceux qui connaisse, j'ai modélisé le coeur et la je m'attaque à la programmation , par la suite viendra le schéma élec avec batterie ect.

la j'en suis la:

// Appel de la librairie Adafruit NeoPixel
#include <Adafruit_NeoPixel.h>

//Initialisation de la bande led utilisée avec son nombre et la sortie.
Adafruit_NeoPixel ArcReactorMk50(12, 9, NEO_GRB + NEO_KHZ800);

uint32_t cyan = ArcReactorMk50.Color(0, 255, 255);

//Je fais des variables pour les conditions et l'employer en symbiose avec millis
bool condition0 = true;
int i0 = 0;


int fluctuation = 0; //j'initialise le tableau qui contiendra les leds, elles seront appelé pour executer leurs propres effets.

// ici je vais tenter de travailler sans le delay, le but serai d'enchainer les effets des leds qui seront sur une base de temps aléatoires pour tenter l'effet de fluctuationd d'énergie.
unsigned long ChronoTemp = 0;
unsigned long tempAttente = 1000;

void setup() {

  ArcReactorMk50.begin();
  ArcReactorMk50.show();
  ChronoTemp == millis();
}

void loop() {

  // ici les leds que je voudrai garder fixent durant tous le programme.
  ArcReactorMk50.setPixelColor(11, cyan);
  ArcReactorMk50.setPixelColor(10, cyan);
  ArcReactorMk50.setPixelColor(9, cyan);
  ArcReactorMk50.show();

  if (condition0 == true) {
    if ( millis() - ChronoTemp > tempAttente) {
      for (i0 = 0 ; i0 <= 255; i0 += 1) {
        ArcReactorMk50.setPixelColor(0, ArcReactorMk50.Color(0, i0, i0));
        ArcReactorMk50.show();
        ChronoTemp = millis();
        if (i0 == 255) {
          condition0 == false;
        }
      }
    }
  }
  if (condition0 == false) {
    if ( millis() - ChronoTemp > tempAttente) {
      for (i0 = 255 ; i0 >= 0; i0 -= 1) {
        ArcReactorMk50.setPixelColor(0, ArcReactorMk50.Color(0, i0, i0));
        ArcReactorMk50.show();
        ChronoTemp = millis();
        if (i0 == 0) {
          condition0 == true;
        }
      }
    }
  }
}

Essaie ça

// Appel de la librairie Adafruit NeoPixel
#include <Adafruit_NeoPixel.h>

//Initialisation de la bande led utilisée avec son nombre et la sortie.
Adafruit_NeoPixel ArcReactorMk50(12, 9, NEO_GRB + NEO_KHZ800);

uint32_t cyan = ArcReactorMk50.Color(0, 255, 255);

//Je fais des variables pour les conditions et l'employer en symbiose avec millis
int i0 = 0;
int debut = 0;
int fin = 255;
int increment = 1;

int fluctuation = 0;  //j'initialise le tableau qui contiendra les leds, elles seront appelé pour executer leurs propres effets.

// ici je vais tenter de travailler sans le delay, le but serai d'enchainer les effets des leds qui seront sur une base de temps aléatoires pour tenter l'effet de fluctuation d'énergie.
unsigned long ChronoTemp = 0;
unsigned long tempAttente = 20;

void setup() {

  ArcReactorMk50.begin();
  ArcReactorMk50.show();
  ChronoTemp == millis();
}

void loop() {

  // ici les leds que je voudrai garder fixent durant tous le programme.
  ArcReactorMk50.setPixelColor(11, cyan);
  ArcReactorMk50.setPixelColor(10, cyan);
  ArcReactorMk50.setPixelColor(9, cyan);
  ArcReactorMk50.show();

  // le variable tempAttente donne le rythme de la pulsation
  if (millis() - ChronoTemp > tempAttente) {
    ArcReactorMk50.setPixelColor(0, ArcReactorMk50.Color(0, i0, i0));
    ArcReactorMk50.show();
    ChronoTemp = millis();
    i0 += increment;
    if (i0 == fin) {        // on atteint une borne, on change les paramètres
      if (increment > 0) {  // si on incrémentait
        increment = -1;
        debut = 255;
        fin = 0;
      } else {              // si on décrémentait
        increment = 1;
        debut = 0;
        fin = 255;
      }
    }
  }
}

Au passage, si les lignes ci-dessous ne sont jamais modifiées, elles pourraient passer dans le setup()

  // ici les leds que je voudrai garder fixent durant tous le programme.
  ArcReactorMk50.setPixelColor(11, cyan);
  ArcReactorMk50.setPixelColor(10, cyan);
  ArcReactorMk50.setPixelColor(9, cyan);
  ArcReactorMk50.show();

Bonjour pheonix59540

Oui, le blême est ici
if (i0 == 255) {
condition0 == false;

    if (i0 == 0) {
      condition0 **==** true;

ça doit être
condition0 = false;
et
condition0 = true;

Cordialement
jpbbricole

Ne pas confondre == et =
= c'est pour une affectation
variable = 12345 // la valeur 12345 est stockée dans variable
== c'est pour un test
if(variable == 12345) // si variable contient la valeur 12345 alors la condition est vrai

Bonjour fdufnews

Oui, et dans ce cas

    if (i0 == 255) {
      condition0 **==** false;
    }

on est bien dans une affectation, donc

    if (i0 == 255) {
      condition0 **=** false;
    }

Cordialement
jpbbricole

Ma réponse s'adresse @pheonix59540

Excuses-moi, il n'y en avait pas l'indication :cry:.

Cordialement
jpbbricole

Merci pour l'explication = et == je vais le noter pour eviter les erreurs la .

fdufnews

merci pour le code, je vais l'étudier.
Ducoup la boucle for est pas du tout adapté dans ce cas alors.

Bonsoir pheonix59540

Bienvenue au club :wink:
Voilà une version, inspirée de la tienne, qui fonctionne.

// Appel de la librairie Adafruit NeoPixel
#include <Adafruit_NeoPixel.h>

//Initialisation de la bande led utilisée avec son nombre et la sortie.
Adafruit_NeoPixel ArcReactorMk50(12, 9, NEO_GRB + NEO_KHZ800);

uint32_t cyan = ArcReactorMk50.Color(0, 255, 255);

//Je fais des variables pour les conditions et l'employer en symbiose avec millis
bool condition0 = true;
int i0 = 0;


int fluctuation = 0; //j'initialise le tableau qui contiendra les leds, elles seront appelé pour executer leurs propres effets.

// ici je vais tenter de travailler sans le delay, le but serai d'enchainer les effets des leds qui seront sur une base de temps aléatoires pour tenter l'effet de fluctuationd d'énergie.
unsigned long ChronoTemp = millis();
unsigned long tempAttente = 1000;

void setup() {
	Serial.begin(115200);

	ArcReactorMk50.begin();
	ArcReactorMk50.show();
	ChronoTemp == millis();
}

void loop() {
	// ici les leds que je voudrai garder fixent durant tous le programme.
	ArcReactorMk50.setPixelColor(11, cyan);
	ArcReactorMk50.setPixelColor(10, cyan);
	ArcReactorMk50.setPixelColor(9, cyan);
	ArcReactorMk50.show();

	if ((condition0 == true) && (millis() - ChronoTemp > tempAttente)) {
		for (i0 = 0 ; i0 <= 255; i0 ++) {
			ArcReactorMk50.setPixelColor(0, ArcReactorMk50.Color(0, i0, i0));
			ArcReactorMk50.show();
			delay(5);
		}
		ChronoTemp = millis();
		condition0 = false;
	}

	if ((condition0 == false) && (millis() - ChronoTemp > tempAttente)) {
		for (i0 = 255 ; i0 > 0; i0 --) {
			ArcReactorMk50.setPixelColor(0, ArcReactorMk50.Color(0, i0, i0));
			ArcReactorMk50.show();
			delay(5);
		}
		ChronoTemp = millis();
		condition0 = true;
	}
}

Cordialement
jpbbricole

Merci les gars,

fdufnews J'ai bien compris le code ducoup et c'est bien plus simple écris comme ça.
J'éspère qu'avec le temps j'aurai plus la facilité de penser comme ça ^^.

jpbbricole merci pour l'alternative, mais la le but était de se passer de delay ducoup, j'éssaye d'apprendre à gérer le millis, plus je serai habitué avec, plus se sera facile pour les montages complexe.

Merci =)

Voila le programme final, une tuerie je vais poster une photo et j'espère une vidéo avec mon téléphone.

// Appel de la librairie Adafruit NeoPixel
#include <Adafruit_NeoPixel.h>

//Initialisation de la bande led utilisée avec son nombre et la sortie.
Adafruit_NeoPixel ArcReactorMk50(12, 9, NEO_GRB + NEO_KHZ800);

uint32_t cyan = ArcReactorMk50.Color(0, 255, 255);

//Groupe de variable pour la led L0
int i0 = 0;
int debut0 = 0;
int fin0 = 255;
int increment0 = 15;
unsigned long ChronoTemp0 = 0;
unsigned long tempAttente0 = 10;

//Groupe de variable pour la led i1
int i1 = 0;
int debut1 = 0;
int fin1 = 255;
int increment1 = 15;
unsigned long ChronoTemp1 = 0;
unsigned long tempAttente1 = 5;

//Groupe de variable pour la led i2
int i2 = 0;
int debut2 = 0;
int fin2 = 255;
int increment2 = 15;
unsigned long ChronoTemp2 = 0;
unsigned long tempAttente2 = 5;

//Groupe de variable pour la led i4
int i4 = 0;
int debut4 = 0;
int fin4 = 255;
int increment4 = 15;
unsigned long ChronoTemp4 = 0;
unsigned long tempAttente4 = 5;

//Groupe de variable pour la led i5
int i5 = 0;
int debut5 = 0;
int fin5 = 255;
int increment5 = 15;
unsigned long ChronoTemp5 = 0;
unsigned long tempAttente5 = 5;

//Groupe de variable pour la led i6
int i6 = 0;
int debut6 = 0;
int fin6 = 255;
int increment6 = 15;
unsigned long ChronoTemp6 = 0;
unsigned long tempAttente6 = 5;

//Groupe de variable pour la led i8
int i8 = 0;
int debut8 = 0;
int fin8 = 255;
int increment8 = 15;
unsigned long ChronoTemp8 = 0;
unsigned long tempAttente8 = 5;

//Groupe de variable pour la led i9
int i9 = 0;
int debut9 = 0;
int fin9 = 255;
int increment9 = 15;
unsigned long ChronoTemp9 = 0;
unsigned long tempAttente9 = 5;

//Groupe de variable pour la led i10
int i10 = 0;
int debut10 = 0;
int fin10 = 255;
int increment10 = 15;
unsigned long ChronoTemp10 = 0;
unsigned long tempAttente10 = 5;


void setup() {

  ArcReactorMk50.begin();
  ArcReactorMk50.show();
  ChronoTemp0 == millis();
  ChronoTemp1 == millis();
  ChronoTemp2 == millis();
  ChronoTemp4 == millis();
  ChronoTemp5 == millis();
  ChronoTemp6 == millis();
  ChronoTemp8 == millis();
  ChronoTemp9 == millis();
  ChronoTemp10 == millis();
  // ici les leds que je voudrai garder fixent durant tous le programme.
  ArcReactorMk50.setPixelColor(11, cyan);
  ArcReactorMk50.setPixelColor(7, cyan);
  ArcReactorMk50.setPixelColor(3, cyan);
  ArcReactorMk50.show();
}

void loop() {
  //Ajustement de la luminosité globale.
  ArcReactorMk50.setBrightness(100);

  //différents random pour faire un effet de fluctuation d'énergie.
  tempAttente0 = random(5, 50);
  tempAttente1 = random(10, 100);
  tempAttente2 = random(15, 200);
  tempAttente4 = random(6, 49);
  tempAttente5 = random(11, 99);
  tempAttente6 = random(16, 199);
  tempAttente8 = random(7, 48);
  tempAttente9 = random(12, 98);
  tempAttente10 = random(17, 198);

  //Lancement de la programmation de toutes les leds.
  Led0();
  Led1();
  Led2();
  Led4();
  Led5();
  Led6();
  Led8();
  Led9();
  Led10();
}

//_______________________________________________________________________________________________________

void Led0() {
  if (millis() - ChronoTemp0 > tempAttente0) {
    ArcReactorMk50.setPixelColor(0, ArcReactorMk50.Color(0, i0, i0));
    ArcReactorMk50.show();
    ChronoTemp0 = millis();
    i0 += increment0;
    if (i0 == fin0) {        // on atteint une borne, on change les paramètres
      if (increment0 > 0) {  // si on incrémentait
        increment0 = -15;
        debut0 = 255;
        fin0 = 0;
      } else {              // si on décrémentait
        increment0 = 15;
        debut0 = 0;
        fin0 = 255;
      }
    }
  }
}

//_______________________________________________________________________________________________________

void Led1() {
  if (millis() - ChronoTemp1 > tempAttente1) {
    ArcReactorMk50.setPixelColor(1, ArcReactorMk50.Color(0, i1, i1));
    ArcReactorMk50.show();
    ChronoTemp1 = millis();
    i1 += increment1;
    if (i1 == fin1) {        // on atteint une borne, on change les paramètres
      if (increment1 > 0) {  // si on incrémentait
        increment1 = -15;
        debut1 = 255;
        fin1 = 0;
      } else {              // si on décrémentait
        increment1 = 15;
        debut1 = 0;
        fin1 = 255;
      }
    }
  }
}

//_______________________________________________________________________________________________________

void Led2() {
  if (millis() - ChronoTemp2 > tempAttente2) {
    ArcReactorMk50.setPixelColor(2, ArcReactorMk50.Color(0, i2, i2));
    ArcReactorMk50.show();
    ChronoTemp2 = millis();
    i2 += increment2;
    if (i2 == fin2) {        // on atteint une borne, on change les paramètres
      if (increment2 > 0) {  // si on incrémentait
        increment2 = -15;
        debut2 = 255;
        fin2 = 0;
      } else {              // si on décrémentait
        increment2 = 15;
        debut2 = 0;
        fin2 = 255;
      }
    }
  }
}


//_______________________________________________________________________________________________________

void Led4() {
  if (millis() - ChronoTemp4 > tempAttente4) {
    ArcReactorMk50.setPixelColor(4, ArcReactorMk50.Color(0, i4, i4));
    ArcReactorMk50.show();
    ChronoTemp4 = millis();
    i4 += increment4;
    if (i4 == fin4) {        // on atteint une borne, on change les paramètres
      if (increment4 > 0) {  // si on incrémentait
        increment4 = -15;
        debut4 = 255;
        fin4 = 0;
      } else {              // si on décrémentait
        increment4 = 15;
        debut4 = 0;
        fin4 = 255;
      }
    }
  }
}

//_______________________________________________________________________________________________________

void Led5() {
  if (millis() - ChronoTemp5 > tempAttente5) {
    ArcReactorMk50.setPixelColor(5, ArcReactorMk50.Color(0, i5, i5));
    ArcReactorMk50.show();
    ChronoTemp5 = millis();
    i5 += increment5;
    if (i5 == fin5) {        // on atteint une borne, on change les paramètres
      if (increment5 > 0) {  // si on incrémentait
        increment5 = -15;
        debut5 = 255;
        fin5 = 0;
      } else {              // si on décrémentait
        increment5 = 15;
        debut5 = 0;
        fin5 = 255;
      }
    }
  }
}

//_______________________________________________________________________________________________________

void Led6() {
  if (millis() - ChronoTemp6 > tempAttente6) {
    ArcReactorMk50.setPixelColor(6, ArcReactorMk50.Color(0, i6, i6));
    ArcReactorMk50.show();
    ChronoTemp6 = millis();
    i6 += increment6;
    if (i6 == fin6) {        // on atteint une borne, on change les paramètres
      if (increment6 > 0) {  // si on incrémentait
        increment6 = -15;
        debut6 = 255;
        fin6 = 0;
      } else {              // si on décrémentait
        increment6 = 15;
        debut6 = 0;
        fin6 = 255;
      }
    }
  }
}

//_______________________________________________________________________________________________________

void Led8() {
  if (millis() - ChronoTemp8 > tempAttente8) {
    ArcReactorMk50.setPixelColor(8, ArcReactorMk50.Color(0, i8, i8));
    ArcReactorMk50.show();
    ChronoTemp8 = millis();
    i8 += increment8;
    if (i8 == fin8) {        // on atteint une borne, on change les paramètres
      if (increment8 > 0) {  // si on incrémentait
        increment8 = -15;
        debut8 = 255;
        fin8 = 0;
      } else {              // si on décrémentait
        increment8 = 15;
        debut8 = 0;
        fin8 = 255;
      }
    }
  }
}

//_______________________________________________________________________________________________________

void Led9() {
  if (millis() - ChronoTemp9 > tempAttente9) {
    ArcReactorMk50.setPixelColor(9, ArcReactorMk50.Color(0, i9, i9));
    ArcReactorMk50.show();
    ChronoTemp9 = millis();
    i9 += increment9;
    if (i9 == fin9) {        // on atteint une borne, on change les paramètres
      if (increment9 > 0) {  // si on incrémentait
        increment9 = -15;
        debut9 = 255;
        fin9 = 0;
      } else {              // si on décrémentait
        increment9 = 15;
        debut9 = 0;
        fin9 = 255;
      }
    }
  }
}

//_______________________________________________________________________________________________________

void Led10() {
  if (millis() - ChronoTemp10 > tempAttente10) {
    ArcReactorMk50.setPixelColor(10, ArcReactorMk50.Color(0, i10, i10));
    ArcReactorMk50.show();
    ChronoTemp10 = millis();
    i10 += increment10;
    if (i10 == fin10) {        // on atteint une borne, on change les paramètres
      if (increment10 > 0) {  // si on incrémentait
        increment10 = -15;
        debut10 = 255;
        fin10 = 0;
      } else {              // si on décrémentait
        increment10 = 15;
        debut10 = 0;
        fin10 = 255;
      }
    }
  }
}

Il faut que tu apprennes à te servir des tableaux, tu diminueras énormément la taille de ton code...

et aussi
https://www.locoduino.org/spip.php?article227

20220312_184949_1




Merci je vais aller voir ça!

dans l'initialisation , faire par exemple int i [0,1,2,3 ...]
C'est ça ?
Dans la suite du code c'est compliqué, à l'instant T chaque leds ne peut utiliser de variable commune enfin de compte.