Created
August 22, 2018 00:58
-
-
Save kbostick88/a4b7d847cf0b715e7978854327e2c812 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 "Arch 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////////////////////////////////// | |
// 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}; | |
/****************************** 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 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 | |
/****************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 = 75; // controls the interval between strikes | |
uint8_t flashes = 8; //the upper limit of flashes per strike | |
unsigned int dimmer = 1; | |
uint8_t ledstart; // Starting location of a flash | |
uint8_t ledlen; | |
int lightningcounter = 0; | |
/********FOR FUNKBOX EFFECTS**********/ | |
int idex = 0; //-LED INDEX (0 to NUM_LEDS-1 | |
int TOP_INDEX = int(NUM_LEDS / 2); | |
int thissat = 255; //-FX LOOPS DELAY VAR | |
//////////////////add thishue__ for Police All custom effects here///////////////////////////////////////////////////////// | |
/////////////////use hsv Hue number for one color, for second color change "thishue__ + __" in the setEffect section////// | |
uint8_t thishuepolice = 0; | |
uint8_t thishuehail = 64; | |
uint8_t thishueLovey = 0; | |
uint8_t thishueHalloween = 28; | |
uint8_t thishueHalloween2 = 28; | |
uint8_t thishueHalloween3 = 96; | |
int antipodal_index(int i) { | |
int iN = i + TOP_INDEX; | |
if (i >= TOP_INDEX) { | |
iN = ( i + TOP_INDEX ) % NUM_LEDS; | |
} | |
return iN; | |
} | |
/********FIRE**********/ | |
#define COOLING 55 | |
#define SPARKING 120 | |
bool gReverseDirection = false; | |
/********BPM**********/ | |
uint8_t gHue = 0; | |
char message_buff[100]; | |
WiFiClient espArch; | |
PubSubClient client(espArch); | |
//////////////////////////////////////////////////////////// | |
void setup() { | |
WiFi.setSleepMode(WIFI_NONE_SLEEP); | |
Serial.begin(115200); | |
FastLED.addLeds<LED_TYPE, DATA_PIN, COLOR_ORDER>(leds, NUM_LEDS).setCorrection(TypicalLEDStrip); | |
FastLED.setMaxPowerInVoltsAndMilliamps(12, 10000); //experimental for power management. Feel free to try in your own setup. | |
FastLED.setBrightness(brightness); | |
setupStripedPalette( CRGB::Red, CRGB::Red, CRGB::White, CRGB::White); //for CANDY CANE | |
setupRGWPalette( CRGB::Red, CRGB::White, CRGB::Green, CRGB::White); //for Red Green White | |
setupRGPalette( CRGB::Red, CRGB::Green, CRGB::Red, CRGB::Green); //for Red Green | |
setupThxPalette( CRGB::OrangeRed, CRGB::Olive, CRGB::Maroon, CRGB::Maroon); //for Thanksgiving | |
setupHailPalette( CRGB::Blue, CRGB::Blue, CRGB::Yellow, CRGB::Yellow); //for HAIL | |
setupHalloweenTriPalette( CRGB(255,95,0), CRGB(0,255,0), CRGB(115,0,235), CRGB::Black); //for Halloween Orange Green Purple | |
setupOrangeGreenPalette( CRGB(255,95,0), CRGB(0,255,0), CRGB::Black, CRGB(0,255,0)); //for Halloween Orange & Green | |
setupPurpleGreenPalette( CRGB(115,0,235), CRGB(0,255,0), CRGB::Black, CRGB(0,255,0)); //for Halloween Purple & Green | |
setupOrangePurplePalette( CRGB(255,95,0), CRGB(115,0,235), CRGB::Black, CRGB(255,95,0)); //for Halloween Orange & Purple | |
setupCandyCornPalette( CRGB(255,95,0), CRGB(240,240,0), CRGB(255,255,255), CRGB::Black); //for CandyCane Orange Yellow White | |
setupHJPalette( CRGB::Red, CRGB::Red, CRGB::Green, CRGB::Green); //for Holly Jolly | |
setupIndPalette( CRGB::Red, CRGB::White, CRGB::Blue, CRGB::MediumBlue); //for Independence | |
///////////////////////////////////////////////////////////////////////////////////////////////////////// | |
gPal = HeatColors_p; //for FIRE | |
fill_solid(leds, NUM_LEDS, CRGB(255, 0, 0)); //Startup LED Lights | |
FastLED.show(); | |
setup_wifi(); | |
client.setServer(mqtt_server, 1883); //CHANGE PORT HERE IF NEEDED | |
client.setCallback(callback); | |
//OTA SETUP | |
ArduinoOTA.setPort(OTAport); | |
// Hostname defaults to esp8266-[ChipID] | |
ArduinoOTA.setHostname(SENSORNAME); | |
// No authentication by default | |
ArduinoOTA.setPassword((const char *)OTApassword); | |
ArduinoOTA.onStart([]() { | |
Serial.println("Starting"); | |
}); | |
ArduinoOTA.onEnd([]() { | |
Serial.println("\nEnd"); | |
}); | |
ArduinoOTA.onProgress([](unsigned int progress, unsigned int total) { | |
Serial.printf("Progress: %u%%\r", (progress / (total / 100))); | |
}); | |
ArduinoOTA.onError([](ota_error_t error) { | |
Serial.printf("Error[%u]: ", error); | |
if (error == OTA_AUTH_ERROR) Serial.println("Auth Failed"); | |
else if (error == OTA_BEGIN_ERROR) Serial.println("Begin Failed"); | |
else if (error == OTA_CONNECT_ERROR) Serial.println("Connect Failed"); | |
else if (error == OTA_RECEIVE_ERROR) Serial.println("Receive Failed"); | |
else if (error == OTA_END_ERROR) Serial.println("End Failed"); | |
}); | |
ArduinoOTA.begin(); | |
Serial.println("Ready"); | |
Serial.print("IP Address: "); | |
Serial.println(WiFi.localIP()); | |
} | |
void setup_wifi() { | |
delay(10); | |
Serial.println(); | |
Serial.print("Connecting to "); | |
Serial.println(wifi_ssid); | |
WiFi.mode(WIFI_STA); | |
WiFi.begin(wifi_ssid, wifi_password); | |
while (WiFi.status() != WL_CONNECTED) { | |
delay(500); | |
Serial.print("."); | |
} | |
Serial.println(""); | |
Serial.println("WiFi connected"); | |
Serial.println("IP address: "); | |
Serial.println(WiFi.localIP()); | |
} | |
void callback(char* topic, byte* payload, unsigned int length) { | |
int i = 0; | |
if (String(topic) == setpowersub) { | |
for (i = 0; i < length; i++) { | |
message_buff[i] = payload[i]; | |
} | |
message_buff[i] = '\0'; | |
setPower = String(message_buff); | |
Serial.println("Set Power: " + setPower); | |
if (setPower == "OFF") { | |
client.publish(setpowerpub, "OFF"); | |
} | |
if (setPower == "ON") { | |
client.publish(setpowerpub, "ON"); | |
} | |
} | |
if (String(topic) == seteffectsub) { | |
for (i = 0; i < length; i++) { | |
message_buff[i] = payload[i]; | |
} | |
message_buff[i] = '\0'; | |
setEffect = String(message_buff); | |
Serial.println("Set Effect: " + setEffect); | |
setPower = "ON"; | |
client.publish(setpowerpub, "ON"); | |
if (setEffect == "Twinkle") { | |
twinklecounter = 0; | |
} | |
if (setEffect == "Lightning") { | |
twinklecounter = 0; | |
} | |
} | |
if (String(topic) == setbrightness) { | |
for (i = 0; i < length; i++) { | |
message_buff[i] = payload[i]; | |
} | |
message_buff[i] = '\0'; | |
setBrightness = String(message_buff); | |
Serial.println("Set Brightness: " + setBrightness); | |
brightness = setBrightness.toInt(); | |
setPower = "ON"; | |
client.publish(setpowerpub, "ON"); | |
} | |
if (String(topic) == setcolorsub) { | |
for (i = 0; i < length; i++) { | |
message_buff[i] = payload[i]; | |
} | |
message_buff[i] = '\0'; | |
client.publish(setcolorpub, message_buff); | |
setColor = String(message_buff); | |
Serial.println("Set Color: " + setColor); | |
setPower = "ON"; | |
client.publish(setpowerpub, "ON"); | |
} | |
if (String(topic) == setanimationspeed) { | |
for (i = 0; i < length; i++) { | |
message_buff[i] = payload[i]; | |
} | |
message_buff[i] = '\0'; | |
setAnimationSpeed = String(message_buff); | |
animationspeed = setAnimationSpeed.toInt(); | |
} | |
} | |
void loop() { | |
if (!client.connected()) { | |
reconnect(); | |
} | |
if (WiFi.status() != WL_CONNECTED) { | |
delay(1); | |
Serial.print("WIFI Disconnected. Attempting reconnection."); | |
setup_wifi(); | |
return; | |
} | |
client.loop(); | |
ArduinoOTA.handle(); | |
int Rcolor = setColor.substring(0, setColor.indexOf(',')).toInt(); | |
int Gcolor = setColor.substring(setColor.indexOf(',') + 1, setColor.lastIndexOf(',')).toInt(); | |
int Bcolor = setColor.substring(setColor.lastIndexOf(',') + 1).toInt(); | |
if (setPower == "OFF") { | |
setEffect = "Solid"; | |
for ( int i = 0; i < NUM_LEDS; i++) { | |
leds[i].fadeToBlackBy( 8 ); //FADE OFF LEDS | |
} | |
} | |
///////////////////////////////////////// | |
//////DrZzs custom effects////////////// | |
/////////////////////////////////////// | |
if (setEffect == "Christmas") { // colored stripes pulsing in Shades of GREEN and RED | |
uint8_t BeatsPerMinute = 62; | |
CRGBPalette16 palette = bhw2_xmas_gp; | |
uint8_t beat = beatsin8( BeatsPerMinute, 64, 255); | |
for( int i = 0; i < NUM_LEDS; i++) { //9948 | |
leds[i] = ColorFromPalette(palette, gHue+(i*2), beat-gHue+(i*10)); | |
} | |
} | |
if (setEffect == "St Patty") { // colored stripes pulsing in Shades of GREEN | |
uint8_t BeatsPerMinute = 62; | |
CRGBPalette16 palette = bhw2_greenman_gp; | |
uint8_t beat = beatsin8( BeatsPerMinute, 64, 255); | |
for( int i = 0; i < NUM_LEDS; i++) { //9948 | |
leds[i] = ColorFromPalette(palette, gHue+(i*2), beat-gHue+(i*10)); | |
} | |
} | |
if (setEffect == "Valentine") { // colored stripes pulsing in Shades of PINK and RED | |
uint8_t BeatsPerMinute = 62; | |
CRGBPalette16 palette = bhw2_redrosey_gp; | |
uint8_t beat = beatsin8( BeatsPerMinute, 64, 255); | |
for( int i = 0; i < NUM_LEDS; i++) { //9948 | |
leds[i] = ColorFromPalette(palette, gHue+(i*2), beat-gHue+(i*10)); | |
} | |
} | |
if (setEffect == "Turkey Day") { // colored stripes pulsing in Shades of Brown and ORANGE | |
uint8_t BeatsPerMinute = 62; | |
CRGBPalette16 palette = bhw2_thanks_gp; | |
uint8_t beat = beatsin8( BeatsPerMinute, 64, 255); | |
for( int i = 0; i < NUM_LEDS; i++) { //9948 | |
leds[i] = ColorFromPalette(palette, gHue+(i*2), beat-gHue+(i*10)); | |
} | |
} | |
if (setEffect == "Thanksgiving") { // colored stripes pulsing in Shades of Red and ORANGE and Green | |
static uint8_t startIndex = 0; | |
startIndex = startIndex + 1; /* higher = faster motion */ | |
fill_palette( leds, NUM_LEDS, | |
startIndex, 16, /* higher = narrower stripes */ | |
ThxPalettestriped, 255, LINEARBLEND); | |
} | |
if (setEffect == "USA") { // colored stripes pulsing in Shades of Red White & Blue | |
uint8_t BeatsPerMinute = 62; | |
CRGBPalette16 palette = bhw3_41_gp; | |
uint8_t beat = beatsin8( BeatsPerMinute, 64, 255); | |
for( int i = 0; i < NUM_LEDS; i++) { //9948 | |
leds[i] = ColorFromPalette(palette, gHue+(i*2), beat-gHue+(i*10)); | |
} | |
} | |
if (setEffect == "Independence") { // colored stripes of Red White & Blue | |
static uint8_t startIndex = 0; | |
startIndex = startIndex + 1; /* higher = faster motion */ | |
fill_palette( leds, NUM_LEDS, | |
startIndex, 16, /* higher = narrower stripes */ | |
IndPalettestriped, 255, NOBLEND); | |
} | |
if (setEffect == "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 == "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 your custom effects below//////////// | |
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 == "HalloweenTri") { //Orange Green and Purple | |
static uint8_t startIndex = 0; | |
startIndex = startIndex + 1; /* higher = faster motion */ | |
fill_palette( leds, NUM_LEDS, | |
startIndex, 16, /* higher = narrower stripes */ | |
HalloweenTriPalettestriped, 255, NOBLEND); | |
} | |
if (setEffect == "Purple & Green") { //Purple and Green | |
static uint8_t startIndex = 0; | |
startIndex = startIndex + 1; /* higher = faster motion */ | |
fill_palette( leds, NUM_LEDS, | |
startIndex, 16, /* higher = narrower stripes */ | |
PurpleGreenPalettestriped, 255, NOBLEND); | |
} | |
if (setEffect == "Orange & Green") { //Orange and Green | |
static uint8_t startIndex = 0; | |
startIndex = startIndex + 1; /* higher = faster motion */ | |
fill_palette( leds, NUM_LEDS, | |
startIndex, 16, /* higher = narrower stripes */ | |
OrangeGreenPalettestriped, 255, NOBLEND); | |
} | |
if (setEffect == "Orange & Purple") { //Orange and Green | |
static uint8_t startIndex = 0; | |
startIndex = startIndex + 1; /* higher = faster motion */ | |
fill_palette( leds, NUM_LEDS, | |
startIndex, 16, /* higher = narrower stripes */ | |
OrangePurplePalettestriped, 255, NOBLEND); | |
} | |
if (setEffect == "Candy Corn") { //Candy Corn theme | |
static uint8_t startIndex = 0; | |
startIndex = startIndex + 1; /* higher = faster motion */ | |
fill_palette( leds, NUM_LEDS, | |
startIndex, 16, /* higher = narrower stripes */ | |
CandyCornPalettestriped, 255, NOBLEND); | |
} | |
/////////////end custom effects//////////////// | |
/////////////////////////////////////////////// | |
/////////fastLED & Bruh effects/////////////// | |
///////////////////////////////////////////// | |
if (setEffect == "Sinelon") { | |
fadeToBlackBy( leds, NUM_LEDS, 20); | |
int pos = beatsin16(13, 0, NUM_LEDS); | |
leds[pos] += CRGB(Rcolor, Gcolor, Bcolor); | |
} | |
if (setEffect == "Juggle" ) { // eight colored dots, weaving in and out of sync with each other | |
fadeToBlackBy( leds, NUM_LEDS, 20); | |
byte dothue = 0; | |
for ( int i = 0; i < 8; i++) { | |
leds[beatsin16(i + 7, 0, NUM_LEDS)] |= CRGB(Rcolor, Gcolor, Bcolor); | |
dothue += 32; | |
} | |
} | |
if (setEffect == "Confetti" ) { // random colored speckles that blink in and fade smoothly | |
fadeToBlackBy( leds, NUM_LEDS, 10); | |
int pos = random16(NUM_LEDS); | |
leds[pos] += CRGB(Rcolor + random8(64), Gcolor, Bcolor); | |
} | |
if (setEffect == "Rainbow") { | |
// FastLED's built-in rainbow generator | |
static uint8_t starthue = 0; thishue++; | |
fill_rainbow(leds, NUM_LEDS, thishue, deltahue); | |
} | |
if (setEffect == "Rainbow with Glitter") { // FastLED's built-in rainbow generator with Glitter | |
static uint8_t starthue = 0; | |
thishue++; | |
fill_rainbow(leds, NUM_LEDS, thishue, deltahue); | |
addGlitter(80); | |
} | |
if (setEffect == "Glitter") { | |
fadeToBlackBy( leds, NUM_LEDS, 20); | |
addGlitterColor(80, Rcolor, Gcolor, Bcolor); | |
} | |
if (setEffect == "BPM") { // colored stripes pulsing at a defined Beats-Per-Minute (BPM) | |
uint8_t BeatsPerMinute = 62; | |
CRGBPalette16 palette = PartyColors_p; | |
uint8_t beat = beatsin8( BeatsPerMinute, 64, 255); | |
for( int i = 0; i < NUM_LEDS; i++) { //9948 | |
leds[i] = ColorFromPalette(palette, gHue+(i*2), beat-gHue+(i*10)); | |
} | |
} | |
if (setEffect == "Solid" & setPower == "ON" ) { //Fill entire strand with solid color | |
fill_solid(leds, NUM_LEDS, CRGB(Rcolor, Gcolor, Bcolor)); | |
} | |
if (setEffect == "Twinkle") { | |
twinklecounter = twinklecounter + 1; | |
if (twinklecounter < 2) { //Resets strip if previous animation was running | |
FastLED.clear(); | |
FastLED.show(); | |
} | |
const CRGB lightcolor(8, 7, 1); | |
for ( int i = 0; i < NUM_LEDS; i++) { | |
if ( !leds[i]) continue; // skip black pixels | |
if ( leds[i].r & 1) { // is red odd? | |
leds[i] -= lightcolor; // darken if red is odd | |
} else { | |
leds[i] += lightcolor; // brighten if red is even | |
} | |
} | |
if ( random8() < DENSITY) { | |
int j = random16(NUM_LEDS); | |
if ( !leds[j] ) leds[j] = lightcolor; | |
} | |
} | |
if (setEffect == "Dots") { | |
uint8_t inner = beatsin8(bpm, NUM_LEDS / 4, NUM_LEDS / 4 * 3); | |
uint8_t outer = beatsin8(bpm, 0, NUM_LEDS - 1); | |
uint8_t middle = beatsin8(bpm, NUM_LEDS / 3, NUM_LEDS / 3 * 2); | |
leds[middle] = CRGB::Purple; | |
leds[inner] = CRGB::Blue; | |
leds[outer] = CRGB::Aqua; | |
nscale8(leds, NUM_LEDS, fadeval); | |
} | |
if (setEffect == "Lightning") { | |
twinklecounter = twinklecounter + 1; //Resets strip if previous animation was running | |
Serial.println(twinklecounter); | |
if (twinklecounter < 2) { | |
FastLED.clear(); | |
FastLED.show(); | |
} | |
ledstart = random8(NUM_LEDS); // Determine starting location of flash | |
ledlen = random8(NUM_LEDS - ledstart); // Determine length of flash (not to go beyond NUM_LEDS-1) | |
for (int flashCounter = 0; flashCounter < random8(3, flashes); flashCounter++) { | |
if (flashCounter == 0) dimmer = 5; // the brightness of the leader is scaled down by a factor of 5 | |
else dimmer = random8(1, 3); // return strokes are brighter than the leader | |
fill_solid(leds + ledstart, ledlen, CHSV(255, 0, 255 / dimmer)); | |
FastLED.show(); // Show a section of LED's | |
delay(random8(4, 10)); // each flash only lasts 4-10 milliseconds | |
fill_solid(leds + ledstart, ledlen, CHSV(255, 0, 0)); // Clear the section of LED's | |
FastLED.show(); | |
if (flashCounter == 0) delay (150); // longer delay until next flash after the leader | |
delay(50 + random8(100)); // shorter delay between strokes | |
} | |
delay(random8(frequency) * 100); // delay between strikes | |
} | |
if (setEffect == "Police One") { //POLICE LIGHTS (TWO COLOR SINGLE LED) | |
idex++; | |
if (idex >= NUM_LEDS) { | |
idex = 0; | |
} | |
int idexR = idex; | |
int idexB = antipodal_index(idexR); | |
int thathue = (thishuepolice + 160) % 255; | |
for (int i = 0; i < NUM_LEDS; i++ ) { | |
if (i == idexR) { | |
leds[i] = CHSV(thishuepolice, thissat, 255); | |
} | |
else if (i == idexB) { | |
leds[i] = CHSV(thathue, thissat, 255); | |
} | |
else { | |
leds[i] = CHSV(0, 0, 0); | |
} | |
} | |
} | |
if (setEffect == "Police All") { //POLICE LIGHTS (TWO COLOR SOLID) | |
idex++; | |
if (idex >= NUM_LEDS) { | |
idex = 0; | |
} | |
int idexR = idex; | |
int idexB = antipodal_index(idexR); | |
int thathue = (thishuepolice + 160) % 255; | |
leds[idexR] = CHSV(thishuepolice, thissat, 255); | |
leds[idexB] = CHSV(thathue, thissat, 255); | |
} | |
if (setEffect == "Candy Cane") { | |
static uint8_t startIndex = 0; | |
startIndex = startIndex + 1; /* higher = faster motion */ | |
fill_palette( leds, NUM_LEDS, | |
startIndex, 16, /* higher = narrower stripes */ | |
currentPalettestriped, 255, LINEARBLEND); | |
} | |
if (setEffect == "Cyclon Rainbow") { //Single Dot Down | |
static uint8_t hue = 0; | |
Serial.print("x"); | |
// First slide the led in one direction | |
for(int i = 0; i < NUM_LEDS; i++) { | |
// Set the i'th led to red | |
leds[i] = CHSV(hue++, 255, 255); | |
// Show the leds | |
FastLED.show(); | |
// now that we've shown the leds, reset the i'th led to black | |
// leds[i] = CRGB::Black; | |
fadeall(); | |
// Wait a little bit before we loop around and do it again | |
delay(10); | |
} | |
for(int i = (NUM_LEDS)-1; i >= 0; i--) { | |
// Set the i'th led to red | |
leds[i] = CHSV(hue++, 255, 255); | |
// Show the leds | |
FastLED.show(); | |
// now that we've shown the leds, reset the i'th led to black | |
// leds[i] = CRGB::Black; | |
fadeall(); | |
// Wait a little bit before we loop around and do it again | |
delay(10); | |
} | |
} | |
if (setEffect == "Fire") { | |
Fire2012WithPalette(); | |
} | |
random16_add_entropy( random8()); | |
EVERY_N_MILLISECONDS(10) { | |
nblendPaletteTowardPalette(currentPalette, targetPalette, maxChanges); // FOR NOISE ANIMATION | |
{ gHue++; } | |
if (setEffect == "Easter") { | |
setPower = "ON"; | |
for (int i = 0; i < NUM_LEDS; i++) { // Just ONE loop to fill up the LED array as all of the pixels change. | |
uint8_t index = inoise8(i * scale, dist + i * scale) % 255; // Get a value from the noise function. I'm using both x and y axis. | |
leds[i] = ColorFromPalette(currentPalette, index, 255, LINEARBLEND); // With that value, look up the 8 bit colour palette value and assign it to the current LED. | |
} | |
dist += beatsin8(10, 1, 4); // Moving along the distance (that random number we started out with). Vary it a bit with a sine wave. | |
// In some sketches, I've used millis() instead of an incremented counter. Works a treat. | |
} | |
if (setEffect == "Ripple") { | |
for (int i = 0; i < NUM_LEDS; i++) leds[i] = CHSV(bgcol++, 255, 15); // Rotate background colour. | |
switch (step) { | |
case -1: // Initialize ripple variables. | |
center = random(NUM_LEDS); | |
colour = random8(); | |
step = 0; | |
break; | |
case 0: | |
leds[center] = CHSV(colour, 255, 255); // Display the first pixel of the ripple. | |
step ++; | |
break; | |
case maxsteps: // At the end of the ripples. | |
step = -1; | |
break; | |
default: // Middle of the ripples. | |
leds[(center + step + NUM_LEDS) % NUM_LEDS] += CHSV(colour, 255, myfade / step * 2); // Simple wrap from Marc Miller | |
leds[(center - step + NUM_LEDS) % NUM_LEDS] += CHSV(colour, 255, myfade / step * 2); | |
step ++; // Next step. | |
break; | |
} | |
} | |
} | |
EVERY_N_SECONDS(5) { | |
targetPalette = CRGBPalette16(CHSV(random8(), 255, random8(128, 255)), CHSV(random8(), 255, random8(128, 255)), CHSV(random8(), 192, random8(128, 255)), CHSV(random8(), 255, random8(128, 255))); | |
} | |
FastLED.setBrightness(brightness); //EXECUTE EFFECT COLOR | |
FastLED.show(); | |
if (animationspeed > 0 && animationspeed < 150) { //Sets animation speed based on receieved value | |
FastLED.delay(1000 / animationspeed); | |
} | |
} | |
////////////////////////place setup__Palette and __Palettestriped custom functions here - for Candy Cane effects ///////////////// | |
///////You can use up to 4 colors and change the pattern of A's AB's B's and BA's as you like////////////// | |
void setupStripedPalette( CRGB A, CRGB AB, CRGB B, CRGB BA) | |
{ | |
currentPalettestriped = CRGBPalette16( | |
A, A, A, A, A, A, A, A, B, B, B, B, B, B, B, B | |
); | |
} | |
void setupHailPalette( CRGB A, CRGB AB, CRGB B, CRGB BA) | |
{ | |
hailPalettestriped = CRGBPalette16( | |
A, A, A, A, A, A, A, A, B, B, B, B, B, B, B, B | |
); | |
} | |
void setupHJPalette( CRGB A, CRGB AB, CRGB B, CRGB BA) | |
{ | |
HJPalettestriped = CRGBPalette16( | |
A, A, A, A, A, A, A, A, B, B, B, B, B, B, B, B | |
); | |
} | |
void setupIndPalette( CRGB A, CRGB AB, CRGB B, CRGB BA) | |
{ | |
IndPalettestriped = CRGBPalette16( | |
A, A, A, A, A, AB, AB, AB, AB, AB, B, B, B, B, B, B | |
); | |
} | |
void setupThxPalette( CRGB A, CRGB AB, CRGB B, CRGB BA) | |
{ | |
ThxPalettestriped = CRGBPalette16( | |
A, A, A, A, A, A, A, AB, AB, AB, B, B, B, B, B, B | |
); | |
} | |
void setupHalloweenTriPalette( CRGB A, CRGB AB, CRGB B, CRGB BA) | |
{ | |
HalloweenTriPalettestriped = CRGBPalette16( | |
BA, A, A, A, BA, AB, AB, AB, BA, B, B, B, BA, AB, AB, AB | |
); | |
} | |
void setupPurpleGreenPalette( CRGB A, CRGB AB, CRGB B, CRGB BA) | |
{ | |
PurpleGreenPalettestriped = CRGBPalette16( | |
B, A, A, A, B, AB, AB, AB, B, A, A, A, B, AB, AB, AB | |
); | |
} | |
void setupOrangeGreenPalette( CRGB A, CRGB AB, CRGB B, CRGB BA) | |
{ | |
OrangeGreenPalettestriped = CRGBPalette16( | |
B, A, A, A, B, AB, AB, AB, B, A, A, A, B, AB, AB, AB | |
); | |
} | |
void setupOrangePurplePalette( CRGB A, CRGB AB, CRGB B, CRGB BA) | |
{ | |
OrangePurplePalettestriped = CRGBPalette16( | |
B, A, A, A, B, AB, AB, AB, B, A, A, A, B, AB, AB, AB | |
); | |
} | |
void setupCandyCornPalette( CRGB A, CRGB AB, CRGB B, CRGB BA) | |
{ | |
CandyCornPalettestriped = CRGBPalette16( | |
BA, BA, B, AB, AB, A, A, A, BA, BA, B, AB, AB, A, A, A | |
); | |
} | |
void setupRGWPalette( CRGB A, CRGB AB, CRGB B, CRGB BA) | |
{ | |
RGWPalettestriped = CRGBPalette16( | |
A, A, A, AB, AB, AB, B, B, B, A, A, A, AB, AB, AB, AB | |
); | |
} | |
void setupRGPalette( CRGB A, CRGB AB, CRGB B, CRGB BA) | |
{ | |
RGPalettestriped = CRGBPalette16( | |
A, A, A, A, AB, AB, AB, AB, A, A, A, A, AB, AB, AB, AB | |
); | |
} | |
//////////////////////////////////////////////////////// | |
void fadeall() { for(int i = 0; i < NUM_LEDS; i++) { leds[i].nscale8(250); } } //for CYCLON | |
void Fire2012WithPalette() | |
{ | |
// Array of temperature readings at each simulation cell | |
static byte heat[NUM_LEDS]; | |
// Step 1. Cool down every cell a little | |
for( int i = 0; i < NUM_LEDS; i++) { | |
heat[i] = qsub8( heat[i], random8(0, ((COOLING * 10) / NUM_LEDS) + 2)); | |
} | |
// Step 2. Heat from each cell drifts 'up' and diffuses a little | |
for( int k= NUM_LEDS - 1; k >= 2; k--) { | |
heat[k] = (heat[k - 1] + heat[k - 2] + heat[k - 2] ) / 3; | |
} | |
// Step 3. Randomly ignite new 'sparks' of heat near the bottom | |
if( random8() < SPARKING ) { | |
int y = random8(7); | |
heat[y] = qadd8( heat[y], random8(160,255) ); | |
} | |
// Step 4. Map from heat cells to LED colors | |
for( int j = 0; j < NUM_LEDS; j++) { | |
// Scale the heat value from 0-255 down to 0-240 | |
// for best results with color palettes. | |
byte colorindex = scale8( heat[j], 240); | |
CRGB color = ColorFromPalette( gPal, colorindex); | |
int pixelnumber; | |
if( gReverseDirection ) { | |
pixelnumber = (NUM_LEDS-1) - j; | |
} else { | |
pixelnumber = j; | |
} | |
leds[pixelnumber] = color; | |
} | |
} | |
void addGlitter( fract8 chanceOfGlitter) | |
{ | |
if( random8() < chanceOfGlitter) { | |
leds[ random16(NUM_LEDS) ] += CRGB::White; | |
} | |
} | |
void addGlitterColor( fract8 chanceOfGlitter, int Rcolor, int Gcolor, int Bcolor) | |
{ | |
if( random8() < chanceOfGlitter) { | |
leds[ random16(NUM_LEDS) ] += CRGB(Rcolor, Gcolor, Bcolor); | |
} | |
} | |
void reconnect() { | |
// Loop until we're reconnected | |
while (!client.connected()) { | |
Serial.print("Attempting MQTT connection..."); | |
// Attempt to connect | |
if (client.connect("ArchLEDs", mqtt_user, mqtt_password)) { | |
Serial.println("connected"); | |
FastLED.clear (); //Turns off startup LEDs after connection is made | |
FastLED.show(); | |
client.subscribe(setcolorsub); | |
client.subscribe(setbrightness); | |
//client.subscribe(setcolortemp); | |
client.subscribe(setpowersub); | |
client.subscribe(seteffectsub); | |
client.subscribe(setanimationspeed); | |
client.publish(setpowerpub, "OFF"); | |
} else { | |
Serial.print("failed, rc="); | |
Serial.print(client.state()); | |
Serial.println(" try again in 5 seconds"); | |
// Wait 5 seconds before retrying | |
delay(5000); | |
} | |
} | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment