[Aide] Electronique sur projet Leds connectées avec un Wemos D1 mini

#include "FastLED.h"
#include <EEPROM.h>
 
#if defined(FASTLED_VERSION) && (FASTLED_VERSION < 3001000)
#warning "Requires FastLED 3.1 or later; check github for latest code."
#endif
 
 
//This is where we adjust things to match our unique project:
#define NUM_TILES 11    // adjust to set your number of leds per tiles
#define NUM_LEDS_TILES 12          // adjust to set your number of tiles
#define NUM_LEDS    (NUM_TILES * NUM_LEDS_TILES)      // adjust this to the number of LEDs you have: 16 or more
#define LED_TYPE    WS2811  // adjust this to the type of LEDS. This is for Neopixels
#define DATA_PIN    6        // adjust this to the pin you've connected your LEDs to 
#define BRIGHTNESS  50        // 255 is full brightness, 127 is half, 32 is an eighth.
//#define SATURATION  255    // 0-255, 0 is pure white, 255 is fully saturated color
#define BUTTON_PIN  2        // Connect the button to GND and one of the pins.
//#define COLOR_ORDER GRB    // Try mixing up the letters (RGB, GBR, BRG, etc) for a whole new world of color combinations
#define NUM_MODES 14          //Update this number to the highest number of "cases"
#define MASTER_DELAY 100      // adjust this to change the speed of changing colors in Gradient Random
 
CRGB leds[NUM_LEDS];
 
byte selectedEffect=0;
 
//___
uint16_t pixelsPerTile, numberOfTiles;
 
 
// ************************************************
//  ** Animation Config for Surrbral08 effects **
// ************************************************
 
// ten seconds per color palette makes a good demo
// 20-120 is better for deployment
uint8_t secondsPerPalette = 60;
 
// COOLING: How much does the air cool as it rises?
// Less cooling = taller flames.  More cooling = shorter flames.
// Default 50, suggested range 20-100
uint8_t cooling = 49;
 
// SPARKING: What chance (out of 255) is there that a new spark will be lit?
// Higher chance = more roaring fire.  Lower chance = more flickery fire.
// Default 120, suggested range 50-200.
uint8_t sparking = 160;
uint8_t speed = 20;
// ************************************************
 
// ************************************************
//    ** Values Config for Surrbral08 effects **
// ************************************************
 
#define ARRAY_SIZE(A) (sizeof(A) / sizeof((A)[0]))
#define MILLI_AMPS        3000  // IMPORTANT: set the max milli-Amps of your power supply (4A = 4000mA)
#define FRAMES_PER_SECOND  120    // here you can control the speed. With the Access Point / Web Server the animations run a bit slower.
 
///////////////////////////////////////////////////////////////////////
 
// Forward declarations of an array of cpt-city gradient palettes, and
// a count of how many there are.  The actual color palette definitions
// are at the bottom of this file.
extern const TProgmemRGBGradientPalettePtr gGradientPalettes[];
 
uint8_t gCurrentPaletteNumber = 0;
 
CRGBPalette16 gCurrentPalette(CRGB::Black);
CRGBPalette16 gTargetPalette(gGradientPalettes[0]);
 
CRGBPalette16 IceColors_p = CRGBPalette16(CRGB::Black, CRGB::Blue, CRGB::Aqua, CRGB::White);
 
uint8_t currentPatternIndex = 0; // Index number of which pattern is current
uint8_t autoplay = 0;
 
uint8_t allLeafs = 1;    // Sets if all leafs should get the same color
uint8_t selectedLeaf = 1;    // Sets position of leaf to color
 
uint8_t autoplayDuration = 10;
unsigned long autoPlayTimeout = 0;
 
uint8_t currentPaletteIndex = 0;
 
uint8_t gHue = 0; // rotating "base color" used by many of the patterns
 
CRGB solidColor = CRGB::Blue;
 
// scale the brightness of all pixels down
void dimAll(byte value)
{
  for (int i = 0; i < NUM_LEDS; i++) {
    leds[i].nscale8(value);
  }
}
 
typedef void(*Pattern)();
typedef Pattern PatternList[];
typedef struct {
  Pattern pattern;
  String name;
} PatternAndName;
typedef PatternAndName PatternAndNameList[];
 
#include "Twinkles.h"
#include "TwinkleFOX.h"
#include "GradientPalettes.h"
 
typedef struct {
  CRGBPalette16 palette;
  String name;
} PaletteAndName;
typedef PaletteAndName PaletteAndNameList[];
 
const CRGBPalette16 palettes[] = {
  RainbowColors_p,
  RainbowStripeColors_p,
  CloudColors_p,
  LavaColors_p,
  OceanColors_p,
  ForestColors_p,
  PartyColors_p,
  HeatColors_p
};
 
const uint8_t paletteCount = ARRAY_SIZE(palettes);
 
const String paletteNames[paletteCount] = {
  "Rainbow",
  "Rainbow Stripe",
  "Cloud",
  "Lava",
  "Ocean",
  "Forest",
  "Party",
  "Heat",
};
 
 
// ************************************************
//    ** End Values for Surrbral08 effects **
// ************************************************

void setup() {
  delay( 2000 ); // power-up safety delay
  FastLED.addLeds<LED_TYPE, DATA_PIN, GRB>(leds, NUM_LEDS).setCorrection( TypicalLEDStrip );
  FastLED.setBrightness(BRIGHTNESS);
  digitalWrite (BUTTON_PIN, HIGH);  // internal pull-up resistor
  attachInterrupt (digitalPinToInterrupt (BUTTON_PIN), changeEffect, CHANGE); // pressed
  Serial.begin(9600);
 
  pixelsPerTile = NUM_LEDS_TILES; // Set the default pixel grouping to one full tile at a time
  numberOfTiles = NUM_TILES; // I don't know why I put this here it never changes at runtime...but I suppose it could for some reason...
 
  FastLED.setMaxPowerInVoltsAndMilliamps(5, MILLI_AMPS);
 
}

void loop() {
    // Add entropy to random number generator; we use a lot of it.
  random16_add_entropy(random(65535));
 
// ************************************************
//            ** Use for ColoWaves **
// ************************************************
 
// change to a new cpt-city gradient palette
  EVERY_N_SECONDS(secondsPerPalette) {
    gCurrentPaletteNumber = addmod8(gCurrentPaletteNumber, 1, gGradientPaletteCount);
    gTargetPalette = gGradientPalettes[gCurrentPaletteNumber];
  }
 
  EVERY_N_MILLISECONDS(80) {
    // slowly blend the current palette to the next
    nblendPaletteTowardPalette(gCurrentPalette, gTargetPalette, 8);
    gHue++;  // slowly cycle the "base color" through the rainbow
  }
//************************************************
 
  EEPROM.get(0,selectedEffect);
 
  if(selectedEffect>NUM_MODES) {
    selectedEffect=0;
    EEPROM.put(0,0);
  }
 
  switch(selectedEffect) {
 
               
  case 0  : {
              // Juggle - no parameters
              juggle();
              break;
              }
 
  case 1  : {
              // radialPaletteShift - no parameters
              radialPaletteShift();
              break;
            }
 
  case 2  : {
              // pride - no parameters
              pride();
              break;
            }
 
  case 3  : {
              // water - parameters of speed,
              water(40);
              break;
            }
 
  case 4  : {
              // fire - parameters of speed,
              fire(20);
              break;
            }
             
  case 5  : {
              // confettiFullTiles - no parameters - From Phouky
              confettiFullTile();
              break;
            }
           
  case 6  : {
              // ColorWavesWithPalettes by Mark Kriegsman: https://gist.github.com/kriegsman/8281905786e8b2632aeb
              colorwaves(leds, NUM_TILES * 3, gCurrentPalette);
              break;
            }
 
  case 7  : {
              // confetti - no parameters,
              confetti();
              break;
            }           
 
  case 8  : {
              // Cloud Twinkles - no parameters - from Surrbradl08's Smart Nanoleaf Replica (Thingiverse n° 3354082)
              cloudTwinkles();
              break;
            }
 
  case 9  : {
              // Red and Blue Twinkles - no parameters
              redBlueTwinkles();
              break;
              }
 
  case 10 : {
              // Incandescent Twinkles - no parameters - from Surrbradl08's Smart Nanoleaf Replica (Thingiverse n° 3354082)
              incandescentTwinkles();
              break;
            }
 
  case 11 : {
              // SummerTime Twinkles - no parameters,
              SummerTimeTwinkles();
              break;
            } 
 
  case 12 : {
              // Lava Twinkles - no parameters - from Surrbradl08's Smart Nanoleaf Replica (Thingiverse n° 3354082)
              lavaTwinkles();
              break;
              }
 
  case 13 : {
              // Calmy Evening Twinkles - no parameters,
              CalmyEveningTwinkles();
              break;
            }
 
  case 14  : {
              // Ocean Twinkles - no parameters - from Surrbradl08's Smart Nanoleaf Replica (Thingiverse n° 3354082)
              oceanTwinkles();
              break;
              }
/*             
  case 11  : {
              // bpm - no parameters
              bpm();
              break;
            }
 
 
  case 12  : {
              // Sinelon - no parameters
              sinelon();
              break;
              }           
*/
 
  }
 
  FastLED.show();
  // insert a delay to keep the framerate modest
  FastLED.delay(1000 / FRAMES_PER_SECOND);
}

//-----------------------------------------CONFIG-----------------------------------------//
#define LEAFCOUNT 11
#define PIXELS_PER_LEAF 12
 
#define DATA_PIN      D4          // The pin where the data line is connected to
#define LED_TYPE      WS2811
#define COLOR_ORDER  GRB        // Color order, if e.g. your Colors are swapped then change the order, (RGB, RBG, GBR, GRB, BRG, BGR)
 
#define MILLI_AMPS        10000  // IMPORTANT: set the max milli-Amps of your power supply (4A = 4000mA)
#define FRAMES_PER_SECOND  120    // here you can control the speed. With the Access Point / Web Server the animations run a bit slower.
const bool apMode = false;        // Set to true if the esp8266 should open an Access-Point
 
 
// Animation Config:
// ten seconds per color palette makes a good demo
// 20-120 is better for deployment
uint8_t secondsPerPalette = 60;
 
// COOLING: How much does the air cool as it rises?
// Less cooling = taller flames.  More cooling = shorter flames.
// Default 50, suggested range 20-100
uint8_t cooling = 49;
 
// SPARKING: What chance (out of 255) is there that a new spark will be lit?
// Higher chance = more roaring fire.  Lower chance = more flickery fire.
// Default 120, suggested range 50-200.
uint8_t sparking = 160;
 
uint8_t speed = 20;
 
//---------------------------------------CONFIG END---------------------------------------//

//#define FASTLED_ALLOW_INTERRUPTS 1
//#define INTERRUPT_THRESHOLD 1
#define FASTLED_INTERRUPT_RETRY_COUNT 0
 
#include <FastLED.h>
FASTLED_USING_NAMESPACE
 
extern "C" {
#include "user_interface.h"
}
 
#include <ESP8266WiFi.h>
//#include <ESP8266mDNS.h>
#include <ESP8266WebServer.h>
#include <ESP8266HTTPUpdateServer.h>
//#include <WebSocketsServer.h>
#include <FS.h>
#include <EEPROM.h>
//#include <IRremoteESP8266.h>
#include "GradientPalettes.h"
 
#define ARRAY_SIZE(A) (sizeof(A) / sizeof((A)[0]))
 
#include "Field.h"
 
//#define RECV_PIN D4
//IRrecv irReceiver(RECV_PIN);
 
//#include "Commands.h"
 
ESP8266WebServer webServer(80);
//WebSocketsServer webSocketsServer = WebSocketsServer(81);
ESP8266HTTPUpdateServer httpUpdateServer;
 
#include "FSBrowser.h"
 
 
#define NUM_LEDS (PIXELS_PER_LEAF * LEAFCOUNT)
 
 
#include "Secrets.h" // this file is intentionally not included in the sketch, so nobody accidentally commits their secret information.
// create a Secrets.h file with the following:
 
// AP mode password
// const char WiFiAPPSK[] = "your-password";
 
// Wi-Fi network to connect to (if not in AP mode)
// char* ssid = "your-ssid";
// char* password = "your-password";
 
 
CRGB leds[NUM_LEDS];
 
const uint8_t brightnessCount = 5;
uint8_t brightnessMap[brightnessCount] = { 16, 32, 64, 128, 255 };
uint8_t brightnessIndex = 0;
 
char vals[4 + LEAFCOUNT * 5][4] = {""};
 
///////////////////////////////////////////////////////////////////////
 
// Forward declarations of an array of cpt-city gradient palettes, and
// a count of how many there are.  The actual color palette definitions
// are at the bottom of this file.
extern const TProgmemRGBGradientPalettePtr gGradientPalettes[];
 
uint8_t gCurrentPaletteNumber = 0;
 
CRGBPalette16 gCurrentPalette(CRGB::Black);
CRGBPalette16 gTargetPalette(gGradientPalettes[0]);
 
CRGBPalette16 IceColors_p = CRGBPalette16(CRGB::Black, CRGB::Blue, CRGB::Aqua, CRGB::White);
 
uint8_t currentPatternIndex = 0; // Index number of which pattern is current
uint8_t autoplay = 0;
 
uint8_t allLeafs = 1;    // Sets if all leafs should get the same color
uint8_t selectedLeaf = 1;    // Sets position of leaf to color
 
uint8_t autoplayDuration = 10;
unsigned long autoPlayTimeout = 0;
 
uint8_t currentPaletteIndex = 0;
 
uint8_t gHue = 0; // rotating "base color" used by many of the patterns
 
uint8_t breathe = 0;  // value for starting custom pattern
uint8_t breathe_dir = 1;  // 1== rising
char cpattern[500] = "";
 
CRGB solidColor = CRGB::Blue;
 
// scale the brightness of all pixels down
void dimAll(byte value)
{
  for (int i = 0; i < NUM_LEDS; i++) {
    leds[i].nscale8(value);
  }
}
 
typedef void(*Pattern)();
typedef Pattern PatternList[];
typedef struct {
  Pattern pattern;
  String name;
} PatternAndName;
typedef PatternAndName PatternAndNameList[];
 
#include "Twinkles.h"
#include "TwinkleFOX.h"
 
// List of patterns to cycle through.  Each is defined as a separate function below.
 
PatternAndNameList patterns = {
  { pride,                  "Pride" },
  { colorWaves,            "Color Waves" },
 
  // twinkle patterns
  { rainbowTwinkles,        "Rainbow Twinkles" },
  { snowTwinkles,          "Snow Twinkles" },
  { cloudTwinkles,          "Cloud Twinkles" },
  { incandescentTwinkles,  "Incandescent Twinkles" },
 
  // TwinkleFOX patterns
  { retroC9Twinkles,        "Retro C9 Twinkles" },
  { redWhiteTwinkles,      "Red & White Twinkles" },
  { blueWhiteTwinkles,      "Blue & White Twinkles" },
  { redGreenWhiteTwinkles,  "Red, Green & White Twinkles" },
  { fairyLightTwinkles,    "Fairy Light Twinkles" },
  { snow2Twinkles,          "Snow 2 Twinkles" },
  { hollyTwinkles,          "Holly Twinkles" },
  { iceTwinkles,            "Ice Twinkles" },
  { partyTwinkles,          "Party Twinkles" },
  { forestTwinkles,        "Forest Twinkles" },
  { lavaTwinkles,          "Lava Twinkles" },
  { fireTwinkles,          "Fire Twinkles" },
  { cloud2Twinkles,        "Cloud 2 Twinkles" },
  { oceanTwinkles,          "Ocean Twinkles" },
 
  { rainbow,                "Rainbow" },
  { rainbowWithGlitter,    "Rainbow With Glitter" },
  { rainbowSolid,          "Solid Rainbow" },
  { confetti,              "Confetti" },
  { sinelon,                "Sinelon" },
  { bpm,                    "Beat" },
  { juggle,                "Juggle" },
  { fire,                  "Fire" },
  { water,                  "Water" },
 
  { showSolidColor,        "Solid Color" },
 
  { SetCustomPattern,      "Custom Pattern"}
};
 
const uint8_t patternCount = ARRAY_SIZE(patterns);
 
typedef struct {
  CRGBPalette16 palette;
  String name;
} PaletteAndName;
typedef PaletteAndName PaletteAndNameList[];
 
const CRGBPalette16 palettes[] = {
  RainbowColors_p,
  RainbowStripeColors_p,
  CloudColors_p,
  LavaColors_p,
  OceanColors_p,
  ForestColors_p,
  PartyColors_p,
  HeatColors_p
};
 
const uint8_t paletteCount = ARRAY_SIZE(palettes);
 
const String paletteNames[paletteCount] = {
  "Rainbow",
  "Rainbow Stripe",
  "Cloud",
  "Lava",
  "Ocean",
  "Forest",
  "Party",
  "Heat",
};
 
#include "Fields.h"

void setup() {
  WiFi.setSleepMode(WIFI_NONE_SLEEP);
 
  Serial.begin(115200);
  delay(100);
  Serial.setDebugOutput(true);
 
  FastLED.addLeds<LED_TYPE, DATA_PIN, COLOR_ORDER>(leds, NUM_LEDS);        // for WS2812 (Neopixel)
  FastLED.setDither(false);
  FastLED.setCorrection(TypicalLEDStrip);
  FastLED.setBrightness(brightness);
  FastLED.setMaxPowerInVoltsAndMilliamps(5, MILLI_AMPS);
  fill_solid(leds, NUM_LEDS, CRGB::Black);
  FastLED.show();
 
  EEPROM.begin(512);
  loadSettings();
 
  FastLED.setBrightness(brightness);
 
  //  irReceiver.enableIRIn(); // Start the receiver
 
  Serial.println();
  Serial.print(F("Heap: ")); Serial.println(system_get_free_heap_size());
  Serial.print(F("Boot Vers: ")); Serial.println(system_get_boot_version());
  Serial.print(F("CPU: ")); Serial.println(system_get_cpu_freq());
  Serial.print(F("SDK: ")); Serial.println(system_get_sdk_version());
  Serial.print(F("Chip ID: ")); Serial.println(system_get_chip_id());
  Serial.print(F("Flash ID: ")); Serial.println(spi_flash_get_id());
  Serial.print(F("Flash Size: ")); Serial.println(ESP.getFlashChipRealSize());
  Serial.print(F("Vcc: ")); Serial.println(ESP.getVcc());
  Serial.println();
 
  SPIFFS.begin();
  {
    Serial.println("SPIFFS contents:");
 
    Dir dir = SPIFFS.openDir("/");
    while (dir.next()) {
      String fileName = dir.fileName();
      size_t fileSize = dir.fileSize();
      Serial.printf("FS File: %s, size: %s\n", fileName.c_str(), String(fileSize).c_str());
    }
    Serial.printf("\n");
  }
 
  //disabled due to https://github.com/jasoncoon/esp8266-fastled-webserver/issues/62
  //initializeWiFi();
 
  if (apMode)
  {
    WiFi.mode(WIFI_AP);
 
    // Do a little work to get a unique-ish name. Append the
    // last two bytes of the MAC (HEX'd) to "Thing-":
    uint8_t mac[WL_MAC_ADDR_LENGTH];
    WiFi.softAPmacAddress(mac);
    String macID = String(mac[WL_MAC_ADDR_LENGTH - 2], HEX) +
                  String(mac[WL_MAC_ADDR_LENGTH - 1], HEX);
    macID.toUpperCase();
    String AP_NameString = "HexaLeaf_Lights" ; // + macID;
 
    char AP_NameChar[AP_NameString.length() + 1];
    memset(AP_NameChar, 0, AP_NameString.length() + 1);
 
    for (int i = 0; i < AP_NameString.length(); i++)
      AP_NameChar[i] = AP_NameString.charAt(i);
 
    WiFi.softAP(AP_NameChar, WiFiAPPSK);
 
    Serial.printf("Connect to Wi-Fi access point: %s\n", AP_NameChar);
    Serial.println("and open http://192.168.4.1 in your browser");
  }
  else
  {
    WiFi.mode(WIFI_STA);
    Serial.printf("Connecting to %s\n", ssid);
    if (String(WiFi.SSID()) != String(ssid)) {
      WiFi.begin(ssid, password);
    }
  }
 
  httpUpdateServer.setup(&webServer);
 
  webServer.on("/all", HTTP_GET, []() {
    String json = getFieldsJson(fields, fieldCount);
    webServer.send(200, "text/json", json);
  });
 
  webServer.on("/fieldValue", HTTP_GET, []() {
    String name = webServer.arg("name");
    String value = getFieldValue(name, fields, fieldCount);
    webServer.send(200, "text/json", value);
  });
 
  webServer.on("/fieldValue", HTTP_POST, []() {
    String name = webServer.arg("name");
    String value = webServer.arg("value");
    String newValue = setFieldValue(name, value, fields, fieldCount);
    webServer.send(200, "text/json", newValue);
  });
 
  webServer.on("/power", HTTP_POST, []() {
    String value = webServer.arg("value");
    setPower(value.toInt());
    sendInt(power);
  });
 
  webServer.on("/cooling", HTTP_POST, []() {
    String value = webServer.arg("value");
    cooling = value.toInt();
    broadcastInt("cooling", cooling);
    sendInt(cooling);
  });
 
  webServer.on("/sparking", HTTP_POST, []() {
    String value = webServer.arg("value");
    sparking = value.toInt();
    broadcastInt("sparking", sparking);
    sendInt(sparking);
  });
 
  webServer.on("/speed", HTTP_POST, []() {
    String value = webServer.arg("value");
    speed = value.toInt();
    broadcastInt("speed", speed);
    sendInt(speed);
  });
 
  webServer.on("/twinkleSpeed", HTTP_POST, []() {
    String value = webServer.arg("value");
    twinkleSpeed = value.toInt();
    if (twinkleSpeed < 0) twinkleSpeed = 0;
    else if (twinkleSpeed > 8) twinkleSpeed = 8;
    broadcastInt("twinkleSpeed", twinkleSpeed);
    sendInt(twinkleSpeed);
  });
 
  webServer.on("/twinkleDensity", HTTP_POST, []() {
    String value = webServer.arg("value");
    twinkleDensity = value.toInt();
    if (twinkleDensity < 0) twinkleDensity = 0;
    else if (twinkleDensity > 8) twinkleDensity = 8;
    broadcastInt("twinkleDensity", twinkleDensity);
    sendInt(twinkleDensity);
  });
 
  webServer.on("/solidColor", HTTP_POST, []() {
    String r = webServer.arg("r");
    String g = webServer.arg("g");
    String b = webServer.arg("b");
    setSolidColor(r.toInt(), g.toInt(), b.toInt());
    sendString(String(solidColor.r) + "," + String(solidColor.g) + "," + String(solidColor.b));
    Serial.println(String(solidColor.r) + "," + String(solidColor.g) + "," + String(solidColor.b));
  });
 
  webServer.on("/pattern", HTTP_POST, []() {
    String value = webServer.arg("value");
    if (value.toInt() <= 29)
    {
      setPattern(value.toInt());
      sendInt(currentPatternIndex);
    }
  });
 
  webServer.on("/patternName", HTTP_POST, []() {
    String value = webServer.arg("value");
    setPatternName(value);
    sendInt(currentPatternIndex);
  });
 
  webServer.on("/palette", HTTP_POST, []() {
    String value = webServer.arg("value");
    setPalette(value.toInt());
    sendInt(currentPaletteIndex);
  });
 
  webServer.on("/paletteName", HTTP_POST, []() {
    String value = webServer.arg("value");
    setPaletteName(value);
    sendInt(currentPaletteIndex);
  });
 
  webServer.on("/brightness", HTTP_POST, []() {
    String value = webServer.arg("value");
    setBrightness(value.toInt());
    sendInt(brightness);
  });
 
  webServer.on("/autoplay", HTTP_POST, []() {
    String value = webServer.arg("value");
    setAutoplay(value.toInt());
    sendInt(autoplay);
  });
 
  webServer.on("/autoplayDuration", HTTP_POST, []() {
    String value = webServer.arg("value");
    setAutoplayDuration(value.toInt());
    sendInt(autoplayDuration);
  });
 
  webServer.on("/allLeafs", HTTP_POST, []() {
    String value = webServer.arg("value");
    setAllLeafs(value.toInt());
    sendInt(allLeafs);
  });
 
  webServer.on("/selectedLeaf", HTTP_POST, []() {
    String value = webServer.arg("value");
    setSelectedLeaf(value.toInt());
    sendInt(selectedLeaf);
  });
 
 
  webServer.on("/custom", HTTP_POST, []() {
    String value = webServer.arg("value");
    Serial.println(value);
    value.toCharArray(cpattern, 500);
    Serial.println(value);
    sendString(value);
    setPattern(30);
  });
 
 
  //list directory
  webServer.on("/list", HTTP_GET, handleFileList);
  //load editor
  webServer.on("/edit", HTTP_GET, []() {
    if (!handleFileRead("/edit.htm")) webServer.send(404, "text/plain", "FileNotFound");
  });
  //create file
  webServer.on("/edit", HTTP_PUT, handleFileCreate);
  //delete file
  webServer.on("/edit", HTTP_DELETE, handleFileDelete);
  //first callback is called after the request has ended with all parsed arguments
  //second callback handles file uploads at that location
  webServer.on("/edit", HTTP_POST, []() {
    webServer.send(200, "text/plain", "");
  }, handleFileUpload);
 
  webServer.serveStatic("/", SPIFFS, "/", "max-age=86400");
 
  webServer.begin();
  Serial.println("HTTP web server started");
 
  //  webSocketsServer.begin();
  //  webSocketsServer.onEvent(webSocketEvent);
  //  Serial.println("Web socket server started");
 
  autoPlayTimeout = millis() + (autoplayDuration * 1000);
}

void sendInt(uint8_t value)
{
  sendString(String(value));
}
 
void sendString(String value)
{
  webServer.send(200, "text/plain", value);
}
 
void broadcastInt(String name, uint8_t value)
{
  String json = "{\"name\":\"" + name + "\",\"value\":" + String(value) + "}";
  //  webSocketsServer.broadcastTXT(json);
}
 
void broadcastString(String name, String value)
{
  String json = "{\"name\":\"" + name + "\",\"value\":\"" + String(value) + "\"}";
  //  webSocketsServer.broadcastTXT(json);
}

void loop() {
  // Add entropy to random number generator; we use a lot of it.
  random16_add_entropy(random(65535));
 
  //  dnsServer.processNextRequest();
  //  webSocketsServer.loop();
  webServer.handleClient();
 
  //  handleIrInput();
 
  if (power == 0) {
    fill_solid(leds, NUM_LEDS, CRGB::Black);
    FastLED.show();
    // FastLED.delay(15);
    return;
  }
 
  static bool hasConnected = false;
  EVERY_N_SECONDS(1) {
    if (WiFi.status() != WL_CONNECTED) {
      //      Serial.printf("Connecting to %s\n", ssid);
      hasConnected = false;
    }
    else if (!hasConnected) {
      hasConnected = true;
      Serial.print("Connected! Open http://");
      Serial.print(WiFi.localIP());
      Serial.println(" in your browser");
    }
  }
 
  // EVERY_N_SECONDS(10) {
  //  Serial.print( F("Heap: ") ); Serial.println(system_get_free_heap_size());
  // }
 
  // change to a new cpt-city gradient palette
  EVERY_N_SECONDS(secondsPerPalette) {
    gCurrentPaletteNumber = addmod8(gCurrentPaletteNumber, 1, gGradientPaletteCount);
    gTargetPalette = gGradientPalettes[gCurrentPaletteNumber];
  }
 
  EVERY_N_MILLISECONDS(80) {
    // slowly blend the current palette to the next
    nblendPaletteTowardPalette(gCurrentPalette, gTargetPalette, 8);
    gHue++;  // slowly cycle the "base color" through the rainbow
  }
 
  EVERY_N_MILLIS_I(thistimer, 128-(speed/2)) {
    if (breathe_dir == 1)breathe++; else breathe--;
    if (breathe >= 255)breathe_dir = 0;
    else if (breathe <= 0) breathe_dir = 1;
    //Serial.println(breathe);
  }
  thistimer.setPeriod(64-(speed/4));
 
  if (autoplay && (millis() > autoPlayTimeout)) {
    adjustPattern(true);
    autoPlayTimeout = millis() + (autoplayDuration * 1000);
  }
 
  // Call the current pattern function once, updating the 'leds' array
  patterns[currentPatternIndex].pattern();
 
  FastLED.show();
 
  // insert a delay to keep the framerate modest
  FastLED.delay(1000 / FRAMES_PER_SECOND);
}