claudiusmarius

XIA MusicBox

Jan 14th, 2022
917
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2.   // Claude DUFOURMONT Le 06/01/2022
  3.   // Réalisation d'une boîte à musique avec animation lumineuse
  4.   // Correction  logarithmique du volume par code
  5.   // Rajout de tempo pour coupure d'alimentation : MosfetGate passe à LOW dés que le temps écoulé est supérieur à interval
  6.   // La tempo fonctionne avec une animation lumineuse, mais avec une durée supplémentaire imputable au déroulement del'animation
  7.   // La tempo est réglable via un potentiomètre et un générateur de fonction 3 segments, segment1 : de 1 à 6mn - zone2 : de 6 à 60mn - segment3 : de 60 à 600mn
  8.   // segment1: LED bleue - segment2 : LED bleue et jaune - segment3 : LED jaune
  9.   // MosfetGate vient agir sur un BD232 (BJT NPN Puissance)via un optocoupleur pour couper le VCC des matrices => Ok (ne marche pas par coupure 0V),ce n'est pas l'isolement
  10.   // galvanique qui est recherché, c'est une astuce de circuiterie
  11.   // MosfetGate vient agir sur Mosfet canal N directement pour couper le 0V du DFPlayer-Mini ==> Ok
  12.   // Une résistance associée à une zener de 3.3v (triée pour être légérement inférieure), permet d'adapter le niveau 5V ATtiny85 avec le niveau 3.3V de la puce du DFPlayer -Mini
  13.   // Ajout de plusieurs scenariis d'animation lumineuse, bien sur le temps augmente
  14.   // Rajout d'un BP pour positionner la sortie MosfetGate à zéro
  15.   // Rajout d'un BP pour actionner le DFPlayer-Mini sur pause
  16.   // Rajout d'un BP pour actionner le DFPlayer-Mini sur start
  17.   // L'essai n'a pas été concluant avec des interruptions sur les falling des BP ==> le test BP est réalisé régulièrement dans le code (un peu pifométriquement, mais ça marche)
  18.   // Mise en place de 4 condensateurs (20nF) et résistances PullUp (12K) pour éviter les rebonds
  19.   // Rajout d'un fil par soudure sur le Pad RESET : Attention fil souple uniquement, si c'est un PINHEADER, le Pad sera arraché en cas de flexion
  20.   // Seeeduino XIAO et ATtiny85 + DFPlayer mini
  21.   // Schéma utilisé : en cours de mise à jour.
  22.   // Le potar son est pris en compte à chaque redémarrage uniquement
  23.   // Le code est prévu pour 1/3 dossier et est pris en compte au redémarrage uniquement (plus est possible avec modification)
  24.   //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  25.   // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!EN DEVELOPPEMENT!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  26.  
  27.   // ***********************************************************ATTENTION LE POTAR DE SON N'EST PLUS PRIS EN COMPTE **????*****************************************************
  28.  
  29.   #include <Adafruit_NeoPixel.h>
  30.    
  31.   #define BrocheDAC A0                                            // Envoie signal ANA vers ATtiny85 pour discriminer Pause/Start DFPlayer-Mini
  32.   #define potPinInterval A4                                       // RP2 10K
  33.  
  34.   #define BrocheBuzzer 1
  35.   int ValueDAC;                                                   // Echelle : 0 -> 1023 points (analogWriteResolution(10)) pour 0 -> 3.3v
  36.  
  37.   #define BrocheLedGaucheTempo 2                                  // LED2 Bleue en série avec R12 valeur 33 ohms
  38.   #define BrocheLedDroiteTempo 3                                  // LED1 Jaune en série avec R11 valeur 82 ohms            
  39.  
  40.   #define MosfetGate 5
  41.   bool Outtime = false;
  42.  
  43.   #define BPMosfetGate 7                                          // 1 (vert) fil blanc
  44.   int etatBPMosfetGate = LOW;
  45.  
  46.   #define BPPause 8                                               // 2 (jaune) fil jaune
  47.   int etatBPPause = LOW;
  48.  
  49.   #define BPStart 9                                               // 3 (jaune) fil noir
  50.   int etatBPStart = LOW;
  51.  
  52.   #define BPAux 10                                                // 4 (jaune) fil vert
  53.   int etatBPAux = LOW;
  54.  
  55.   #define LED_PIN1    6
  56.                
  57.   #define NUM_LEDS1 100                                           // Nombre total de LEDs WS2812B utilisées (4 matrices de 5X5)                          
  58.  
  59.   Adafruit_NeoPixel strip1(NUM_LEDS1, LED_PIN1, NEO_GRB + NEO_KHZ800);
  60.    
  61.   float a;  
  62.  
  63.   byte colors[3][3] = { {0xff, 0,0},
  64.                         {0xff, 0xff, 0xff},
  65.                         {0   , 0   , 0xff} };
  66.  
  67.   // RunningLights(0xff,0,0, 50);        // red
  68.   // RunningLights(0xff,0xff,0xff, 50);  // white
  69.   //RunningLights(0,0,0xff, 50);        // blue
  70.  
  71.   unsigned long interval;                                         // Initialisation variable permettant de gérer la tempo de mise à l'arrêt des auxilliaires
  72.  
  73.   unsigned long zz = 0;                                           // Initialisation variable permettant de sortir de la fonction BouncingColoredBalls()
  74.    
  75.   void setup()
  76.   {
  77.   analogWrite(BrocheDAC, 1000);
  78.  
  79.   int ValueDAC = 0;
  80.  
  81.   pinMode (MosfetGate, OUTPUT);
  82.  
  83.   pinMode (BrocheBuzzer, OUTPUT);
  84.  
  85.   pinMode (BPMosfetGate, INPUT);
  86.  
  87.   pinMode (BPPause, INPUT);
  88.  
  89.   pinMode (BPStart, INPUT);
  90.  
  91.   pinMode (BPAux, INPUT);
  92.  
  93.   pinMode (BrocheLedGaucheTempo, OUTPUT);
  94.  
  95.   pinMode (BrocheLedDroiteTempo, OUTPUT);
  96.    
  97.   analogReadResolution(10);                                        // Spécification résolution à utiliser pour la lecture ANA
  98.   analogWriteResolution(10);                                       // Spécification résolution à utiliser pour l'écriture ANA (DAC)
  99.  
  100.   digitalWrite (BrocheLedGaucheTempo, LOW);                        // Allumage LED bleue (bord droit zone1)
  101.   digitalWrite (BrocheLedDroiteTempo, LOW);                        // Allumage LED jaune (bord gauche zone3) nota : si nous sommes en zone2 LED bleue et jaune allumées
  102.  
  103.  
  104.   digitalWrite (MosfetGate, HIGH);
  105.  
  106.   //|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
  107.   delay(300);                                                      //||||||||||||||| Attention tempo très importante sinon le DFPlayer mini ne démarre pas ||||||||||||||||||
  108.   //|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
  109.  
  110.   Buzzer(50, 120, 5);
  111.   Serial.begin(115200);                                            // Démarrage de la liaison série (pour moniteur et traceur série)
  112.  
  113.   strip1.begin();          
  114.   strip1.show();            
  115.   strip1.setBrightness(1);
  116.    
  117.   delay (10);
  118.   }
  119.  
  120.   void loop()
  121.   {
  122.   analogWrite(BrocheDAC, ValueDAC);                                // Positionnement de la dernière ValueDAC sur son port
  123.  
  124.   TestBP ();                                                       // Renvoi vers la fonction TestBP () pour lecture des entrées associées et lancement actions associées
  125.  
  126.   analogRead (potPinInterval);                                        
  127.   int ab = analogRead (potPinInterval);
  128.  
  129.   //***********************************
  130.  
  131.   //||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
  132.   //||||||||||||||||||||||||| IMPORTANT : CI-DESSOUS TOUS LES CALCULS SONT EFFECTUES EN MILLISECONDES, J'AURAIS PU LES CONVERTIR DES LE DEBUT EN MINUTES |||||||||||||||||||||||
  133.   //|||||||||||||||||||||||||||||||||||||||| POUR TRAVAILLER AVEC DES NOMBRES MOINS LONGS, C'EST CE QUE JE FERAI LA PROCHAINE FOIS ||||||||||||||||||||||||||||||||||||||||||||]
  134.   //||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
  135.  
  136.   delay (5);
  137.   if (ab < 342)
  138.   {
  139.   interval = 10*( map (ab, 0, 341, 0,36000));                      // Segment1 de 0 à 6 mn sur le 1er tiers du potentiomètre,le facteur 10 est pour diminuer les nombres dans le map
  140.   digitalWrite (BrocheLedGaucheTempo, HIGH);
  141.   digitalWrite (BrocheLedDroiteTempo, LOW);
  142.   }
  143.   delay (5);
  144.    
  145.   if ( (ab < 683) && (ab > 341))
  146.   {
  147.   interval = 10*( map (ab, 342,682,36000,360000));                 // Segment2 de 6 à 60 mn sur le 2ème tiers du potentiomètre
  148.   digitalWrite (BrocheLedGaucheTempo, HIGH);
  149.   digitalWrite (BrocheLedDroiteTempo, HIGH);
  150.  
  151.   }
  152.   delay (5);
  153.  
  154.   if ( (ab < 1024) && (ab > 682))
  155.   {
  156.   interval = 10*( map (ab, 683,1023,360000,3600000));              // Segment3 de 60 à 600 mn sur le 3ème tiers du potentiomètre
  157.   digitalWrite (BrocheLedGaucheTempo, LOW);
  158.   digitalWrite (BrocheLedDroiteTempo, HIGH);
  159.   }
  160.   delay (5);
  161.  
  162.   Serial.println ((interval/60000) + 1);                           // Affichage de la tempo en minutes (en rajoutant une minute "parasite")
  163.  
  164.   if (millis() >= interval && Outtime == false)                    // Outime false permet de n'actionner la tempo qu'une fois parmi tous les cycles
  165.      
  166.   {
  167.   Buzzer(130, 200, 8);
  168.   ValueDAC = 310;
  169.   delay (10);
  170.   analogWrite(BrocheDAC, ValueDAC);
  171.   delay (100);
  172.   digitalWrite (MosfetGate, LOW);
  173.   etatBPMosfetGate = LOW;
  174.   delay (10);
  175.  
  176.   TestBP ();                                                       // Renvoi vers la fonction TestBP () pour lecture des entrées associées et lancement actions associées
  177.  
  178.   strip1.clear();
  179.   TestBP ();
  180.   strip1.show();
  181.   delay (10);
  182.  
  183.   Outtime =true;
  184.   }
  185.  
  186.   TestBP ();                                                       // Renvoi vers la fonction TestBP () pour lecture des entrées associées et lancement actions associées
  187.  
  188.   delay(10);
  189.   strip1.clear();
  190.  
  191.   TestBP ();                                                       // Renvoi vers la fonction TestBP () pour lecture des entrées associées et lancement actions associées
  192.  
  193.   byte colors[3][3] = { {0xff, 0,0},
  194.                         {0xff, 0xff, 0xff},
  195.                         {0   , 0   , 0xff} };
  196.  
  197.  
  198. //########################################################## Liste des scenarri lumineux à enchaîner DEBUT #############################################
  199.  
  200.   TwinkleRandom(800, 1, true);                              
  201.   TwinkleRandom(800, 1, false);                            
  202.  
  203.  
  204.   for (int jjj=0; jjj <10; jjj++)
  205.     {
  206.     for (int jj=0; jj <50; jj++)
  207.     {
  208.     Sparkle(random(255), random(255), random(255), 0);
  209.     }
  210.  
  211.     for (int jj=0; jj <10; jj++)
  212.     {
  213.     Sparkle(random(255), random(255), random(255), 100);
  214.     }
  215.   }
  216.  
  217.   for (int jj=0; jj <700; jj++)
  218.   {
  219.   Sparkle(random(255), random(255), random(255), 0);
  220.   }
  221.  
  222.   for (int jj=0; jj <100; jj++)
  223.   {
  224.   Sparkle(random(255), random(255), random(255), 100);
  225.   }
  226.  
  227.   BouncingColoredBalls(3, colors);                                
  228.    
  229.   rainbow(.0001);
  230.   rainbow(.001);
  231.    
  232.   theaterChaseRainbow(4);                                          
  233.  
  234.   rainbowCycle(20);
  235.    
  236.   FadeInOut(0x00, 0x00, 0xff); // blue                              
  237.  
  238.   RunningLights(0,0,0xff, 50);        // blue                          
  239.  
  240.   NewKITT(0xff, 0, 0, 8, 10, 50);
  241.  
  242.   SnowSparkle(0x10, 0x10, 0x10, 20, 200);      
  243.  
  244.   CylonBounce(0xff, 0, 0, 4, 10, 50);                                              
  245.  
  246.   CylonBounce(0xff, 0, 0, 20, 1, 1);
  247.   CylonBounce(0, 0xff, 0, 20, 1, 1);                                                
  248.   CylonBounce(0, 0, 0xff, 20, 1, 1);                                                
  249.  
  250.   //########################################################## Liste des scenarri lumineux à enchainer FIN #############################################
  251.  
  252.   }
  253.  
  254.    //*****************************************************************************************************************************************
  255.  
  256.   void showStrip()
  257.   {
  258.   #ifdef ADAFRUIT_NEOPIXEL_H
  259.   // NeoPixel
  260.   strip1.show();
  261.   #endif
  262.   #ifndef ADAFRUIT_NEOPIXEL_H
  263.   // FastLED
  264.   FastLED.show();
  265.   #endif
  266.   }
  267.  
  268.   void setPixel(int Pixel, byte red, byte green, byte blue)
  269.   {
  270.   #ifdef ADAFRUIT_NEOPIXEL_H
  271.   // NeoPixel
  272.   strip1.setPixelColor(Pixel, strip1.Color(red, green, blue));
  273.   #endif
  274.   #ifndef ADAFRUIT_NEOPIXEL_H
  275.   // FastLED
  276.   leds[Pixel].r = red;
  277.   leds[Pixel].g = green;
  278.   leds[Pixel].b = blue;
  279.   #endif
  280.   }
  281.  
  282.   void setAll(byte red, byte green, byte blue)
  283.   {
  284.   for(int i = 0; i < NUM_LEDS1; i++ )
  285.   {
  286.   setPixel(i, red, green, blue);
  287.   }
  288.   showStrip();
  289.   }
  290.  
  291.   //*****************************************************************************************************************************************
  292.  
  293.  
  294.   void meteorRain(byte red, byte green, byte blue, byte meteorSize, byte meteorTrailDecay, boolean meteorRandomDecay, int SpeedDelay)
  295.   {  
  296.   setAll(0,0,0);
  297.  
  298.   for(int i = 0; i < NUM_LEDS1+NUM_LEDS1; i++)
  299.   {
  300.   for(int j=0; j<NUM_LEDS1; j++)
  301.   {
  302.  
  303.   if( (!meteorRandomDecay) || (random(10)>5) )
  304.   {
  305.   fadeToBlack(j, meteorTrailDecay );        
  306.   }
  307.   }
  308.  
  309.   for(int j = 0; j < meteorSize; j++)
  310.   {
  311.  
  312.   if( ( i-j <NUM_LEDS1) && (i-j>=0) )
  313.   {
  314.   setPixel(i-j, red, green, blue);
  315.   }
  316.  
  317.   }
  318.   showStrip();
  319.   delay(SpeedDelay);
  320.   }
  321.   }
  322.  
  323.   void theaterChaseRainbow(int SpeedDelay)
  324.   {
  325.  
  326.   TestBP ();                                                       // Renvoi vers la fonction TestBP () pour lecture des entrées associées et lancement actions associées
  327.  
  328.   byte *c;
  329.  
  330.   TestBP ();
  331.  
  332.   for (int j=0; j < 256; j++)
  333.   {     // cycle all 256 colors in the wheel
  334.   for (int q=0; q < 3; q++)
  335.   {
  336.   for (int i=0; i < NUM_LEDS1; i=i+3)
  337.   {
  338.   c = Wheel( (i+j) % 255);
  339.   setPixel(i+q, *c, *(c+1), *(c+2));    //turn every third pixel on
  340.  
  341.   //TestBP ();                                                     // Renvoi vers la fonction TestBP () pour lecture des entrées associées et lancement actions associées
  342.  
  343.   }
  344.  
  345.   TestBP ();
  346.  
  347.   showStrip();
  348.   delay(SpeedDelay);
  349.  
  350.   TestBP ();                                                       // Renvoi vers la fonction TestBP () pour lecture des entrées associées et lancement actions associées
  351.  
  352.   for (int i=0; i < NUM_LEDS1; i=i+3)
  353.   {
  354.  
  355.   TestBP ();                                                       // Renvoi vers la fonction TestBP () pour lecture des entrées associées et lancement actions associées
  356.  
  357.   setPixel(i+q, 0,0,0);        //turn every third pixel off
  358.   }
  359.   }
  360.   }
  361.   }
  362.  
  363.   void fadeToBlack(int ledNo, byte fadeValue)
  364.   {
  365.   #ifdef ADAFRUIT_NEOPIXEL_H
  366.   uint32_t oldColor;
  367.   uint8_t r, g, b;
  368.   int value;
  369.      
  370.   oldColor = strip1.getPixelColor(ledNo);
  371.   r = (oldColor & 0x00ff0000UL) >> 16;
  372.   g = (oldColor & 0x0000ff00UL) >> 8;
  373.   b = (oldColor & 0x000000ffUL);
  374.  
  375.   r=(r<=10)? 0 : (int) r-(r*fadeValue/256);
  376.   g=(g<=10)? 0 : (int) g-(g*fadeValue/256);
  377.   b=(b<=10)? 0 : (int) b-(b*fadeValue/256);
  378.    
  379.   strip1.setPixelColor(ledNo, r,g,b);
  380.   #endif
  381.   #ifndef ADAFRUIT_NEOPIXEL_H
  382.   #endif  
  383.   }
  384.  
  385.   void RunningLights(byte red, byte green, byte blue, int WaveDelay)
  386.   {
  387.   int Position=0;
  388.   for(int j=0; j<NUM_LEDS1*2; j++)
  389.   {
  390.   Position++; // = 0; //Position + Rate;
  391.   for(int i=0; i<NUM_LEDS1; i++)
  392.   {
  393.   // sine wave, 3 offset waves make a rainbow!
  394.   //float level = sin(i+Position) * 127 + 128;
  395.   //setPixel(i,level,0,0);
  396.   //float level = sin(i+Position) * 127 + 128;
  397.   setPixel(i,((sin(i+Position) * 127 + 128)/255)*red,
  398.   ((sin(i+Position) * 127 + 128)/255)*green,
  399.   ((sin(i+Position) * 127 + 128)/255)*blue);
  400.   }
  401.      
  402.   showStrip();
  403.   delay(WaveDelay);
  404.   }
  405.   }
  406.  
  407.   void SnowSparkle(byte red, byte green, byte blue, int SparkleDelay, int SpeedDelay)
  408.   {
  409.   setAll(red,green,blue);
  410.   int Pixel = random(NUM_LEDS1);
  411.   setPixel(Pixel,0xff,0xff,0xff);
  412.  
  413.   showStrip();
  414.   delay(SparkleDelay);
  415.   setPixel(Pixel,red,green,blue);
  416.   showStrip();
  417.   delay(SpeedDelay);
  418.   }
  419.  
  420.   void CylonBounce(byte red, byte green, byte blue, int EyeSize, int SpeedDelay, int ReturnDelay)
  421.   {
  422.   for(int i = 0; i < NUM_LEDS1-EyeSize-2; i++)
  423.   {
  424.   setAll(0,0,0);
  425.   TestBP ();
  426.   setPixel(i, red/10, green/10, blue/10);
  427.   for(int j = 1; j <= EyeSize; j++)
  428.   {
  429.   setPixel(i+j, red, green, blue);
  430.   }
  431.   setPixel(i+EyeSize+1, red/10, green/10, blue/10);
  432.   showStrip();
  433.   delay(SpeedDelay);
  434.   }
  435.   delay(ReturnDelay);
  436.   for(int i = NUM_LEDS1-EyeSize-2; i > 0; i--)
  437.   {
  438.   setAll(0,0,0);
  439.   setPixel(i, red/10, green/10, blue/10);
  440.   for(int j = 1; j <= EyeSize; j++)
  441.   {
  442.   setPixel(i+j, red, green, blue);
  443.   }
  444.   setPixel(i+EyeSize+1, red/10, green/10, blue/10);
  445.   showStrip();
  446.   delay(SpeedDelay);
  447.   }
  448.   delay(ReturnDelay);
  449.   }
  450.  
  451.   void NewKITT(byte red, byte green, byte blue, int EyeSize, int SpeedDelay, int ReturnDelay)
  452.   {
  453.   RightToLeft(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
  454.   LeftToRight(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
  455.   OutsideToCenter(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
  456.   CenterToOutside(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
  457.   LeftToRight(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
  458.   RightToLeft(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
  459.   OutsideToCenter(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
  460.   CenterToOutside(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
  461.   }
  462.  
  463.   void CenterToOutside(byte red, byte green, byte blue, int EyeSize, int SpeedDelay, int ReturnDelay)
  464.   {
  465.   for(int i =((NUM_LEDS1-EyeSize)/2); i>=0; i--)
  466.   {
  467.   setAll(0,0,0);
  468.   setPixel(i, red/10, green/10, blue/10);
  469.   for(int j = 1; j <= EyeSize; j++)
  470.   {
  471.   setPixel(i+j, red, green, blue);
  472.   }
  473.   setPixel(i+EyeSize+1, red/10, green/10, blue/10);
  474.   setPixel(NUM_LEDS1-i, red/10, green/10, blue/10);
  475.   for(int j = 1; j <= EyeSize; j++)
  476.   {
  477.   setPixel(NUM_LEDS1-i-j, red, green, blue);
  478.   }
  479.   setPixel(NUM_LEDS1-i-EyeSize-1, red/10, green/10, blue/10);
  480.   showStrip();
  481.   delay(SpeedDelay);
  482.   }
  483.   delay(ReturnDelay);
  484.   }
  485.  
  486.   void OutsideToCenter(byte red, byte green, byte blue, int EyeSize, int SpeedDelay, int ReturnDelay)
  487.   {
  488.   for(int i = 0; i<=((NUM_LEDS1-EyeSize)/2); i++)
  489.   {
  490.   setAll(0,0,0);
  491.   setPixel(i, red/10, green/10, blue/10);
  492.   for(int j = 1; j <= EyeSize; j++)
  493.   {
  494.   setPixel(i+j, red, green, blue);
  495.   }
  496.   setPixel(i+EyeSize+1, red/10, green/10, blue/10);
  497.   setPixel(NUM_LEDS1-i, red/10, green/10, blue/10);
  498.   for(int j = 1; j <= EyeSize; j++)
  499.   {
  500.   setPixel(NUM_LEDS1-i-j, red, green, blue);
  501.   }
  502.   setPixel(NUM_LEDS1-i-EyeSize-1, red/10, green/10, blue/10);
  503.   showStrip();
  504.   delay(SpeedDelay);
  505.   }
  506.   delay(ReturnDelay);
  507.   }
  508.  
  509.   void LeftToRight(byte red, byte green, byte blue, int EyeSize, int SpeedDelay, int ReturnDelay)
  510.   {
  511.   for(int i = 0; i < NUM_LEDS1-EyeSize-2; i++)
  512.   {
  513.   setAll(0,0,0);
  514.   setPixel(i, red/10, green/10, blue/10);
  515.   for(int j = 1; j <= EyeSize; j++)
  516.   {
  517.   setPixel(i+j, red, green, blue);
  518.   }
  519.   setPixel(i+EyeSize+1, red/10, green/10, blue/10);
  520.   showStrip();
  521.   delay(SpeedDelay);
  522.   }
  523.   delay(ReturnDelay);
  524.   }
  525.  
  526.   void RightToLeft(byte red, byte green, byte blue, int EyeSize, int SpeedDelay, int ReturnDelay)
  527.   {
  528.   for(int i = NUM_LEDS1-EyeSize-2; i > 0; i--)
  529.   {
  530.   setAll(0,0,0);
  531.   setPixel(i, red/10, green/10, blue/10);
  532.   for(int j = 1; j <= EyeSize; j++)
  533.   {
  534.   setPixel(i+j, red, green, blue);
  535.   }
  536.   setPixel(i+EyeSize+1, red/10, green/10, blue/10);
  537.   showStrip();
  538.   delay(SpeedDelay);
  539.   }
  540.   delay(ReturnDelay);
  541.   }
  542.  
  543.   void Strobe(byte red, byte green, byte blue, int StrobeCount, int FlashDelay, int EndPause)
  544.   {
  545.   for(int j = 0; j < StrobeCount; j++)
  546.   {
  547.   setAll(red,green,blue);
  548.  
  549.   TestBP();                                                        // Renvoi vers la fonction TestBP () pour lecture des entrées associées et lancement actions associées
  550.  
  551.   showStrip();
  552.   delay(FlashDelay);
  553.   setAll(0,0,0);
  554.  
  555.   TestBP();                                                        // Renvoi vers la fonction TestBP () pour lecture des entrées associées et lancement actions associées
  556.  
  557.   showStrip();
  558.   delay(FlashDelay);
  559.   }
  560.   delay(EndPause);
  561.   }
  562.  
  563.   void FadeInOut(byte red, byte green, byte blue)
  564.   {
  565.   float r, g, b;
  566.   for(int k = 0; k < 256; k=k+1)
  567.   {
  568.   r = (k/256.0)*red;
  569.   g = (k/256.0)*green;
  570.   b = (k/256.0)*blue;
  571.   setAll(r,g,b);
  572.   showStrip();
  573.   }
  574.   for(int k = 255; k >= 0; k=k-2)
  575.   {
  576.   r = (k/256.0)*red;
  577.   g = (k/256.0)*green;
  578.   b = (k/256.0)*blue;
  579.   setAll(r,g,b);
  580.   showStrip();
  581.   }
  582.   }
  583.  
  584.   void colorWipe(byte red, byte green, byte blue, int SpeedDelay)
  585.   {
  586.   for(uint16_t i=0; i<NUM_LEDS1; i++)
  587.   {
  588.   setPixel(i, red, green, blue);
  589.   showStrip();
  590.   delay(SpeedDelay);
  591.   }
  592.   }
  593.  
  594.   //**********************************************************************
  595.   //**********************************************************************
  596.   void TwinkleRandom(int Count, int SpeedDelay, boolean OnlyOne)
  597.   {
  598.   setAll(0,0,0);
  599.  
  600.   TestBP ();                                                       // Renvoi vers la fonction TestBP () pour lecture des entrées associées et lancement actions associées
  601.  
  602.   for (int i=0; i<Count; i++)
  603.   {
  604.   setPixel(random(NUM_LEDS1),random(0,255),random(0,255),random(0,255));
  605.   TestBP ();
  606.   showStrip();
  607.      
  608.   TestBP ();                                                       // Renvoi vers la fonction TestBP () pour lecture des entrées associées et lancement actions associées
  609.      
  610.   delay(SpeedDelay);  
  611.  
  612.   if(OnlyOne)
  613.   {
  614.        
  615.   TestBP ();                                                       // Renvoi vers la fonction TestBP () pour lecture des entrées associées et lancement actions associées
  616.        
  617.   setAll(0,0,0);
  618.   }
  619.  
  620.   }
  621.   delay(SpeedDelay);
  622.   }
  623.   //**********************************************************************
  624.   //**********************************************************************
  625.  
  626.   void RGBLoop()
  627.   {
  628.   for(int j = 0; j < 3; j++ )
  629.   {
  630.  
  631.   // Fade IN
  632.    
  633.   for(int k = 0; k < 256; k++)
  634.   {
  635.   switch(j)
  636.   {
  637.   case 0: setAll(k,0,0); break;
  638.   case 1: setAll(0,k,0); break;
  639.   case 2: setAll(0,0,k); break;
  640.   }
  641.   showStrip();
  642.   delay(3);
  643.   }
  644.    
  645.   // Fade OUT
  646.    
  647.   for(int k = 255; k >= 0; k--)
  648.   {
  649.   switch(j) {
  650.   case 0: setAll(k,0,0); break;
  651.   case 1: setAll(0,k,0); break;
  652.   case 2: setAll(0,0,k); break;
  653.   }
  654.   showStrip();
  655.   delay(3);
  656.   }
  657.   }
  658.   }
  659.  
  660.   //**********************************************************************
  661.   //**********************************************************************
  662.  
  663.   void BouncingColoredBalls(int BallCount, byte colors[][3])
  664.    
  665.   {
  666.   float Gravity = -9.81;
  667.   int StartHeight = 1;
  668.   float Height[BallCount];
  669.   float ImpactVelocityStart = sqrt( -2 * Gravity * StartHeight );
  670.   float ImpactVelocity[BallCount];
  671.   float TimeSinceLastBounce[BallCount];
  672.   int   Position[BallCount];
  673.   long  ClockTimeSinceLastBounce[BallCount];
  674.   float Dampening[BallCount];
  675.  
  676.   for (int i = 0 ; i < BallCount ; i++)
  677.   {  
  678.  
  679.   TestBP ();                                                       // Renvoi vers la fonction TestBP () pour lecture des entrées associées et lancement actions associées
  680.    
  681.   ClockTimeSinceLastBounce[i] = millis();
  682.   Height[i] = StartHeight;
  683.   Position[i] = 0;
  684.   ImpactVelocity[i] = ImpactVelocityStart;
  685.   TimeSinceLastBounce[i] = 0;
  686.   Dampening[i] = 0.90 - float(i)/pow(BallCount,2);
  687.   }
  688.  
  689.   while (true)
  690.  
  691.   {
  692.   for (int i = 0 ; i < BallCount ; i++)
  693.   {
  694.   TimeSinceLastBounce[i] =  millis() - ClockTimeSinceLastBounce[i];
  695.   Height[i] = 0.5 * Gravity * pow( TimeSinceLastBounce[i]/1000 , 2.0 ) + ImpactVelocity[i] * TimeSinceLastBounce[i]/1000;
  696.  
  697.   if ( Height[i] < 0 )
  698.   {                      
  699.   Height[i] = 0;
  700.   ImpactVelocity[i] = Dampening[i] * ImpactVelocity[i];
  701.   ClockTimeSinceLastBounce[i] = millis();
  702.   if ( ImpactVelocity[i] < 0.01 )
  703.   {
  704.   ImpactVelocity[i] = ImpactVelocityStart;
  705.   }
  706.   }
  707.  
  708.   Position[i] = round( Height[i] * (NUM_LEDS1 - 1) / StartHeight);
  709.   }
  710.   for (int i = 0 ; i < BallCount ; i++)
  711.   {
  712.   setPixel(Position[i],colors[i][0],colors[i][1],colors[i][2]);
  713.   }
  714.   showStrip();
  715.    
  716.   TestBP ();                                                       // Renvoi vers la fonction TestBP () pour lecture des entrées associées et lancement actions associées
  717.    
  718.   setAll(0,0,0);
  719.  
  720.   zz = zz+1;
  721.  
  722.   if (zz > 10000)
  723.   {
  724.   zz = 0;
  725.   return;
  726.   }
  727.   }
  728.   }
  729.   //**********************************************************************
  730.   //**********************************************************************
  731.  
  732.   void rainbow(int wait)
  733.   {
  734.   for(long firstPixelHue = 0; firstPixelHue < 5*65536; firstPixelHue += 256)
  735.   {
  736.   for(int i=0; i<strip1.numPixels(); i++)
  737.   {
  738.   int pixelHue = firstPixelHue + (i * 65536L / strip1.numPixels());
  739.   strip1.setPixelColor(i, strip1.gamma32(strip1.ColorHSV(pixelHue)));
  740.   }
  741.  
  742.   TestBP ();                                                       // Renvoi vers la fonction TestBP () pour lecture des entrées associées et lancement actions associées
  743.    
  744.   strip1.show();
  745.   delay(wait);  
  746.   }
  747.   }
  748.  
  749.   void Sparkle(byte red, byte green, byte blue, int SpeedDelay)
  750.   {
  751.  
  752.   TestBP ();                                                       // Renvoi vers la fonction TestBP () pour lecture des entrées associées et lancement actions associées
  753.  
  754.   int Pixel = random(NUM_LEDS1);
  755.   setPixel(Pixel,red,green,blue);
  756.  
  757.   TestBP ();                                                       // Renvoi vers la fonction TestBP () pour lecture des entrées associées et lancement actions associées
  758.  
  759.   showStrip();
  760.   delay(SpeedDelay);
  761.   setPixel(Pixel,0,0,0);
  762.   }
  763.  
  764.   void rainbowCycle(int SpeedDelay)
  765.   {
  766.  
  767.   TestBP ();                                                       // Renvoi vers la fonction TestBP () pour lecture des entrées associées et lancement actions associées
  768.  
  769.   byte *c;
  770.   uint16_t i, j;
  771.   for(j=0; j<256*5; j++) // 5 cycles of all colors on wheel
  772.   {
  773.   for(i=0; i< NUM_LEDS1; i++)
  774.   {
  775.   c=Wheel(((i * 256 / NUM_LEDS1) + j) & 255);
  776.   setPixel(i, *c, *(c+1), *(c+2));
  777.   }
  778.    
  779.   TestBP ();                                                       // Renvoi vers la fonction TestBP () pour lecture des entrées associées et lancement actions associées
  780.    
  781.   showStrip();
  782.   delay(SpeedDelay);
  783.   }
  784.   }
  785.   byte * Wheel(byte WheelPos)
  786.   {
  787.   static byte c[3];
  788.  
  789.   if(WheelPos < 85)
  790.   {
  791.   c[0]=WheelPos * 3;
  792.   c[1]=255 - WheelPos * 3;
  793.   c[2]=0;
  794.   }
  795.  
  796.   else if(WheelPos < 170)
  797.   {
  798.   WheelPos -= 85;
  799.   c[0]=255 - WheelPos * 3;
  800.   c[1]=0;
  801.   c[2]=WheelPos * 3;
  802.   }
  803.  
  804.   else
  805.   {
  806.   WheelPos -= 170;
  807.   c[0]=0;
  808.   c[1]=WheelPos * 3;
  809.   c[2]=255 - WheelPos * 3;
  810.   }
  811.  
  812.   return c;
  813.   }
  814.  
  815.   void TestBP ()                                                   // Renvoi vers la fonction TestBP () pour lecture des entrées associées et lancement actions associées
  816.   {
  817.   digitalRead (MosfetGate);
  818.   digitalRead (BPMosfetGate);
  819.   digitalRead (BPPause);
  820.   digitalRead (BPStart);
  821.   digitalRead (BPAux);
  822.   analogRead (potPinInterval);
  823.   int ab = analogRead (potPinInterval);                             // Le placement de cette action également à cet endroit permet d'avoir une acualisation quasi temps réel
  824.  
  825.   etatBPPause == LOW;
  826.   etatBPStart == LOW;
  827.  
  828.   if (digitalRead (BPMosfetGate) == LOW && Outtime == false)
  829.  
  830.   {
  831.   etatBPMosfetGate = HIGH;
  832.   Buzzer(130, 200, 8);
  833.   ValueDAC = 310;
  834.   analogWrite(BrocheDAC, ValueDAC);
  835.   delay (100);
  836.   digitalWrite (MosfetGate, LOW);
  837.   Outtime =true;
  838.   delay (10);
  839.   }
  840.      
  841.   if (digitalRead (BPPause) == LOW && etatBPPause == HIGH)
  842.   {
  843.   Buzzer(600, 60, 1);
  844.   delay (10);
  845.   etatBPPause = HIGH;
  846.   delay (10);
  847.   }
  848.    
  849.   if (digitalRead (BPPause) == LOW && etatBPPause == LOW )
  850.   {
  851.    Buzzer(70, 70, 2);
  852.   delay (10);
  853.   etatBPPause = HIGH;
  854.   delay (10);
  855.   etatBPStart = LOW;
  856.   }
  857.  
  858.   if (digitalRead (BPStart) == LOW && etatBPStart == HIGH )
  859.   {
  860.   Buzzer(600, 60, 1);
  861.   delay (10);
  862.   etatBPStart = HIGH;
  863.   delay (10);
  864.   }
  865.      
  866.   if (digitalRead (BPStart) == LOW && etatBPStart == LOW )
  867.   {
  868.   Buzzer(70, 70, 2);
  869.   delay (10);
  870.   etatBPStart = HIGH;
  871.   delay (10);
  872.   etatBPPause = LOW;
  873.   }
  874.            
  875.   if (digitalRead (BPAux) == LOW)
  876.   {
  877.   etatBPAux = HIGH;
  878.   }
  879.                          
  880.   if (etatBPPause == HIGH)
  881.   {
  882.   etatBPStart = LOW;
  883.   ValueDAC = 310;
  884.   analogWrite(BrocheDAC, ValueDAC);
  885.   }
  886.  
  887.   if (etatBPStart == HIGH)
  888.   {
  889.   etatBPPause = LOW;
  890.   ValueDAC = 620;
  891.   analogWrite(BrocheDAC, ValueDAC);
  892.   }
  893.  
  894.   if (etatBPAux == HIGH)
  895.   {
  896.   Buzzer(70, 70, 6);
  897.   etatBPAux = LOW;
  898.   }
  899.   delay (5);
  900.   if (ab < 342)
  901.   {
  902.   interval = 10*( map (ab, 0, 341, 0,36000));                      //Segment1 de 0 à 6 mn sur le 1er tiers du potentiomètre
  903.   digitalWrite (BrocheLedGaucheTempo, HIGH);
  904.   digitalWrite (BrocheLedDroiteTempo, LOW);
  905.   }
  906.   //delay (5);
  907.    
  908.   if ( (ab < 683) && (ab > 341))
  909.   {
  910.   interval = 10*( map (ab, 342,682,36000,360000));                 //Segment2 de 6 à 60 mn sur le 2ème tiers du potentiomètre
  911.   digitalWrite (BrocheLedGaucheTempo, HIGH);
  912.   digitalWrite (BrocheLedDroiteTempo, HIGH);
  913.  
  914.   }
  915.   //delay (5);
  916.   analogRead (potPinInterval);                                        
  917.  
  918.   if ( (ab < 1024) && (ab > 682))
  919.   {
  920.   interval = 10*( map (ab, 683,1023,360000,3600000));              //Segment3 de 60 à 600 mn sur le 3ème tiers du potentiomètre
  921.   digitalWrite (BrocheLedGaucheTempo, LOW);
  922.   digitalWrite (BrocheLedDroiteTempo, HIGH);
  923.   }
  924.   //delay (5);
  925.  
  926.   }
  927.  
  928.   void Buzzer (int TempsH, int TempsL, int nb)                      // TempsH => délai buzzer ON, TempsL => délai buzzer OFF, nb => nombre de bips
  929.   {
  930.   for (int x = 1; x <= nb; x++)                                     // Boucle le nombre de fois voulu passé par l'argument "int nb"
  931.   {
  932.   digitalWrite(BrocheBuzzer, HIGH);                                 // Active le buzzer
  933.   delay (TempsH);                                                   // Temporisation à l'état haut du buzzer pendant la durée passée par l'argument "int TempsH"
  934.   digitalWrite(BrocheBuzzer, LOW);                                  // Désactive le buzzer
  935.   delay (TempsL);                                                   // Temporisation à l'état bas du buzzer pendant la durée passée par l'argument "int TempsL"
  936.   }
  937.   }
RAW Paste Data