API tools faq
paste
Guest User

Fastled Button sketch

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