API tools faq
paste
Advertisement
liuk90

Untitled

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