API tools faq
paste
Guest User

Untitled

a guest
Jul 7th, 2020
84
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 12.20 KB | None | 0 0
raw download clone embed print report
  1. #include "FastLED.h"
  2. #include <EEPROM.h>
  3. #define NUM_LEDS 150
  4.  
  5. CRGB leds[NUM_LEDS];
  6. #define PIN 5
  7. #define BRIGHTNESS 100
  8.  
  9. #define BUTTON 2
  10. byte selectedEffect=0;
  11.  
  12. void setup()
  13. {
  14. FastLED.addLeds<WS2811, PIN, GRB>(leds, NUM_LEDS).setCorrection( TypicalLEDStrip );
  15. pinMode(2,INPUT_PULLUP); // internal pull-up resistor
  16. attachInterrupt (digitalPinToInterrupt (BUTTON), changeEffect, CHANGE); // pressed
  17. digitalWrite(2, HIGH); // turn on pullup resistors
  18. delay(100); // little 100ms delay before attaching the interrupt for the button
  19.  
  20. }
  21.  
  22. // *** REPLACE FROM HERE ***
  23. void loop() {
  24. EEPROM.get(0,selectedEffect);
  25.  
  26. if(selectedEffect>9) {
  27. selectedEffect=0;
  28. EEPROM.put(0,0);
  29. }
  30.  
  31. switch(selectedEffect) {
  32.  
  33.  
  34.  
  35.  
  36.  
  37.  
  38. case 1 : {
  39. // NewKITT - Color (red, green, blue), eye size, speed delay, end pause
  40. NewKITT(0x00, 0xff, 0x11, 8, 10, 50);
  41. break;
  42. }
  43.  
  44. case 2 : {
  45. // Twinkle - Color (red, green, blue), count, speed delay, only one twinkle (true/false)
  46. RunningLights(0xff,0xd7,0x00, 50);
  47. break;
  48. }
  49.  
  50.  
  51.  
  52. case 3 : {
  53. // Sparkle - Color (red, green, blue), speed delay
  54. Sparkle(0x4d, 0x4d, 0xff, 0);
  55. break;
  56. }
  57.  
  58. case 4 : {
  59. // SnowSparkle - Color (red, green, blue), sparkle delay, speed delay
  60. SnowSparkle(0x38, 0x00, 0x33, 20, random(100,1000));
  61. break;
  62. }
  63.  
  64.  
  65.  
  66. case 5 : {
  67. // rainbowCycle - speed delay
  68. rainbowCycle(20);
  69. break;
  70. }
  71.  
  72.  
  73.  
  74. case 6 : {
  75. // theaterChaseRainbow - Speed delay
  76. theaterChaseRainbow(50);
  77. break;
  78. }
  79.  
  80. case 7 : {
  81. // Fire - Cooling rate, Sparking rate, speed delay
  82. Fire(55,120,15);
  83. break;
  84. }
  85.  
  86.  
  87. // simple bouncingBalls not included, since BouncingColoredBalls can perform this as well as shown below
  88. // BouncingColoredBalls - Number of balls, color (red, green, blue) array, continuous
  89. // CAUTION: If set to continuous then this effect will never stop!!!
  90.  
  91.  
  92.  
  93.  
  94.  
  95. case 8 : {
  96. // meteorRain - Color (red, green, blue), meteor size, trail decay, random trail decay (true/false), speed delay
  97. meteorRain(0x38,0x00,0xff,10, 64, true, 30);
  98. break;
  99. }
  100. }
  101. }
  102.  
  103. void changeEffect() {
  104. if (digitalRead (BUTTON) == HIGH) {
  105. selectedEffect++;
  106. EEPROM.put(0, selectedEffect);
  107. asm volatile (" jmp 0");
  108. }
  109. }
  110.  
  111.  
  112. // *************************
  113. // ** LEDEffect Functions **
  114. // *************************
  115.  
  116.  
  117.  
  118.  
  119. void NewKITT(byte red, byte green, byte blue, int EyeSize, int SpeedDelay, int ReturnDelay){
  120. RightToLeft(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
  121. LeftToRight(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
  122. OutsideToCenter(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
  123. CenterToOutside(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
  124. LeftToRight(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
  125. RightToLeft(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
  126. OutsideToCenter(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
  127. CenterToOutside(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
  128. }
  129.  
  130. // used by NewKITT
  131. void CenterToOutside(byte red, byte green, byte blue, int EyeSize, int SpeedDelay, int ReturnDelay) {
  132. for(int i =((NUM_LEDS-EyeSize)/2); i>=0; i--) {
  133. setAll(0,0,0);
  134.  
  135. setPixel(i, red/10, green/10, blue/10);
  136. for(int j = 1; j <= EyeSize; j++) {
  137. setPixel(i+j, red, green, blue);
  138. }
  139. setPixel(i+EyeSize+1, red/10, green/10, blue/10);
  140.  
  141. setPixel(NUM_LEDS-i, red/10, green/10, blue/10);
  142. for(int j = 1; j <= EyeSize; j++) {
  143. setPixel(NUM_LEDS-i-j, red, green, blue);
  144. }
  145. setPixel(NUM_LEDS-i-EyeSize-1, red/10, green/10, blue/10);
  146.  
  147. showStrip();
  148. delay(SpeedDelay);
  149. }
  150. delay(ReturnDelay);
  151. }
  152.  
  153. // used by NewKITT
  154. void OutsideToCenter(byte red, byte green, byte blue, int EyeSize, int SpeedDelay, int ReturnDelay) {
  155. for(int i = 0; i<=((NUM_LEDS-EyeSize)/2); i++) {
  156. setAll(0,0,0);
  157.  
  158. setPixel(i, red/10, green/10, blue/10);
  159. for(int j = 1; j <= EyeSize; j++) {
  160. setPixel(i+j, red, green, blue);
  161. }
  162. setPixel(i+EyeSize+1, red/10, green/10, blue/10);
  163.  
  164. setPixel(NUM_LEDS-i, red/10, green/10, blue/10);
  165. for(int j = 1; j <= EyeSize; j++) {
  166. setPixel(NUM_LEDS-i-j, red, green, blue);
  167. }
  168. setPixel(NUM_LEDS-i-EyeSize-1, red/10, green/10, blue/10);
  169.  
  170. showStrip();
  171. delay(SpeedDelay);
  172. }
  173. delay(ReturnDelay);
  174. }
  175.  
  176. // used by NewKITT
  177. void LeftToRight(byte red, byte green, byte blue, int EyeSize, int SpeedDelay, int ReturnDelay) {
  178. for(int i = 0; i < NUM_LEDS-EyeSize-2; i++) {
  179. setAll(0,0,0);
  180. setPixel(i, red/10, green/10, blue/10);
  181. for(int j = 1; j <= EyeSize; j++) {
  182. setPixel(i+j, red, green, blue);
  183. }
  184. setPixel(i+EyeSize+1, red/10, green/10, blue/10);
  185. showStrip();
  186. delay(SpeedDelay);
  187. }
  188. delay(ReturnDelay);
  189. }
  190.  
  191. // used by NewKITT
  192. void RightToLeft(byte red, byte green, byte blue, int EyeSize, int SpeedDelay, int ReturnDelay) {
  193. for(int i = NUM_LEDS-EyeSize-2; i > 0; i--) {
  194. setAll(0,0,0);
  195. setPixel(i, red/10, green/10, blue/10);
  196. for(int j = 1; j <= EyeSize; j++) {
  197. setPixel(i+j, red, green, blue);
  198. }
  199. setPixel(i+EyeSize+1, red/10, green/10, blue/10);
  200. showStrip();
  201. delay(SpeedDelay);
  202. }
  203. delay(ReturnDelay);
  204. }
  205.  
  206. void Twinkle(byte red, byte green, byte blue, int Count, int SpeedDelay, boolean OnlyOne) {
  207. setAll(0,0,0);
  208.  
  209. for (int i=0; i<Count; i++) {
  210. setPixel(random(NUM_LEDS),red,green,blue);
  211. showStrip();
  212. delay(SpeedDelay);
  213. if(OnlyOne) {
  214. setAll(0,0,0);
  215. }
  216. }
  217.  
  218. delay(SpeedDelay);
  219. }
  220.  
  221.  
  222. void Sparkle(byte red, byte green, byte blue, int SpeedDelay) {
  223. int Pixel = random(NUM_LEDS);
  224. setPixel(Pixel,red,green,blue);
  225. showStrip();
  226. delay(SpeedDelay);
  227. setPixel(Pixel,0,0,0);
  228. }
  229.  
  230. void SnowSparkle(byte red, byte green, byte blue, int SparkleDelay, int SpeedDelay) {
  231. setAll(red,green,blue);
  232.  
  233. int Pixel = random(NUM_LEDS);
  234. setPixel(Pixel,0xff,0xff,0xff);
  235. showStrip();
  236. delay(SparkleDelay);
  237. setPixel(Pixel,red,green,blue);
  238. showStrip();
  239. delay(SpeedDelay);
  240. }
  241.  
  242. void RunningLights(byte red, byte green, byte blue, int WaveDelay) {
  243. int Position=0;
  244.  
  245. for(int i=0; i<NUM_LEDS*2; i++)
  246. {
  247. Position++; // = 0; //Position + Rate;
  248. for(int i=0; i<NUM_LEDS; i++) {
  249. // sine wave, 3 offset waves make a rainbow!
  250. //float level = sin(i+Position) * 127 + 128;
  251. //setPixel(i,level,0,0);
  252. //float level = sin(i+Position) * 127 + 128;
  253. setPixel(i,((sin(i+Position) * 127 + 128)/255)*red,
  254. ((sin(i+Position) * 127 + 128)/255)*green,
  255. ((sin(i+Position) * 127 + 128)/255)*blue);
  256. }
  257.  
  258. showStrip();
  259. delay(WaveDelay);
  260. }
  261. }
  262.  
  263.  
  264.  
  265. void rainbowCycle(int SpeedDelay) {
  266. byte *c;
  267. uint16_t i, j;
  268.  
  269. for(j=0; j<256*5; j++) { // 5 cycles of all colors on wheel
  270. for(i=0; i< NUM_LEDS; i++) {
  271. c=Wheel(((i * 256 / NUM_LEDS) + j) & 255);
  272. setPixel(i, *c, *(c+1), *(c+2));
  273. }
  274. showStrip();
  275. delay(SpeedDelay);
  276. }
  277. }
  278.  
  279. // used by rainbowCycle and theaterChaseRainbow
  280. byte * Wheel(byte WheelPos) {
  281. static byte c[3];
  282.  
  283. if(WheelPos < 85) {
  284. c[0]=WheelPos * 3;
  285. c[1]=255 - WheelPos * 3;
  286. c[2]=0;
  287. } else if(WheelPos < 170) {
  288. WheelPos -= 85;
  289. c[0]=255 - WheelPos * 3;
  290. c[1]=0;
  291. c[2]=WheelPos * 3;
  292. } else {
  293. WheelPos -= 170;
  294. c[0]=0;
  295. c[1]=WheelPos * 3;
  296. c[2]=255 - WheelPos * 3;
  297. }
  298.  
  299. return c;
  300. }
  301.  
  302.  
  303.  
  304. void theaterChaseRainbow(int SpeedDelay) {
  305. byte *c;
  306.  
  307. for (int j=0; j < 256; j++) { // cycle all 256 colors in the wheel
  308. for (int q=0; q < 3; q++) {
  309. for (int i=0; i < NUM_LEDS; i=i+3) {
  310. c = Wheel( (i+j) % 255);
  311. setPixel(i+q, *c, *(c+1), *(c+2)); //turn every third pixel on
  312. }
  313. showStrip();
  314.  
  315. delay(SpeedDelay);
  316.  
  317. for (int i=0; i < NUM_LEDS; i=i+3) {
  318. setPixel(i+q, 0,0,0); //turn every third pixel off
  319. }
  320. }
  321. }
  322. }
  323.  
  324. void Fire(int Cooling, int Sparking, int SpeedDelay) {
  325. static byte heat[NUM_LEDS];
  326. int cooldown;
  327.  
  328. // Step 1. Cool down every cell a little
  329. for( int i = 0; i < NUM_LEDS; i++) {
  330. cooldown = random(0, ((Cooling * 10) / NUM_LEDS) + 2);
  331.  
  332. if(cooldown>heat[i]) {
  333. heat[i]=0;
  334. } else {
  335. heat[i]=heat[i]-cooldown;
  336. }
  337. }
  338.  
  339. // Step 2. Heat from each cell drifts 'up' and diffuses a little
  340. for( int k= NUM_LEDS - 1; k >= 2; k--) {
  341. heat[k] = (heat[k - 1] + heat[k - 2] + heat[k - 2]) / 3;
  342. }
  343.  
  344. // Step 3. Randomly ignite new 'sparks' near the bottom
  345. if( random(255) < Sparking ) {
  346. int y = random(7);
  347. heat[y] = heat[y] + random(160,255);
  348. //heat[y] = random(160,255);
  349. }
  350.  
  351. // Step 4. Convert heat to LED colors
  352. for( int j = 0; j < NUM_LEDS; j++) {
  353. setPixelHeatColor(j, heat[j] );
  354. }
  355.  
  356. showStrip();
  357. delay(SpeedDelay);
  358. }
  359.  
  360. void setPixelHeatColor (int Pixel, byte temperature) {
  361. // Scale 'heat' down from 0-255 to 0-191
  362. byte t192 = round((temperature/255.0)*191);
  363.  
  364. // calculate ramp up from
  365. byte heatramp = t192 & 0x3F; // 0..63
  366. heatramp <<= 2; // scale up to 0..252
  367.  
  368. // figure out which third of the spectrum we're in:
  369. if( t192 > 0x80) { // hottest
  370. setPixel(Pixel, 255, 255, heatramp);
  371. } else if( t192 > 0x40 ) { // middle
  372. setPixel(Pixel, 255, heatramp, 0);
  373. } else { // coolest
  374. setPixel(Pixel, heatramp, 0, 0);
  375. }
  376. }
  377.  
  378.  
  379.  
  380. void meteorRain(byte red, byte green, byte blue, byte meteorSize, byte meteorTrailDecay, boolean meteorRandomDecay, int SpeedDelay) {
  381. setAll(0,0,0);
  382.  
  383. for(int i = 0; i < NUM_LEDS+NUM_LEDS; i++) {
  384.  
  385.  
  386. // fade brightness all LEDs one step
  387. for(int j=0; j<NUM_LEDS; j++) {
  388. if( (!meteorRandomDecay) || (random(10)>5) ) {
  389. fadeToBlack(j, meteorTrailDecay );
  390. }
  391. }
  392.  
  393. // draw meteor
  394. for(int j = 0; j < meteorSize; j++) {
  395. if( ( i-j <NUM_LEDS) && (i-j>=0) ) {
  396. setPixel(i-j, red, green, blue);
  397. }
  398. }
  399.  
  400. showStrip();
  401. delay(SpeedDelay);
  402. }
  403. }
  404.  
  405. // used by meteorrain
  406. void fadeToBlack(int ledNo, byte fadeValue) {
  407. #ifdef ADAFRUIT_NEOPIXEL_H
  408. // NeoPixel
  409. uint32_t oldColor;
  410. uint8_t r, g, b;
  411. int value;
  412.  
  413. oldColor = strip.getPixelColor(ledNo);
  414. r = (oldColor & 0x00ff0000UL) >> 16;
  415. g = (oldColor & 0x0000ff00UL) >> 8;
  416. b = (oldColor & 0x000000ffUL);
  417.  
  418. r=(r<=10)? 0 : (int) r-(r*fadeValue/256);
  419. g=(g<=10)? 0 : (int) g-(g*fadeValue/256);
  420. b=(b<=10)? 0 : (int) b-(b*fadeValue/256);
  421.  
  422. strip.setPixelColor(ledNo, r,g,b);
  423. #endif
  424. #ifndef ADAFRUIT_NEOPIXEL_H
  425. // FastLED
  426. leds[ledNo].fadeToBlackBy( fadeValue );
  427. #endif
  428. }
  429.  
  430. // *** REPLACE TO HERE ***
  431.  
  432.  
  433.  
  434. // ***************************************
  435. // ** FastLed/NeoPixel Common Functions **
  436. // ***************************************
  437.  
  438. // Apply LED color changes
  439. void showStrip() {
  440. #ifdef ADAFRUIT_NEOPIXEL_H
  441. // NeoPixel
  442. strip.show();
  443. #endif
  444. #ifndef ADAFRUIT_NEOPIXEL_H
  445. // FastLED
  446. FastLED.show();
  447. #endif
  448. }
  449.  
  450. // Set a LED color (not yet visible)
  451. void setPixel(int Pixel, byte red, byte green, byte blue) {
  452. #ifdef ADAFRUIT_NEOPIXEL_H
  453. // NeoPixel
  454. strip.setPixelColor(Pixel, strip.Color(red, green, blue));
  455. #endif
  456. #ifndef ADAFRUIT_NEOPIXEL_H
  457. // FastLED
  458. leds[Pixel].r = red;
  459. leds[Pixel].g = green;
  460. leds[Pixel].b = blue;
  461. #endif
  462. }
  463.  
  464. // Set all LEDs to a given color and apply it (visible)
  465. void setAll(byte red, byte green, byte blue) {
  466. for(int i = 0; i < NUM_LEDS; i++ ) {
  467. setPixel(i, red, green, blue);
  468. }
  469. showStrip();
  470. }
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!