dillonradio

Untitled

Mar 7th, 2016
141
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 12.86 KB | None | 0 0
  1. /* candle for Adafruit NeoPixel
  2.    1 pixel version
  3.    by Tim Bartlett, December 2013
  4.    Version for FastLED and removed instances of delay()
  5.    Adapted by Rob Hilken, March 2016
  6. */
  7.  
  8. // current settings for 3.5v Teensy 3.1
  9.  
  10. #include <FastLED.h>
  11. #define LED_PIN 2
  12. #define NUM_LEDS 1
  13. #define BRIGHTNESS  100 // set at 25 to run powersaving
  14.  
  15. struct CRGB leds[NUM_LEDS];
  16.  
  17.  
  18. // these are not used yet and may not be the final method of getting the array of LEDs working
  19. byte isLedStatus[NUM_LEDS];             // LED Status: 0=off, 1=on, 2=fading
  20. unsigned long isLedOnTimes[NUM_LEDS];   // millis() at switching on LED
  21. unsigned long onTime = 20000;           // interval after which to fade cande (milliseconds)
  22.  
  23.  
  24. // color variables: mix RGB (0-255) for desired yellow
  25. byte redPx = 255;
  26. byte grnHigh = 100; //110-120 for 5v, 135 for 3.3v
  27. byte bluePx = 10; //10 for 5v, 15 for 3.3v
  28.  
  29. // animation time variables, with recommendations
  30. byte burnDepth = 14; //10 for 5v, 14 for 3.3v -- how much green dips below grnHigh for normal burn -
  31. byte flutterDepth = 30; //25 for 5v, 30 for 3.3v -- maximum dip for flutter
  32. byte cycleTime = 120; //120 -- duration of one dip in milliseconds
  33.  
  34. // global variables
  35. unsigned long currentMillis;
  36. byte fDelay;
  37. byte burnDelay;
  38. byte burnLow;
  39. byte flickDelay;
  40. byte flickLow;
  41. byte flutDelay;
  42. byte flutLow;
  43.  
  44.  
  45. // declare functions because of bug
  46. // https://github.com/FastLED/FastLED/issues/234
  47. bool flutter(byte f, byte n);
  48. bool flicker(byte f, byte n);
  49. bool burn(byte f, byte n);
  50. void on(byte n);
  51. bool fire(byte grnLow, byte animLed);
  52. bool doDelay(unsigned long duration);
  53. void candleAnimation(byte animateCandleNumber);
  54. // end of declaring variables due to bug
  55.  
  56.  
  57. void setup() {
  58.   FastLED.addLeds<WS2811, LED_PIN, RGB>(leds, NUM_LEDS);
  59.   FastLED.setBrightness( BRIGHTNESS );
  60.   fill_solid(leds, NUM_LEDS, CRGB::Black);
  61.  
  62.   randomSeed(analogRead(0));
  63.  
  64.   byte flickerDepth = (burnDepth + flutterDepth) / 2.4;
  65.   burnLow = grnHigh - burnDepth;
  66.   burnDelay = (cycleTime / 2) / burnDepth;
  67.   flickLow = grnHigh - flickerDepth;
  68.   flickDelay = (cycleTime / 2) / flickerDepth;
  69.   flutLow = grnHigh - flutterDepth;
  70.   flutDelay = ((cycleTime / 2) / flutterDepth);
  71.  
  72.   Serial.begin(9600);
  73.   // while (!Serial);       // while the serial stream is not open, do nothing:
  74.  
  75.   /*  // Print variable values for debugging
  76.     Serial.print("flickerDepth = ");
  77.     Serial.println(flickerDepth);
  78.     Serial.print("burnLow = ");
  79.     Serial.println(burnLow);
  80.     Serial.print("burnDelay = ");
  81.     Serial.println(burnDelay);
  82.     Serial.print("flickLow = ");
  83.     Serial.println(flickLow);
  84.     Serial.print("flickDelay = ");
  85.     Serial.println(flickDelay);
  86.     Serial.print("flutLow = ");
  87.     Serial.println(flutLow);
  88.     Serial.print("flutDelay = ");
  89.     Serial.println(flutDelay);
  90.     Serial.println(" ");
  91.   */
  92.  
  93. }
  94.  
  95. void loop() {
  96.   currentMillis = millis();
  97.   candleAnimation(0); // pass ledNumber
  98.   FastLED.show();
  99. }
  100.  
  101. void candleAnimation(byte animateCandleNumber)
  102. {
  103.   /*  each state of the animation calls one of the following animation elements:
  104.         1. on() = solid yellow - does not need a flicker so does not pass a variable
  105.         2. burn(onForSeconds) = candle is burning normally, flickering slightly
  106.         3. flicker(onForSeconds) = candle flickers noticably
  107.         4. flutter(onForSeconds) = the candle needs air!
  108.       the onForSeconds variable tells how long to play that animation element for and also
  109.       passes down into the elements that require effects
  110.   */
  111.  
  112.   // initial value is random
  113.   static byte statenumber = random(0, 4);
  114.  
  115.   // random animation length between 2 and 8 seconds
  116.   byte onForSeconds = random(2, 8); // in seconds
  117.  
  118.   switch (statenumber)
  119.   {
  120.     // state 0: on for seconds equal to onForSeconds
  121.     case 0:
  122.       // on
  123.       on(animateCandleNumber); // does not pass the variable as no effect is required
  124.       // delay
  125.       if (doDelay(onForSeconds * 1000)) // converts to seconds
  126.       {
  127.         // For debugging
  128.         // Serial.print("Finished case 0: On for ");
  129.         // Serial.print(onForSeconds);
  130.         // Serial.println(" seconds");
  131.  
  132.         // go to next state
  133.         statenumber = random(0, 4);
  134.       }
  135.       break;
  136.  
  137.     // state 1: burn for seconds equal to onForSeconds
  138.     case 1:
  139.       // burn
  140.       if (burn(onForSeconds, animateCandleNumber) == true)
  141.       {
  142.         // For debugging
  143.         //Serial.print("Finished case 1: Burn for ");
  144.         //Serial.print(onForSeconds);
  145.         //Serial.println(" seconds");
  146.  
  147.         // go to next state
  148.         statenumber = random(0, 4);
  149.       }
  150.       break;
  151.  
  152.     // state 2: flicker for seconds equal to onForSeconds
  153.     case 2:
  154.       // flicker
  155.       if (flicker(onForSeconds, animateCandleNumber) == true)
  156.       {
  157.  
  158.         // Serial.print("Finished case 2: Flicker for ");
  159.         // Serial.print(onForSeconds);
  160.         // Serial.println(" seconds");
  161.  
  162.         // go to next state
  163.         statenumber = random(0, 4);
  164.       }
  165.       break;
  166.  
  167.     // state 3: flutter for seconds equal to onForSeconds
  168.     case 3:
  169.       // flutter
  170.       if (flutter(onForSeconds, animateCandleNumber) == true)
  171.       {
  172.         // For debugging
  173.         // Serial.print("Finished case 3: Flutter for ");
  174.         // Serial.print(onForSeconds);
  175.         // Serial.println(" seconds");
  176.  
  177.         // go to next state
  178.         statenumber = random(0, 4);
  179.       }
  180.       break;
  181.   }
  182. }
  183.  
  184.  
  185. /*
  186.   For Main Animation States
  187.   non-blocking delay for duration milliseconds
  188.   returns false if delay in progress, else true
  189. */
  190. bool doDelay(unsigned long duration)
  191. {
  192.   // variable to keep track of previous millis
  193.   static unsigned long previousMillis = 0;
  194.  
  195.   // if delay not started
  196.   if (previousMillis == 0)
  197.   {
  198.     // start delay
  199.     previousMillis = currentMillis;
  200.   }
  201.   // if delay has lapsed
  202.   if (currentMillis - previousMillis >= duration)
  203.   {
  204.     // reset previous millis
  205.     previousMillis = 0;
  206.     // indicate that delay has lapsed
  207.     return true;
  208.   }
  209.   // indicate delay in progress
  210.   return false;
  211. }
  212.  
  213.  
  214. /*
  215.   For Animation Element Effects
  216.   non-blocking delay for duration milliseconds
  217.   returns false if delay in progress, else true
  218. */
  219. // basic fire function - not called in main loop
  220.  
  221. bool fire(byte grnLow, byte animLed) {
  222.   // remember if we're dimming (true) or brightening (false)
  223.   static bool fDimming = true;
  224.   // remember value for grnPx
  225.   static int grnPx = grnHigh;
  226.   // remember start time of delay
  227.   static unsigned long previousMillis = 0;
  228.  
  229.   // if in dimming mode
  230.   if (fDimming == true)
  231.   {
  232.     // Serial.println("Dimming");
  233.     // if timing not started yet
  234.     if (previousMillis == 0)
  235.     {
  236.       //write to LED memory. rendering done in the loop()
  237.       leds[animLed] = CRGB(redPx, grnPx, bluePx);
  238.  
  239.       // set start time
  240.       previousMillis = currentMillis;
  241.     }
  242.  
  243.     // if delay lapsed
  244.     if (currentMillis - previousMillis >= fDelay)
  245.     {
  246.       // decrement grnPx
  247.       grnPx--;
  248.  
  249.       // reset start time
  250.       previousMillis = 0;
  251.     }
  252.     // if lower limit reached
  253.     if (grnPx <= grnLow)
  254.     {
  255.       // switch to next state
  256.       fDimming = false;
  257.     }
  258.   }
  259.  
  260.   // if in brightening mode
  261.   //Serial.println("Brightening");
  262.  
  263.   else
  264.   {
  265.     // if timing not started yet
  266.     if (previousMillis == 0)
  267.     {
  268.       //write to LED memory. rendering done in the loop()
  269.       leds[animLed] = CRGB(redPx, grnPx, bluePx);
  270.  
  271.       // set start time
  272.       previousMillis = currentMillis;
  273.     }
  274.  
  275.     // if delay lapsed
  276.     if (currentMillis - previousMillis >= fDelay)
  277.     {
  278.       // increment grnPx
  279.       grnPx++;
  280.  
  281.       // reset start time
  282.       previousMillis = 0;
  283.     }
  284.  
  285.     // if upper limit reached
  286.     if (grnPx >= grnHigh)
  287.     {
  288.       // switch to previous state
  289.       fDimming = true;  // This is causing a bug. when commented grnPx continues to rise
  290.  
  291.       // indicate that we have done one cycle dim and brighten
  292.       // Serial.println("Fire=true");
  293.       return true;
  294.  
  295.     }
  296.   }
  297.  
  298.   // indicate function not completed yet
  299.   // Serial.println("Fire=false");
  300.   return false;
  301. }
  302.  
  303.  
  304. // fire animations
  305. void on(byte n) {
  306.   byte grnPx = grnHigh - 5;
  307.  
  308.   //write to LED memory. rendering done in the loop()
  309.   leds[n] = CRGB(redPx, grnPx, bluePx);
  310. }
  311.  
  312. bool burn(byte f, byte n) {
  313.  
  314.   byte fRep = f * (1000 / cycleTime);
  315.   fDelay = burnDelay;
  316.  
  317.   // remember var count; initial value zero
  318.   static byte var = 0;
  319.  
  320.   // call fire; if the result is true, a cycle has been completed
  321.   if (fire(burnLow, n) == true)
  322.   {
  323.     // increment var
  324.     var++;
  325.   }
  326.  
  327.   // if not fRep cycles done
  328.   if (var < fRep)
  329.   {
  330.     // indicate burn (still) in progress
  331.     return false;
  332.   }
  333.   else {
  334.     // reset var
  335.     var = 0;
  336.     // indicate burn completed
  337.     // Serial.println("Burn Complete");
  338.     return true;
  339.   }
  340. }
  341.  
  342. bool flicker(byte f, byte n) {
  343.  
  344.   byte fRep = f * (1000 / cycleTime);
  345.   static byte statenumber = 0;
  346.   static byte var = 0;
  347.  
  348.   switch (statenumber)
  349.   {
  350.     // state 0: burn once
  351.     case 0:
  352.  
  353.       fDelay = burnDelay;
  354.  
  355.       // call fire; if the result is true, a cycle has been completed
  356.       if (fire(burnLow, n) == true)
  357.       {
  358.         // reset var
  359.         var = 0;
  360.         // go to next state
  361.         statenumber = 1;
  362.       }
  363.       break;
  364.  
  365.     // state 1: flicker fRep times
  366.     case 1:
  367.  
  368.       fDelay = flickDelay;
  369.  
  370.       // call fire; if the result is true, a cycle has been completed
  371.       if (fire(flickLow, n) == true)
  372.       {
  373.         // increment var
  374.         var++;
  375.       }
  376.  
  377.       // if not fRep cycles done
  378.       if (var < fRep)
  379.       {
  380.         // indicate burn (still) in progress
  381.         return false;
  382.       }
  383.       else
  384.       {
  385.         // reset var
  386.         var = 0;
  387.         // go to next state
  388.         statenumber = 2;
  389.  
  390.       }
  391.       break;
  392.  
  393.     // state 2: burn three times
  394.     case 2:
  395.  
  396.       fDelay = burnDelay;
  397.  
  398.       // call fire; if the result is true, a cycle has been completed
  399.       if (fire(burnLow, n) == true)
  400.       {
  401.         // increment var
  402.         var++;
  403.       }
  404.  
  405.       // if not fRep cycles done
  406.       if (var < 3)
  407.       {
  408.         // indicate burn (still) in progress
  409.         return false;
  410.       }
  411.       else
  412.       {
  413.         // reset var
  414.         var = 0;
  415.  
  416.         // reset switch state
  417.         statenumber = 0;
  418.  
  419.         // indicate burn completed
  420.         return true;
  421.       }
  422.       break;
  423.   }
  424.   // indicate function not completed yet
  425.   return false;
  426. }
  427.  
  428. bool flutter(byte f, byte n) {
  429.  
  430.   byte fRep = f * (1000 / cycleTime);
  431.  
  432.   static byte statenumber = 0;
  433.   static byte var = 0;
  434.  
  435.   switch (statenumber)
  436.   {
  437.     // state 0: burn once
  438.     case 0:
  439.       fDelay = burnDelay;
  440.  
  441.       // call fire; if the result is true, a cycle has been completed
  442.       if (fire(burnLow, n) == true)
  443.       {
  444.         // go to next state
  445.         statenumber = 1;
  446.       }
  447.       break;
  448.  
  449.     // state 1: flicker once
  450.     case 1:
  451.       fDelay = flickDelay;
  452.  
  453.       // call fire; if the result is true, a cycle has been completed
  454.       if (fire(flickLow, n) == true)
  455.       {
  456.         // go to next state
  457.         statenumber = 2;
  458.         // reset var
  459.         var = 0;
  460.       }
  461.       break;
  462.  
  463.     // state 2 flutter fRep times
  464.     case 2:
  465.       fDelay = flutDelay;
  466.  
  467.       // call fire; if the result is true, a cycle has been completed
  468.       if (fire(flutLow, n) == true)
  469.       {
  470.         // increment var
  471.         var++;
  472.       }
  473.  
  474.       // if not fRep cycles done
  475.       if (var < fRep)
  476.       {
  477.         // indicate burn (still) in progress
  478.         return false;
  479.       }
  480.  
  481.       if (var == fRep)
  482.       {
  483.         // go to next state
  484.         statenumber = 3;
  485.  
  486.         // reset var
  487.         var = 0;
  488.       }
  489.       break;
  490.  
  491.     // state 3: flicker two times
  492.     case 3:
  493.       fDelay = flickDelay;
  494.  
  495.       // call fire; if the result is true, a cycle has been completed
  496.       if (fire(flickLow, n) == true)
  497.       {
  498.         // increment var
  499.         var++;
  500.       }
  501.  
  502.       // if not fRep cycles done
  503.       if (var < 2)
  504.       {
  505.         // indicate burn (still) in progress
  506.         return false;
  507.       }
  508.  
  509.       if (var == 2)
  510.       {
  511.         // go to next state
  512.         statenumber = 4;
  513.  
  514.         // reset var
  515.         var = 0;
  516.       }
  517.       break;
  518.  
  519.     // state 4: burn two times
  520.     case 4:
  521.       fDelay = burnDelay;
  522.  
  523.       // call fire; if the result is true, a cycle has been completed
  524.       if (fire(burnLow, n) == true)
  525.       {
  526.         // increment var
  527.         var++;
  528.       }
  529.  
  530.       // if not fRep cycles done
  531.       if (var < 2)
  532.       {
  533.         // indicate burn (still) in progress
  534.         return false;
  535.       }
  536.       else
  537.       {
  538.         // reset var
  539.         var = 0;
  540.         // reset switch state
  541.         statenumber = 0;
  542.         // indicate burn completed
  543.         return true;
  544.       }
  545.       break;
  546.  
  547.   }
  548.   // indicate function not completed yet
  549.   return false;
  550. }
Advertisement
Add Comment
Please, Sign In to add comment