8-mode Neopixel Sign

#include <Adafruit_NeoPixel.h>
#include <FastLED.h>
#include <JC_Button.h>

#define COLOR_ORDER GRB
#define CHIPSET     WS2812

#define MAIN_LEDS_TOTAL 112
#define SEGMENT_START_1 0
#define SEGMENT_COUNT_1 10
#define SEGMENT_START_2 10
#define SEGMENT_COUNT_2 14
#define SEGMENT_START_3 24
#define SEGMENT_COUNT_3 16
#define SEGMENT_START_4 40
#define SEGMENT_COUNT_4 16
#define SEGMENT_START_5 56
#define SEGMENT_COUNT_5 16
#define SEGMENT_START_6 72
#define SEGMENT_COUNT_6 16
#define SEGMENT_START_7 88
#define SEGMENT_COUNT_7 14
#define SEGMENT_START_8 102
#define SEGMENT_COUNT_8 10

#define MODE_BUTTON_PIN 15 // A1 on nano
#define DATA_PIN 14 // A0 on nano

#define MODE_COUNT_MAXIMUM 8 // number of different lighting modes

#define DIM_YELLOW_COLOR 0xFFFF00
#define BRIGHT_YELLOW_COLOR 0x999900
#define BRIGHT_BLUE_COLOR 0x0000FF
#define WHITE_COLOR 0X999999
#define BRIGHT_RED_COLOR 0XFF0300

// brightness settings are to work with a 1A power supply, with this specific number of LEDs.
// can be increased or decreased if using a different power supply or a different number of LEDs.
#define BRIGHTNESS_NOMINAL 12
#define BRIGHTNESS_MID 32
#define BRIGHTNESS_STROBE 100
#define BRIGHTNESS_MAX 127

#define DEMO_SPEED 5000 // ms to change animations in demo mode, higher is slower

#define FIRE_SPEED 50 // ms between fire refresh rate, higher is slower
#define FIRE_COOLING 70
#define FIRE_SPARKING 270
// #define FIRE_ROW_LEDS 11
// #define FIRE_ROW_COUNT 5

#define SPARKLE_SPEED 75 // ms between sparkle refresh rate, higher is slower

#define RAINBOW_SWEEP_SPEED 10 // ms between rainbow sweep movement, higher is slower
#define RAINBOW_FILL_SPEED 5 // ms between rainbow fill movement, higher is slower

#define FADE_SPEED 1 // ms between fade steps, higher is slower

#define CONFETTI_SPEED 75 // ms to between confetti refresh rate, higher is slower
#define CONFETTI_FADE 20 // cycles to fade confetti, higher is faster

#define STROBE_SPEED 70 // ms between strobes, higher is slower

Adafruit_NeoPixel MainStrip = Adafruit_NeoPixel(MAIN_LEDS_TOTAL, DATA_PIN, NEO_GRB + NEO_KHZ800);

Button ModeButton(MODE_BUTTON_PIN);       // define the button that increases brightness

CRGBPalette16 gPal;     // Palette color for flames


unsigned long TimerMaster = 0; // master clock timer
unsigned long TimerDemo = 0; // fire update timer
unsigned long TimerFire = 0; // fire update timer
unsigned long TimerSparkle = 0; // sparkle update timer
unsigned long TimerSweep = 0; // sweep update timer
unsigned long TimerFill = 0; // rainbow fill update timer
unsigned long TimerConfetti = 0; // confetti update timer
unsigned long TimerStrobe = 0; // strobe update timer
unsigned long TimerFade = 0; // fade update timer

bool DemoMode = 1; // Power up in demo mode, change to 0 the first time the button is pressed

int ModeCounter = 1; // cycle through different animation modes


int ColorWheel = 0; // int to hold starting rainbow color
bool FadeToggle = 0; // bool to hold fading in or out
int FadeValue = BRIGHTNESS_MID;

bool StrobeToggle = 0; // bool to toggle strobe on or off

byte heat[MAIN_LEDS_TOTAL]; // global array of heat values
CRGB leds[MAIN_LEDS_TOTAL]; // global array for confetti leds

void setup()
{
  delay(500); // sanity delay
  gPal = HeatColors_p;
  MainStrip.begin(); // initialize fire strip
  MainStrip.setBrightness(BRIGHTNESS_NOMINAL);
  ModeButton.begin();
}

void loop()
{
  TimerMaster = millis();

  if ((TimerMaster >= TimerDemo) && (DemoMode == 1))
  {
    ModeCounter++;
    // If it reaches the end, reset to beginning
    if (ModeCounter > MODE_COUNT_MAXIMUM)
    {
      ModeCounter = 1;
    }
    TimerDemo = (TimerMaster + DEMO_SPEED);
  }

  ModeButton.read();
  if (ModeButton.wasPressed() )
  {
    if (DemoMode == 1) // if still in demo mode, stop demo cycling and keep current animation
    {
      DemoMode = 0;
    }
    else
    {
      // If not in demo mode, increase to the next animation mode
      ModeCounter++;
      // If it reaches the end, reset to beginning
      if (ModeCounter > MODE_COUNT_MAXIMUM)
      {
        ModeCounter = 1;
      }
      MainStrip.fill(0x000000);
      MainStrip.show();
    }
  }






  // Mode 1: Rainbow sweep
  if (ModeCounter == 1)
  {
    MainStrip.setBrightness(BRIGHTNESS_MAX);
    if (TimerMaster >= TimerSweep)
    {
      if (ColorWheel >= 255)
      {
        ColorWheel = 0;
      }
      MainStrip.fill(Wheel(ColorWheel - 0), SEGMENT_START_1, SEGMENT_COUNT_1);
      MainStrip.fill(Wheel(ColorWheel - 10), SEGMENT_START_2, SEGMENT_COUNT_2);
      MainStrip.fill(Wheel(ColorWheel - 20), SEGMENT_START_3, SEGMENT_COUNT_3);
      MainStrip.fill(Wheel(ColorWheel - 30), SEGMENT_START_4, SEGMENT_COUNT_4);
      MainStrip.fill(Wheel(ColorWheel - 40), SEGMENT_START_5, SEGMENT_COUNT_5);
      MainStrip.fill(Wheel(ColorWheel - 50), SEGMENT_START_6, SEGMENT_COUNT_6);
      MainStrip.fill(Wheel(ColorWheel - 60), SEGMENT_START_7, SEGMENT_COUNT_7);
      MainStrip.fill(Wheel(ColorWheel - 70), SEGMENT_START_8, SEGMENT_COUNT_8);
      ColorWheel++;
      MainStrip.show();
      TimerSweep = (TimerMaster + RAINBOW_SWEEP_SPEED);
    }
  }

  // Mode 2: Rainbow fill
  if (ModeCounter == 2)
  {
    MainStrip.setBrightness(BRIGHTNESS_MAX);
    if (TimerMaster >= TimerFill)
    {
      if (ColorWheel >= 255)
      {
        ColorWheel = 0;
      }
      MainStrip.fill(Wheel(ColorWheel));
      ColorWheel++;
      MainStrip.show();
      TimerFill = (TimerMaster + RAINBOW_FILL_SPEED);
    }
  }

  // Mode 3:  Sparkling yellow
  if (ModeCounter == 3)
  {
    MainStrip.setBrightness(BRIGHTNESS_MAX);

    if (TimerMaster >= TimerSparkle)
    {
      MainStrip.fill(BRIGHT_YELLOW_COLOR);
      MainStrip.setPixelColor(random(MAIN_LEDS_TOTAL), 0xFFFFFF);
      MainStrip.show();
      TimerSparkle = (TimerMaster + SPARKLE_SPEED);
    }
  }

  // Mode 4: Orange fire
  if (ModeCounter == 4 )
  {
    gPal = HeatColors_p;
    MainStrip.setBrightness(BRIGHTNESS_MAX);
    if (TimerMaster >= TimerFire)
    {
      Fire2022(SEGMENT_START_1, SEGMENT_COUNT_1, 0, random(FIRE_COOLING * 0.8, FIRE_COOLING * 1.2), random(FIRE_SPARKING * 0.8, FIRE_SPARKING * 1.2));
      Fire2022(SEGMENT_START_2, SEGMENT_COUNT_2, 0, random(FIRE_COOLING * 0.8, FIRE_COOLING * 1.2), random(FIRE_SPARKING * 0.8, FIRE_SPARKING * 1.2));
      Fire2022(SEGMENT_START_3, SEGMENT_COUNT_3, 0, random(FIRE_COOLING * 0.8, FIRE_COOLING * 1.2), random(FIRE_SPARKING * 0.8, FIRE_SPARKING * 1.2));
      Fire2022(SEGMENT_START_4, SEGMENT_COUNT_4, 0, random(FIRE_COOLING * 0.8, FIRE_COOLING * 1.2), random(FIRE_SPARKING * 0.8, FIRE_SPARKING * 1.2));
      Fire2022(SEGMENT_START_5, SEGMENT_COUNT_5, 0, random(FIRE_COOLING * 0.8, FIRE_COOLING * 1.2), random(FIRE_SPARKING * 0.8, FIRE_SPARKING * 1.2));
      Fire2022(SEGMENT_START_6, SEGMENT_COUNT_6, 0, random(FIRE_COOLING * 0.8, FIRE_COOLING * 1.2), random(FIRE_SPARKING * 0.8, FIRE_SPARKING * 1.2));
      Fire2022(SEGMENT_START_7, SEGMENT_COUNT_7, 0, random(FIRE_COOLING * 0.8, FIRE_COOLING * 1.2), random(FIRE_SPARKING * 0.8, FIRE_SPARKING * 1.2));
      Fire2022(SEGMENT_START_8, SEGMENT_COUNT_8, 0, random(FIRE_COOLING * 0.8, FIRE_COOLING * 1.2), random(FIRE_SPARKING * 0.8, FIRE_SPARKING * 1.2));
      TimerFire = (TimerMaster + FIRE_SPEED);
      MainStrip.show();
    }
  }


  // Mode 5: Blue fire
  if (ModeCounter == 5 )
  {
    gPal = CRGBPalette16( CRGB::Black, CRGB::Blue, CRGB::Aqua,  CRGB::White);
    MainStrip.setBrightness(BRIGHTNESS_MAX);
    if (TimerMaster >= TimerFire)
    {
      Fire2022(SEGMENT_START_1, SEGMENT_COUNT_1, 0, random(FIRE_COOLING * 0.8, FIRE_COOLING * 1.2), random(FIRE_SPARKING * 0.8, FIRE_SPARKING * 1.2));
      Fire2022(SEGMENT_START_2, SEGMENT_COUNT_2, 0, random(FIRE_COOLING * 0.8, FIRE_COOLING * 1.2), random(FIRE_SPARKING * 0.8, FIRE_SPARKING * 1.2));
      Fire2022(SEGMENT_START_3, SEGMENT_COUNT_3, 0, random(FIRE_COOLING * 0.8, FIRE_COOLING * 1.2), random(FIRE_SPARKING * 0.8, FIRE_SPARKING * 1.2));
      Fire2022(SEGMENT_START_4, SEGMENT_COUNT_4, 0, random(FIRE_COOLING * 0.8, FIRE_COOLING * 1.2), random(FIRE_SPARKING * 0.8, FIRE_SPARKING * 1.2));
      Fire2022(SEGMENT_START_5, SEGMENT_COUNT_5, 0, random(FIRE_COOLING * 0.8, FIRE_COOLING * 1.2), random(FIRE_SPARKING * 0.8, FIRE_SPARKING * 1.2));
      Fire2022(SEGMENT_START_6, SEGMENT_COUNT_6, 0, random(FIRE_COOLING * 0.8, FIRE_COOLING * 1.2), random(FIRE_SPARKING * 0.8, FIRE_SPARKING * 1.2));
      Fire2022(SEGMENT_START_7, SEGMENT_COUNT_7, 0, random(FIRE_COOLING * 0.8, FIRE_COOLING * 1.2), random(FIRE_SPARKING * 0.8, FIRE_SPARKING * 1.2));
      Fire2022(SEGMENT_START_8, SEGMENT_COUNT_8, 0, random(FIRE_COOLING * 0.8, FIRE_COOLING * 1.2), random(FIRE_SPARKING * 0.8, FIRE_SPARKING * 1.2));
      TimerFire = (TimerMaster + FIRE_SPEED);
      MainStrip.show();
    }
  }

  // Mode 6:  Sparkling blue
  if (ModeCounter == 6)
  {
    MainStrip.setBrightness(BRIGHTNESS_MAX);

    if (TimerMaster >= TimerSparkle)
    {
      MainStrip.fill(BRIGHT_BLUE_COLOR);
      MainStrip.setPixelColor(random(MAIN_LEDS_TOTAL), 0xFFFFFF);
      MainStrip.show();
      TimerSparkle = (TimerMaster + SPARKLE_SPEED);
    }
  }

  // Mode 7:  Fading red
  if (ModeCounter == 7 )
  {
    MainStrip.fill(BRIGHT_RED_COLOR);
    if (TimerMaster >= TimerFade)
    {
      if (FadeToggle == 0)
      {
        FadeValue++;
        if (FadeValue >= BRIGHTNESS_MAX)
        {
          FadeToggle = 1;
        }
      }
      else
      {
        FadeValue--;
        if (FadeValue <= BRIGHTNESS_MID)
        {
          FadeToggle = 0;
        }

      }
      MainStrip.setBrightness(FadeValue);
      MainStrip.show();
      TimerFade = (TimerMaster + FADE_SPEED);
    }
  }

  // Mode 8:  Strobe
  if (ModeCounter == 8 )
  {
    MainStrip.setBrightness(BRIGHTNESS_STROBE);

    if (TimerMaster >= TimerStrobe)
    {
      if (StrobeToggle == 0)
      {
        MainStrip.fill(WHITE_COLOR);
      }
      else
      {
        MainStrip.fill(0x000000);
      }
      MainStrip.show();
      StrobeToggle = !StrobeToggle;
      TimerStrobe = (TimerMaster + STROBE_SPEED);
    }
  }
  /*

     confetti was stupid

    // Mode 9:  Confetti
    if (ModeCounter == 9 )
    {
      MainStrip.setBrightness(BRIGHTNESS_MAX);
      gPal = RainbowColors_p;
      if (TimerMaster >= TimerConfetti)
      {
        fadeToBlackBy(leds, MAIN_LEDS_TOTAL, CONFETTI_FADE);
        leds[random8(MAIN_LEDS_TOTAL)] = Wheel(random8(255));
        for ( int i = 0; i < MAIN_LEDS_TOTAL; i++)
        {
          MainStrip.setPixelColor(i, leds[i].r, leds[i].g, leds[i].b);
        }
        MainStrip.show();
        TimerConfetti = (TimerMaster + CONFETTI_SPEED);
      }


    }
  */

}



void Fire2022(int LED_START_NUM, int FIRE_ROW_LEDS, bool gReverseDirection, int cool, int spark)
{
  // Step 1.  Cool down every cell a little
  for ( int i = LED_START_NUM; i < (FIRE_ROW_LEDS + LED_START_NUM); i++)
  {
    heat[i] = qsub8( heat[i],  random8(0, ((cool * 10) / FIRE_ROW_LEDS) + 2));
  }

  // Step 2.  Heat from each cell drifts 'up' and diffuses a little
  for ( int k = (FIRE_ROW_LEDS + LED_START_NUM - 1) ; k >= (LED_START_NUM + 2); k--)
  {
    heat[k] = (heat[k - 1] + heat[k - 2] + heat[k - 2] ) / 3;
  }

  // Step 3.  Randomly ignite new 'sparks' of heat near the bottom
  if ( random8() < spark )
  {
    int y = random8(3);
    //int y = 0;
    heat[LED_START_NUM + y] = qadd8( heat[LED_START_NUM + y], random8(160, 255) );
  }

  // Step 4.  Map from heat cells to LED colors
  for ( int j = LED_START_NUM; j < (FIRE_ROW_LEDS + LED_START_NUM); j++)
  {
    // CRGB color = HeatColor(min(150, heat[j]));
    CRGB color = ColorFromPalette(gPal, min(150, heat[j]));
    int pixelnumber;
    if ( gReverseDirection )
    {
      pixelnumber = ((FIRE_ROW_LEDS + LED_START_NUM) - 1) - (j - LED_START_NUM);
    }
    else
    {
      pixelnumber = j;
    }
    MainStrip.setPixelColor(pixelnumber, color.r, color.g, color.b);
  }
}

// Input a value 0 to 255 to get a color value.
// The colours are a transition r - g - b - back to r.
uint32_t Wheel(byte WheelPos)
{
  WheelPos = 255 - WheelPos;
  if (WheelPos < 85)
  {
    return MainStrip.Color(255 - WheelPos * 3, 0, WheelPos * 3);
  }
  else if (WheelPos < 170)
  {
    WheelPos -= 85;
    return MainStrip.Color(0, WheelPos * 3, 255 - WheelPos * 3);
  }
  else
  {
    WheelPos -= 170;
    return MainStrip.Color(WheelPos * 3, 255 - WheelPos * 3, 0);
  }
}