API tools faq
paste
Advertisement
claudiusmarius

MusicBox-Seeeduino

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