Skip to content

Instantly share code, notes, and snippets.

@kbostick88

kbostick88/Holiday lights

Last active December 11, 2018 12:50
Show Gist options
  • Star 1 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save kbostick88/5991938db32ae6f611934d69be706ffc to your computer and use it in GitHub Desktop.
Save kbostick88/5991938db32ae6f611934d69be706ffc to your computer and use it in GitHub Desktop.
Download ZIP
Raw
Holiday lights
#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 "Pillar 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 WS2811 //change to match your LED type
#define COLOR_ORDER RGB //change to match your LED configuration, ws2812 are GRB, 2811 are RGB
#define NUM_LEDS 50 //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/mqttstripPillar/colorstatus"
#define setcolorsub "bruh/mqttstripPillar/setcolor"
#define setpowersub "bruh/mqttstripPillar/setpower"
#define seteffectsub "bruh/mqttstripPillar/seteffect"
#define setbrightness "bruh/mqttstripPillar/setbrightness"
#define setcolorpub "bruh/mqttstripPillar/setcolorpub"
#define setpowerpub "bruh/mqttstripPillar/setpowerpub"
#define seteffectpub "bruh/mqttstripPillar/seteffectpub"
#define setbrightnesspub "bruh/mqttstripPillar/setbrightnesspub"
#define setanimationspeed "bruh/mqttstripPillar/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;
extern const TProgmemPalette16 myEasterPalette 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 STROBE**************/
uint8_t strobeIntervalMs = 50; // controls the interval between strobe flashes
CRGB strobeColor = CRGB::White; // the "on" color of the strobe
/********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 espPillar;
PubSubClient client(espPillar);
////////////////////////////////////////////////////////////
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 == "Strobe") {
Strobe();
}
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 == "Red Green White Loop") {
uint8_t delayValue = map ( animationspeed, 0, 150, 5, 255 );
static uint8_t startIndex = 0;
startIndex = startIndex + 0; /* higher = faster motion */
for(int i = 0; i < NUM_LEDS; i++) {
leds[i] = CRGB(255, 0, 0);
FastLED.show();
delay(delayValue);
}
for(int i = (NUM_LEDS)-1; i >= 0; i--) {
leds[i] = CRGB(0, 255, 0);
FastLED.show();
delay(delayValue);
}
for(int i = 0; i < NUM_LEDS; i++) {
leds[i] = CRGB(255, 255, 255);
FastLED.show();
delay(delayValue);
}
for(int i = (NUM_LEDS)-1; i >= 0; i--) {
leds[i] = CRGB(0, 255, 0);
FastLED.show();
delay(delayValue);
}
}
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);
}
if (setEffect == "Easter Colors") {
FillLEDsFromEasterPaletteColors( colorIndex);
}
if (setEffect == "Easter Moving") {
FillLEDsFromEasterPaletteColors( colorIndex);
colorIndex++;
}
/////////////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
};
const TProgmemPalette16 myEasterPalette PROGMEM =
{
CRGB::Aqua,
CRGB::Aqua,
CRGB::Aqua,
CRGB::Aqua,
CRGB::GreenYellow,
CRGB::GreenYellow,
CRGB::GreenYellow,
CRGB::GreenYellow,
CRGB::Fuchsia,
CRGB::Fuchsia,
CRGB::Fuchsia,
CRGB::Fuchsia,
CRGB::Green,
CRGB::Green,
CRGB::Green,
CRGB::Green
};
void Strobe() {
if ((millis() / strobeIntervalMs) % 2) {
fill_solid(leds, NUM_LEDS, CRGB::Black);
} else {
fill_solid(leds, NUM_LEDS, strobeColor);
}
}
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 FillLEDsFromEasterPaletteColors( uint8_t colorIndex)
{
uint8_t brightness = 255;
currentPalette = myEasterPalette;
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("PillarLEDs", 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);
}
}
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment