Last active
August 21, 2018 18:50
-
-
Save kbostick88/6b4271e6c61612c3082f52d6d7213d57 to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
#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 "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}; | |
//bue 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}; | |
//orange and purple | |
// 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/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]; | |
/****************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 | |
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 = 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 espClient; | |
PubSubClient client(espClient); | |
//////////////////////////////////////////////////////////// | |
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); | |
//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 == "C9") { | |
FillLEDsFromPaletteColors( uint8_t colorIndex); | |
uint8_t brightness = 255; | |
for( int i = 0; i < NUM_LEDS; i++) { | |
leds[i] = ColorFromPalette( currentPalette, colorIndex, brightness, NOBLEND); | |
colorIndex += 3; | |
} | |
} | |
if (setEffect == "C9") { | |
FillLEDsFromPaletteColors( colorIndex); | |
} | |
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 FillLEDsFromPaletteColors( uint8_t colorIndex) | |
{ | |
uint8_t brightness = 255; | |
for( int i = 0; i < NUM_LEDS-1; i++) { | |
leds[i] = ColorFromPalette( currentPalette, colorIndex, brightness, NOBLEND); | |
colorIndex += 3; | |
} | |
} | |
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("PorchLEDs", 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