Compare text

Find the difference between two text files

Display

Layout

Real-time editorHide whitespace changesHide unchanged linesDisable line wrap

Diff precision

Syntax

Process

Diffchecker Desktop The most secure way to run Diffchecker. Get the Diffchecker Desktop app: your diffs never leave your computer!Get Desktop

Untitled diff

Created 8 years agoDiff never expires

10 removals

Lines
Total
Removed

Characters
Total
Removed

To continue using this feature, upgrade to Diffchecker Pro View Pricing

732 lines

7 additions

Lines
Total
Added

Characters
Total
Added

To continue using this feature, upgrade to Diffchecker Pro View Pricing

730 lines

#include <Adafruit_NeoPixel.h>

#include <ESP8266WiFi.h>

#include <PubSubClient.h>

#define FASTLED_INTERRUPT_RETRY_COUNT 0

#include <FastLED.h>

#include <ArduinoOTA.h>

#include <ESP8266mDNS.h>

#include <WiFiUdp.h>

/************ WIFI and MQTT INFORMATION (CHANGE THESE FOR YOUR SETUP) ******************/

#define wifi_ssid "**" //enter your WIFI SSID

#define wifi_password "**" //enter your WIFI Password

/**************************** FOR OTA **************************************************/

#define SENSORNAME "Holiday LED Arduino" //change this to whatever you want to call your device

#define OTApassword "**" //the password you will need to enter to upload remotely via the ArduinoIDE

int OTAport = 8266;

#define mqtt_server "192.168.145.245" // Enter your MQTT server adderss or IP. I use my DuckDNS adddress (yourname.duckdns.org) in this field

#define mqtt_user "**" //enter your MQTT username

#define mqtt_password "**" //enter your password

/************ FastLED Defintions ******************/

#define DATA_PIN D4 //on the NodeMCU 1.0, FastLED will default to the D5 pin after throwing an error during compiling. Leave as is.

#define LED_TYPE WS2812B //change to match your LED type

#define COLOR_ORDER GRB //change to match your LED configuration, ws2812 are GRB, 2811 are RGB

#define NUM_LEDS 223 //change to match your setup, for multiple runs of LEDs use the number of the run with the most LEDs.

///////////////DrZzs Palettes for custom BPM effects//////////////////////////

///////////////Add any custom palettes here//////////////////////////////////

//Thanksgiving colors

// Gradient palette "bhw2_thanks_gp", originally from

// http://soliton.vm.bytemark.co.uk/pub/cpt-city/bhw/bhw2/tn/bhw2_thanks.png.index.html

// converted for FastLED with gammas (2.6, 2.2, 2.5)

// Size: 36 bytes of program space.

DEFINE_GRADIENT_PALETTE( bhw2_thanks_gp ) {

0, 9, 5, 1,

48, 25, 9, 1,

76, 137, 27, 1,

96, 98, 42, 1,

124, 144, 79, 1,

153, 98, 42, 1,

178, 137, 27, 1,

211, 23, 9, 1,

255, 9, 5, 1};

//Red/Pink colors

// Gradient palette "bhw2_redrosey_gp", originally from

// http://soliton.vm.bytemark.co.uk/pub/cpt-city/bhw/bhw2/tn/bhw2_redrosey.png.index.html

// converted for FastLED with gammas (2.6, 2.2, 2.5)

// Size: 32 bytes of program space.

DEFINE_GRADIENT_PALETTE( bhw2_redrosey_gp ) {

0, 103, 1, 10,

33, 109, 1, 12,

76, 159, 5, 48,

119, 175, 55,103,

127, 175, 55,103,

178, 159, 5, 48,

221, 109, 1, 12,

255, 103, 1, 10};

//Blue to Red - has light blue white and pink

// Gradient palette "bluered_gp", originally from

// http://soliton.vm.bytemark.co.uk/pub/cpt-city/h5/tn/bluered.png.index.html

// converted for FastLED with gammas (2.6, 2.2, 2.5)

// Size: 12 bytes of program space.

DEFINE_GRADIENT_PALETTE( bluered_gp ) {

0, 0, 0,255,

127, 255,255,255,

255, 255, 0, 0};

//Green and Red

// Gradient palette "bhw2_xmas_gp", originally from

// http://soliton.vm.bytemark.co.uk/pub/cpt-city/bhw/bhw2/tn/bhw2_xmas.png.index.html

// converted for FastLED with gammas (2.6, 2.2, 2.5)

// Size: 48 bytes of program space.

DEFINE_GRADIENT_PALETTE( bhw2_xmas_gp ) {

0, 0, 12, 0,

40, 0, 55, 0,

66, 1,117, 2,

77, 1, 84, 1,

81, 0, 55, 0,

119, 0, 12, 0,

153, 42, 0, 0,

181, 121, 0, 0,

204, 255, 12, 8,

224, 121, 0, 0,

244, 42, 0, 0,

255, 42, 0, 0};

//Purple orange yellow colors

// Gradient palette "bhw2_xc_gp", originally from

// http://soliton.vm.bytemark.co.uk/pub/cpt-city/bhw/bhw2/tn/bhw2_xc.png.index.html

// converted for FastLED with gammas (2.6, 2.2, 2.5)

// Size: 28 bytes of program space.

Saved diffs

Original text

Open file

#include <Adafruit_NeoPixel.h>
#include <ESP8266WiFi.h>
#include <PubSubClient.h>
#define FASTLED_INTERRUPT_RETRY_COUNT 0
#include <FastLED.h>
#include <ArduinoOTA.h>
#include <ESP8266mDNS.h>
#include <WiFiUdp.h>
/************ WIFI and MQTT INFORMATION (CHANGE THESE FOR YOUR SETUP) ******************/
#define wifi_ssid "**" //enter your WIFI SSID
#define wifi_password "**" //enter your WIFI Password

/**************************** FOR OTA **************************************************/
#define SENSORNAME "Holiday LED Arduino" //change this to whatever you want to call your device
#define OTApassword "**" //the password you will need to enter to upload remotely via the ArduinoIDE
int OTAport = 8266;

#define mqtt_server "192.168.145.245" // Enter your MQTT server adderss or IP. I use my DuckDNS adddress (yourname.duckdns.org) in this field
#define mqtt_user "**" //enter your MQTT username
#define mqtt_password "**" //enter your password

/************ FastLED Defintions ******************/

#define DATA_PIN    D4 //on the NodeMCU 1.0, FastLED will default to the D5 pin after throwing an error during compiling. Leave as is. 
#define LED_TYPE    WS2812B //change to match your LED type
#define COLOR_ORDER GRB //change to match your LED configuration, ws2812 are GRB, 2811 are RGB
#define NUM_LEDS    223 //change to match your setup, for multiple runs of LEDs use the number of the run with the most LEDs.

///////////////DrZzs Palettes for custom BPM effects//////////////////////////
///////////////Add any custom palettes here//////////////////////////////////

//Thanksgiving colors
// Gradient palette "bhw2_thanks_gp", originally from
// http://soliton.vm.bytemark.co.uk/pub/cpt-city/bhw/bhw2/tn/bhw2_thanks.png.index.html
// converted for FastLED with gammas (2.6, 2.2, 2.5)
// Size: 36 bytes of program space.

DEFINE_GRADIENT_PALETTE( bhw2_thanks_gp ) {
    0,   9,  5,  1,
   48,  25,  9,  1,
   76, 137, 27,  1,
   96,  98, 42,  1,
  124, 144, 79,  1,
  153,  98, 42,  1,
  178, 137, 27,  1,
  211,  23,  9,  1,
  255,   9,  5,  1};

//Red/Pink colors
// Gradient palette "bhw2_redrosey_gp", originally from
// http://soliton.vm.bytemark.co.uk/pub/cpt-city/bhw/bhw2/tn/bhw2_redrosey.png.index.html
// converted for FastLED with gammas (2.6, 2.2, 2.5)
// Size: 32 bytes of program space.

DEFINE_GRADIENT_PALETTE( bhw2_redrosey_gp ) {
    0, 103,  1, 10,
   33, 109,  1, 12,
   76, 159,  5, 48,
  119, 175, 55,103,
  127, 175, 55,103,
  178, 159,  5, 48,
  221, 109,  1, 12,
  255, 103,  1, 10};

//Blue to Red - has light blue white and pink
// Gradient palette "bluered_gp", originally from
// http://soliton.vm.bytemark.co.uk/pub/cpt-city/h5/tn/bluered.png.index.html
// converted for FastLED with gammas (2.6, 2.2, 2.5)
// Size: 12 bytes of program space.

DEFINE_GRADIENT_PALETTE( bluered_gp ) {
    0,   0,  0,255,
  127, 255,255,255,
  255, 255,  0,  0};

//Green and Red
// Gradient palette "bhw2_xmas_gp", originally from
// http://soliton.vm.bytemark.co.uk/pub/cpt-city/bhw/bhw2/tn/bhw2_xmas.png.index.html
// converted for FastLED with gammas (2.6, 2.2, 2.5)
// Size: 48 bytes of program space.

DEFINE_GRADIENT_PALETTE( bhw2_xmas_gp ) {
    0,   0, 12,  0,
   40,   0, 55,  0,
   66,   1,117,  2,
   77,   1, 84,  1,
   81,   0, 55,  0,
  119,   0, 12,  0,
  153,  42,  0,  0,
  181, 121,  0,  0,
  204, 255, 12,  8,
  224, 121,  0,  0,
  244,  42,  0,  0,
  255,  42,  0,  0};

//Purple orange yellow colors
// Gradient palette "bhw2_xc_gp", originally from
// http://soliton.vm.bytemark.co.uk/pub/cpt-city/bhw/bhw2/tn/bhw2_xc.png.index.html
// converted for FastLED with gammas (2.6, 2.2, 2.5)
// Size: 28 bytes of program space.

DEFINE_GRADIENT_PALETTE( bhw2_xc_gp ) {
    0,   4,  2,  9,
   58,  16,  0, 47,
  122,  24,  0, 16,
  158, 144,  9,  1,
  183, 179, 45,  1,
  219, 220,114,  2,
  255, 234,237,  1};

//Yellow orange purple blue
// Gradient palette "bhw1_04_gp", originally from
// http://soliton.vm.bytemark.co.uk/pub/cpt-city/bhw/bhw1/tn/bhw1_04.png.index.html
// converted for FastLED with gammas (2.6, 2.2, 2.5)
// Size: 20 bytes of program space.

DEFINE_GRADIENT_PALETTE( bhw1_04_gp ) {
    0, 229,227,  1,
   15, 227,101,  3,
  142,  40,  1, 80,
  198,  17,  1, 79,
  255,   0,  0, 45};

//blue and yellow
// Gradient palette "bhw4_051_gp", originally from
// http://soliton.vm.bytemark.co.uk/pub/cpt-city/bhw/bhw4/tn/bhw4_051.png.index.html
// converted for FastLED with gammas (2.6, 2.2, 2.5)
// Size: 36 bytes of program space.

//More thanksgiving colors
// Gradient palette "fs2006_gp", originally from
// http://soliton.vm.bytemark.co.uk/pub/cpt-city/cl/tn/fs2006.png.index.html
// converted for FastLED with gammas (2.6, 2.2, 2.5)
// Size: 56 bytes of program space.

DEFINE_GRADIENT_PALETTE( fs2006_gp ) {
    0,   0, 49,  5,
   34,   0, 49,  5,
   34,  79,168, 66,
   62,  79,168, 66,
   62, 252,168, 92,
  103, 252,168, 92,
  103, 234, 81, 29,
  143, 234, 81, 29,
  143, 222, 30,  1,
  184, 222, 30,  1,
  184,  90, 13,  1,
  238,  90, 13,  1,
  238, 210,  1,  1,
  255, 210,  1,  1};

DEFINE_GRADIENT_PALETTE( bhw4_051_gp ) {
    0,   1,  1,  4,
   28,  16, 24, 77,
   66,  35, 87,160,
  101, 125,187,205,
  127, 255,233, 13,
  145, 125,187,205,
  193,  28, 70,144,
  224,  14, 19, 62,
  255,   1,  1,  4};

//dark blue light blue colors
// Gradient palette "blue_g2_5_gp", originally from
// http://soliton.vm.bytemark.co.uk/pub/cpt-city/go2/webtwo/tn/blue-g2-5.png.index.html
// converted for FastLED with gammas (2.6, 2.2, 2.5)
// Size: 16 bytes of program space.

DEFINE_GRADIENT_PALETTE( blue_g2_5_gp ) {
    0,   2,  6, 63,
  127,   2,  9, 67,
  255,   255, 255, 115,
  255,   255, 255, 0};

//Blue White Red colors
// Gradient palette "bhw3_41_gp", originally from
// http://soliton.vm.bytemark.co.uk/pub/cpt-city/bhw/bhw3/tn/bhw3_41.png.index.html
// converted for FastLED with gammas (2.6, 2.2, 2.5)
// Size: 36 bytes of program space.

DEFINE_GRADIENT_PALETTE( bhw3_41_gp ) {
    0,   0,  0, 45,
   71,   7, 12,255,
   76,  75, 91,255,
   76, 255,255,255,
   81, 255,255,255,
  178, 255,255,255,
  179, 255, 55, 45,
  196, 255,  0,  0,
  255,  42,  0,  0};

DEFINE_GRADIENT_PALETTE( test_gp ) {
    0,  255,  0,  0, // Red
// 32,  171, 85,  0, // Orange
// 64,  171,171,  0, // Yellow
// 96,    0,255,  0, // Green
//128,    0,171, 85, // Aqua
  160,    0,  0,255, // Blue
//192,   85,  0,171, // Purple
//224,  171,  0, 85, // Pink
//255,  255,  0,  0};// and back to Red
};

//Green colors
// Gradient palette "bhw2_greenman_gp", originally from
// http://soliton.vm.bytemark.co.uk/pub/cpt-city/bhw/bhw2/tn/bhw2_greenman.png.index.html
// converted for FastLED with gammas (2.6, 2.2, 2.5)
// Size: 12 bytes of program space.

DEFINE_GRADIENT_PALETTE( bhw2_greenman_gp ) {
    0,   1, 22,  1,
  130,   1,168,  2,
  255,   1, 22,  1};

//blue and yellow
// Gradient palette "Pills_3_gp", originally from
// http://soliton.vm.bytemark.co.uk/pub/cpt-city/ds/icons/tn/Pills-3.png.index.html
// converted for FastLED with gammas (2.6, 2.2, 2.5)
// Size: 12 bytes of program space.

DEFINE_GRADIENT_PALETTE( Pills_3_gp ) {
    0,   4, 12,122,
  127,  55, 58, 50,
  255, 192,147, 11};

/****************************** MQTT TOPICS (change these topics as you wish)  ***************************************/

#define colorstatuspub "bruh/mqttstrip/colorstatus"
#define setcolorsub "bruh/mqttstrip/setcolor"
#define setpowersub "bruh/mqttstrip/setpower"
#define seteffectsub "bruh/mqttstrip/seteffect"
#define setbrightness "bruh/mqttstrip/setbrightness"

#define setcolorpub "bruh/mqttstrip/setcolorpub"
#define setpowerpub "bruh/mqttstrip/setpowerpub"
#define seteffectpub "bruh/mqttstrip/seteffectpub"
#define setbrightnesspub "bruh/mqttstrip/setbrightnesspub"
#define setanimationspeed "bruh/mqttstrip/setanimationspeed"

/*************************** EFFECT CONTROL VARIABLES AND INITIALIZATIONS ************************************/

#if defined(FASTLED_VERSION) && (FASTLED_VERSION < 3001000)
#warning "Requires FastLED 3.1 or later; check github for latest code."
#endif

String setColor ="0,0,150";
String setPower;
String setEffect = "Solid";
String setBrightness = "150";
int brightness = 150;
String setAnimationSpeed;
int animationspeed = 240;
String setColorTemp;
int Rcolor = 0;
int Gcolor = 0;
int Bcolor = 0;
CRGB leds[NUM_LEDS];

TBlendType    currentBlending;

/****************FOR CANDY CANE-like desings***************/
CRGBPalette16 currentPalettestriped; //for Candy Cane
CRGBPalette16 RGWPalettestriped; //for Red Green White
CRGBPalette16 RGPalettestriped; //for Red Green Glitter
CRGBPalette16 hailPalettestriped; //for Hail
CRGBPalette16 ThxPalettestriped; //for Thanksgiving
CRGBPalette16 HalloweenPalettestriped; //for Halloween Purple and Orange EFFECT
CRGBPalette16 Halloween2Palettestriped; //for Halloween Orange and Green EFFECT
CRGBPalette16 Halloween3Palettestriped; //for Halloween Purple and Green EFFECT
CRGBPalette16 HalloweenTriPalettestriped; //for 3 color Halloween Purple, Orange and Green
CRGBPalette16 PurpleGreenPalettestriped; //for Halloween Purple and Green
CRGBPalette16 OrangeGreenPalettestriped; //for Halloween Orange and Green
CRGBPalette16 OrangePurplePalettestriped; //for Halloween Orange and Green
CRGBPalette16 CandyCornPalettestriped; //for Candy Corn
CRGBPalette16 HJPalettestriped; //for Holly Jolly
CRGBPalette16 IndPalettestriped; //for Independence
CRGBPalette16 gPal; //for fire
extern const TProgmemPalette16 myC9Palette PROGMEM;

/****************FOR NOISE - I'm using this one for Easter***************/
static uint16_t dist;         // A random number for our noise generator.
uint16_t scale = 30;          // Wouldn't recommend changing this on the fly, or the animation will be really blocky.
uint8_t maxChanges = 48;      // Value for blending between palettes.
CRGBPalette16 targetPalette(OceanColors_p);
CRGBPalette16 currentPalette(CRGB::Black);
uint8_t colorIndex;

/*****************For TWINKLE********/
#define DENSITY     80
int twinklecounter = 0;

/*********FOR RIPPLE***********/
uint8_t colour;                                               // Ripple colour is randomized.
int center = 0;                                               // Center of the current ripple.
int step = -1;                                                // -1 is the initializing step.
uint8_t myfade = 255;                                         // Starting brightness.
#define maxsteps 16                                           // Case statement wouldn't allow a variable.
uint8_t bgcol = 0;                                            // Background colour rotates.
int thisdelay = 20;                                           // Standard delay value.

/**************FOR RAINBOW***********/
uint8_t thishue = 0;                                          // Starting hue value.
uint8_t deltahue = 10;

/**************FOR DOTS**************/
uint8_t   count =   0;                                        // Count up to 255 and then reverts to 0
uint8_t fadeval = 224;                                        // Trail behind the LED's. Lower => faster fade.
uint8_t bpm = 30;

/**************FOR LIGHTNING**************/
uint8_t frequency = 75;                                       // controls the interval between strikes
uint8_t flashes = 8;                                          //the upper limit of flashes per strike
unsigned int dimmer = 1;
uint8_t ledstart;                                             // Starting location of a flash
uint8_t ledlen;
int lightningcounter = 0;

/********FOR FUNKBOX EFFECTS**********/
int idex = 0;                //-LED INDEX (0 to NUM_LEDS-1
int TOP_INDEX = int(NUM_LEDS / 2);
int thissat = 255;           //-FX LOOPS DELAY VAR

//////////////////add thishue__ for Police All custom effects here/////////////////////////////////////////////////////////
/////////////////use hsv Hue number for one color, for second color change "thishue__ + __" in the setEffect section//////

uint8_t thishuepolice = 0;
uint8_t thishuehail = 64;
uint8_t thishueLovey = 0; 
uint8_t thishueHalloween = 28;  
uint8_t thishueHalloween2 = 28; 
uint8_t thishueHalloween3 = 96;    
int antipodal_index(int i) {
  int iN = i + TOP_INDEX;
  if (i >= TOP_INDEX) {
    iN = ( i + TOP_INDEX ) % NUM_LEDS;
  }
  return iN;
}

/********FIRE**********/
#define COOLING  55
#define SPARKING 120
bool gReverseDirection = false;

/********BPM**********/
uint8_t gHue = 0;
char message_buff[100];

WiFiClient espArch;
PubSubClient client(espArch);

////////////////////////////////////////////////////////////

void setup() {
  WiFi.setSleepMode(WIFI_NONE_SLEEP);
  Serial.begin(115200);

FastLED.addLeds<LED_TYPE, DATA_PIN, COLOR_ORDER>(leds, NUM_LEDS).setCorrection(TypicalLEDStrip);
  FastLED.setMaxPowerInVoltsAndMilliamps(12, 10000); //experimental for power management. Feel free to try in your own setup.
  FastLED.setBrightness(brightness);

setupStripedPalette( CRGB::Red, CRGB::Red, CRGB::White, CRGB::White); //for CANDY CANE
  setupRGWPalette( CRGB::Red, CRGB::White, CRGB::Green, CRGB::White); //for Red Green White
  setupRGPalette( CRGB::Red, CRGB::Green, CRGB::Red, CRGB::Green); //for Red Green 
  setupThxPalette( CRGB::OrangeRed, CRGB::Olive, CRGB::Maroon, CRGB::Maroon); //for Thanksgiving
  setupHailPalette( CRGB::Blue, CRGB::Blue, CRGB::Yellow, CRGB::Yellow); //for HAIL
  setupHalloweenTriPalette( CRGB(255,95,0), CRGB(0,255,0), CRGB(115,0,235), CRGB::Black); //for Halloween Orange Green Purple
  setupOrangeGreenPalette( CRGB(255,95,0), CRGB(0,255,0), CRGB::Black, CRGB(0,255,0)); //for Halloween Orange & Green
  setupPurpleGreenPalette( CRGB(115,0,235), CRGB(0,255,0), CRGB::Black, CRGB(0,255,0)); //for Halloween Purple & Green
  setupOrangePurplePalette( CRGB(255,95,0), CRGB(115,0,235), CRGB::Black, CRGB(255,95,0)); //for Halloween Orange & Purple
  setupCandyCornPalette( CRGB(255,95,0), CRGB(240,240,0), CRGB(255,255,255), CRGB::Black); //for CandyCane Orange Yellow White
  setupHJPalette( CRGB::Red, CRGB::Red, CRGB::Green, CRGB::Green); //for Holly Jolly
  setupIndPalette( CRGB::Red, CRGB::White, CRGB::Blue, CRGB::MediumBlue); //for Independence

/////////////////////////////////////////////////////////////////////////////////////////////////////////
  
  gPal = HeatColors_p; //for FIRE

fill_solid(leds, NUM_LEDS, CRGB(255, 0, 0)); //Startup LED Lights
  FastLED.show();

setup_wifi();

client.setServer(mqtt_server, 1883); //CHANGE PORT HERE IF NEEDED
  client.setCallback(callback);

//OTA SETUP
  ArduinoOTA.setPort(OTAport);
  // Hostname defaults to esp8266-[ChipID]
  ArduinoOTA.setHostname(SENSORNAME);

// No authentication by default
  ArduinoOTA.setPassword((const char *)OTApassword);

ArduinoOTA.onStart([]() {
    Serial.println("Starting");
  });
  ArduinoOTA.onEnd([]() {
    Serial.println("\nEnd");
  });
  ArduinoOTA.onProgress([](unsigned int progress, unsigned int total) {
    Serial.printf("Progress: %u%%\r", (progress / (total / 100)));
  });
  ArduinoOTA.onError([](ota_error_t error) {
    Serial.printf("Error[%u]: ", error);
    if (error == OTA_AUTH_ERROR) Serial.println("Auth Failed");
    else if (error == OTA_BEGIN_ERROR) Serial.println("Begin Failed");
    else if (error == OTA_CONNECT_ERROR) Serial.println("Connect Failed");
    else if (error == OTA_RECEIVE_ERROR) Serial.println("Receive Failed");
    else if (error == OTA_END_ERROR) Serial.println("End Failed");
  });
  ArduinoOTA.begin();

Serial.println("Ready");
  Serial.print("IP Address: ");
  Serial.println(WiFi.localIP());
}

void setup_wifi() {

delay(10);
  Serial.println();
  Serial.print("Connecting to ");
  Serial.println(wifi_ssid);

WiFi.mode(WIFI_STA);
  WiFi.begin(wifi_ssid, wifi_password);

while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }

Serial.println("");
  Serial.println("WiFi connected");
  Serial.println("IP address: ");
  Serial.println(WiFi.localIP());
}

void callback(char* topic, byte* payload, unsigned int length) {
  int i = 0;

if (String(topic) == setpowersub) {
    for (i = 0; i < length; i++) {
      message_buff[i] = payload[i];
    }
    message_buff[i] = '\0';
    setPower = String(message_buff);
    Serial.println("Set Power: " + setPower);
    if (setPower == "OFF") {
      client.publish(setpowerpub, "OFF");
    }

if (setPower == "ON") {
      client.publish(setpowerpub, "ON");
    }
  }

if (String(topic) == seteffectsub) {
    for (i = 0; i < length; i++) {
      message_buff[i] = payload[i];
    }
    message_buff[i] = '\0';
    setEffect = String(message_buff);
    Serial.println("Set Effect: " + setEffect);
    setPower = "ON";
    client.publish(setpowerpub, "ON");
    if (setEffect == "Twinkle") {
      twinklecounter = 0;
    }
    if (setEffect == "Lightning") {
      twinklecounter = 0;
    }
  }

if (String(topic) == setbrightness) {
    for (i = 0; i < length; i++) {
      message_buff[i] = payload[i];
    }
    message_buff[i] = '\0';
    setBrightness = String(message_buff);
    Serial.println("Set Brightness: " + setBrightness);
    brightness = setBrightness.toInt();
    setPower = "ON";
    client.publish(setpowerpub, "ON");
  }

if (String(topic) == setcolorsub) {
    for (i = 0; i < length; i++) {
      message_buff[i] = payload[i];
    }
    message_buff[i] = '\0';
    client.publish(setcolorpub, message_buff);
    setColor = String(message_buff);
    Serial.println("Set Color: " + setColor);
    setPower = "ON";
    client.publish(setpowerpub, "ON");
    }

if (String(topic) == setanimationspeed) {
    for (i = 0; i < length; i++) {
      message_buff[i] = payload[i];
    }
    message_buff[i] = '\0';
    setAnimationSpeed = String(message_buff);
    animationspeed = setAnimationSpeed.toInt();
  }
}

void loop() {

if (!client.connected()) {
    reconnect();
  }

if (WiFi.status() != WL_CONNECTED) {
    delay(1);
    Serial.print("WIFI Disconnected. Attempting reconnection.");
    setup_wifi();
    return;
  }

client.loop();

ArduinoOTA.handle();

int Rcolor = setColor.substring(0, setColor.indexOf(',')).toInt();
  int Gcolor = setColor.substring(setColor.indexOf(',') + 1, setColor.lastIndexOf(',')).toInt();
  int Bcolor = setColor.substring(setColor.lastIndexOf(',') + 1).toInt();

if (setPower == "OFF") {
    setEffect = "Solid";
    for ( int i = 0; i < NUM_LEDS; i++) {
      leds[i].fadeToBlackBy( 8 );   //FADE OFF LEDS
    }
  }
  
/////////////////////////////////////////  
//////DrZzs custom effects//////////////
///////////////////////////////////////

if (setEffect == "Christmas") {                                  // colored stripes pulsing in Shades of GREEN and RED 
    uint8_t BeatsPerMinute = 62;
    CRGBPalette16 palette = bhw2_xmas_gp;
    uint8_t beat = beatsin8( BeatsPerMinute, 64, 255);
    for( int i = 0; i < NUM_LEDS; i++) { //9948
    leds[i] = ColorFromPalette(palette, gHue+(i*2), beat-gHue+(i*10));
  }
}

if (setEffect == "St Patty") {                                  // colored stripes pulsing in Shades of GREEN 
    uint8_t BeatsPerMinute = 62;
    CRGBPalette16 palette = bhw2_greenman_gp;
    uint8_t beat = beatsin8( BeatsPerMinute, 64, 255);
    for( int i = 0; i < NUM_LEDS; i++) { //9948
    leds[i] = ColorFromPalette(palette, gHue+(i*2), beat-gHue+(i*10));
  }
}

if (setEffect == "Valentine") {                                  // colored stripes pulsing in Shades of PINK and RED 
    uint8_t BeatsPerMinute = 62;
    CRGBPalette16 palette = bhw2_redrosey_gp;
    uint8_t beat = beatsin8( BeatsPerMinute, 64, 255);
    for( int i = 0; i < NUM_LEDS; i++) { //9948
    leds[i] = ColorFromPalette(palette, gHue+(i*2), beat-gHue+(i*10));
  }
}

if (setEffect == "Turkey Day") {                                  // colored stripes pulsing in Shades of Brown and ORANGE 
    uint8_t BeatsPerMinute = 62;
    CRGBPalette16 palette = bhw2_thanks_gp;
    uint8_t beat = beatsin8( BeatsPerMinute, 64, 255);
    for( int i = 0; i < NUM_LEDS; i++) { //9948
    leds[i] = ColorFromPalette(palette, gHue+(i*2), beat-gHue+(i*10));
  }
}

if (setEffect == "Thanksgiving") {                                  // colored stripes pulsing in Shades of Red and ORANGE and Green 
    static uint8_t startIndex = 0;
    startIndex = startIndex + 1; /* higher = faster motion */

fill_palette( leds, NUM_LEDS,
                  startIndex, 16, /* higher = narrower stripes */
                  ThxPalettestriped, 255, LINEARBLEND);
}
  
  if (setEffect == "USA") {                                  // colored stripes pulsing in Shades of Red White & Blue 
    uint8_t BeatsPerMinute = 62;
    CRGBPalette16 palette = bhw3_41_gp;
    uint8_t beat = beatsin8( BeatsPerMinute, 64, 255);
    for( int i = 0; i < NUM_LEDS; i++) { //9948
    leds[i] = ColorFromPalette(palette, gHue+(i*2), beat-gHue+(i*10));
  }
}

if (setEffect == "Independence") {                        // colored stripes of Red White & Blue
    static uint8_t startIndex = 0;
    startIndex = startIndex + 1; /* higher = faster motion */

fill_palette( leds, NUM_LEDS,
                  startIndex, 16, /* higher = narrower stripes */
                  IndPalettestriped, 255, NOBLEND);
}

if (setEffect == "Go Blue") {                                  // colored stripes pulsing in Shades of Maize and Blue
    uint8_t BeatsPerMinute = 62;
    CRGBPalette16 palette = Pills_3_gp;
    uint8_t beat = beatsin8( BeatsPerMinute, 64, 255);
    for( int i = 0; i < NUM_LEDS; i++) { //9948
    leds[i] = ColorFromPalette(palette, gHue+(i*2), beat-gHue+(i*10));
  }
}

if (setEffect == "Hail") {
    static uint8_t startIndex = 0;
    startIndex = startIndex + 1; /* higher = faster motion */

fill_palette( leds, NUM_LEDS,
                  startIndex, 16, /* higher = narrower stripes */
                  hailPalettestriped, 255, LINEARBLEND);
}
  
  if (setEffect == "Touchdown") {                 //Maize and Blue with POLICE ALL animation
    idex++;
    if (idex >= NUM_LEDS) {
      idex = 0;
    }
    int idexY = idex;
    int idexB = antipodal_index(idexY);
    int thathue = (thishuehail + 96) % 255;
    leds[idexY] = CHSV(thishuehail, thissat, 255);
    leds[idexB] = CHSV(thathue, thissat, 255);
  }

if (setEffect == "Lovey Day") {                 //Valentine's Day colors (TWO COLOR SOLID)
    idex++;
    if (idex >= NUM_LEDS) {
      idex = 0;
    }
    int idexR = idex;
    int idexB = antipodal_index(idexR);
    int thathue = (thishueLovey + 244) % 255;
    leds[idexR] = CHSV(thishueLovey, thissat, 255);
    leds[idexB] = CHSV(thathue, thissat, 255);
  }

if (setEffect == "Holly Jolly") {
    static uint8_t startIndex = 0;
    startIndex = startIndex + 1; /* higher = faster motion */

fill_palette( leds, NUM_LEDS,
                  startIndex, 16, /* higher = narrower stripes */
                  HJPalettestriped, 255, NOBLEND);
  }

/////////////////End DrZzs effects/////////////
///////////////////////////////////////////////

////////My custom effects below////////////

if (setEffect == "C9") {  
 FillLEDsFromPaletteColors( colorIndex);
}

if (setEffect == "C9 Moving") {  
 FillLEDsFromPaletteColors( colorIndex);
  colorIndex++;
}

if (setEffect == "Red Green White") {     //Red Green and White
    static uint8_t startIndex = 0;
    startIndex = startIndex + 1; /* higher = faster motion */

fill_palette( leds, NUM_LEDS,
                  startIndex, 16, /* higher = narrower stripes */
                  RGWPalettestriped, 255, NOBLEND);
  }

if (setEffect == "Red Green With Glitter") {      //Red Green colors with Glitter
    static uint8_t startIndex = 0;
    startIndex = startIndex + 1; /* higher = faster motion */

fill_palette( leds, NUM_LEDS,
                  startIndex, 16, /* higher = narrower stripes */
                  RGPalettestriped, 255, NOBLEND);
                  addGlitter(320);
  }

if (setEffect == "Orange & Purple EFFECT") {                 //Orange and Purple colors (TWO COLOR SOLID)
    idex++;
    if (idex >= NUM_LEDS) {
      idex = 0;
    }
    int idexR = idex;
    int idexB = antipodal_index(idexR);
    int thathue = (thishueHalloween + 170) % 255; 
    leds[idexR] = CHSV(thishueHalloween, thissat, 255);
    leds[idexB] = CHSV(thathue, thissat, 255);
  }

if (setEffect == "Orange & Green EFFECT") {                 //Orange and Green colors (TWO COLOR SOLID)
    idex++;
    if (idex >= NUM_LEDS) {
      idex = 0;
    }
    int idexR = idex;
    int idexB = antipodal_index(idexR);
    int thathue = (thishueHalloween2 + 66) % 255; 
    leds[idexR] = CHSV(thishueHalloween2, thissat, 255);
    leds[idexB] = CHSV(thathue, thissat, 255);
  }

if (setEffect == "Purple & Green EFFECT") {                 //Purple and Green colors (TWO COLOR SOLID)
    idex++;
    if (idex >= NUM_LEDS) {
      idex = 0;
    }
    int idexR = idex;
    int idexB = antipodal_index(idexR);
    int thathue = (thishueHalloween3 + 96) % 255; 
    leds[idexR] = CHSV(thishueHalloween3, thissat, 255);
    leds[idexB] = CHSV(thathue, thissat, 255);
  }

if (setEffect == "HalloweenTri") {       //Orange Green and Purple
    static uint8_t startIndex = 0;
    startIndex = startIndex + 1; /* higher = faster motion */

fill_palette( leds, NUM_LEDS,
                  startIndex, 16, /* higher = narrower stripes */
                  HalloweenTriPalettestriped, 255, NOBLEND);
  }

if (setEffect == "Purple & Green") {       //Purple and Green 
    static uint8_t startIndex = 0;
    startIndex = startIndex + 1; /* higher = faster motion */

fill_palette( leds, NUM_LEDS,
                  startIndex, 16, /* higher = narrower stripes */
                  PurpleGreenPalettestriped, 255, NOBLEND);
  }

if (setEffect == "Orange & Green") {       //Orange and Green
    static uint8_t startIndex = 0;
    startIndex = startIndex + 1; /* higher = faster motion */

fill_palette( leds, NUM_LEDS,
                  startIndex, 16, /* higher = narrower stripes */
                  OrangeGreenPalettestriped, 255, NOBLEND);
  }

if (setEffect == "Orange & Purple") {       //Orange and Green
    static uint8_t startIndex = 0;
    startIndex = startIndex + 1; /* higher = faster motion */

fill_palette( leds, NUM_LEDS,
                  startIndex, 16, /* higher = narrower stripes */
                  OrangePurplePalettestriped, 255, NOBLEND);
  }

if (setEffect == "Candy Corn") {      //Candy Corn theme
    static uint8_t startIndex = 0;
    startIndex = startIndex + 1; /* higher = faster motion */

fill_palette( leds, NUM_LEDS,
                  startIndex, 16, /* higher = narrower stripes */
                  CandyCornPalettestriped, 255, NOBLEND);
  }

/////////////end custom effects////////////////

///////////////////////////////////////////////
/////////fastLED & Bruh effects///////////////
/////////////////////////////////////////////
  
  if (setEffect == "Sinelon") {
    fadeToBlackBy( leds, NUM_LEDS, 20);
    int pos = beatsin16(13, 0, NUM_LEDS);
    leds[pos] += CRGB(Rcolor, Gcolor, Bcolor);
  }

if (setEffect == "Juggle" ) {                           // eight colored dots, weaving in and out of sync with each other
    fadeToBlackBy( leds, NUM_LEDS, 20);
    byte dothue = 0;
    for ( int i = 0; i < 8; i++) {
      leds[beatsin16(i + 7, 0, NUM_LEDS)] |= CRGB(Rcolor, Gcolor, Bcolor);
      dothue += 32;
    }
  }

if (setEffect == "Confetti" ) {                       // random colored speckles that blink in and fade smoothly
    fadeToBlackBy( leds, NUM_LEDS, 10);
    int pos = random16(NUM_LEDS);
    leds[pos] += CRGB(Rcolor + random8(64), Gcolor, Bcolor);
  }

if (setEffect == "Rainbow") {
    // FastLED's built-in rainbow generator
    static uint8_t starthue = 0;    thishue++;
    fill_rainbow(leds, NUM_LEDS, thishue, deltahue);
  }

if (setEffect == "Rainbow with Glitter") {               // FastLED's built-in rainbow generator with Glitter
    static uint8_t starthue = 0;
    thishue++;
    fill_rainbow(leds, NUM_LEDS, thishue, deltahue);
    addGlitter(80);
  }

if (setEffect == "Glitter") {
    fadeToBlackBy( leds, NUM_LEDS, 20);
    addGlitterColor(80, Rcolor, Gcolor, Bcolor);
  }

if (setEffect == "BPM") {                                  // colored stripes pulsing at a defined Beats-Per-Minute (BPM)
  uint8_t BeatsPerMinute = 62;
  CRGBPalette16 palette = PartyColors_p;
  uint8_t beat = beatsin8( BeatsPerMinute, 64, 255);
  for( int i = 0; i < NUM_LEDS; i++) { //9948
    leds[i] = ColorFromPalette(palette, gHue+(i*2), beat-gHue+(i*10));
  }
}

if (setEffect == "Solid" & setPower == "ON" ) {          //Fill entire strand with solid color
    fill_solid(leds, NUM_LEDS, CRGB(Rcolor, Gcolor, Bcolor));
  }

if (setEffect == "Twinkle") {
    twinklecounter = twinklecounter + 1;
    if (twinklecounter < 2) {                               //Resets strip if previous animation was running
      FastLED.clear();
      FastLED.show();
    }
    const CRGB lightcolor(8, 7, 1);
    for ( int i = 0; i < NUM_LEDS; i++) {
      if ( !leds[i]) continue; // skip black pixels
      if ( leds[i].r & 1) { // is red odd?
        leds[i] -= lightcolor; // darken if red is odd
      } else {
        leds[i] += lightcolor; // brighten if red is even
      }
    }
    if ( random8() < DENSITY) {
      int j = random16(NUM_LEDS);
      if ( !leds[j] ) leds[j] = lightcolor;
    }
  }

if (setEffect == "Dots") {
    uint8_t inner = beatsin8(bpm, NUM_LEDS / 4, NUM_LEDS / 4 * 3);
    uint8_t outer = beatsin8(bpm, 0, NUM_LEDS - 1);
    uint8_t middle = beatsin8(bpm, NUM_LEDS / 3, NUM_LEDS / 3 * 2);
    leds[middle] = CRGB::Purple;
    leds[inner] = CRGB::Blue;
    leds[outer] = CRGB::Aqua;
    nscale8(leds, NUM_LEDS, fadeval);
  }

if (setEffect == "Lightning") {
    twinklecounter = twinklecounter + 1;                     //Resets strip if previous animation was running
    Serial.println(twinklecounter);
    if (twinklecounter < 2) {
      FastLED.clear();
      FastLED.show();
    }
    ledstart = random8(NUM_LEDS);           // Determine starting location of flash
    ledlen = random8(NUM_LEDS - ledstart);  // Determine length of flash (not to go beyond NUM_LEDS-1)
    for (int flashCounter = 0; flashCounter < random8(3, flashes); flashCounter++) {
      if (flashCounter == 0) dimmer = 5;    // the brightness of the leader is scaled down by a factor of 5
      else dimmer = random8(1, 3);          // return strokes are brighter than the leader
      fill_solid(leds + ledstart, ledlen, CHSV(255, 0, 255 / dimmer));
      FastLED.show();                       // Show a section of LED's
      delay(random8(4, 10));                // each flash only lasts 4-10 milliseconds
      fill_solid(leds + ledstart, ledlen, CHSV(255, 0, 0)); // Clear the section of LED's
      FastLED.show();
      if (flashCounter == 0) delay (150);   // longer delay until next flash after the leader
      delay(50 + random8(100));             // shorter delay between strokes
    }
    delay(random8(frequency) * 100);        // delay between strikes
  }

if (setEffect == "Police One") {                    //POLICE LIGHTS (TWO COLOR SINGLE LED)
    idex++;
    if (idex >= NUM_LEDS) {
      idex = 0;
    }
    int idexR = idex;
    int idexB = antipodal_index(idexR);
    int thathue = (thishuepolice + 160) % 255;
    for (int i = 0; i < NUM_LEDS; i++ ) {
      if (i == idexR) {
        leds[i] = CHSV(thishuepolice, thissat, 255);
      }
      else if (i == idexB) {
        leds[i] = CHSV(thathue, thissat, 255);
      }
      else {
        leds[i] = CHSV(0, 0, 0);
      }
    }

}

if (setEffect == "Police All") {                 //POLICE LIGHTS (TWO COLOR SOLID)
    idex++;
    if (idex >= NUM_LEDS) {
      idex = 0;
    }
    int idexR = idex;
    int idexB = antipodal_index(idexR);
    int thathue = (thishuepolice + 160) % 255;
    leds[idexR] = CHSV(thishuepolice, thissat, 255);
    leds[idexB] = CHSV(thathue, thissat, 255);
  }

if (setEffect == "Candy Cane") {
    static uint8_t startIndex = 0;
    startIndex = startIndex + 1; /* higher = faster motion */

fill_palette( leds, NUM_LEDS,
                  startIndex, 16, /* higher = narrower stripes */
                  currentPalettestriped, 255, LINEARBLEND);
  }

if (setEffect == "Cyclon Rainbow") {                    //Single Dot Down
  static uint8_t hue = 0;
  Serial.print("x");
  // First slide the led in one direction
  for(int i = 0; i < NUM_LEDS; i++) {
    // Set the i'th led to red 
    leds[i] = CHSV(hue++, 255, 255);
    // Show the leds
    FastLED.show(); 
    // now that we've shown the leds, reset the i'th led to black
    // leds[i] = CRGB::Black;
    fadeall();
    // Wait a little bit before we loop around and do it again
    delay(10);
  }
  for(int i = (NUM_LEDS)-1; i >= 0; i--) {
    // Set the i'th led to red 
    leds[i] = CHSV(hue++, 255, 255);
    // Show the leds
    FastLED.show();
    // now that we've shown the leds, reset the i'th led to black
    // leds[i] = CRGB::Black;
    fadeall();
    // Wait a little bit before we loop around and do it again
    delay(10);
  }
}

if (setEffect == "Fire") { 
      Fire2012WithPalette();
  }
     random16_add_entropy( random8());

EVERY_N_MILLISECONDS(10) {
    nblendPaletteTowardPalette(currentPalette, targetPalette, maxChanges);  // FOR NOISE ANIMATION
    { gHue++; }

if (setEffect == "Easter") {
      setPower = "ON";
      for (int i = 0; i < NUM_LEDS; i++) {                                     // Just ONE loop to fill up the LED array as all of the pixels change.
        uint8_t index = inoise8(i * scale, dist + i * scale) % 255;            // Get a value from the noise function. I'm using both x and y axis.
        leds[i] = ColorFromPalette(currentPalette, index, 255, LINEARBLEND);   // With that value, look up the 8 bit colour palette value and assign it to the current LED.
      }
      dist += beatsin8(10, 1, 4);                                              // Moving along the distance (that random number we started out with). Vary it a bit with a sine wave.
      // In some sketches, I've used millis() instead of an incremented counter. Works a treat.
    }

if (setEffect == "Ripple") {
      for (int i = 0; i < NUM_LEDS; i++) leds[i] = CHSV(bgcol++, 255, 15);  // Rotate background colour.
      switch (step) {
        case -1:                                                          // Initialize ripple variables.
          center = random(NUM_LEDS);
          colour = random8();
          step = 0;
          break;
        case 0:
          leds[center] = CHSV(colour, 255, 255);                          // Display the first pixel of the ripple.
          step ++;
          break;
        case maxsteps:                                                    // At the end of the ripples.
          step = -1;
          break;
        default:                                                             // Middle of the ripples.
          leds[(center + step + NUM_LEDS) % NUM_LEDS] += CHSV(colour, 255, myfade / step * 2);   // Simple wrap from Marc Miller
          leds[(center - step + NUM_LEDS) % NUM_LEDS] += CHSV(colour, 255, myfade / step * 2);
          step ++;                                                         // Next step.
          break;
      }
    }

}

EVERY_N_SECONDS(5) {
    targetPalette = CRGBPalette16(CHSV(random8(), 255, random8(128, 255)), CHSV(random8(), 255, random8(128, 255)), CHSV(random8(), 192, random8(128, 255)), CHSV(random8(), 255, random8(128, 255)));
  }

FastLED.setBrightness(brightness);  //EXECUTE EFFECT COLOR
  FastLED.show();

if (animationspeed > 0 && animationspeed < 150) {  //Sets animation speed based on receieved value
    FastLED.delay(1000 / animationspeed);
  }

}

////////////////////////place setup__Palette and __Palettestriped custom functions here - for Candy Cane effects ///////////////// 
///////You can use up to 4 colors and change the pattern of A's AB's B's and BA's as you like//////////////

void setupStripedPalette( CRGB A, CRGB AB, CRGB B, CRGB BA)
{
  currentPalettestriped = CRGBPalette16(
                            A, A, A, A, A, A, A, A, B, B, B, B, B, B, B, B
                          );
}

void setupHailPalette( CRGB A, CRGB AB, CRGB B, CRGB BA)
{
  hailPalettestriped = CRGBPalette16(
                            A, A, A, A, A, A, A, A, B, B, B, B, B, B, B, B
                          );
}

void setupHJPalette( CRGB A, CRGB AB, CRGB B, CRGB BA)
{
  HJPalettestriped = CRGBPalette16(
                            A, A, A, A, A, A, A, A, B, B, B, B, B, B, B, B
                          );
}

void setupIndPalette( CRGB A, CRGB AB, CRGB B, CRGB BA)
{
  IndPalettestriped = CRGBPalette16(
                            A, A, A, A, A, AB, AB, AB, AB, AB, B, B, B, B, B, B
                          );
}

void setupThxPalette( CRGB A, CRGB AB, CRGB B, CRGB BA)
{
  ThxPalettestriped = CRGBPalette16(
                            A, A, A, A, A, A, A, AB, AB, AB, B, B, B, B, B, B
                          );
}

void setupHalloweenTriPalette( CRGB A, CRGB AB, CRGB B, CRGB BA)
{
  HalloweenTriPalettestriped = CRGBPalette16(
                            BA, A, A, A, BA, AB, AB, AB, BA, B, B, B, BA, AB, AB, AB
                          );
}

void setupPurpleGreenPalette( CRGB A, CRGB AB, CRGB B, CRGB BA)
{
  PurpleGreenPalettestriped = CRGBPalette16(
                            B, A, A, A, B, AB, AB, AB, B, A, A, A, B, AB, AB, AB
                          );
}

void setupOrangeGreenPalette( CRGB A, CRGB AB, CRGB B, CRGB BA)
{
  OrangeGreenPalettestriped = CRGBPalette16(
                              B, A, A, A, B, AB, AB, AB, B, A, A, A, B, AB, AB, AB
                          );
}

void setupOrangePurplePalette( CRGB A, CRGB AB, CRGB B, CRGB BA)
{
  OrangePurplePalettestriped = CRGBPalette16(
                              B, A, A, A, B, AB, AB, AB, B, A, A, A, B, AB, AB, AB
                          );
}

void setupCandyCornPalette( CRGB A, CRGB AB, CRGB B, CRGB BA)
{
  CandyCornPalettestriped = CRGBPalette16(
                            BA, BA, B, AB, AB, A, A, A, BA, BA, B, AB, AB, A, A, A 
                          );
}

void setupRGWPalette( CRGB A, CRGB AB, CRGB B, CRGB BA)
{
  RGWPalettestriped = CRGBPalette16(
                            A, A, A, AB, AB, AB, B, B, B, A, A, A, AB, AB, AB, AB
                          );
}

void setupRGPalette( CRGB A, CRGB AB, CRGB B, CRGB BA)
{
  RGPalettestriped = CRGBPalette16(
                            A, A, A, A, AB, AB, AB, AB, A, A, A, A, AB, AB, AB, AB
                          );
}

////////////////////////////////////////////////////////

void fadeall() { for(int i = 0; i < NUM_LEDS; i++) { leds[i].nscale8(250); } } //for CYCLON

void Fire2012WithPalette()
{
// Array of temperature readings at each simulation cell
  static byte heat[NUM_LEDS];

// Step 1.  Cool down every cell a little
    for( int i = 0; i < NUM_LEDS; i++) {
      heat[i] = qsub8( heat[i],  random8(0, ((COOLING * 10) / NUM_LEDS) + 2));
    }
  
    // Step 2.  Heat from each cell drifts 'up' and diffuses a little
    for( int k= NUM_LEDS - 1; k >= 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() < SPARKING ) {
      int y = random8(7);
      heat[y] = qadd8( heat[y], random8(160,255) );
    }

// Step 4.  Map from heat cells to LED colors
    for( int j = 0; j < NUM_LEDS; j++) {
      // Scale the heat value from 0-255 down to 0-240
      // for best results with color palettes.
      byte colorindex = scale8( heat[j], 240);
      CRGB color = ColorFromPalette( gPal, colorindex);
      int pixelnumber;
      if( gReverseDirection ) {
        pixelnumber = (NUM_LEDS-1) - j;
      } else {
        pixelnumber = j;
      }
      leds[pixelnumber] = color;
    }
}

const TProgmemPalette16 myC9Palette PROGMEM =
{
    CRGB::Red,
    CRGB::DarkOrange,
    CRGB::Blue,
    CRGB::Green,
    
    CRGB::Yellow,
    CRGB::White,
    CRGB::Red,
    CRGB::DarkOrange,
    
    CRGB::Blue,
    CRGB::Green,
    CRGB::Yellow,
    CRGB::White,
    CRGB::Red,
    CRGB::DarkOrange,
    CRGB::Blue,
    CRGB::Green
};

void FillLEDsFromPaletteColors( uint8_t colorIndex)
{
    uint8_t brightness = 255;
    currentPalette = myC9Palette;
    currentBlending = NOBLEND;

for( int i = 0; i < NUM_LEDS-1; i++) {
        leds[i] = ColorFromPalette( currentPalette, colorIndex, brightness, NOBLEND);
        colorIndex += 16;
    }
}

void addGlitter( fract8 chanceOfGlitter) 
{
  if( random8() < chanceOfGlitter) {
    leds[ random16(NUM_LEDS) ] += CRGB::White;
  }
}

void addGlitterColor( fract8 chanceOfGlitter, int Rcolor, int Gcolor, int Bcolor) 
{
  if( random8() < chanceOfGlitter) {
    leds[ random16(NUM_LEDS) ] += CRGB(Rcolor, Gcolor, Bcolor);
  }
}

void reconnect() {
  // Loop until we're reconnected
  while (!client.connected()) {
    Serial.print("Attempting MQTT connection...");
    // Attempt to connect
  if (client.connect("ArchLEDs", mqtt_user, mqtt_password)) {
      Serial.println("connected");

FastLED.clear (); //Turns off startup LEDs after connection is made
      FastLED.show();

client.subscribe(setcolorsub);
      client.subscribe(setbrightness);
      //client.subscribe(setcolortemp);
      client.subscribe(setpowersub);
      client.subscribe(seteffectsub);
      client.subscribe(setanimationspeed);
      client.publish(setpowerpub, "OFF");
    } else {
      Serial.print("failed, rc=");
      Serial.print(client.state());
      Serial.println(" try again in 5 seconds");
      // Wait 5 seconds before retrying
      delay(5000);
    }
  }
}

Changed text