AnimationsLumineuses01_2023

// ATTENTION SOIGNER LE DECOUPLAGE SINON ALEAS POSSIBLES
  // By Claude DUFOURMONT YouTube
  #include <Adafruit_NeoPixel.h>
  #include <initializer_list>                   // Inclut la bibliothèque pour utiliser des listes d'initialisation

  // --------------------------------------------------------------------------------------------------------------------------------------------------------------
  // La bibliothèque <initializer_list> est utilisée pour travailler avec des listes d'initialisation en C++.
  // Une liste d'initialisation est une séquence de valeurs délimitée par des accolades {}.
  // Elle est souvent utilisée pour initialiser des conteneurs ou des structures de données.
  // Dans ce code, cette bibliothèque peut être utilisée pour initialiser des objets ou des variables avec une liste de valeurs spécifiques.
  // Elle est incluse au début du code pour que l'on puisse l'utiliser ultérieurement dans le programme
  // --------------------------------------------------------------------------------------------------------------------------------------------------------------

  #define BrocheNeopixel01 7
  #define BrocheNeopixel02 8
  #define BrocheBuzzer A6 // Broche du buzzer
  #define BrochePotarSelection A3

  #define NLed01 8                              // Nbre de Leds Barette
  #define NLed02 25                             // Nbre de Leds Matrice

  #define Luminosite01 20                       // Luminosité Barette (de 0 à 255)
  #define Luminosite02 6                        // Lumunosité Matrice (de 0 à 255)

  #define NCouleurs01 14                        // Nombre de couleurs (RGB) pour les cercles de l'Animation01

  Adafruit_NeoPixel Strip01(NLed01, BrocheNeopixel01, NEO_GRB + NEO_KHZ800);  // Création de l'objet Adafruit_NeoPixel 01 (Barette de 8 Leds)
  Adafruit_NeoPixel Strip02(NLed02, BrocheNeopixel02, NEO_GRB + NEO_KHZ800);  // Création de l'objet Adafruit_NeoPixel 02 (Matrice de 5X5 Leds)

  // ===============================Définition des couleurs en RGB ici (par exemple, Rouge, Vert, Bleu)============================================================
  int CouleurCercle[NCouleurs01][14] =
  {
  {200, 0, 0},   // Rouge
  {10, 0, 0},
  {0, 255, 0},   // Vert
  {0, 10, 0},
  {0, 0, 255},    // Bleu
  {0, 0, 10},
  {200, 200, 0},  // Jaune
  {10, 10, 0},
  {0, 0, 0},
  {200, 0, 200},
  {10, 0, 10},
  {0, 200, 200},
  {0, 10, 10},
  {180, 180, 180} // Blanc
  };
  // ==============================================================================================================================================================

  int ValeurAnalogiquePotar;                            // Valeur analogique en provenance du curseur du potentiomètre (de 0 à 1023 points)

  unsigned long Time00 = 500;                           // Temps d'enchainement Animation00 (ms)
  unsigned long Time01 = 60;                            // Temps d'enchainement Animation01(ms)

  unsigned long TempsPrecedentAnimation = 0;            // Dernier temps de début de l'animation (valable pour l'Animation00 et  l'Animation01)

  int animationStep = 0;                                // Première étape de l'Animation00 (10 étapes)

  // =============================================Définition de la position des Leds pour les 3 cercles============================================================
  int PetitCercle[] = {12}; // LED centrale
  int CercleMoyen[] = {6, 7, 8, 11, 13, 16, 17, 18};
  int GrandCercle[] = {0, 1, 2, 3, 4, 5, 9, 10, 14, 15, 19, 20, 21, 22, 23, 24};
  // ==============================================================================================================================================================

  int CercleActuel = 0;                                 // Indice du cercle actuel (0: petit, 1: moyen, 2: grand)
  int IndiceCouleur = 0;                                // Indice de la couleur actuelle (0: rouge, 1: vert, 2: bleu)

  int CouleursLed[NLed02][3];                           // Tableau pour stocker les couleurs actuelles de chaque LED

  void setup()
  {
  // ===========================================Initialisation de la matrice 5X5 avec les couleurs éteintes==================================================
  for (int i = 0; i < NLed02; i++)
  {
  for (int j = 0; j < 3; j++)
  {
  CouleursLed[i][j] = 0;
  }
  }
  analogReadResolution(10);                           // Paramètrage du Seeeduino XIAO en résolution 10 bits en lecture (0 à 1023 points)
  pinMode(BrocheNeopixel01, OUTPUT);
  pinMode(BrocheNeopixel02, OUTPUT);
  pinMode(BrocheBuzzer, OUTPUT);

  Strip01.begin();                                    // Initialisation de la barette Néopixel  de 8 Leds
  Strip01.setBrightness(Luminosite01);

  Strip02.begin();                                    // Initialisation de la matrice Néopixel  de 5X5 Leds
  Strip02.setBrightness(Luminosite02);

  buzz(50, 10, 6);                                    // Actionnement du Buzzer au démarrage (Haut à 50 ms puis Bas à 10 ms) X 6
  }

  void loop()
  {
  ValeurAnalogiquePotar = analogRead(BrochePotarSelection);  // Lecture en points de la tension sur le curseur du potentiomètre et affection et affectation à ValeurAnalogiquePotar
  static int ZonePrecedente = -1;                           // Variable pour stocker la zone précédente

  int ZoneActuelle = -1;                                    // Variable pour stocker la zone actuelle

  // ===============Selon la valeur lue, détermination de la zone dans laquelle nous sommes et quel figure afficher ou quelle Animation effectuer==================
  if (ValeurAnalogiquePotar < 128)
  {
  ZoneActuelle = 0;
  figure00();
  }
  else if (ValeurAnalogiquePotar < 256)
  {
  ZoneActuelle = 1;
  figure01();
  }
  else if (ValeurAnalogiquePotar < 384)
  {
  ZoneActuelle = 2;
  figure02();
  }
  else if (ValeurAnalogiquePotar < 512)
  {
  ZoneActuelle = 3;
  figure03();
  }
  else if (ValeurAnalogiquePotar < 640)
  {
  ZoneActuelle = 4;
  figure04();
  }
  else if (ValeurAnalogiquePotar < 768)
  {
  ZoneActuelle = 5;
  figure05();
  }
  else if (ValeurAnalogiquePotar < 896)
  {
  ZoneActuelle = 6;
  Animation00();
  }
  else
  {
  ZoneActuelle = 7;
  Animation01();
  }
  // ===============================================================================================================================================================

  // ============================================Emission d'un bip seulement en cas de changement de zone=====================================================
  if (ZoneActuelle != ZonePrecedente)
  {
  buzz(10, 2, 4);
  Strip01.clear();
  Strip01.setPixelColor(ZoneActuelle, 255, 255, 0);

  ZonePrecedente = ZoneActuelle;
  }
  Strip01.show();
  Strip02.show();
  }

  // =========================================================Fonctions pour les figures statiques==================================================================

  void figure00()
  {
  Strip02.clear();
  Strip02.setPixelColor(12, 255, 0, 0);
  }

  void figure01()
  {
  Strip02.clear();
  for (int i : {6, 7, 8, 11, 13, 16, 17, 18})
  {
  Strip02.setPixelColor(i, 0, 255, 0);
  }
  }

  void figure02()
  {
  Strip02.clear();
  for (int i : {0, 1, 2, 3, 4, 5, 9, 10, 14, 15, 19, 20, 21, 22, 23, 24})
  {
  Strip02.setPixelColor(i, 0, 0, 255);
  }
  }

  void figure03()
  {
  Strip02.clear();
  Strip02.setPixelColor(12, 0, 0, 255);
  }

  void figure04()
  {
  Strip02.clear();
  for (int i : {6, 7, 8, 11, 13, 16, 17, 18})
  {
  Strip02.setPixelColor(i, 255, 0, 0);
  }
  }

  void figure05()
  {
  Strip02.clear();
  for (int i : {0, 1, 2, 3, 4, 5, 9, 10, 14, 15, 19, 20, 21, 22, 23, 24})
  {
  Strip02.setPixelColor(i, 0, 255, 0);
  }
  }

  void figure06()
  {
  Strip02.clear();
  for (int i = 0; i < NLed02; i++)
  {
  Strip02.setPixelColor(i, 0, 0, 255);
  }
  }

  void figure07()
  {
  Strip02.clear();
  for (int i = 0; i < NLed02; i++)
  {
  Strip02.setPixelColor(i, 255, 255, 0);
  }
  }
  // ==============================================================================================================================================================


  // ===================================================Fonctions pour les Chiffres 0 à 9 =========================================================================
  void Chiffre00()
  {
  Strip02.clear();
  for (int i : {0, 1, 2, 7, 9, 10, 12, 17, 19, 20, 21, 22})
  //for (int i : {1, 2, 3, 6, 8, 11, 13, 16, 18, 21, 22, 23})
  {
  Strip02.setPixelColor(i, 190, 0, 0);
  //Strip02.setPixelColor(i, 0, 255, 0);
  //Strip02.setPixelColor(i, 0, 0, 255);
  }
  }

  void Chiffre01()
  {
  Strip02.clear();
  //for (int i : {2, 7, 12, 17 , 22})
  for (int i : {3, 6, 13, 16 , 23})
  {
  //Strip02.setPixelColor(i, 255, 0, 0);
  Strip02.setPixelColor(i, 0, 210, 0);
  //Strip02.setPixelColor(i, 0, 0, 255);
  }
  }

  void Chiffre02()
  {
  Strip02.clear();
  for (int i : {0, 1, 2, 7, 10, 11, 12, 19, 20, 21, 22})
  //for (int i : {1, 2, 3, 6, 11, 12, 13, 18, 21, 22, 23})
  {
  //Strip02.setPixelColor(i, 255, 0, 0);
  //Strip02.setPixelColor(i, 0, 255, 0);
  Strip02.setPixelColor(i, 0, 0, 255);
  }
  }

  void Chiffre03()
  {
  Strip02.clear();
  //for (int i : {0, 1, 2, 7, 10, 11, 12, 17, 20, 21, 22})
  for (int i : {1, 2, 3, 6, 11, 12, 13, 16, 21, 22, 23})
  {
  Strip02.setPixelColor(i, 190, 0, 0);
  //Strip02.setPixelColor(i, 0, 255, 0);
  //Strip02.setPixelColor(i, 0, 0, 255);
  }
  }

  void Chiffre04()
  {
  Strip02.clear();
  for (int i : {0, 7, 9, 10, 11, 12, 17, 22})
  //for (int i : {1, 6, 8, 11, 12, 13, 16, 23})
  {
  //Strip02.setPixelColor(i, 255, 0, 0);
  Strip02.setPixelColor(i, 0, 210, 0);
  //Strip02.setPixelColor(i, 0, 0, 255);
  }
  }

  void Chiffre05()
  {
  Strip02.clear();
  //for (int i : {0, 1, 2, 9, 10, 11, 12, 17, 20, 21, 22})
  for (int i : {1, 2, 3, 8, 11, 12, 13, 16, 21, 22, 23})
  {
  //Strip02.setPixelColor(i, 255, 0, 0);
  //Strip02.setPixelColor(i, 0, 255, 0);
  Strip02.setPixelColor(i, 0, 0, 255);
  }
  }

  void Chiffre06()
  {
  Strip02.clear();
  for (int i : {0, 1, 2, 9, 10, 11, 12, 17, 19, 20, 21, 22})
  //for (int i : {1, 2, 3, 8, 11, 12, 13, 16, 18, 21, 22, 23})
  {
  Strip02.setPixelColor(i, 190, 0, 0);
  //Strip02.setPixelColor(i, 0, 255, 0);
  //Strip02.setPixelColor(i, 0, 0, 255);
  }
  }

  void Chiffre07()
  {
  Strip02.clear();
  //for (int i : {0, 1, 2, 7, 12, 17 , 22})
  for (int i : {1, 2, 3, 6, 13, 16 , 23})
  {
  //Strip02.setPixelColor(i, 255, 0, 0);
  Strip02.setPixelColor(i, 0, 210, 0);
  //Strip02.setPixelColor(i, 0, 0, 255);
  }
  }

  void Chiffre08()
  {
  Strip02.clear();
  for (int i : {0, 1, 2, 7, 9, 10, 11, 12, 17, 19, 20, 21, 22})
  //for (int i : {1, 2, 3, 6, 8, 11, 12, 13, 16, 18, 21, 22, 23})
  {
  //Strip02.setPixelColor(i, 255, 0, 0);
  //Strip02.setPixelColor(i, 0, 255, 0);
  Strip02.setPixelColor(i, 0, 0, 255);
  }
  }

  void Chiffre09()
  {
  Strip02.clear();
  //for (int i : {0, 1, 2, 7, 9, 10, 11, 12, 17,20, 21, 22})
  for (int i : {1, 2, 3, 6, 8, 11, 12, 13, 16, 21, 22, 23})
  {
  //Strip02.setPixelColor(i, 255, 0, 0);
  //Strip02.setPixelColor(i, 0, 255, 0);
  //Strip02.setPixelColor(i, 0, 0, 255);
  Strip02.setPixelColor(i, 150, 150, 150);
  }
  }

  // =========================================================Fonctions pour les Animations===================================================================

  void Animation00()                                    // Animation de défilement de Chiffres

  // --------------------------------------------------------------------------------------------------------------------------------------------------------------
  // La fonction Animation00 gère une animation de défilement de chiffres.
  // Elle bascule entre différents chiffres (de 0 à 9) en fonction de la variable animationStep.
  // À chaque étape, elle appelle une fonction spécifique (par exemple, Chiffre00, Chiffre01, etc.) pour afficher le chiffre correspondant sur votre matrice de LED.
  // Le délai entre chaque chiffre est déterminé par la variable Time00. Lorsque l'animation est terminée, elle revient à zéro.
  // --------------------------------------------------------------------------------------------------------------------------------------------------------------

  {
  unsigned long TempsActuel = millis();
  if (TempsActuel - TempsPrecedentAnimation >= Time00)  // Changement de chiffre à chaque fois que le temps écoulé de la présentation du chiffre dépasse ou est égal à Time00
  {
  TempsPrecedentAnimation = TempsActuel;                // On réactualise le dernier temps de début de l 'Animation
  switch (animationStep)                                // On passe au Chiffre suivant
  {
  case 0:
  Chiffre00();
  break;
  case 1:
  Chiffre01();
  break;
  case 2:
  Chiffre02();
  break;
  case 3:
  Chiffre03();
  break;
  case 4:
  Chiffre04();
  break;
  case 5:
  Chiffre05();
  break;
  case 6:
  Chiffre06();
  break;
  case 7:
  Chiffre07();
  break;
  case 8:
  Chiffre08();
  break;
  case 9:
  Chiffre09();
  break;
  }

  animationStep = (animationStep + 1) % 10;           // On incrémente et si nous sommes à 10 c'est zéro
  Strip02.show();                                     // Affichage du Chiffre
  }
  }

  void Animation01()                                  // Animation de défilement de Figures

  // --------------------------------------------------------------------------------------------------------------------------------------------------------------
  // La fonction Animation01 gère une animation de défilement de formes géométriques sur la matrice 5X5 LEDs.
  // Elle alterne entre trois cercles différents (petit, moyen, grand) et applique une couleur spécifique à chaque LED dans le cercle en cours.
  // Les délais entre les changements de cercles sont déterminés par la variable Time01.
  // Elle utilise également une variable IndiceCouleur pour alterner entre différentes couleurs définies au préalable dans le tableau CouleurCercle.
  // --------------------------------------------------------------------------------------------------------------------------------------------------------------
  {
  unsigned long TempsActuel = millis();
  if (TempsActuel - TempsPrecedentAnimation >= Time01)
  {
  TempsPrecedentAnimation = TempsActuel;
  Strip02.clear();


  // .................................................Allumage du cercle actuel avec la couleur actuelle.............................................................
  int* LedsActuelles;                                     // Tableau des LEDs pour le cercle actuel
  int size;

  if (CercleActuel == 0)
  {
  LedsActuelles = PetitCercle;                            // Utilisation du tableau des LEDs pour le petit cercle
  size = sizeof(PetitCercle) / sizeof(PetitCercle[0]);    // Calcul de la taille du petit cercle
  }
  else if (CercleActuel == 1)
  {
  LedsActuelles = CercleMoyen;                            // Utilisation du tableau des LEDs pour le cercle moyen
  size = sizeof(CercleMoyen) / sizeof(CercleMoyen[0]);    // Calcul de la taille du cercle moyen
  }
  else
  {
  LedsActuelles = GrandCercle;                            // Utilisation du tableau des LEDs pour le grand cercle
  size = sizeof(GrandCercle) / sizeof(GrandCercle[0]);    // Calcul de la taille du grand cercle
  }

  for (int i = 0; i < size; i++)
  {
  int ledIndex = LedsActuelles[i];
  for (int j = 0; j < 3; j++)
  {
  CouleursLed[ledIndex][j] = CouleurCercle[IndiceCouleur][j];
  }
  }

  // .....................................................Application des couleurs actuelles à la matrice..........................................................
  for (int i = 0; i < NLed02; i++)
  {
  Strip02.setPixelColor(i, CouleursLed[i][0], CouleursLed[i][1], CouleursLed[i][2]);
  }
  Strip02.show();

  // ......................................................Passage au cercle suivant (petit, moyen, grand).........................................................
  CercleActuel = (CercleActuel + 1) % 3;                     // Passage au cercle suivant tout en restant inférieur ou égal à 2 ( 0 à 2 -->3)

  // .....................................................Passage à la couleur suivante (rouge, vert, bleu)........................................................
  if (CercleActuel == 0)
  {
  IndiceCouleur = (IndiceCouleur + 1) % NCouleurs01;
  }
  }
  }


  // ==================================================================Fonction Buzzer==============================================================================

  void buzz (int TempsHIGH, int TempsLOW, int NombreCycles)
  {
  for (int x = 1; x <= NombreCycles; x++)
  {
  digitalWrite(BrocheBuzzer, HIGH);
  delay (TempsHIGH);
  digitalWrite(BrocheBuzzer, LOW);
  delay (TempsLOW);
  }
  }