API tools faq
paste
Advertisement
claudiusmarius

Luminous Music Box

claudiusmarius
Dec 21st, 2021
1,093
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 19.05 KB | None | 0 0
raw download clone embed print report
  1. //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2.   // Claude DUFOURMONT Le 21/12/2021
  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.   // 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
  8.   // galvanique qui est recherché, c'est une astuce de circuiterie
  9.   // MosfetGate vient agir sur Mosfet canal N directement pour couper le 0V du DFPlayermini ==> Ok
  10.   // Ajout de plusieurs scenariis d'animation lumineuse, bien sur le temps augmente
  11.   // Rajout Mosfet et BP sur +Vcc XIAO pour pouvoir le faire redémarrer ==> Ok  ++++++++++++ ANNULE +++++++++++
  12.   // Rajout d'un BP d'interruption pour mettre la sortie MosfetGate à zéro
  13.   // Rajout d'un BP d'interruption pour mettre la musique sur pause
  14.   // Rajout d'un BP d'interruption pour mettre la musique sur start
  15.   // Mise en place de 4 condensateurs (20nF) et résistances PullUp (12K) pour éviter les rebonds
  16.   // <<<<<<<<<<<<<<<<Il existe encore des bugs : les interruptions bloquent parfois le programme et parfois on ne sait pas redémarrer le programme, il faut razzr>>>>>>>>>>>>>>>
  17.   // 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
  18.   // Seeeduino XIAO et DFPlayer mini
  19.   // Remise au propre des breadboard faite, avec réaffectation des ports.
  20.   // Schéma utilisé : en cours de mise à jour.
  21.   // Le potar son estpris en compte à chaque redémarrage
  22.   //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  23.   // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!EN DEVELOPPEMENT!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  24.  
  25.   // ***********************************************************ATTENTION LE POTAR DE SON N'EST PLUS PRIS EN COMPTE **????*****************************************************
  26.  
  27.   #include <SoftwareSerial.h>
  28.   #include "DFRobotDFPlayerMini.h"
  29.   #include <Adafruit_NeoPixel.h>
  30.   #include <math.h>
  31.  
  32.   float ratio;                                              // Pour log
  33.   float ratio1024;                                          // Pour log
  34.  
  35.   SoftwareSerial mySoftwareSerial(1,2); // RX, TX
  36.  
  37.   #define TX 1
  38.   #define potPinSound A3
  39.   #define potPinInterval A4
  40.   #define MosfetGate 5
  41.  
  42.   #define BPMosfetGate 7                                   // 1 (vert) fil blanc
  43.   int etatBPMosfetGate = LOW;
  44.  
  45.   #define BPPause 8                                        // 2 (jaune) fil jaune
  46.   int etatBPPause = LOW;
  47.  
  48.   #define BPStart 9                                        // 3 (jaune) fil noir
  49.   int etatBPStart = LOW;
  50.  
  51.   #define BPAux 10                                         // 4 (jaune) fil vert
  52.   int etatBPAux = LOW;
  53.  
  54.   #define LED_PIN1    6
  55.                
  56.   #define NUM_LEDS1 100                          
  57.  
  58.   Adafruit_NeoPixel strip1(NUM_LEDS1, LED_PIN1, NEO_GRB + NEO_KHZ800);
  59.    
  60.   DFRobotDFPlayerMini myDFPlayer;
  61.  
  62.   byte volumeLevel; //variable for holding volume level;
  63.   float a;  
  64.  
  65.   byte colors[3][3] = { {0xff, 0,0},
  66.                         {0xff, 0xff, 0xff},
  67.                         {0   , 0   , 0xff} };
  68.  
  69.   // RunningLights(0xff,0,0, 50);        // red
  70.   // RunningLights(0xff,0xff,0xff, 50);  // white
  71.   //RunningLights(0,0,0xff, 50);        // blue
  72.  
  73.  
  74.    
  75.   void setup()
  76.   {
  77.   pinMode (MosfetGate, OUTPUT);
  78.   digitalWrite (MosfetGate, HIGH);
  79.   delay(300);                           //>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Attention tempo très importante sinon le DFPlayer mini ne démarre pas <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  80.  
  81.  
  82.   attachInterrupt(BPMosfetGate, traite_int1, FALLING);
  83.  
  84.  
  85.   attachInterrupt(BPPause, traite_int2, FALLING);
  86.  
  87.  
  88.   attachInterrupt(BPStart, traite_int3, FALLING);
  89.  
  90.  
  91.   //attachInterrupt(BPStart, traite_int4, FALLING);
  92.  
  93.  
  94.   double y = 1025;                                                  // Pour log
  95.   double LOG1025 = log10 (y);                                       // Pour log
  96.  
  97.   a= analogRead(potPinSound);                                       // Pour log
  98.      
  99.   double x = a;                                                     // Pour log
  100.   double LOG10x = log10 (x);
  101.   ratio = log10 (x) / log10 (y);                                    // Pour log
  102.   ratio1024 = ratio*1024;                                           // Pour log
  103.  
  104.   //-------------------------------------------------------------------------------------------------------------------------------------------------------------
  105.   //volumeLevel = map(analogRead(potPin), 0, 1023, 0, 30);
  106.                                                
  107.                                            
  108.                                                
  109.                                                 //------------------------------------------------------- OU ----------------------------------------------------
  110.  
  111.  
  112.  
  113.   volumeLevel = map(ratio1024, 0, 1023, 0, 30);
  114.  
  115.  
  116.   //-------------------------------------------------------------------------------------------------------------------------------------------------------------
  117.  
  118.   mySoftwareSerial.begin(9600);
  119.   myDFPlayer.begin (mySoftwareSerial);
  120.   myDFPlayer.volume(volumeLevel);
  121.  
  122.   myDFPlayer.loop(6);                                    
  123.   //delay (1000);
  124.  
  125.   strip1.begin();          
  126.   strip1.show();            
  127.   strip1.setBrightness(1);
  128.  
  129.   }
  130.  
  131.   void loop()
  132.   {
  133.  
  134.   const long interval = 50000000;                                                                                                                                
  135.   unsigned long previousMillis = 0;
  136.   unsigned long currentMillis = millis();                                                
  137.  
  138.   if (currentMillis - previousMillis >= interval)        
  139.   {
  140.   digitalWrite (MosfetGate, LOW);
  141.   delay (10);
  142.   strip1.clear();
  143.   strip1.show();
  144.   delay (10);
  145.   previousMillis = currentMillis;
  146.   }
  147.   volumeLevel= 0;
  148.   delay(10);
  149.   strip1.clear();
  150.  
  151.  
  152.   byte colors[3][3] = { {0xff, 0,0},
  153.                         {0xff, 0xff, 0xff},
  154.                         {0   , 0   , 0xff} };
  155.  
  156.   //BouncingColoredBalls(3, colors);
  157.    rainbow(.0001);
  158.    
  159.    theaterChaseRainbow(50);
  160.  
  161.    meteorRain(0xff,0xff,0xff,20, 5, false, 0);
  162.  
  163.    RGBLoop();
  164.                                              
  165.   TwinkleRandom(20, 5, false);
  166.  
  167.   rainbowCycle(20);
  168.  
  169.   meteorRain(0xff,0xff,0xff,5, 60, false, 0);
  170.    
  171.   FadeInOut(0x00, 0x00, 0xff); // blue
  172.  
  173.   RunningLights(0,0,0xff, 50);        // blue
  174.  
  175.   Strobe(0xff, 0xff, 0xff, 10, 50, 1000);
  176.  
  177.   NewKITT(0xff, 0, 0, 8, 10, 50);SnowSparkle(0x10, 0x10, 0x10, 20, 200);
  178.  
  179.   CylonBounce(0xff, 0, 0, 4, 10, 50);
  180.  
  181.  
  182.   }
  183.  
  184.    //*****************************************************************************************************************************************
  185.  
  186.  
  187.   void showStrip() {
  188.   #ifdef ADAFRUIT_NEOPIXEL_H
  189.   strip1.show();
  190.   #endif
  191.   #ifndef ADAFRUIT_NEOPIXEL_H
  192.   #endif
  193.   }
  194.  
  195.   void setPixel(int Pixel, byte red, byte green, byte blue) {
  196.   #ifdef ADAFRUIT_NEOPIXEL_H
  197.   strip1.setPixelColor(Pixel, strip1.Color(red, green, blue));
  198.   #endif
  199.   #ifndef ADAFRUIT_NEOPIXEL_H
  200.   #endif
  201.   }
  202.  
  203.   void setAll(byte red, byte green, byte blue) {
  204.   for(int i = 0; i < NUM_LEDS1; i++ ) {
  205.   setPixel(i, red, green, blue);
  206.   }
  207.   showStrip();
  208.   }
  209.   //*****************************************************************************************************************************************
  210.  
  211.  
  212.   void meteorRain(byte red, byte green, byte blue, byte meteorSize, byte meteorTrailDecay, boolean meteorRandomDecay, int SpeedDelay) {  
  213.   setAll(0,0,0);
  214.  
  215.   for(int i = 0; i < NUM_LEDS1+NUM_LEDS1; i++) {
  216.  
  217.   for(int j=0; j<NUM_LEDS1; j++) {
  218.   if( (!meteorRandomDecay) || (random(10)>5) ) {
  219.   fadeToBlack(j, meteorTrailDecay );        
  220.   }
  221.   }
  222.  
  223.   for(int j = 0; j < meteorSize; j++) {
  224.   if( ( i-j <NUM_LEDS1) && (i-j>=0) ) {
  225.   setPixel(i-j, red, green, blue);
  226.   }
  227.   }
  228.    
  229.   showStrip();
  230.   delay(SpeedDelay);
  231.   }
  232.   }
  233.  
  234.   void theaterChaseRainbow(int SpeedDelay)
  235.   {
  236.   byte *c;
  237.  
  238.   for (int j=0; j < 256; j++)
  239.   {     // cycle all 256 colors in the wheel
  240.   for (int q=0; q < 3; q++)
  241.   {
  242.   for (int i=0; i < NUM_LEDS1; i=i+3)
  243.   {
  244.           c = Wheel( (i+j) % 255);
  245.           setPixel(i+q, *c, *(c+1), *(c+2));    //turn every third pixel on
  246.   }
  247.   showStrip();
  248.   delay(SpeedDelay);
  249.   for (int i=0; i < NUM_LEDS1; i=i+3)
  250.   {
  251.   setPixel(i+q, 0,0,0);        //turn every third pixel off
  252.   }
  253.   }
  254.   }
  255.   }
  256.  
  257.  
  258.   void fadeToBlack(int ledNo, byte fadeValue) {
  259.   #ifdef ADAFRUIT_NEOPIXEL_H
  260.   uint32_t oldColor;
  261.   uint8_t r, g, b;
  262.   int value;
  263.    
  264.   oldColor = strip1.getPixelColor(ledNo);
  265.   r = (oldColor & 0x00ff0000UL) >> 16;
  266.   g = (oldColor & 0x0000ff00UL) >> 8;
  267.   b = (oldColor & 0x000000ffUL);
  268.  
  269.   r=(r<=10)? 0 : (int) r-(r*fadeValue/256);
  270.   g=(g<=10)? 0 : (int) g-(g*fadeValue/256);
  271.   b=(b<=10)? 0 : (int) b-(b*fadeValue/256);
  272.    
  273.   strip1.setPixelColor(ledNo, r,g,b);
  274.   #endif
  275.   #ifndef ADAFRUIT_NEOPIXEL_H
  276.   #endif  
  277.   }
  278.  
  279.   void RunningLights(byte red, byte green, byte blue, int WaveDelay) {
  280.   int Position=0;
  281.  
  282.   for(int j=0; j<NUM_LEDS1*2; j++)
  283.   {
  284.       Position++; // = 0; //Position + Rate;
  285.       for(int i=0; i<NUM_LEDS1; i++) {
  286.         // sine wave, 3 offset waves make a rainbow!
  287.         //float level = sin(i+Position) * 127 + 128;
  288.         //setPixel(i,level,0,0);
  289.         //float level = sin(i+Position) * 127 + 128;
  290.         setPixel(i,((sin(i+Position) * 127 + 128)/255)*red,
  291.                    ((sin(i+Position) * 127 + 128)/255)*green,
  292.                    ((sin(i+Position) * 127 + 128)/255)*blue);
  293.       }
  294.      
  295.       showStrip();
  296.       delay(WaveDelay);
  297.   }
  298.   }
  299.  
  300.   void SnowSparkle(byte red, byte green, byte blue, int SparkleDelay, int SpeedDelay) {
  301.   setAll(red,green,blue);
  302.  
  303.   int Pixel = random(NUM_LEDS1);
  304.   setPixel(Pixel,0xff,0xff,0xff);
  305.   showStrip();
  306.   delay(SparkleDelay);
  307.   setPixel(Pixel,red,green,blue);
  308.   showStrip();
  309.   delay(SpeedDelay);
  310.   }
  311.  
  312.   void CylonBounce(byte red, byte green, byte blue, int EyeSize, int SpeedDelay, int ReturnDelay){
  313.  
  314.   for(int i = 0; i < NUM_LEDS1-EyeSize-2; i++) {
  315.     setAll(0,0,0);
  316.     setPixel(i, red/10, green/10, blue/10);
  317.     for(int j = 1; j <= EyeSize; j++) {
  318.       setPixel(i+j, red, green, blue);
  319.     }
  320.     setPixel(i+EyeSize+1, red/10, green/10, blue/10);
  321.     showStrip();
  322.     delay(SpeedDelay);
  323.   }
  324.  
  325.   delay(ReturnDelay);
  326.  
  327.   for(int i = NUM_LEDS1-EyeSize-2; i > 0; i--) {
  328.     setAll(0,0,0);
  329.     setPixel(i, red/10, green/10, blue/10);
  330.     for(int j = 1; j <= EyeSize; j++) {
  331.       setPixel(i+j, red, green, blue);
  332.     }
  333.     setPixel(i+EyeSize+1, red/10, green/10, blue/10);
  334.     showStrip();
  335.     delay(SpeedDelay);
  336.   }
  337.  
  338.   delay(ReturnDelay);
  339.   }
  340.  
  341.   void NewKITT(byte red, byte green, byte blue, int EyeSize, int SpeedDelay, int ReturnDelay){
  342.   RightToLeft(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
  343.   LeftToRight(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
  344.   OutsideToCenter(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
  345.   CenterToOutside(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
  346.   LeftToRight(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
  347.   RightToLeft(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
  348.   OutsideToCenter(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
  349.   CenterToOutside(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
  350.   }
  351.  
  352.   void CenterToOutside(byte red, byte green, byte blue, int EyeSize, int SpeedDelay, int ReturnDelay) {
  353.   for(int i =((NUM_LEDS1-EyeSize)/2); i>=0; i--) {
  354.     setAll(0,0,0);
  355.    
  356.     setPixel(i, red/10, green/10, blue/10);
  357.     for(int j = 1; j <= EyeSize; j++) {
  358.       setPixel(i+j, red, green, blue);
  359.     }
  360.     setPixel(i+EyeSize+1, red/10, green/10, blue/10);
  361.    
  362.     setPixel(NUM_LEDS1-i, red/10, green/10, blue/10);
  363.     for(int j = 1; j <= EyeSize; j++) {
  364.       setPixel(NUM_LEDS1-i-j, red, green, blue);
  365.     }
  366.     setPixel(NUM_LEDS1-i-EyeSize-1, red/10, green/10, blue/10);
  367.    
  368.     showStrip();
  369.     delay(SpeedDelay);
  370.   }
  371.   delay(ReturnDelay);
  372.   }
  373.  
  374.   void OutsideToCenter(byte red, byte green, byte blue, int EyeSize, int SpeedDelay, int ReturnDelay) {
  375.   for(int i = 0; i<=((NUM_LEDS1-EyeSize)/2); i++) {
  376.     setAll(0,0,0);
  377.    
  378.     setPixel(i, red/10, green/10, blue/10);
  379.     for(int j = 1; j <= EyeSize; j++) {
  380.       setPixel(i+j, red, green, blue);
  381.     }
  382.     setPixel(i+EyeSize+1, red/10, green/10, blue/10);
  383.    
  384.     setPixel(NUM_LEDS1-i, red/10, green/10, blue/10);
  385.     for(int j = 1; j <= EyeSize; j++) {
  386.       setPixel(NUM_LEDS1-i-j, red, green, blue);
  387.     }
  388.     setPixel(NUM_LEDS1-i-EyeSize-1, red/10, green/10, blue/10);
  389.    
  390.     showStrip();
  391.     delay(SpeedDelay);
  392.   }
  393.   delay(ReturnDelay);
  394.   }
  395.  
  396.   void LeftToRight(byte red, byte green, byte blue, int EyeSize, int SpeedDelay, int ReturnDelay) {
  397.   for(int i = 0; i < NUM_LEDS1-EyeSize-2; i++) {
  398.     setAll(0,0,0);
  399.     setPixel(i, red/10, green/10, blue/10);
  400.     for(int j = 1; j <= EyeSize; j++) {
  401.       setPixel(i+j, red, green, blue);
  402.     }
  403.     setPixel(i+EyeSize+1, red/10, green/10, blue/10);
  404.     showStrip();
  405.     delay(SpeedDelay);
  406.   }
  407.   delay(ReturnDelay);
  408.   }
  409.  
  410.   void RightToLeft(byte red, byte green, byte blue, int EyeSize, int SpeedDelay, int ReturnDelay) {
  411.   for(int i = NUM_LEDS1-EyeSize-2; i > 0; i--) {
  412.     setAll(0,0,0);
  413.     setPixel(i, red/10, green/10, blue/10);
  414.     for(int j = 1; j <= EyeSize; j++) {
  415.       setPixel(i+j, red, green, blue);
  416.     }
  417.     setPixel(i+EyeSize+1, red/10, green/10, blue/10);
  418.     showStrip();
  419.     delay(SpeedDelay);
  420.   }
  421.   delay(ReturnDelay);
  422.   }
  423.  
  424.   void Strobe(byte red, byte green, byte blue, int StrobeCount, int FlashDelay, int EndPause){
  425.   for(int j = 0; j < StrobeCount; j++) {
  426.     setAll(red,green,blue);
  427.     showStrip();
  428.     delay(FlashDelay);
  429.     setAll(0,0,0);
  430.     showStrip();
  431.     delay(FlashDelay);
  432.   }
  433.  
  434.   delay(EndPause);
  435.   }
  436.  
  437.   void FadeInOut(byte red, byte green, byte blue){
  438.   float r, g, b;
  439.      
  440.   for(int k = 0; k < 256; k=k+1) {
  441.     r = (k/256.0)*red;
  442.     g = (k/256.0)*green;
  443.     b = (k/256.0)*blue;
  444.     setAll(r,g,b);
  445.     showStrip();
  446.   }
  447.      
  448.   for(int k = 255; k >= 0; k=k-2) {
  449.     r = (k/256.0)*red;
  450.     g = (k/256.0)*green;
  451.     b = (k/256.0)*blue;
  452.     setAll(r,g,b);
  453.     showStrip();
  454.   }
  455.   }
  456.  
  457.   void colorWipe(byte red, byte green, byte blue, int SpeedDelay) {
  458.   for(uint16_t i=0; i<NUM_LEDS1; i++) {
  459.       setPixel(i, red, green, blue);
  460.       showStrip();
  461.       delay(SpeedDelay);
  462.   }
  463.   }
  464.  
  465.   void TwinkleRandom(int Count, int SpeedDelay, boolean OnlyOne) {
  466.   setAll(0,0,0);
  467.  
  468.   for (int i=0; i<Count; i++) {
  469.      setPixel(random(NUM_LEDS1),random(0,255),random(0,255),random(0,255));
  470.      showStrip();
  471.      delay(SpeedDelay);
  472.      if(OnlyOne) {
  473.        setAll(0,0,0);
  474.      }
  475.    }
  476.  
  477.   delay(SpeedDelay);
  478.   }
  479.  
  480.   void RGBLoop(){
  481.   for(int j = 0; j < 3; j++ ) {
  482.     // Fade IN
  483.     for(int k = 0; k < 256; k++) {
  484.       switch(j) {
  485.         case 0: setAll(k,0,0); break;
  486.         case 1: setAll(0,k,0); break;
  487.         case 2: setAll(0,0,k); break;
  488.       }
  489.       showStrip();
  490.       delay(3);
  491.     }
  492.     // Fade OUT
  493.     for(int k = 255; k >= 0; k--) {
  494.       switch(j) {
  495.         case 0: setAll(k,0,0); break;
  496.         case 1: setAll(0,k,0); break;
  497.         case 2: setAll(0,0,k); break;
  498.       }
  499.       showStrip();
  500.       delay(3);
  501.     }
  502.   }
  503.   }
  504.  
  505.   void BouncingColoredBalls(int BallCount, byte colors[][3]) {
  506.   float Gravity = -9.81;
  507.   int StartHeight = 1;
  508.  
  509.   float Height[BallCount];
  510.   float ImpactVelocityStart = sqrt( -2 * Gravity * StartHeight );
  511.   float ImpactVelocity[BallCount];
  512.   float TimeSinceLastBounce[BallCount];
  513.   int   Position[BallCount];
  514.   long  ClockTimeSinceLastBounce[BallCount];
  515.   float Dampening[BallCount];
  516.  
  517.   for (int i = 0 ; i < BallCount ; i++) {  
  518.     ClockTimeSinceLastBounce[i] = millis();
  519.     Height[i] = StartHeight;
  520.     Position[i] = 0;
  521.     ImpactVelocity[i] = ImpactVelocityStart;
  522.     TimeSinceLastBounce[i] = 0;
  523.     Dampening[i] = 0.90 - float(i)/pow(BallCount,2);
  524.   }
  525.  
  526.   while (true) {
  527.     for (int i = 0 ; i < BallCount ; i++) {
  528.       TimeSinceLastBounce[i] =  millis() - ClockTimeSinceLastBounce[i];
  529.       Height[i] = 0.5 * Gravity * pow( TimeSinceLastBounce[i]/1000 , 2.0 ) + ImpactVelocity[i] * TimeSinceLastBounce[i]/1000;
  530.  
  531.       if ( Height[i] < 0 ) {                      
  532.         Height[i] = 0;
  533.         ImpactVelocity[i] = Dampening[i] * ImpactVelocity[i];
  534.         ClockTimeSinceLastBounce[i] = millis();
  535.  
  536.         if ( ImpactVelocity[i] < 0.01 ) {
  537.           ImpactVelocity[i] = ImpactVelocityStart;
  538.         }
  539.       }
  540.       Position[i] = round( Height[i] * (NUM_LEDS1 - 1) / StartHeight);
  541.     }
  542.  
  543.     for (int i = 0 ; i < BallCount ; i++) {
  544.       setPixel(Position[i],colors[i][0],colors[i][1],colors[i][2]);
  545.     }
  546.    
  547.     showStrip();
  548.     setAll(0,0,0);
  549.   }
  550.   }
  551.  
  552.  
  553.    void rainbow(int wait)
  554.   {
  555.    
  556.   for(long firstPixelHue = 0; firstPixelHue < 5*65536; firstPixelHue += 256)
  557.       {
  558.       for(int i=0; i<strip1.numPixels(); i++)
  559.      
  560.         {
  561.         int pixelHue = firstPixelHue + (i * 65536L / strip1.numPixels());
  562.         strip1.setPixelColor(i, strip1.gamma32(strip1.ColorHSV(pixelHue)));
  563.         }
  564.  
  565.    strip1.show();
  566.    delay(wait);  
  567.       }
  568.   }
  569.  
  570.   void traite_int1()
  571.   {
  572.  
  573.   // fonction exécutée si interruption détectée
  574.   etatBPMosfetGate = !etatBPMosfetGate;
  575.   volumeLevel= 0;
  576.  
  577.   //digitalWrite(pinled, etat);
  578.   //delay(10);
  579.   digitalWrite (MosfetGate, LOW);
  580.  
  581.  
  582.   }
  583.  
  584.   void traite_int2()
  585.   {
  586.  
  587.   //pinMode(pinled, OUTPUT);
  588.   //delay(10);
  589.   //digitalWrite(pinled, HIGH);
  590.  
  591.   myDFPlayer.pause();
  592.   //delay(10);
  593.  
  594.   }
  595.  
  596.   void traite_int3()
  597.   {
  598.   //delay(10);
  599.   digitalWrite (MosfetGate, HIGH);
  600.   myDFPlayer.start();
  601.   //delay(10);
  602.   }
  603.  
  604.   /*void traite_int4()
  605.   {
  606.   delay(10);
  607.   digitalWrite (MosfetGate, HIGH);
  608.   myDFPlayer.start();
  609.   delay(10);
  610.   }*/
  611.  
  612.   void rainbowCycle(int SpeedDelay) {
  613.   byte *c;
  614.   uint16_t i, j;
  615.  
  616.   for(j=0; j<256*5; j++) { // 5 cycles of all colors on wheel
  617.     for(i=0; i< NUM_LEDS1; i++) {
  618.       c=Wheel(((i * 256 / NUM_LEDS1) + j) & 255);
  619.       setPixel(i, *c, *(c+1), *(c+2));
  620.     }
  621.     showStrip();
  622.     delay(SpeedDelay);
  623.   }
  624.   }
  625.  
  626.   byte * Wheel(byte WheelPos) {
  627.   static byte c[3];
  628.  
  629.   if(WheelPos < 85) {
  630.    c[0]=WheelPos * 3;
  631.    c[1]=255 - WheelPos * 3;
  632.    c[2]=0;
  633.   } else if(WheelPos < 170) {
  634.    WheelPos -= 85;
  635.    c[0]=255 - WheelPos * 3;
  636.    c[1]=0;
  637.    c[2]=WheelPos * 3;
  638.   } else {
  639.    WheelPos -= 170;
  640.    c[0]=0;
  641.    c[1]=WheelPos * 3;
  642.    c[2]=255 - WheelPos * 3;
  643.   }
  644.  
  645.   return c;
  646.   }
  647.  
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!