API tools faq
paste
Advertisement
Guest User

Untitled

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