1,016 BruhZzs_LEDs_Pub.ino
View file
@@ -0,0 +1,1016 @@
/*
.______ .______ __ __ __ __ ___ __ __ .___________. ______ .___ ___. ___ .___________. __ ______ .__ __.
| _ \ | _ \ | | | | | | | | / \ | | | | | | / __ \ | \/ | / \ | || | / __ \ | \ | |
| |_) | | |_) | | | | | | |__| | / ^ \ | | | | `---| |----`| | | | | \ / | / ^ \ `---| |----`| | | | | | | \| |
| _ < | / | | | | | __ | / /_\ \ | | | | | | | | | | | |\/| | / /_\ \ | | | | | | | | | . ` |
| |_) | | |\ \-.| `--' | | | | | / _____ \ | `--' | | | | `--' | | | | | / _____ \ | | | | | `--' | | |\ |
|______/ | _| `.__| \______/ |__| |__| /__/ \__\ \______/ |__| \______/ |__| |__| /__/ \__\ |__| |__| \______/ |__| \__|
This is the code I use for my MQTT LED Strip controlled from Home Assistant. It's a work in progress, but works great! Huge shout out to all the people I copied ideas from as a scoured around the internet. If you recoginze your code here and want credit, let me know and I'll get that added. Cheers!
*/

#include <Adafruit_NeoPixel.h>
#include <ESP8266WiFi.h>
#include <PubSubClient.h>
#define FASTLED_INTERRUPT_RETRY_COUNT 0
#include <FastLED.h>


/************ WIFI and MQTT INFORMATION (CHANGE THESE FOR YOUR SETUP) ******************/
#define wifi_ssid "xxxx" //enter your WIFI SSID
#define wifi_password "xxxxx" //enter your WIFI Password

#define mqtt_server "xxx.xxx.xx.xx" // Enter your MQTT server adderss or IP. I use my DuckDNS adddress (yourname.duckdns.org) in this field
#define mqtt_user "xxxx" //enter your MQTT username
#define mqtt_password "xxxx" //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 WS2811 //change to match your LED type
#define COLOR_ORDER RGB //change to match your LED configuration // RGB for 2811's | GRB for 2812's //
#define NUM_LEDS 175 //change to match your setup

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

// 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};

// 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};

// 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};

// 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};

// 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};

// 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};

// 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.

// 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};

// 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};

// 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
};

// 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};

// 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};

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

DEFINE_GRADIENT_PALETTE( Orange_to_Purple_gp ) {
0, 208, 50, 1,
127, 146, 27, 45,
255, 97, 12,178};

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

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

#define setcolorpub "bruh/mqttstripSide/setcolorpub"
#define setpowerpub "bruh/mqttstripSide/setpowerpub"
#define seteffectpub "bruh/mqttstripSide/seteffectpub"
#define setbrightnesspub "bruh/mqttstripSide/setbrightnesspub"
#define setanimationspeed "bruh/mqttstripSide/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];

/****************FOR CANDY CANE-like desings***************/
CRGBPalette16 currentPalettestriped; //for Candy Cane
CRGBPalette16 hailPalettestriped; //for Hail
CRGBPalette16 ThxPalettestriped; //for Thanksgiving
CRGBPalette16 HalloweenPalettestriped; //for Halloween
CRGBPalette16 HJPalettestriped; //for Holly Jolly
CRGBPalette16 IndPalettestriped; //for Independence
CRGBPalette16 gPal; //for fire

/****************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);

/*****************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 = 50; // 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;
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 espCLEDside;
PubSubClient client(espCLEDside);

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

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
setupThxPalette( CRGB::OrangeRed, CRGB::Olive, CRGB::Maroon, CRGB::Maroon); //for Thanksgiving
setupHailPalette( CRGB::Blue, CRGB::Blue, CRGB::Yellow, CRGB::Yellow); //for HAIL
setupHalloweenPalette( CRGB::DarkOrange, CRGB::DarkOrange, CRGB::Indigo, CRGB::Indigo); //for Halloween
setupHJPalette( CRGB::Red, CRGB::Red, CRGB::Green, CRGB::Green); //for Holly Jolly
setupIndPalette( CRGB::FireBrick, CRGB::Cornsilk, CRGB::MediumBlue, 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);
}


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();
}
client.loop();


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, LINEARBLEND);
}


if (setEffect == "Halloween") { // colored stripes pulsing in Shades of Purple and Orange
uint8_t BeatsPerMinute = 62;
CRGBPalette16 palette = Orange_to_Purple_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 == "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 == "Punkin") {
static uint8_t startIndex = 0;
startIndex = startIndex + 1; /* higher = faster motion */

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

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, LINEARBLEND);
}

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

////////Place your custom effects below////////////




/////////////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 setupHalloweenPalette( CRGB A, CRGB AB, CRGB B, CRGB BA)
{
HalloweenPalettestriped = CRGBPalette16(
A, A, A, A, A, A, A, A, B, B, B, B, B, B, B, B
);
}

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

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;
}
}


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("espCLEDdev", 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);
}
}
}