S_Robertson

Rainbow/Blue/Purple NeoPixel Code v0.03

Nov 21st, 2020
968
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #import <Adafruit_NeoPixel.h>;
  2.  
  3. //---------------------------
  4. // Parameters
  5. // NeoPixel parameters
  6. #define LED_PIN           3
  7. #define LED_COUNT         12
  8. #define LED_BRIGHTNESS    64
  9.  
  10.  
  11. // Define the input pin
  12. #define BUTTON_PIN        2
  13.  
  14. // Define the delay length (aka speed; higher numbers are slower)
  15. #define DELAY_LENGTH_RAINBOW      10
  16. #define DELAY_LENGTH_BLUE         150
  17. #define DELAY_LENGTH_PURPLE       150
  18.  
  19. // Define the number of times to repeat each pattern
  20. #define CYCLE_MAX_RAINBOW         75
  21. #define CYCLE_MAX_BLUE            5
  22. #define CYCLE_MAX_PURPLE          5
  23. #define CYCLE_MAX                 1474559   // 1,474,559 is the max possible value before the int rolls over into negatives and the comparison breaks.
  24.  
  25.  
  26. #define DEBUG
  27. //---------------------------
  28.  
  29. //---------------------------
  30. // Globals
  31. // Create the strip state machine
  32. enum StateMachine { OFF, INIT_RAINBOW, RAINBOW, UPDATE_RAINBOW, INIT_BLUE, BLUE, UPDATE_BLUE, INIT_PURPLE, PURPLE, UPDATE_PURPLE, INIT_OFF };
  33. StateMachine strip_state;
  34.  
  35. // Create the timer
  36. unsigned long timer;
  37.  
  38. // Create the color index
  39. int index;
  40. // Create the cycle counter
  41. int cycle_count;
  42.  
  43. // Create the debounce flag for the button
  44. bool debounce;
  45.  
  46.  
  47. // Create the strip
  48. Adafruit_NeoPixel strip = Adafruit_NeoPixel(LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800);
  49. //---------------------------
  50.  
  51. void setup() {
  52.   // Initialize and clear the strip
  53.   strip.begin();
  54.   strip.setBrightness(LED_BRIGHTNESS);
  55.   strip.clear();
  56.  
  57.   // Set the state of the LED strip to INIT_RAINBOW
  58.   strip_state = INIT_RAINBOW;
  59.  
  60.   // Set the rainbow index to 0
  61.   index = 0;
  62.  
  63.   // Initialize the button
  64.   pinMode(BUTTON_PIN, INPUT_PULLUP);
  65.  
  66.   // Initialize the debounce flag;
  67.   debounce = 0;
  68.  
  69. #ifdef DEBUG
  70.   //Init serial
  71.   Serial.begin(9600);
  72. #endif
  73. }
  74.  
  75. void loop() {
  76.   // Run the state machine
  77.   switch (strip_state) {
  78.     //    State: INIT_OFF
  79.     case INIT_OFF:
  80. #ifdef DEBUG
  81.       Serial.println("STATE: OFF");
  82. #endif
  83.       //    Turn all LEDs off
  84.       strip.clear();
  85.       strip.show();
  86.       //    Set the state to OFF
  87.       strip_state = OFF;
  88.  
  89.     //    State: OFF
  90.     case OFF:
  91.       break;
  92.  
  93.     //    State: INIT_RAINBOW
  94.     case INIT_RAINBOW:
  95. #ifdef DEBUG
  96.       Serial.println("STATE: RAINBOW");
  97. #endif
  98.  
  99.       // Set timer
  100.       timer = millis() + DELAY_LENGTH_RAINBOW;
  101.  
  102.       // Set the state to RAINBOW
  103.       strip_state = RAINBOW;
  104.  
  105.     // State: RAINBOW
  106.     case RAINBOW:
  107.       // If timer has expired, update the effect
  108.       if (millis() > timer) {
  109.         strip_state = UPDATE_RAINBOW;
  110.       }
  111.  
  112.       checkButton(BUTTON_PIN);
  113.  
  114.       if (cycle_count >= CYCLE_MAX_RAINBOW) {
  115.         cycle_count = 0;
  116.         index = index % 256;
  117.         strip_state = INIT_BLUE;
  118.       }
  119.  
  120.       break;
  121.  
  122.     case UPDATE_RAINBOW:
  123.  
  124. #ifdef DEBUG
  125.       Serial.println("STATE: RAINBOW_UPDATE");
  126. #endif
  127.  
  128.       // Set timer
  129.       timer = millis() + DELAY_LENGTH_RAINBOW;
  130.  
  131. #ifdef DEBUG
  132.       Serial.print("Millis: ");
  133.       Serial.print(millis());
  134.       Serial.print("     Timer: ");
  135.       Serial.print(timer);
  136.       Serial.print("     Cycle: ");
  137.       Serial.print(cycle_count);
  138.       Serial.println();
  139. #endif
  140.  
  141.       updateStrip(strip);
  142.  
  143.       strip_state = RAINBOW;
  144.  
  145.       break;
  146.  
  147.     //    State: INIT_BLUE
  148.     case INIT_BLUE:
  149. #ifdef DEBUG
  150.       Serial.println("STATE: BLUE");
  151. #endif
  152.  
  153.       // Set timer
  154.       timer = millis() + DELAY_LENGTH_BLUE;
  155.  
  156.       // Set the state to BLUE
  157.       strip_state = BLUE;
  158.  
  159.     //    State: BLUE
  160.     case BLUE:
  161.       if (millis() > timer) {
  162.         strip_state = UPDATE_BLUE;
  163.       }
  164.  
  165.       checkButton(BUTTON_PIN);
  166.  
  167.       if (cycle_count >= CYCLE_MAX_BLUE) {
  168.         cycle_count = 0;
  169.         index = index % 256;
  170.         strip_state = INIT_PURPLE;
  171.       }
  172.  
  173.       break;
  174.  
  175.     case UPDATE_BLUE:
  176.  
  177. #ifdef DEBUG
  178.       Serial.println("STATE: BLUE_UPDATE");
  179. #endif
  180.  
  181.       // Set timer
  182.       timer = millis() + DELAY_LENGTH_BLUE;
  183.  
  184. #ifdef DEBUG
  185.       Serial.print("Millis: ");
  186.       Serial.print(millis());
  187.       Serial.print("     Timer: ");
  188.       Serial.print(timer);
  189.       Serial.print("     Cycle: ");
  190.       Serial.print(cycle_count);
  191.       Serial.println();
  192. #endif
  193.  
  194.       updateStrip(strip);
  195.  
  196.       strip_state = BLUE;
  197.  
  198.       break;
  199.  
  200.     //    State: INIT_PURPLE
  201.     case INIT_PURPLE:
  202. #ifdef DEBUG
  203.       Serial.println("STATE: PURPLE");
  204. #endif
  205.  
  206.       // Set timer
  207.       timer = millis() + DELAY_LENGTH_PURPLE;
  208.  
  209.       // Set the state to PURPLE
  210.       strip_state = PURPLE;
  211.  
  212.     //    State: PURPLE
  213.     case PURPLE:
  214.       if (millis() > timer) {
  215.         strip_state = UPDATE_PURPLE;
  216.       }
  217.  
  218.       checkButton(BUTTON_PIN);
  219.  
  220.       if (cycle_count >= CYCLE_MAX_PURPLE) {
  221.         cycle_count = 0;
  222.         index = index % 256;
  223.         strip_state = INIT_RAINBOW;
  224.       }
  225.  
  226.       break;
  227.  
  228.     case UPDATE_PURPLE:
  229.  
  230. #ifdef DEBUG
  231.       Serial.println("STATE: PURPLE_UPDATE");
  232. #endif
  233.  
  234.       // Set timer
  235.       timer = millis() + DELAY_LENGTH_PURPLE;
  236.  
  237. #ifdef DEBUG
  238.       Serial.print("Millis: ");
  239.       Serial.print(millis());
  240.       Serial.print("     Timer: ");
  241.       Serial.print(timer);
  242.       Serial.print("     Cycle: ");
  243.       Serial.print(cycle_count);
  244.       Serial.println();
  245. #endif
  246.  
  247.       updateStrip(strip);
  248.  
  249.       strip_state = PURPLE;
  250.  
  251.       break;
  252.  
  253.     //  Default State: Change to INIT_RAINBOW
  254.     //    We should never end up here
  255.     //    .."should"..
  256.     default:
  257. #ifdef DEBUG
  258.       Serial.println("STATE: DEFAULT");
  259. #endif
  260.       strip_state = INIT_RAINBOW;
  261.       break;
  262.   }
  263. }
  264.  
  265. void checkButton(int _pin) {
  266.  
  267.   //      Check if the debounce flag is still set
  268.   if ( debounce == 1 ) {
  269.     // If so, check if button has been released
  270.     if ( digitalRead(_pin) == HIGH ) {
  271.       debounce = 0;
  272. #ifdef DEBUG
  273.       Serial.print("Button ");
  274.       Serial.print(_pin);
  275.       Serial.println(" released");
  276. #endif
  277.     }
  278.   } else {
  279.     //    Check if button has been pressed
  280.     if ( digitalRead(_pin) == LOW ) {
  281.       //      If so, set the cycle_count to it's maximum value
  282.       cycle_count = CYCLE_MAX;
  283.       // Set the debounce flag
  284.       debounce = 1;
  285.  
  286. #ifdef DEBUG
  287.       Serial.print("Button ");
  288.       Serial.print(_pin);
  289.       Serial.println(" activated");
  290. #endif
  291.     }
  292.   }
  293. }
  294.  
  295. void updateStrip(Adafruit_NeoPixel &_strip) {
  296.   index++;
  297.   // Check if the cycle has completed
  298.   if (index >= 256) {
  299.     index = index % 256;
  300.     cycle_count++;
  301.   }
  302.  
  303.   //    Fill the strip with colors
  304.   for (int i = 0; i < LED_COUNT; i++) {
  305.     //_strip.setPixelColor(i, Wheel(((i * 256 / _strip.numPixels()) + index) & 255) );
  306.     _strip.setPixelColor(i, getColorByState(strip.numPixels(), strip_state, i) );
  307.   }
  308.   // Display effect
  309.   _strip.show();
  310. }
  311.  
  312.  
  313. uint32_t getColorByState(int _maxPixels, StateMachine _state, int _i) {
  314.   switch (_state) {
  315.     case INIT_OFF:
  316.     case OFF:
  317.       return Adafruit_NeoPixel::Color(0, 0, 0);
  318.       break;
  319.     case INIT_RAINBOW:
  320.     case RAINBOW:
  321.     case UPDATE_RAINBOW:
  322.       return Wheel(((_i * 256 / _maxPixels) + index) & 255);
  323.       break;
  324.     case INIT_BLUE:
  325.     case BLUE:
  326.     case UPDATE_BLUE:
  327.       return Adafruit_NeoPixel::Color(0, 0, (((_i + index) * 256 / _maxPixels) & 255));
  328.       break;
  329.     case INIT_PURPLE:
  330.     case PURPLE:
  331.     case UPDATE_PURPLE:
  332.       return Adafruit_NeoPixel::Color((((_i + index) * 256 / _maxPixels) & 255), 0, 0.65 * (((_i + index) * 256 / _maxPixels) & 255));
  333.       break;
  334.     default:
  335.       return Adafruit_NeoPixel::Color(0, 0, 0);
  336.       break;
  337.   }
  338. }
  339.  
  340.  
  341.  
  342. // Color FX
  343.  
  344. // Input a value 0 to 255 to get a color value.
  345. // The colours are a transition r - g - b - back to r.
  346. uint32_t Wheel(byte WheelPos)
  347. {
  348.   WheelPos = 255 - WheelPos;
  349.   if (WheelPos < 85)
  350.   {
  351.     return Adafruit_NeoPixel::Color(255 - WheelPos * 3, 0, WheelPos * 3);
  352.   }
  353.   else if (WheelPos < 170)
  354.   {
  355.     WheelPos -= 85;
  356.     return Adafruit_NeoPixel::Color(0, WheelPos * 3, 255 - WheelPos * 3);
  357.   }
  358.   else
  359.   {
  360.     WheelPos -= 170;
  361.     return Adafruit_NeoPixel::Color(WheelPos * 3, 255 - WheelPos * 3, 0);
  362.   }
  363. }
RAW Paste Data