NEOPIXEL BEST PRATICES

/* Un programme de test de bande led NeoPixel.

// NEOPIXEL BEST PRATICES pour un fonctionnement plus fiable:
// - Ajoutez 1000 uF CAPACITOR entre les connexions + et - de la bande NeoPixel.
// - MINIMISER LA LONGUEUR DU CABLAGE entre la carte de microcontrôleur et le premier pixel.
// - L'entrée DATA-IN de la bande NeoPixel doit passer par un RESISTOR 300-500 OHM.
// - ÉVITER de connecter NeoPixels sur un circuit virtuel. Si vous devez, TOUJOURS
// connecte GROUND (-) en premier, puis +, puis data.
// - Lors de l'utilisation d'un microcontrôleur 3.3V avec une bande NeoPixel alimentée par 5V,
// Un CONVERTISSEUR DE NIVEAU LOGIQUE sur la ligne de données est FORTEMENT RECOMMANDÉ.
// (Ignorer ces informations peut fonctionner correctement sur votre workbench mais peut échouer sur le terrain)
*/

#include <Adafruit_NeoPixel.h>
#ifdef __AVR__
 #include <avr/power.h> // Requis pour le Trinket Adafruit 16 MHz
#endif

/*// Quelle broche sur l'Arduino est connectée au NeoPixels?
// Sur Trinket ou Gemma, nous suggérons de changer ceci en 1:*/
#define LED_PIN    6

/* Combien de NeoPixels sont attachés à l'Arduino? */
#define LED_COUNT 8

// Déclarez notre objet NeoPixel:

Adafruit_NeoPixel strip(LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800);
/*// Argument 1 = Nombre de pixels dans la bande NeoPixel
// Argument 2 = Numéro de broche Arduino (la plupart sont valides)
// Argument 3 = drapeaux de type pixel, additionnez-les si nécessaire:
// NEO_KHZ800 flux binaire 800 KHz (la plupart des produits NeoPixel avec LEDs WS2812)
// NEO_KHZ400 400 KHz (pixels FLORA classiques 'v1' (pas v2), pilotes WS2811)
// NEO_GRB Les pixels sont câblés pour le flux binaire GRB (la plupart des produits NeoPixel).
// NEO_RGB Les pixels sont câblés pour le flux binaire RVB (v1 pixels FLORA, pas v2)
// NEO_RGBW Les pixels sont câblés pour le bitstream RGBW (produits NeoPixel RGBW)
*/

// Fonction setup () - s'exécute une fois au démarrage --------------------------------

void setup() {
 /*// Ces lignes sont spécifiquement conçues pour prendre en charge l'Adafruit Trinket 5V 16 MHz.
   // N'importe quel autre tableau, vous pouvez enlever cette partie (mais aucun mal en la laissant):*/
#if defined(__AVR_ATtiny85__) && (F_CPU == 16000000)
  clock_prescale_set(clock_div_1);
#endif
  // FIN du code spécifique à Trinket.

  strip.begin();           // INITIALIZE NeoPixel Strip Object (OBLIGATOIRE)
  strip.show();            // Désactiver tous les pixels dès que possible
  strip.setBrightness(50); // Réglez LUMINOSITÉ sur environ 1/5 (max = 255)
}


// Fonction loop () - tourne plusieurs fois tant que le tableau est allumé ---------------

void loop() {
  /* Remplissez le long de la bande de différentes couleurs ...*/
  colorWipe(strip.Color(255,   0,   0), 50); // Red
  colorWipe(strip.Color(  0, 255,   0), 50); // Green
  colorWipe(strip.Color(  0,   0, 255), 50); // Blue

  /* Faites un effet de théâtre dans différentes couleurs ...*/
  theaterChase(strip.Color(127, 127, 127), 50); /* Blanc, moitié luminosité*/
  theaterChase(strip.Color(127,   0,   0), 50); /* Rouge, moitié luminosité*/
  theaterChase(strip.Color(  0,   0, 127), 50); /* Bleu, moitié luminosité*/

  rainbow(10);             /* Cycle arc-en-ciel qui coule sur toute la bande*/
  theaterChaseRainbow(50); /* Variante de théâtreChase améliorée par Rainbow*/
}


// Quelques fonctions propres à la création d'effets animés -----------------

/*
// Remplit une bande de pixels les uns après les autres avec une couleur. La bande n'est pas effacée
// premier; quoi que ce soit là sera couvert pixel par pixel. Passer en couleur
// (en tant que valeur 32 bits 'compactée', que vous pouvez obtenir en appelant
// strip.Color (rouge, vert, bleu) comme indiqué dans la fonction loop () ci-dessus),
// et un délai (en millisecondes) entre les pixels.*/
void colorWipe(uint32_t color, int wait) {
  for(int i=0; i<strip.numPixels(); i++) { /* Pour chaque pixel en bande ...*/
    strip.setPixelColor(i, color);         /*  Définir la couleur du pixel (en RAM)*/
    strip.show();                          /*  Mettre à jour la bande pour correspondre*/
    delay(wait);                           /*  Pause un instant*/
  }
}

/* Lumières de poursuite de style chapiteau. Passer dans une couleur (valeur 32 bits,
// a la strip.Color (r, g, b) comme mentionné ci-dessus), et un temps de retard (en ms)
// entre les cadres.*/
void theaterChase(uint32_t color, int wait) {
  for(int a=0; a<10; a++) {  /* Répétez 10 fois ...*/
    for(int b=0; b<3; b++) { /*  'b' compte de 0 à 2 ...*/
      strip.clear();         /*   Définissez tous les pixels de la RAM sur 0 (désactivé)*/
      /* "c" compte en partant de "b" jusqu'à la fin de la bande par pas de 3 ...*/
      for(int c=b; c<strip.numPixels(); c += 3) {
        strip.setPixelColor(c, color); /* Définit le pixel 'c' sur la valeur 'color'*/
      }
      strip.show(); /* Mettre à jour la bande avec le nouveau contenu*/
      delay(wait);  /* Pause un instant*/
    }
  }
}

/* Cycle arc-en-ciel sur toute la bande. Passer le temps de retard (en ms) entre les images.*/
void rainbow(int wait) {
   /* La teinte du premier pixel exécute 5 boucles complètes dans la roue chromatique.
   // La roue chromatique a une plage de 65 536 mais cela ne pose pas de problème si nous la retournons, donc
   // compte juste de 0 à 5 * 65536. Ajout de 256 à firstPixelHue à chaque fois
   // signifie que nous ferons 5 * 65536/256 = 1280 passages dans cette boucle externe:*/
  for(long firstPixelHue = 0; firstPixelHue < 5*65536; firstPixelHue += 256) {
    for(int i=0; i<strip.numPixels(); i++) { /* Pour chaque pixel en bande ...
       // Décale la teinte de pixel d'un montant pour faire un tour complet du
       // roue chromatique (plage de 65536) sur la longueur de la bande
       // (étapes strip.numPixels ()):*/
      int pixelHue = firstPixelHue + (i * 65536L / strip.numPixels());
       /* strip.ColorHSV () peut prendre 1 ou 3 arguments: une teinte (0 à 65535) ou
       // éventuellement ajouter saturation et valeur (luminosité) (de 0 à 255).
       // Nous n'utilisons ici que la variante de teinte à un seul argument. Le résultat
       // est passé par strip.gamma32 () pour fournir des couleurs 'plus vraies'
       // avant d'assigner à chaque pixel:*/
      strip.setPixelColor(i, strip.gamma32(strip.ColorHSV(pixelHue)));
    }
    strip.show(); /* Mettre à jour la bande avec le nouveau contenu*/
    delay(wait);  /* Pause un instant*/
  }
}

/* Chapiteau de théâtre rehaussé d'arc-en-ciel. Passer le temps de retard (en ms) entre les images.*/
void theaterChaseRainbow(int wait) {
  int firstPixelHue = 0;     /* Le premier pixel commence au rouge (teinte 0)*/
  for(int a=0; a<30; a++) {  /* Répétez 30 fois ...*/
    for(int b=0; b<3; b++) { /*  'b' compte de 0 à 2 ...*/
      strip.clear();         /*   Définissez tous les pixels de la RAM sur 0 (désactivé)
      // 'c' compte en partant de 'b' jusqu'à la fin de la bande par incréments de 3 ...*/
      for(int c=b; c<strip.numPixels(); c += 3) {
        /* la teinte du pixel 'c' est compensée par un montant pour en faire un plein
        // révolution de la roue chromatique (gamme 65536) sur la longueur
        // de la bande (strip.numPixels() steps):*/
        int      hue   = firstPixelHue + c * 65536L / strip.numPixels();
        uint32_t color = strip.gamma32(strip.ColorHSV(hue)); /* teinte -> RVB*/
        strip.setPixelColor(c, color); /* Définit le pixel 'c' sur la valeur 'color'*/
      }
      strip.show();                /* Mettre à jour la bande avec le nouveau contenu*/
      delay(wait);                 /* Pause un instant*/
      firstPixelHue += 65536 / 90; /* Un cycle de roue chromatique sur 90 images*/
    }
  }
}