API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Dec 20th, 2018
132
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 20.91 KB | None | 0 0
raw download clone embed print report
  1. #include "FastLED.h"
  2. #include <EEPROM.h>
  3. #define NUM_LEDS 60
  4. CRGB leds[NUM_LEDS];
  5. #define PIN 7
  6.  
  7. #define BUTTON 2
  8. byte selectedEffect=0;
  9.  
  10. void setup()
  11. {
  12.   FastLED.addLeds<WS2811, PIN, GRB>(leds, NUM_LEDS).setCorrection( TypicalLEDStrip );
  13.   digitalWrite (BUTTON, HIGH);  // internal pull-up resistor
  14.   attachInterrupt (digitalPinToInterrupt (BUTTON), changeEffect, CHANGE); // pressed
  15.   Serial.begin(9600);
  16. }
  17.  
  18. // *** REPLACE FROM HERE ***
  19. void loop() {
  20.  
  21.   EEPROM.get(0,selectedEffect);
  22.  
  23.   if(selectedEffect>18) {
  24.     selectedEffect=0;
  25.     EEPROM.put(0,0);
  26.   }
  27.   Serial.println(selectedEffect);
  28.   switch(selectedEffect) {
  29.    
  30.     case 0  : {
  31.                 // RGBLoop - no parameters
  32.                 RGBLoop();
  33.                 break;
  34.               }
  35.  
  36.     case 1  : {
  37.                 // FadeInOut - Color (red, green. blue)
  38.                 FadeInOut(0xff, 0x00, 0x00); // red
  39.                 FadeInOut(0xff, 0xff, 0xff); // white
  40.                 FadeInOut(0x00, 0x00, 0xff); // blue
  41.                 break;
  42.               }
  43.              
  44.     case 2  : {
  45.                 // Strobe - Color (red, green, blue), number of flashes, flash speed, end pause
  46.                 Strobe(0xff, 0xff, 0xff, 10, 50, 1000);
  47.                 break;
  48.               }
  49.  
  50.     case 3  : {
  51.                 // HalloweenEyes - Color (red, green, blue), Size of eye, space between eyes, fade (true/false), steps, fade delay, end pause
  52.                 HalloweenEyes(0xff, 0x00, 0x00,
  53.                               1, 4,
  54.                               true, random(5,50), random(50,150),
  55.                               random(1000, 10000));
  56.                 HalloweenEyes(0xff, 0x00, 0x00,
  57.                               1, 4,
  58.                               true, random(5,50), random(50,150),
  59.                               random(1000, 10000));
  60.                 break;
  61.               }
  62.              
  63.     case 4  : {
  64.                 // CylonBounce - Color (red, green, blue), eye size, speed delay, end pause
  65.                 CylonBounce(0xff, 0x00, 0x00, 4, 10, 50);
  66.                 break;
  67.               }
  68.              
  69.     case 5  : {
  70.                 // NewKITT - Color (red, green, blue), eye size, speed delay, end pause
  71.                 NewKITT(0xff, 0x00, 0x00, 8, 10, 50);
  72.                 break;
  73.               }
  74.              
  75.     case 6  : {
  76.                 // Twinkle - Color (red, green, blue), count, speed delay, only one twinkle (true/false)
  77.                 Twinkle(0xff, 0x00, 0x00, 10, 100, false);
  78.                 break;
  79.               }
  80.              
  81.     case 7  : {
  82.                 // TwinkleRandom - twinkle count, speed delay, only one (true/false)
  83.                 TwinkleRandom(20, 100, false);
  84.                 break;
  85.               }
  86.              
  87.     case 8  : {
  88.                 // Sparkle - Color (red, green, blue), speed delay
  89.                 Sparkle(0xff, 0xff, 0xff, 0);
  90.                 break;
  91.               }
  92.                
  93.     case 9  : {
  94.                 // SnowSparkle - Color (red, green, blue), sparkle delay, speed delay
  95.                 SnowSparkle(0x10, 0x10, 0x10, 20, random(100,1000));
  96.                 break;
  97.               }
  98.              
  99.     case 10 : {
  100.                 // Running Lights - Color (red, green, blue), wave dealy
  101.                 RunningLights(0xff,0x00,0x00, 50);  // red
  102.                 RunningLights(0xff,0xff,0xff, 50);  // white
  103.                 RunningLights(0x00,0x00,0xff, 50);  // blue
  104.                 break;
  105.               }
  106.              
  107.     case 11 : {
  108.                 // colorWipe - Color (red, green, blue), speed delay
  109.                 colorWipe(0x00,0xff,0x00, 50);
  110.                 colorWipe(0x00,0x00,0x00, 50);
  111.                 break;
  112.               }
  113.  
  114.     case 12 : {
  115.                 // rainbowCycle - speed delay
  116.                 rainbowCycle(20);
  117.                 break;
  118.               }
  119.  
  120.     case 13 : {
  121.                 // theatherChase - Color (red, green, blue), speed delay
  122.                 theaterChase(0xff,0,0,50);
  123.                 break;
  124.               }
  125.  
  126.     case 14 : {
  127.                 // theaterChaseRainbow - Speed delay
  128.                 theaterChaseRainbow(50);
  129.                 break;
  130.               }
  131.  
  132.     case 15 : {
  133.                 // Fire - Cooling rate, Sparking rate, speed delay
  134.                 Fire(55,120,15);
  135.                 break;
  136.               }
  137.  
  138.  
  139.               // simple bouncingBalls not included, since BouncingColoredBalls can perform this as well as shown below
  140.               // BouncingColoredBalls - Number of balls, color (red, green, blue) array, continuous
  141.               // CAUTION: If set to continuous then this effect will never stop!!!
  142.              
  143.     case 16 : {
  144.                 // mimic BouncingBalls
  145.                 byte onecolor[1][3] = { {0xff, 0x00, 0x00} };
  146.                 BouncingColoredBalls(1, onecolor, false);
  147.                 break;
  148.               }
  149.  
  150.     case 17 : {
  151.                 // multiple colored balls
  152.                 byte colors[3][3] = { {0xff, 0x00, 0x00},
  153.                                       {0xff, 0xff, 0xff},
  154.                                       {0x00, 0x00, 0xff} };
  155.                 BouncingColoredBalls(3, colors, false);
  156.                 break;
  157.               }
  158.  
  159.     case 18 : {
  160.                 // meteorRain - Color (red, green, blue), meteor size, trail decay, random trail decay (true/false), speed delay
  161.                 meteorRain(0xff,0xff,0xff,10, 64, true, 30);
  162.                 break;
  163.               }
  164.   }
  165. }
  166.  
  167. void changeEffect() {
  168.   if (digitalRead (BUTTON) == HIGH) {
  169.     selectedEffect++;
  170.     delay(500);
  171.     EEPROM.put(0, selectedEffect);
  172.     asm volatile ("  jmp 0");
  173.   }
  174. }
  175.  
  176.  
  177. // *************************
  178. // ** LEDEffect Functions **
  179. // *************************
  180.  
  181. void RGBLoop(){
  182.   for(int j = 0; j < 3; j++ ) {
  183.     // Fade IN
  184.     for(int k = 0; k < 256; k++) {
  185.       switch(j) {
  186.         case 0: setAll(k,0,0); break;
  187.         case 1: setAll(0,k,0); break;
  188.         case 2: setAll(0,0,k); break;
  189.       }
  190.       showStrip();
  191.       delay(3);
  192.     }
  193.     // Fade OUT
  194.     for(int k = 255; k >= 0; k--) {
  195.       switch(j) {
  196.         case 0: setAll(k,0,0); break;
  197.         case 1: setAll(0,k,0); break;
  198.         case 2: setAll(0,0,k); break;
  199.       }
  200.       showStrip();
  201.       delay(3);
  202.     }
  203.   }
  204. }
  205.  
  206. void FadeInOut(byte red, byte green, byte blue){
  207.   float r, g, b;
  208.      
  209.   for(int k = 0; k < 256; k=k+1) {
  210.     r = (k/256.0)*red;
  211.     g = (k/256.0)*green;
  212.     b = (k/256.0)*blue;
  213.     setAll(r,g,b);
  214.     showStrip();
  215.   }
  216.      
  217.   for(int k = 255; k >= 0; k=k-2) {
  218.     r = (k/256.0)*red;
  219.     g = (k/256.0)*green;
  220.     b = (k/256.0)*blue;
  221.     setAll(r,g,b);
  222.     showStrip();
  223.   }
  224. }
  225.  
  226. void Strobe(byte red, byte green, byte blue, int StrobeCount, int FlashDelay, int EndPause){
  227.   for(int j = 0; j < StrobeCount; j++) {
  228.     setAll(red,green,blue);
  229.     showStrip();
  230.     delay(FlashDelay);
  231.     setAll(0,0,0);
  232.     showStrip();
  233.     delay(FlashDelay);
  234.   }
  235.  
  236.  delay(EndPause);
  237. }
  238.  
  239. void HalloweenEyes(byte red, byte green, byte blue,
  240.                    int EyeWidth, int EyeSpace,
  241.                    boolean Fade, int Steps, int FadeDelay,
  242.                    int EndPause){
  243.   randomSeed(analogRead(0));
  244.  
  245.   int i;
  246.   int StartPoint  = random( 0, NUM_LEDS - (2*EyeWidth) - EyeSpace );
  247.   int Start2ndEye = StartPoint + EyeWidth + EyeSpace;
  248.  
  249.   for(i = 0; i < EyeWidth; i++) {
  250.     setPixel(StartPoint + i, red, green, blue);
  251.     setPixel(Start2ndEye + i, red, green, blue);
  252.   }
  253.  
  254.   showStrip();
  255.  
  256.   if(Fade==true) {
  257.     float r, g, b;
  258.  
  259.     for(int j = Steps; j >= 0; j--) {
  260.       r = j*(red/Steps);
  261.       g = j*(green/Steps);
  262.       b = j*(blue/Steps);
  263.      
  264.       for(i = 0; i < EyeWidth; i++) {
  265.         setPixel(StartPoint + i, r, g, b);
  266.         setPixel(Start2ndEye + i, r, g, b);
  267.       }
  268.      
  269.       showStrip();
  270.       delay(FadeDelay);
  271.     }
  272.   }
  273.  
  274.   setAll(0,0,0); // Set all black
  275.  
  276.   delay(EndPause);
  277. }
  278.  
  279. void CylonBounce(byte red, byte green, byte blue, int EyeSize, int SpeedDelay, int ReturnDelay){
  280.  
  281.   for(int i = 0; i < NUM_LEDS-EyeSize-2; i++) {
  282.     setAll(0,0,0);
  283.     setPixel(i, red/10, green/10, blue/10);
  284.     for(int j = 1; j <= EyeSize; j++) {
  285.       setPixel(i+j, red, green, blue);
  286.     }
  287.     setPixel(i+EyeSize+1, red/10, green/10, blue/10);
  288.     showStrip();
  289.     delay(SpeedDelay);
  290.   }
  291.  
  292.   delay(ReturnDelay);
  293.  
  294.   for(int i = NUM_LEDS-EyeSize-2; i > 0; i--) {
  295.     setAll(0,0,0);
  296.     setPixel(i, red/10, green/10, blue/10);
  297.     for(int j = 1; j <= EyeSize; j++) {
  298.       setPixel(i+j, red, green, blue);
  299.     }
  300.     setPixel(i+EyeSize+1, red/10, green/10, blue/10);
  301.     showStrip();
  302.     delay(SpeedDelay);
  303.   }
  304.  
  305.   delay(ReturnDelay);
  306. }
  307.  
  308. void NewKITT(byte red, byte green, byte blue, int EyeSize, int SpeedDelay, int ReturnDelay){
  309.   RightToLeft(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
  310.   LeftToRight(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
  311.   OutsideToCenter(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
  312.   CenterToOutside(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
  313.   LeftToRight(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
  314.   RightToLeft(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
  315.   OutsideToCenter(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
  316.   CenterToOutside(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
  317. }
  318.  
  319. // used by NewKITT
  320. void CenterToOutside(byte red, byte green, byte blue, int EyeSize, int SpeedDelay, int ReturnDelay) {
  321.   for(int i =((NUM_LEDS-EyeSize)/2); i>=0; i--) {
  322.     setAll(0,0,0);
  323.    
  324.     setPixel(i, red/10, green/10, blue/10);
  325.     for(int j = 1; j <= EyeSize; j++) {
  326.       setPixel(i+j, red, green, blue);
  327.     }
  328.     setPixel(i+EyeSize+1, red/10, green/10, blue/10);
  329.    
  330.     setPixel(NUM_LEDS-i, red/10, green/10, blue/10);
  331.     for(int j = 1; j <= EyeSize; j++) {
  332.       setPixel(NUM_LEDS-i-j, red, green, blue);
  333.     }
  334.     setPixel(NUM_LEDS-i-EyeSize-1, red/10, green/10, blue/10);
  335.    
  336.     showStrip();
  337.     delay(SpeedDelay);
  338.   }
  339.   delay(ReturnDelay);
  340. }
  341.  
  342. // used by NewKITT
  343. void OutsideToCenter(byte red, byte green, byte blue, int EyeSize, int SpeedDelay, int ReturnDelay) {
  344.   for(int i = 0; i<=((NUM_LEDS-EyeSize)/2); i++) {
  345.     setAll(0,0,0);
  346.    
  347.     setPixel(i, red/10, green/10, blue/10);
  348.     for(int j = 1; j <= EyeSize; j++) {
  349.       setPixel(i+j, red, green, blue);
  350.     }
  351.     setPixel(i+EyeSize+1, red/10, green/10, blue/10);
  352.    
  353.     setPixel(NUM_LEDS-i, red/10, green/10, blue/10);
  354.     for(int j = 1; j <= EyeSize; j++) {
  355.       setPixel(NUM_LEDS-i-j, red, green, blue);
  356.     }
  357.     setPixel(NUM_LEDS-i-EyeSize-1, red/10, green/10, blue/10);
  358.    
  359.     showStrip();
  360.     delay(SpeedDelay);
  361.   }
  362.   delay(ReturnDelay);
  363. }
  364.  
  365. // used by NewKITT
  366. void LeftToRight(byte red, byte green, byte blue, int EyeSize, int SpeedDelay, int ReturnDelay) {
  367.   for(int i = 0; i < NUM_LEDS-EyeSize-2; i++) {
  368.     setAll(0,0,0);
  369.     setPixel(i, red/10, green/10, blue/10);
  370.     for(int j = 1; j <= EyeSize; j++) {
  371.       setPixel(i+j, red, green, blue);
  372.     }
  373.     setPixel(i+EyeSize+1, red/10, green/10, blue/10);
  374.     showStrip();
  375.     delay(SpeedDelay);
  376.   }
  377.   delay(ReturnDelay);
  378. }
  379.  
  380. // used by NewKITT
  381. void RightToLeft(byte red, byte green, byte blue, int EyeSize, int SpeedDelay, int ReturnDelay) {
  382.   for(int i = NUM_LEDS-EyeSize-2; i > 0; i--) {
  383.     setAll(0,0,0);
  384.     setPixel(i, red/10, green/10, blue/10);
  385.     for(int j = 1; j <= EyeSize; j++) {
  386.       setPixel(i+j, red, green, blue);
  387.     }
  388.     setPixel(i+EyeSize+1, red/10, green/10, blue/10);
  389.     showStrip();
  390.     delay(SpeedDelay);
  391.   }
  392.   delay(ReturnDelay);
  393. }
  394.  
  395. void Twinkle(byte red, byte green, byte blue, int Count, int SpeedDelay, boolean OnlyOne) {
  396.   setAll(0,0,0);
  397.  
  398.   for (int i=0; i<Count; i++) {
  399.      setPixel(random(NUM_LEDS),red,green,blue);
  400.      showStrip();
  401.      delay(SpeedDelay);
  402.      if(OnlyOne) {
  403.        setAll(0,0,0);
  404.      }
  405.    }
  406.  
  407.   delay(SpeedDelay);
  408. }
  409.  
  410. void TwinkleRandom(int Count, int SpeedDelay, boolean OnlyOne) {
  411.   setAll(0,0,0);
  412.  
  413.   for (int i=0; i<Count; i++) {
  414.      setPixel(random(NUM_LEDS),random(0,255),random(0,255),random(0,255));
  415.      showStrip();
  416.      delay(SpeedDelay);
  417.      if(OnlyOne) {
  418.        setAll(0,0,0);
  419.      }
  420.    }
  421.  
  422.   delay(SpeedDelay);
  423. }
  424.  
  425. void Sparkle(byte red, byte green, byte blue, int SpeedDelay) {
  426.   int Pixel = random(NUM_LEDS);
  427.   setPixel(Pixel,red,green,blue);
  428.   showStrip();
  429.   delay(SpeedDelay);
  430.   setPixel(Pixel,0,0,0);
  431. }
  432.  
  433. void SnowSparkle(byte red, byte green, byte blue, int SparkleDelay, int SpeedDelay) {
  434.   setAll(red,green,blue);
  435.  
  436.   int Pixel = random(NUM_LEDS);
  437.   setPixel(Pixel,0xff,0xff,0xff);
  438.   showStrip();
  439.   delay(SparkleDelay);
  440.   setPixel(Pixel,red,green,blue);
  441.   showStrip();
  442.   delay(SpeedDelay);
  443. }
  444.  
  445. void RunningLights(byte red, byte green, byte blue, int WaveDelay) {
  446.   int Position=0;
  447.  
  448.   for(int i=0; i<NUM_LEDS*2; i++)
  449.   {
  450.       Position++; // = 0; //Position + Rate;
  451.       for(int i=0; i<NUM_LEDS; i++) {
  452.         // sine wave, 3 offset waves make a rainbow!
  453.         //float level = sin(i+Position) * 127 + 128;
  454.         //setPixel(i,level,0,0);
  455.         //float level = sin(i+Position) * 127 + 128;
  456.         setPixel(i,((sin(i+Position) * 127 + 128)/255)*red,
  457.                    ((sin(i+Position) * 127 + 128)/255)*green,
  458.                    ((sin(i+Position) * 127 + 128)/255)*blue);
  459.       }
  460.      
  461.       showStrip();
  462.       delay(WaveDelay);
  463.   }
  464. }
  465.  
  466. void colorWipe(byte red, byte green, byte blue, int SpeedDelay) {
  467.   for(uint16_t i=0; i<NUM_LEDS; i++) {
  468.       setPixel(i, red, green, blue);
  469.       showStrip();
  470.       delay(SpeedDelay);
  471.   }
  472. }
  473.  
  474. void rainbowCycle(int SpeedDelay) {
  475.   byte *c;
  476.   uint16_t i, j;
  477.  
  478.   for(j=0; j<256*5; j++) { // 5 cycles of all colors on wheel
  479.     for(i=0; i< NUM_LEDS; i++) {
  480.       c=Wheel(((i * 256 / NUM_LEDS) + j) & 255);
  481.       setPixel(i, *c, *(c+1), *(c+2));
  482.     }
  483.     showStrip();
  484.     delay(SpeedDelay);
  485.   }
  486. }
  487.  
  488. // used by rainbowCycle and theaterChaseRainbow
  489. byte * Wheel(byte WheelPos) {
  490.   static byte c[3];
  491.  
  492.   if(WheelPos < 85) {
  493.    c[0]=WheelPos * 3;
  494.    c[1]=255 - WheelPos * 3;
  495.    c[2]=0;
  496.   } else if(WheelPos < 170) {
  497.    WheelPos -= 85;
  498.    c[0]=255 - WheelPos * 3;
  499.    c[1]=0;
  500.    c[2]=WheelPos * 3;
  501.   } else {
  502.    WheelPos -= 170;
  503.    c[0]=0;
  504.    c[1]=WheelPos * 3;
  505.    c[2]=255 - WheelPos * 3;
  506.   }
  507.  
  508.   return c;
  509. }
  510.  
  511. void theaterChase(byte red, byte green, byte blue, int SpeedDelay) {
  512.   for (int j=0; j<10; j++) {  //do 10 cycles of chasing
  513.     for (int q=0; q < 3; q++) {
  514.       for (int i=0; i < NUM_LEDS; i=i+3) {
  515.         setPixel(i+q, red, green, blue);    //turn every third pixel on
  516.       }
  517.       showStrip();
  518.      
  519.       delay(SpeedDelay);
  520.      
  521.       for (int i=0; i < NUM_LEDS; i=i+3) {
  522.         setPixel(i+q, 0,0,0);        //turn every third pixel off
  523.       }
  524.     }
  525.   }
  526. }
  527.  
  528. void theaterChaseRainbow(int SpeedDelay) {
  529.   byte *c;
  530.  
  531.   for (int j=0; j < 256; j++) {     // cycle all 256 colors in the wheel
  532.     for (int q=0; q < 3; q++) {
  533.         for (int i=0; i < NUM_LEDS; i=i+3) {
  534.           c = Wheel( (i+j) % 255);
  535.           setPixel(i+q, *c, *(c+1), *(c+2));    //turn every third pixel on
  536.         }
  537.         showStrip();
  538.        
  539.         delay(SpeedDelay);
  540.        
  541.         for (int i=0; i < NUM_LEDS; i=i+3) {
  542.           setPixel(i+q, 0,0,0);        //turn every third pixel off
  543.         }
  544.     }
  545.   }
  546. }
  547.  
  548. void Fire(int Cooling, int Sparking, int SpeedDelay) {
  549.   static byte heat[NUM_LEDS];
  550.   int cooldown;
  551.  
  552.   // Step 1.  Cool down every cell a little
  553.   for( int i = 0; i < NUM_LEDS; i++) {
  554.     cooldown = random(0, ((Cooling * 10) / NUM_LEDS) + 2);
  555.    
  556.     if(cooldown>heat[i]) {
  557.       heat[i]=0;
  558.     } else {
  559.       heat[i]=heat[i]-cooldown;
  560.     }
  561.   }
  562.  
  563.   // Step 2.  Heat from each cell drifts 'up' and diffuses a little
  564.   for( int k= NUM_LEDS - 1; k >= 2; k--) {
  565.     heat[k] = (heat[k - 1] + heat[k - 2] + heat[k - 2]) / 3;
  566.   }
  567.    
  568.   // Step 3.  Randomly ignite new 'sparks' near the bottom
  569.   if( random(255) < Sparking ) {
  570.     int y = random(7);
  571.     heat[y] = heat[y] + random(160,255);
  572.     //heat[y] = random(160,255);
  573.   }
  574.  
  575.   // Step 4.  Convert heat to LED colors
  576.   for( int j = 0; j < NUM_LEDS; j++) {
  577.     setPixelHeatColor(j, heat[j] );
  578.   }
  579.  
  580.   showStrip();
  581.   delay(SpeedDelay);
  582. }
  583.  
  584. void setPixelHeatColor (int Pixel, byte temperature) {
  585.   // Scale 'heat' down from 0-255 to 0-191
  586.   byte t192 = round((temperature/255.0)*191);
  587.  
  588.   // calculate ramp up from
  589.   byte heatramp = t192 & 0x3F; // 0..63
  590.   heatramp <<= 2; // scale up to 0..252
  591.  
  592.   // figure out which third of the spectrum we're in:
  593.   if( t192 > 0x80) {                     // hottest
  594.     setPixel(Pixel, 255, 255, heatramp);
  595.   } else if( t192 > 0x40 ) {             // middle
  596.     setPixel(Pixel, 255, heatramp, 0);
  597.   } else {                               // coolest
  598.     setPixel(Pixel, heatramp, 0, 0);
  599.   }
  600. }
  601.  
  602. void BouncingColoredBalls(int BallCount, byte colors[][3], boolean continuous) {
  603.   float Gravity = -9.81;
  604.   int StartHeight = 1;
  605.  
  606.   float Height[BallCount];
  607.   float ImpactVelocityStart = sqrt( -2 * Gravity * StartHeight );
  608.   float ImpactVelocity[BallCount];
  609.   float TimeSinceLastBounce[BallCount];
  610.   int   Position[BallCount];
  611.   long  ClockTimeSinceLastBounce[BallCount];
  612.   float Dampening[BallCount];
  613.   boolean ballBouncing[BallCount];
  614.   boolean ballsStillBouncing = true;
  615.  
  616.   for (int i = 0 ; i < BallCount ; i++) {  
  617.     ClockTimeSinceLastBounce[i] = millis();
  618.     Height[i] = StartHeight;
  619.     Position[i] = 0;
  620.     ImpactVelocity[i] = ImpactVelocityStart;
  621.     TimeSinceLastBounce[i] = 0;
  622.     Dampening[i] = 0.90 - float(i)/pow(BallCount,2);
  623.     ballBouncing[i]=true;
  624.   }
  625.  
  626.   while (ballsStillBouncing) {
  627.     for (int i = 0 ; i < BallCount ; i++) {
  628.       TimeSinceLastBounce[i] =  millis() - ClockTimeSinceLastBounce[i];
  629.       Height[i] = 0.5 * Gravity * pow( TimeSinceLastBounce[i]/1000 , 2.0 ) + ImpactVelocity[i] * TimeSinceLastBounce[i]/1000;
  630.  
  631.       if ( Height[i] < 0 ) {                      
  632.         Height[i] = 0;
  633.         ImpactVelocity[i] = Dampening[i] * ImpactVelocity[i];
  634.         ClockTimeSinceLastBounce[i] = millis();
  635.  
  636.         if ( ImpactVelocity[i] < 0.01 ) {
  637.           if (continuous) {
  638.             ImpactVelocity[i] = ImpactVelocityStart;
  639.           } else {
  640.             ballBouncing[i]=false;
  641.           }
  642.         }
  643.       }
  644.       Position[i] = round( Height[i] * (NUM_LEDS - 1) / StartHeight);
  645.     }
  646.  
  647.     ballsStillBouncing = false; // assume no balls bouncing
  648.     for (int i = 0 ; i < BallCount ; i++) {
  649.       setPixel(Position[i],colors[i][0],colors[i][1],colors[i][2]);
  650.       if ( ballBouncing[i] ) {
  651.         ballsStillBouncing = true;
  652.       }
  653.     }
  654.    
  655.     showStrip();
  656.     setAll(0,0,0);
  657.   }
  658. }
  659.  
  660. void meteorRain(byte red, byte green, byte blue, byte meteorSize, byte meteorTrailDecay, boolean meteorRandomDecay, int SpeedDelay) {  
  661.   setAll(0,0,0);
  662.  
  663.   for(int i = 0; i < NUM_LEDS+NUM_LEDS; i++) {
  664.    
  665.    
  666.     // fade brightness all LEDs one step
  667.     for(int j=0; j<NUM_LEDS; j++) {
  668.       if( (!meteorRandomDecay) || (random(10)>5) ) {
  669.         fadeToBlack(j, meteorTrailDecay );        
  670.       }
  671.     }
  672.    
  673.     // draw meteor
  674.     for(int j = 0; j < meteorSize; j++) {
  675.       if( ( i-j <NUM_LEDS) && (i-j>=0) ) {
  676.         setPixel(i-j, red, green, blue);
  677.       }
  678.     }
  679.    
  680.     showStrip();
  681.     delay(SpeedDelay);
  682.   }
  683. }
  684.  
  685. // used by meteorrain
  686. void fadeToBlack(int ledNo, byte fadeValue) {
  687.  #ifdef ADAFRUIT_NEOPIXEL_H
  688.     // NeoPixel
  689.     uint32_t oldColor;
  690.     uint8_t r, g, b;
  691.     int value;
  692.    
  693.     oldColor = strip.getPixelColor(ledNo);
  694.     r = (oldColor & 0x00ff0000UL) >> 16;
  695.     g = (oldColor & 0x0000ff00UL) >> 8;
  696.     b = (oldColor & 0x000000ffUL);
  697.  
  698.     r=(r<=10)? 0 : (int) r-(r*fadeValue/256);
  699.     g=(g<=10)? 0 : (int) g-(g*fadeValue/256);
  700.     b=(b<=10)? 0 : (int) b-(b*fadeValue/256);
  701.    
  702.     strip.setPixelColor(ledNo, r,g,b);
  703.  #endif
  704.  #ifndef ADAFRUIT_NEOPIXEL_H
  705.    // FastLED
  706.    leds[ledNo].fadeToBlackBy( fadeValue );
  707.  #endif  
  708. }
  709.  
  710. // *** REPLACE TO HERE ***
  711.  
  712.  
  713.  
  714. // ***************************************
  715. // ** FastLed/NeoPixel Common Functions **
  716. // ***************************************
  717.  
  718. // Apply LED color changes
  719. void showStrip() {
  720.  #ifdef ADAFRUIT_NEOPIXEL_H
  721.    // NeoPixel
  722.    strip.show();
  723.  #endif
  724.  #ifndef ADAFRUIT_NEOPIXEL_H
  725.    // FastLED
  726.    FastLED.show();
  727.  #endif
  728. }
  729.  
  730. // Set a LED color (not yet visible)
  731. void setPixel(int Pixel, byte red, byte green, byte blue) {
  732.  #ifdef ADAFRUIT_NEOPIXEL_H
  733.    // NeoPixel
  734.    strip.setPixelColor(Pixel, strip.Color(red, green, blue));
  735.  #endif
  736.  #ifndef ADAFRUIT_NEOPIXEL_H
  737.    // FastLED
  738.    leds[Pixel].r = red;
  739.    leds[Pixel].g = green;
  740.    leds[Pixel].b = blue;
  741.      //Serial.println("hue");
  742.  
  743.   // leds[Pixel].setHue(20);  // ne fonctionne pas animation fixe
  744.   leds[Pixel] += CHSV( 100, 0, 0);
  745.  #endif
  746. }
  747.  
  748. // Set all LEDs to a given color and apply it (visible)
  749. void setAll(byte red, byte green, byte blue) {
  750.   for(int i = 0; i < NUM_LEDS; i++ ) {
  751.     setPixel(i, red, green, blue);
  752.   }
  753.   showStrip();
  754. }
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!