Added mapping for half-cube

Map.h

@@ -0,0 +1,193 @@
+uint8_t cubeWidth = 8;
+uint8_t cubeDepth = 8;
+uint8_t cubeHeight = 8;
+
+uint8_t coordsX[NUM_LEDS] = { 7, 7, 7, 7, 7, 7, 7, 7, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 6, 5, 4, 3, 2, 1, 0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 6, 5, 4, 3, 2, 1, 0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 6, 5, 4, 3, 2, 1, 0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 6, 5, 4, 3, 2, 1, 0, 0, 1, 2, 3, 4, 5, 6, 7 };
+uint8_t coordsY[NUM_LEDS] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 };
+uint8_t coordsZ[NUM_LEDS] = { 7, 6, 5, 4, 3, 2, 1, 0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 6, 5, 4, 3, 2, 1, 0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 6, 5, 4, 3, 2, 1, 0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 6, 5, 4, 3, 2, 1, 0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 6, 5, 4, 3, 2, 1, 0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 6, 5, 4, 3, 2, 1, 0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 6, 5, 4, 3, 2, 1, 0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 6, 5, 4, 3, 2, 1, 0, 0, 1, 2, 3, 4, 5, 6, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+
+void cubeTest() {
+  static uint8_t x = 0;
+  static uint8_t y = 0;
+  static uint8_t z = 0;
+
+  EVERY_N_MILLIS(255 - speed) {
+    x++;
+    if(x >= cubeWidth) {
+      x = 0;
+      y++;
+      if(y >= cubeDepth) {
+        y = 0;
+        z++;
+        if(z >= cubeHeight) {
+          z = 0;
+        }
+      }
+    }
+    
+    FastLED.clear();
+
+    CHSV color = CHSV(gHue, 255, 255);
+    
+    for(uint8_t i = 0; i < NUM_LEDS; i++) {
+      uint8_t cx = coordsX[i];
+      uint8_t cy = coordsY[i];
+      uint8_t cz = coordsZ[i];
+      
+      if((cx == x && cy == y) || (cx == x && cz == z) || (cy == y && cz == z)) {
+        leds[i] = color;
+      }
+    }
+  }
+}
+
+void cubeXPalette() {
+  uint8_t hues = 8;
+
+  for (uint8_t i = 0; i < NUM_LEDS; i++) {
+    uint8_t x = coordsX[i];
+
+    leds[i] = ColorFromPalette(palettes[currentPaletteIndex], beat8(speed) - (x * hues));
+  }
+}
+
+void cubeYPalette() {
+  uint8_t hues = 8;
+
+  for (uint8_t i = 0; i < NUM_LEDS; i++) {
+    uint8_t y = coordsY[i];
+
+    leds[i] = ColorFromPalette(palettes[currentPaletteIndex], beat8(speed) - (y * hues));
+  }
+}
+
+void cubeZPalette() {
+  uint8_t hues = 8;
+
+  for (uint8_t i = 0; i < NUM_LEDS; i++) {
+    uint8_t z = coordsZ[i];
+
+    leds[i] = ColorFromPalette(palettes[currentPaletteIndex], beat8(speed) - (z * hues));
+  }
+}
+
+void cubeXYPalette() {
+  uint8_t hues = 8;
+
+  for (uint8_t i = 0; i < NUM_LEDS; i++) {
+    uint8_t x = coordsX[i];
+    uint8_t y = coordsY[i];
+
+    leds[i] = ColorFromPalette(palettes[currentPaletteIndex], beat8(speed) - ((x + y) * hues));
+  }
+}
+
+void cubeXZPalette() {
+  uint8_t hues = 8;
+
+  for (uint8_t i = 0; i < NUM_LEDS; i++) {
+    uint8_t x = coordsX[i];
+    uint8_t z = coordsZ[i];
+
+    leds[i] = ColorFromPalette(palettes[currentPaletteIndex], beat8(speed) - ((x + z) * hues));
+  }
+}
+
+void cubeYZPalette() {
+  uint8_t hues = 8;
+
+  for (uint8_t i = 0; i < NUM_LEDS; i++) {
+    uint8_t y = coordsY[i];
+    uint8_t z = coordsZ[i];
+
+    leds[i] = ColorFromPalette(palettes[currentPaletteIndex], beat8(speed) - ((y + z) * hues));
+  }
+}
+
+void cubeXYZPalette() {
+  uint8_t hues = 8;
+
+  for (uint8_t i = 0; i < NUM_LEDS; i++) {
+    uint8_t x = coordsX[i];
+    uint8_t y = coordsY[i];
+    uint8_t z = coordsZ[i];
+
+    leds[i] = ColorFromPalette(palettes[currentPaletteIndex], beat8(speed) - ((x + y + z) * hues));
+  }
+}
+
+void cubeXGradientPalette() {
+  uint8_t hues = 8;
+  
+  for (uint8_t i = 0; i < NUM_LEDS; i++) {
+    uint8_t x = coordsX[i];
+
+    leds[i] = ColorFromPalette(gCurrentPalette, beat8(speed) - (x * hues));
+  }
+}
+
+void cubeYGradientPalette() {
+  uint8_t hues = 8;
+  
+  for (uint8_t i = 0; i < NUM_LEDS; i++) {
+    uint8_t y = coordsY[i];
+
+    leds[i] = ColorFromPalette(gCurrentPalette, beat8(speed) - (y * hues));
+  }
+}
+
+void cubeZGradientPalette() {
+  uint8_t hues = 8;
+  
+  for (uint8_t i = 0; i < NUM_LEDS; i++) {
+    uint8_t z = coordsZ[i];
+
+    leds[i] = ColorFromPalette(gCurrentPalette, beat8(speed) - (z * hues));
+  }
+}
+
+void cubeXYGradientPalette() {
+  uint8_t hues = 8;
+  
+  for (uint8_t i = 0; i < NUM_LEDS; i++) {
+    uint8_t x = coordsX[i];
+    uint8_t y = coordsY[i];
+
+    leds[i] = ColorFromPalette(gCurrentPalette, beat8(speed) - ((x + y) * hues));
+  }
+}
+
+void cubeXZGradientPalette() {
+  uint8_t hues = 8;
+
+  for (uint8_t i = 0; i < NUM_LEDS; i++) {
+    uint8_t x = coordsX[i];
+    uint8_t z = coordsZ[i];
+
+    leds[i] = ColorFromPalette(gCurrentPalette, beat8(speed) - ((x + z) * hues));
+  }
+}
+
+void cubeYZGradientPalette() {
+  uint8_t hues = 8;
+
+  for (uint8_t i = 0; i < NUM_LEDS; i++) {
+    uint8_t y = coordsY[i];
+    uint8_t z = coordsZ[i];
+
+    leds[i] = ColorFromPalette(gCurrentPalette, beat8(speed) - ((y + z) * hues));
+  }
+}
+
+void cubeXYZGradientPalette() {
+  uint8_t hues = 8;
+
+  for (uint8_t i = 0; i < NUM_LEDS; i++) {
+    uint8_t x = coordsX[i];
+    uint8_t y = coordsY[i];
+    uint8_t z = coordsZ[i];
+
+    leds[i] = ColorFromPalette(gCurrentPalette, beat8(speed) - ((x + y + z) * hues));
+  }
+}
+

Noise.h

@@ -0,0 +1,346 @@
+/*
+   ESP8266 + FastLED + IR Remote: https://github.com/jasoncoon/esp8266-fastled-webserver
+   Copyright (C) 2015-2016 Jason Coon
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#define MAX_DIMENSION ((MatrixWidth > MatrixHeight) ? MatrixWidth : MatrixHeight)
+
+// The 16 bit version of our coordinates
+uint16_t noisex;
+uint16_t noisey;
+uint16_t noisez;
+
+// We're using the x/y dimensions to map to the x/y pixels on the matrix.  We'll
+// use the z-axis for "time".  speed determines how fast time moves forward.  Try
+// 1 for a very slow moving effect, or 60 for something that ends up looking like
+// water.
+int noisespeedx = 0;
+int noisespeedy = 1;
+int noisespeedz = 0;
+
+// Scale determines how far apart the pixels in our noise matrix are.  Try
+// changing these values around to see how it affects the motion of the display.  The
+// higher the value of scale, the more "zoomed out" the noise will be.  A value
+// of 1 will be so zoomed in, you'll mostly see solid colors.
+uint16_t noisescale = 1; // scale is set dynamically once we've started up
+
+// This is the array that we keep our computed noise values in
+uint8_t noise[MAX_DIMENSION][MAX_DIMENSION];
+
+uint8_t colorLoop = 0;
+
+CRGBPalette16 blackAndWhiteStripedPalette;
+
+// This function sets up a palette of black and white stripes,
+// using code.  Since the palette is effectively an array of
+// sixteen CRGB colors, the various fill_* functions can be used
+// to set them up.
+void SetupBlackAndWhiteStripedPalette()
+{
+  // 'black out' all 16 palette entries...
+  fill_solid( blackAndWhiteStripedPalette, 16, CRGB::Black);
+  // and set every fourth one to white.
+  blackAndWhiteStripedPalette[0] = CRGB::White;
+  blackAndWhiteStripedPalette[4] = CRGB::White;
+  blackAndWhiteStripedPalette[8] = CRGB::White;
+  blackAndWhiteStripedPalette[12] = CRGB::White;
+
+}
+
+CRGBPalette16 blackAndBlueStripedPalette;
+
+// This function sets up a palette of black and blue stripes,
+// using code.  Since the palette is effectively an array of
+// sixteen CRGB colors, the various fill_* functions can be used
+// to set them up.
+void SetupBlackAndBlueStripedPalette()
+{
+  // 'black out' all 16 palette entries...
+  fill_solid( blackAndBlueStripedPalette, 16, CRGB::Black);
+
+  for(uint8_t i = 0; i < 6; i++) {
+    blackAndBlueStripedPalette[i] = CRGB::Blue;
+  }
+}
+
+// There are several different palettes of colors demonstrated here.
+//
+// FastLED provides several 'preset' palettes: RainbowColors_p, RainbowStripeColors_p,
+// OceanColors_p, CloudColors_p, LavaColors_p, ForestColors_p, and PartyColors_p.
+//
+// Additionally, you can manually define your own color palettes, or you can write
+// code that creates color palettes on the fly.
+
+void drawNoise(CRGBPalette16 palette, uint8_t hueReduce = 0)
+{
+  for (uint8_t x = 0; x < MatrixWidth; x++) {
+    for(uint8_t y = 0; y < MatrixHeight; y++) {
+      uint16_t i = XY(x, y);
+      
+      int xoffset = noisescale * x;
+      int yoffset = noisescale * y;
+  
+      uint8_t data = inoise8(x + xoffset + noisex, y + yoffset + noisey, noisez);
+  
+      // The range of the inoise8 function is roughly 16-238.
+      // These two operations expand those values out to roughly 0..255
+      // You can comment them out if you want the raw noise data.
+      data = qsub8(data, 16);
+      data = qadd8(data, scale8(data, 39));
+  
+      if(hueReduce > 0 && data >= hueReduce)
+        data -= hueReduce;
+  
+      leds[i] = ColorFromPalette(palette, data, 255, LINEARBLEND);
+    }
+  }
+
+  noisex += noisespeedx;
+  noisey += noisespeedy;
+  noisez += noisespeedz;
+}
+
+void drawNoise3d(CRGBPalette16 palette, uint8_t hueReduce = 0)
+{
+  for(uint8_t i = 0; i < NUM_LEDS; i++) {
+    uint8_t x = coordsX[i];
+    uint8_t y = coordsY[i];
+    uint8_t z = coordsZ[i];
+   
+    int xoffset = noisescale * x;
+    int yoffset = noisescale * y;
+    int zoffset = noisescale * z;
+
+    uint8_t data = inoise8(x + xoffset + noisex, y + yoffset + noisey, z + zoffset + noisez);
+
+    // The range of the inoise8 function is roughly 16-238.
+    // These two operations expand those values out to roughly 0..255
+    // You can comment them out if you want the raw noise data.
+    data = qsub8(data, 16);
+    data = qadd8(data, scale8(data, 39));
+
+    if(hueReduce > 0 && data >= hueReduce)
+      data -= hueReduce;
+
+    leds[i] = ColorFromPalette(palette, data, 255, LINEARBLEND); 
+  }
+  
+  noisex += noisespeedx;
+  noisey += noisespeedy;
+  noisez += noisespeedz;
+}
+
+void rainbowNoise() {
+  noisespeedx = 0;
+  noisespeedy = -1;
+  noisespeedz = 0;
+  noisescale = 24;
+  colorLoop = 0;
+  drawNoise(RainbowColors_p);
+}
+
+void rainbowNoise3d() {
+  noisespeedx = 0;
+  noisespeedy = 0;
+  noisespeedz = -1;
+  noisescale = 24;
+  colorLoop = 0;
+  drawNoise3d(RainbowColors_p);
+}
+
+void rainbowStripeNoise() {
+  noisespeedx = 0;
+  noisespeedy = -2;
+  noisespeedz = 0;
+  noisescale = 24;
+  colorLoop = 0;
+  drawNoise(RainbowStripeColors_p);
+}
+
+void rainbowStripeNoise3d() {
+  noisespeedx = 0;
+  noisespeedy = 0;
+  noisespeedz = -2;
+  noisescale = 24;
+  colorLoop = 0;
+  drawNoise3d(RainbowStripeColors_p);
+}
+
+void partyNoise() {
+  noisespeedx = -9;
+  noisespeedy = 0;
+  noisespeedz = 0;
+  noisescale = 32;
+  colorLoop = 0;
+  drawNoise(PartyColors_p);
+}
+
+void partyNoise3d() {
+  noisespeedx = -9;
+  noisespeedy = 0;
+  noisespeedz = 0;
+  noisescale = 32;
+  colorLoop = 0;
+  drawNoise3d(PartyColors_p);
+}
+
+void forestNoise() {
+  noisespeedx = -9;
+  noisespeedy = 0;
+  noisespeedz = 0;
+  noisescale = 32;
+  colorLoop = 0;
+  drawNoise(ForestColors_p);
+}
+
+void forestNoise3d() {
+  noisespeedx = -9;
+  noisespeedy = 0;
+  noisespeedz = 0;
+  noisescale = 32;
+  colorLoop = 0;
+  drawNoise3d(ForestColors_p);
+}
+
+void cloudNoise() {
+  noisespeedx = -2;
+  noisespeedy = 0;
+  noisespeedz = 0;
+  noisescale = 24;
+  colorLoop = 0;
+  drawNoise(CloudColors_p);
+}
+
+void cloudNoise3d() {
+  noisespeedx = -2;
+  noisespeedy = 0;
+  noisespeedz = 0;
+  noisescale = 24;
+  colorLoop = 0;
+  drawNoise3d(CloudColors_p);
+}
+
+void fireNoise() {
+  noisespeedx = 0; // 24;
+  noisespeedy = -32;
+  noisespeedz = 0;
+  noisescale = 64;
+  colorLoop = 0;
+  drawNoise(HeatColors_p, 60);
+}
+
+void fireNoise3d() {
+  noisespeedx = 0;
+  noisespeedy = 0;
+  noisespeedz = 32;
+  noisescale = 64;
+  colorLoop = 0;
+  drawNoise3d(HeatColors_p, 60);
+}
+
+void fireNoise2() {
+  noisespeedx = 0;
+  noisespeedy = -8;
+  noisespeedz = 3;
+  noisescale = 32;
+  colorLoop = 0;
+  drawNoise(HeatColors_p);
+}
+
+void fireNoise23d() {
+  noisespeedx = 1;
+  noisespeedy = 3;
+  noisespeedz = 8;
+  noisescale = 32;
+  colorLoop = 0;
+  drawNoise3d(HeatColors_p);
+}
+
+void lavaNoise() {
+  noisespeedx = 0;
+  noisespeedy = -1;
+  noisespeedz = 1;
+  noisescale = 24;
+  colorLoop = 0;
+  drawNoise(LavaColors_p);
+}
+
+void lavaNoise3d() {
+  noisespeedx = 1;
+  noisespeedy = 3;
+  noisespeedz = -8;
+  noisescale = 32;
+  colorLoop = 0;
+  drawNoise3d(LavaColors_p);
+}
+
+void oceanNoise() {
+  noisespeedx = -2;
+  noisespeedy = 0;
+  noisespeedz = 4;
+  noisescale = 24;
+  colorLoop = 0;
+  drawNoise(OceanColors_p);
+}
+
+void oceanNoise3d() {
+  noisespeedx = -2;
+  noisespeedy = 0;
+  noisespeedz = 4;
+  noisescale = 24;
+  colorLoop = 0;
+  drawNoise3d(OceanColors_p);
+}
+
+void blackAndWhiteNoise() {
+  SetupBlackAndWhiteStripedPalette();
+  noisespeedx = -12;
+  noisespeedy = 0;
+  noisespeedz = 0;
+  noisescale = 24;
+  colorLoop = 0;
+  drawNoise(blackAndWhiteStripedPalette);
+}
+
+void blackAndWhiteNoise3d() {
+  SetupBlackAndWhiteStripedPalette();
+  noisespeedx = -12;
+  noisespeedy = 0;
+  noisespeedz = 0;
+  noisescale = 24;
+  colorLoop = 0;
+  drawNoise3d(blackAndWhiteStripedPalette);
+}
+
+void blackAndBlueNoise() {
+  SetupBlackAndBlueStripedPalette();
+  noisespeedx = 0;
+  noisespeedy = 8;
+  noisespeedz = 0;
+  noisescale = 32;
+  colorLoop = 0;
+  drawNoise(blackAndBlueStripedPalette);
+}
+
+void blackAndBlueNoise3d() {
+  SetupBlackAndBlueStripedPalette();
+  noisespeedx = -4;
+  noisespeedy = -4;
+  noisespeedz = -4;
+  noisescale = 32;
+  colorLoop = 0;
+  drawNoise3d(blackAndBlueStripedPalette);
+}

README.md

@@ -1,22 +1,26 @@
-FastLED + ESP8266 Web Server
+Ultim8x8 RGB LED Panel + FastLED + ESP8266 Web Server
 =========
 
-Control an addressable LED strip with an ESP8266 via a web browser or infrared remote control.
+Control an [ULTiM8x8 RGB LED Panel] with an ESP8266 via a web browser.
+
+[Demo Video](https://www.youtube.com/watch?v=xigy7J_K7Aw):
+
+[![Demo Video](http://img.youtube.com/vi/xigy7J_K7Aw/0.jpg)](http://www.youtube.com/watch?v=xigy7J_K7Aw)
 
 Hardware
 --------
 
-An ESP8266 development board, such as the [Adafruit HUZZAH ESP8266 Breakout]:
+[ULTiM8x8 RGB LED Panel](https://www.crowdsupply.com/maniacal-labs-wyolum/ultim8x8)
 
-[![Adafruit HUZZAH ESP8266 Breakout](https://cdn-shop.adafruit.com/310x233/2471-10.jpg)](https://www.adafruit.com/products/2471)
+[![ULTiM8x8 RGB LED Panel](https://www.crowdsupply.com/img/7d3e/ultim8x8-bothboards_jpg_project-body.jpg)](https://www.crowdsupply.com/maniacal-labs-wyolum/ultim8x8)
 
-Addressable LED strip, such as the [Adafruit NeoPixel Ring]:
+[Adafruit Feather HUZZAH with ESP8266 WiFi](https://www.adafruit.com/products/2821)
 
-[![Adafruit NeoPixel Ring](https://www.adafruit.com/images/145x109/1586-00.jpg)](https://www.adafruit.com/product/1586)
+[![Adafruit Feather HUZZAH with ESP8266 WiFi](https://cdn-shop.adafruit.com/310x233/2821-01.jpg)](https://www.adafruit.com/products/2821)
 
 Features
 --------
-* Turn the NeoPixel Ring on and off
+* Turn the LEDs on and off
 * Adjust the brightness
 * Change the display pattern
 * Adjust the color
@@ -30,17 +34,27 @@ Patterns are requested by the app from the ESP8266, so as new patterns are added
 
 The web app is stored in SPIFFS (on-board flash memory).
 
-The web app is a single page app with separate files for js and css, using [jQuery](https://jquery.com) and [Bootstrap](http://getbootstrap.com).  It has buttons for On/Off, a slider for brightness, a pattern selector, and a color picker (using [jQuery MiniColors](http://labs.abeautifulsite.net/jquery-minicolors)).  Event handlers for the controls are wired up, so you don't have to click a 'Send' button after making changes.  The brightness slider and the color picker use a delayed event handler, to prevent from flooding the ESP8266 web server with too many requests too quickly.
+The web app is a single page app that uses [jQuery](https://jquery.com) and [Bootstrap](http://getbootstrap.com).  It has buttons for On/Off, a slider for brightness, a pattern selector, and a color picker (using [jQuery MiniColors](http://labs.abeautifulsite.net/jquery-minicolors)).  Event handlers for the controls are wired up, so you don't have to click a 'Send' button after making changes.  The brightness slider and the color picker use a delayed event handler, to prevent from flooding the ESP8266 web server with too many requests too quickly.
-
-The only drawback to SPIFFS that I've found so far is uploading the files is extremely slow, requiring several minutes, regardless of how large the files are.  It's so slow that I've been just developing the web app and debugging locally on my desktop (with a hard-coded IP for the ESP8266), before uploading to SPIFFS and testing on the ESP8266.
 
+The only drawback to SPIFFS that I've found so far is uploading the files can be extremely slow, requiring several minutes, sometimes regardless of how large the files are.  It can be so slow that I've been just developing the web app and debugging locally on my desktop (with a hard-coded IP for the ESP8266), before uploading to SPIFFS and testing on the ESP8266.
 
 Installing
 -----------
+The app is installed via the Arduino IDE which can be [downloaded here](https://www.arduino.cc/en/main/software). The ESP8266 boards will need to be added to the Arduino IDE which is achieved as follows. Click File > Preferences and copy and paste the URL "http://arduino.esp8266.com/stable/package_esp8266com_index.json" into the Additional Boards Manager URLs field. Click OK. Click Tools > Boards: ... > Boards Manager. Find and click on ESP8266 (using the Search function may expedite this). Click on Install. After installation, click on Close and then select your ESP8266 board from the Tools > Board: ... menu.
+
+The app depends on the following libraries. They must either be downloaded from GitHub and placed in the Arduino 'libraries' folder, or installed as [described here](https://www.arduino.cc/en/Guide/Libraries) by using the Arduino library manager.
+
+* [FastLED](https://github.com/FastLED/FastLED)
+* [IRremoteESP8266](https://github.com/markszabo/IRremoteESP8266)
+* [Arduino WebSockets](https://github.com/Links2004/arduinoWebSockets)
+
+Download the app code from GitHub using the green Clone or Download button from [the GitHub project main page](https://github.com/jasoncoon/esp8266-fastled-webserver) and click Download ZIP. Decompress the ZIP file in your Arduino sketch folder.
 
 The web app needs to be uploaded to the ESP8266's SPIFFS.  You can do this within the Arduino IDE after installing the [Arduino ESP8266FS tool](https://github.com/esp8266/Arduino/blob/master/doc/filesystem.md#uploading-files-to-file-system).
 
-With ESP8266FS installed run the sketch and then upload the web app using `ESP8266 Sketch Data Upload` command in the Arduino Tools menu.
+With ESP8266FS installed upload the web app using `ESP8266 Sketch Data Upload` command in the Arduino Tools menu.
+
+Then enter your wi-fi network SSID and password in the .ino file, and upload the sketch using the Upload button.
 
 Compression
 -----------

TwinkleFOX.h

@@ -194,7 +194,7 @@ void drawTwinkles()
 
   uint8_t backgroundBrightness = bg.getAverageLight();
 
-  for(uint8_t i = 0; i < NUM_LEDS; i++) {
+  for(uint16_t i = 0; i < NUM_LEDS; i++) {
     CRGB& pixel = leds[i];
 
     PRNG16 = (uint16_t)(PRNG16 * 2053) + 1384; // next 'random' number

esp8266-fastled-webserver.ino

@@ -1,19 +1,19 @@
 /*
- * ESP8266 + FastLED + IR Remote: https://github.com/jasoncoon/esp8266-fastled-webserver
+   ESP8266 + FastLED + IR Remote: https://github.com/jasoncoon/esp8266-fastled-webserver
- * Copyright (C) 2015-2016 Jason Coon
+   Copyright (C) 2015-2016 Jason Coon
- *
+
- * This program is free software: you can redistribute it and/or modify
+   This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
+   it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
+   the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
+   (at your option) any later version.
- *
+
- * This program is distributed in the hope that it will be useful,
+   This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
+   GNU General Public License for more details.
- *
+
- * You should have received a copy of the GNU General Public License
+   You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include <FastLED.h>
@@ -24,25 +24,25 @@ extern "C" {
 }
 
 #include <ESP8266WiFi.h>
-#include <ESP8266mDNS.h>
+//#include <ESP8266mDNS.h>
 #include <ESP8266WebServer.h>
 #include <ESP8266HTTPUpdateServer.h>
 #include <WebSocketsServer.h>
 #include <FS.h>
 #include <EEPROM.h>
-#include <IRremoteESP8266.h>
+//#include <IRremoteESP8266.h>
 #include "GradientPalettes.h"
 
 #define ARRAY_SIZE(A) (sizeof(A) / sizeof((A)[0]))
 
 #include "Field.h"
 
-#define HOSTNAME "ESP8266-" ///< Hostname. The setup function adds the Chip ID at the end.
+#define HOSTNAME "ESP8266-Feather-" ///< Hostname. The setup function adds the Chip ID at the end.
 
-#define RECV_PIN D4
+//#define RECV_PIN D4
-IRrecv irReceiver(RECV_PIN);
+//IRrecv irReceiver(RECV_PIN);
 
-#include "Commands.h"
+//#include "Commands.h"
 
 const bool apMode = false;
 
@@ -59,10 +59,15 @@ ESP8266HTTPUpdateServer httpUpdateServer;
 
 #include "FSBrowser.h"
 
-#define DATA_PIN      D8
+#define DATA_PIN      13
-#define LED_TYPE      WS2811
+#define CLK_PIN       14
-#define COLOR_ORDER   GRB
+#define LED_TYPE      APA102
-#define NUM_LEDS      24
+#define COLOR_ORDER   BGR
+#define MatrixWidth   24
+#define MatrixHeight  8
+#define NUM_LEDS      MatrixWidth * MatrixHeight
+
+const bool MatrixSerpentineLayout = true;
 
 #define MILLI_AMPS         2000     // 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.
@@ -115,6 +120,28 @@ uint8_t gHue = 0; // rotating "base color" used by many of the patterns
 
 CRGB solidColor = CRGB::Blue;
 
+uint16_t XY( uint8_t x, uint8_t y)
+{
+  uint16_t i;
+
+  if ( MatrixSerpentineLayout == false) {
+    i = (y * MatrixWidth) + x;
+  }
+
+  if ( MatrixSerpentineLayout == true) {
+    if ( x & 0x01) {
+      // Odd columns run backwards
+      uint8_t reverseY = (MatrixHeight - 1) - y;
+      i = (x * MatrixHeight) + reverseY;
+    } else {
+      // Even rows run forwards
+      i = (x * MatrixHeight) + y;
+    }
+  }
+
+  return i;
+}
+
 // scale the brightness of all pixels down
 void dimAll(byte value)
 {
@@ -123,6 +150,36 @@ void dimAll(byte value)
   }
 }
 
+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",
+};
+
 typedef void (*Pattern)();
 typedef Pattern PatternList[];
 typedef struct {
@@ -133,12 +190,72 @@ typedef PatternAndName PatternAndNameList[];
 
 #include "Twinkles.h"
 #include "TwinkleFOX.h"
+#include "Map.h"
+#include "Noise.h"
 
 // List of patterns to cycle through.  Each is defined as a separate function below.
 
 PatternAndNameList patterns = {
   { pride,                  "Pride" },
+  { pride2,                 "Pride 2" },
   { colorWaves,             "Color Waves" },
+  { colorWaves2,            "Color Waves 2" },
+
+  { cubeTest,       "Cube XYZ Test" },
+  
+  { cubeXPalette,   "Cube X Palette" },
+  { cubeYPalette,   "Cube Y Palette" },
+  { cubeZPalette,   "Cube Z Palette" },
+  
+  { cubeXYPalette,  "Cube XY Palette" },
+  { cubeXZPalette,  "Cube XZ Palette" },
+  { cubeYZPalette,  "Cube YZ Palette" },
+  { cubeXYZPalette, "Cube XYZ Palette" },
+
+  { cubeXGradientPalette,   "Cube X Gradient Palette" },
+  { cubeYGradientPalette,   "Cube Y Gradient Palette" },
+  { cubeZGradientPalette,   "Cube Z Gradient Palette" },
+  
+  { cubeXYGradientPalette,  "Cube XY Gradient Palette" },
+  { cubeXZGradientPalette,  "Cube XZ Gradient Palette" },
+  { cubeYZGradientPalette,  "Cube YZ Gradient Palette" },
+  { cubeXYZGradientPalette, "Cube XYZ Gradient Palette" },
+
+  // 3d noise patterns
+  { fireNoise3d, "Fire Noise 3D" },
+  { fireNoise23d, "Fire Noise 2 3D" },
+  { lavaNoise3d, "Lava Noise 3D" },
+  { rainbowNoise3d, "Rainbow Noise 3D" },
+  { rainbowStripeNoise3d, "Rainbow Stripe Noise 3D" },
+  { partyNoise3d, "Party Noise 3D" },
+  { forestNoise3d, "Forest Noise 3D" },
+  { cloudNoise3d, "Cloud Noise 3D" },
+  { oceanNoise3d, "Ocean Noise 3D" },
+  { blackAndWhiteNoise3d, "Black & White Noise 3D" },
+  { blackAndBlueNoise3d, "Black & Blue Noise 3D" },
+  
+  { xyMatrixTest,           "Matrix Test" },
+
+  { verticalPalette,           "Vertical Palette" },
+  { diagonalPalette,           "Diagonal Palette" },
+  { horizontalPalette,         "Horizontal Palette" },
+
+  { verticalGradientPalette,   "Vertical Gradient Palette" },
+  { diagonalGradientPalette,   "Diagonal Gradient Palette" },
+  { horizontalGradientPalette, "Horizontal Gradient Palette" },
+
+  // noise patterns
+  { fireNoise, "Fire Noise" },
+  { fireNoise2, "Fire Noise 2" },
+  { lavaNoise, "Lava Noise" },
+  { rainbowNoise, "Rainbow Noise" },
+  { rainbowStripeNoise, "Rainbow Stripe Noise" },
+  { partyNoise, "Party Noise" },
+  { forestNoise, "Forest Noise" },
+  { cloudNoise, "Cloud Noise" },
+  { oceanNoise, "Ocean Noise" },
+  { blackAndWhiteNoise, "Black & White Noise" },
+  { blackAndBlueNoise, "Black & Blue Noise" },
 
   // twinkle patterns
   { rainbowTwinkles,        "Rainbow Twinkles" },
@@ -177,36 +294,6 @@ PatternAndNameList patterns = {
 
 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() {
@@ -214,9 +301,9 @@ void setup() {
   delay(100);
   Serial.setDebugOutput(true);
 
-  FastLED.addLeds<LED_TYPE, DATA_PIN, COLOR_ORDER>(leds, NUM_LEDS);         // for WS2812 (Neopixel)
+  //FastLED.addLeds<LED_TYPE, DATA_PIN, COLOR_ORDER>(leds, NUM_LEDS);     // for WS2812 (Neopixel)
-  //FastLED.addLeds<LED_TYPE,DATA_PIN,CLK_PIN,COLOR_ORDER>(leds, NUM_LEDS); // for APA102 (Dotstar)
+  FastLED.addLeds<LED_TYPE, DATA_PIN, CLK_PIN, COLOR_ORDER>(leds, NUM_LEDS); // for APA102 (Dotstar)
-  FastLED.setDither(false);
+  FastLED.setDither(true);
   FastLED.setCorrection(TypicalLEDStrip);
   FastLED.setBrightness(brightness);
   FastLED.setMaxPowerInVoltsAndMilliamps(5, MILLI_AMPS);
@@ -228,7 +315,7 @@ void setup() {
 
   FastLED.setBrightness(brightness);
 
-  irReceiver.enableIRIn(); // Start the receiver
+  //  irReceiver.enableIRIn(); // Start the receiver
 
   Serial.println();
   Serial.print( F("Heap: ") ); Serial.println(system_get_free_heap_size());
@@ -263,10 +350,10 @@ void setup() {
   for (uint8_t i = 0; i < hostname.length(); i++)
     hostnameChar[i] = hostname.charAt(i);
 
-  MDNS.begin(hostnameChar);
+  //  MDNS.begin(hostnameChar);
 
   // Add service to MDNS-SD
-  MDNS.addService("http", "tcp", 80);
+  //  MDNS.addService("http", "tcp", 80);
 
   // Print hostname.
   Serial.println("Hostname: " + hostname);
@@ -346,7 +433,7 @@ void setup() {
 
   webServer.on("/speed", HTTP_POST, []() {
     String value = webServer.arg("value");
-    speed = value.toInt();
+    setSpeed(value.toInt());
     broadcastInt("speed", speed);
     sendInt(speed);
   });
@@ -476,7 +563,7 @@ void loop() {
   webSocketsServer.loop();
   webServer.handleClient();
 
-  handleIrInput();
+  //  handleIrInput();
 
   if (power == 0) {
     fill_solid(leds, NUM_LEDS, CRGB::Black);
@@ -512,7 +599,7 @@ void loop() {
   FastLED.show();
 
   // insert a delay to keep the framerate modest
-  // FastLED.delay(1000 / FRAMES_PER_SECOND);
+  FastLED.delay(1000 / FRAMES_PER_SECOND);
 }
 
 void webSocketEvent(uint8_t num, WStype_t type, uint8_t * payload, size_t length) {
@@ -552,212 +639,212 @@ void webSocketEvent(uint8_t num, WStype_t type, uint8_t * payload, size_t length
   }
 }
 
-void handleIrInput()
+//void handleIrInput()
-{
+//{
-  InputCommand command = readCommand();
+//  InputCommand command = readCommand();
-
+//
-  if (command != InputCommand::None) {
+//  if (command != InputCommand::None) {
-    Serial.print("command: ");
+//    Serial.print("command: ");
-    Serial.println((int) command);
+//    Serial.println((int) command);
-  }
+//  }
-
+//
-  switch (command) {
+//  switch (command) {
-    case InputCommand::Up: {
+//    case InputCommand::Up: {
-        adjustPattern(true);
+//        adjustPattern(true);
-        break;
+//        break;
-      }
+//      }
-    case InputCommand::Down: {
+//    case InputCommand::Down: {
-        adjustPattern(false);
+//        adjustPattern(false);
-        break;
+//        break;
-      }
+//      }
-    case InputCommand::Power: {
+//    case InputCommand::Power: {
-        setPower(power == 0 ? 1 : 0);
+//        setPower(power == 0 ? 1 : 0);
-        break;
+//        break;
-      }
+//      }
-    case InputCommand::BrightnessUp: {
+//    case InputCommand::BrightnessUp: {
-        adjustBrightness(true);
+//        adjustBrightness(true);
-        break;
+//        break;
-      }
+//      }
-    case InputCommand::BrightnessDown: {
+//    case InputCommand::BrightnessDown: {
-        adjustBrightness(false);
+//        adjustBrightness(false);
-        break;
+//        break;
-      }
+//      }
-    case InputCommand::PlayMode: { // toggle pause/play
+//    case InputCommand::PlayMode: { // toggle pause/play
-        setAutoplay(!autoplay);
+//        setAutoplay(!autoplay);
-        break;
+//        break;
-      }
+//      }
-
+//
-    // pattern buttons
+//    // pattern buttons
-
+//
-    case InputCommand::Pattern1: {
+//    case InputCommand::Pattern1: {
-        setPattern(0);
+//        setPattern(0);
-        break;
+//        break;
-      }
+//      }
-    case InputCommand::Pattern2: {
+//    case InputCommand::Pattern2: {
-        setPattern(1);
+//        setPattern(1);
-        break;
+//        break;
-      }
+//      }
-    case InputCommand::Pattern3: {
+//    case InputCommand::Pattern3: {
-        setPattern(2);
+//        setPattern(2);
-        break;
+//        break;
-      }
+//      }
-    case InputCommand::Pattern4: {
+//    case InputCommand::Pattern4: {
-        setPattern(3);
+//        setPattern(3);
-        break;
+//        break;
-      }
+//      }
-    case InputCommand::Pattern5: {
+//    case InputCommand::Pattern5: {
-        setPattern(4);
+//        setPattern(4);
-        break;
+//        break;
-      }
+//      }
-    case InputCommand::Pattern6: {
+//    case InputCommand::Pattern6: {
-        setPattern(5);
+//        setPattern(5);
-        break;
+//        break;
-      }
+//      }
-    case InputCommand::Pattern7: {
+//    case InputCommand::Pattern7: {
-        setPattern(6);
+//        setPattern(6);
-        break;
+//        break;
-      }
+//      }
-    case InputCommand::Pattern8: {
+//    case InputCommand::Pattern8: {
-        setPattern(7);
+//        setPattern(7);
-        break;
+//        break;
-      }
+//      }
-    case InputCommand::Pattern9: {
+//    case InputCommand::Pattern9: {
-        setPattern(8);
+//        setPattern(8);
-        break;
+//        break;
-      }
+//      }
-    case InputCommand::Pattern10: {
+//    case InputCommand::Pattern10: {
-        setPattern(9);
+//        setPattern(9);
-        break;
+//        break;
-      }
+//      }
-    case InputCommand::Pattern11: {
+//    case InputCommand::Pattern11: {
-        setPattern(10);
+//        setPattern(10);
-        break;
+//        break;
-      }
+//      }
-    case InputCommand::Pattern12: {
+//    case InputCommand::Pattern12: {
-        setPattern(11);
+//        setPattern(11);
-        break;
+//        break;
-      }
+//      }
-
+//
-    // custom color adjustment buttons
+//    // custom color adjustment buttons
-
+//
-    case InputCommand::RedUp: {
+//    case InputCommand::RedUp: {
-        solidColor.red += 8;
+//        solidColor.red += 8;
-        setSolidColor(solidColor);
+//        setSolidColor(solidColor);
-        break;
+//        break;
-      }
+//      }
-    case InputCommand::RedDown: {
+//    case InputCommand::RedDown: {
-        solidColor.red -= 8;
+//        solidColor.red -= 8;
-        setSolidColor(solidColor);
+//        setSolidColor(solidColor);
-        break;
+//        break;
-      }
+//      }
-    case InputCommand::GreenUp: {
+//    case InputCommand::GreenUp: {
-        solidColor.green += 8;
+//        solidColor.green += 8;
-        setSolidColor(solidColor);
+//        setSolidColor(solidColor);
-        break;
+//        break;
-      }
+//      }
-    case InputCommand::GreenDown: {
+//    case InputCommand::GreenDown: {
-        solidColor.green -= 8;
+//        solidColor.green -= 8;
-        setSolidColor(solidColor);
+//        setSolidColor(solidColor);
-        break;
+//        break;
-      }
+//      }
-    case InputCommand::BlueUp: {
+//    case InputCommand::BlueUp: {
-        solidColor.blue += 8;
+//        solidColor.blue += 8;
-        setSolidColor(solidColor);
+//        setSolidColor(solidColor);
-        break;
+//        break;
-      }
+//      }
-    case InputCommand::BlueDown: {
+//    case InputCommand::BlueDown: {
-        solidColor.blue -= 8;
+//        solidColor.blue -= 8;
-        setSolidColor(solidColor);
+//        setSolidColor(solidColor);
-        break;
+//        break;
-      }
+//      }
-
+//
-    // color buttons
+//    // color buttons
-
+//
-    case InputCommand::Red: {
+//    case InputCommand::Red: {
-        setSolidColor(CRGB::Red);
+//        setSolidColor(CRGB::Red);
-        break;
+//        break;
-      }
+//      }
-    case InputCommand::RedOrange: {
+//    case InputCommand::RedOrange: {
-        setSolidColor(CRGB::OrangeRed);
+//        setSolidColor(CRGB::OrangeRed);
-        break;
+//        break;
-      }
+//      }
-    case InputCommand::Orange: {
+//    case InputCommand::Orange: {
-        setSolidColor(CRGB::Orange);
+//        setSolidColor(CRGB::Orange);
-        break;
+//        break;
-      }
+//      }
-    case InputCommand::YellowOrange: {
+//    case InputCommand::YellowOrange: {
-        setSolidColor(CRGB::Goldenrod);
+//        setSolidColor(CRGB::Goldenrod);
-        break;
+//        break;
-      }
+//      }
-    case InputCommand::Yellow: {
+//    case InputCommand::Yellow: {
-        setSolidColor(CRGB::Yellow);
+//        setSolidColor(CRGB::Yellow);
-        break;
+//        break;
-      }
+//      }
-
+//
-    case InputCommand::Green: {
+//    case InputCommand::Green: {
-        setSolidColor(CRGB::Green);
+//        setSolidColor(CRGB::Green);
-        break;
+//        break;
-      }
+//      }
-    case InputCommand::Lime: {
+//    case InputCommand::Lime: {
-        setSolidColor(CRGB::Lime);
+//        setSolidColor(CRGB::Lime);
-        break;
+//        break;
-      }
+//      }
-    case InputCommand::Aqua: {
+//    case InputCommand::Aqua: {
-        setSolidColor(CRGB::Aqua);
+//        setSolidColor(CRGB::Aqua);
-        break;
+//        break;
-      }
+//      }
-    case InputCommand::Teal: {
+//    case InputCommand::Teal: {
-        setSolidColor(CRGB::Teal);
+//        setSolidColor(CRGB::Teal);
-        break;
+//        break;
-      }
+//      }
-    case InputCommand::Navy: {
+//    case InputCommand::Navy: {
-        setSolidColor(CRGB::Navy);
+//        setSolidColor(CRGB::Navy);
-        break;
+//        break;
-      }
+//      }
-
+//
-    case InputCommand::Blue: {
+//    case InputCommand::Blue: {
-        setSolidColor(CRGB::Blue);
+//        setSolidColor(CRGB::Blue);
-        break;
+//        break;
-      }
+//      }
-    case InputCommand::RoyalBlue: {
+//    case InputCommand::RoyalBlue: {
-        setSolidColor(CRGB::RoyalBlue);
+//        setSolidColor(CRGB::RoyalBlue);
-        break;
+//        break;
-      }
+//      }
-    case InputCommand::Purple: {
+//    case InputCommand::Purple: {
-        setSolidColor(CRGB::Purple);
+//        setSolidColor(CRGB::Purple);
-        break;
+//        break;
-      }
+//      }
-    case InputCommand::Indigo: {
+//    case InputCommand::Indigo: {
-        setSolidColor(CRGB::Indigo);
+//        setSolidColor(CRGB::Indigo);
-        break;
+//        break;
-      }
+//      }
-    case InputCommand::Magenta: {
+//    case InputCommand::Magenta: {
-        setSolidColor(CRGB::Magenta);
+//        setSolidColor(CRGB::Magenta);
-        break;
+//        break;
-      }
+//      }
-
+//
-    case InputCommand::White: {
+//    case InputCommand::White: {
-        setSolidColor(CRGB::White);
+//        setSolidColor(CRGB::White);
-        break;
+//        break;
-      }
+//      }
-    case InputCommand::Pink: {
+//    case InputCommand::Pink: {
-        setSolidColor(CRGB::Pink);
+//        setSolidColor(CRGB::Pink);
-        break;
+//        break;
-      }
+//      }
-    case InputCommand::LightPink: {
+//    case InputCommand::LightPink: {
-        setSolidColor(CRGB::LightPink);
+//        setSolidColor(CRGB::LightPink);
-        break;
+//        break;
-      }
+//      }
-    case InputCommand::BabyBlue: {
+//    case InputCommand::BabyBlue: {
-        setSolidColor(CRGB::CornflowerBlue);
+//        setSolidColor(CRGB::CornflowerBlue);
-        break;
+//        break;
-      }
+//      }
-    case InputCommand::LightBlue: {
+//    case InputCommand::LightBlue: {
-        setSolidColor(CRGB::LightBlue);
+//        setSolidColor(CRGB::LightBlue);
-        break;
+//        break;
-      }
+//      }
-  }
+//  }
-}
+//}
 
 void loadSettings()
 {
@@ -791,6 +878,8 @@ void loadSettings()
     currentPaletteIndex = 0;
   else if (currentPaletteIndex >= paletteCount)
     currentPaletteIndex = paletteCount - 1;
+
+  speed = EEPROM.read(9);
 }
 
 void setPower(uint8_t value)
@@ -914,6 +1003,16 @@ void setPaletteName(String name)
   }
 }
 
+void setSpeed(uint8_t value)
+{
+  speed = value;
+
+  EEPROM.write(9, value);
+  EEPROM.commit();
+
+  broadcastInt("speed", speed);
+}
+
 void adjustBrightness(bool up)
 {
   if (up && brightnessIndex < brightnessCount - 1)
@@ -976,6 +1075,97 @@ void rainbow()
   fill_rainbow( leds, NUM_LEDS, gHue, 255 / NUM_LEDS);
 }
 
+void xyMatrixTest()
+{
+  FastLED.clear();
+
+  static uint8_t x = 0;
+  static uint8_t y = 0;
+
+  leds[XY(x, y)] = CHSV(gHue, 255, 255);
+
+  EVERY_N_MILLIS(30) {
+    x++;
+    if (x >= MatrixWidth) {
+      x = 0;
+      y++;
+      if (y >= MatrixHeight) {
+        y = 0;
+      }
+    }
+  }
+}
+
+void verticalPalette() {
+  uint8_t verticalHues = 256 / MatrixHeight;
+
+  for (uint8_t y = 0; y < MatrixHeight; y++) {
+    CRGB color = ColorFromPalette(palettes[currentPaletteIndex], beat8(speed) + (y * verticalHues));
+
+    for (uint8_t x = 0; x < MatrixWidth; x++) {
+      leds[XY(x, y)] = color;
+    }
+  }
+}
+
+void diagonalPalette() {
+  uint8_t verticalHues = 256 / MatrixHeight;
+
+  for (uint8_t y = 0; y < MatrixHeight; y++) {
+    for (uint8_t x = 0; x < MatrixWidth; x++) {
+      CRGB color = ColorFromPalette(palettes[currentPaletteIndex], beat8(speed) - ((x - y) * verticalHues));
+      leds[XY(x, y)] = color;
+    }
+  }
+}
+
+void horizontalPalette() {
+  uint8_t horizontalHues = 256 / MatrixWidth;
+
+  for (uint8_t x = 0; x < MatrixWidth; x++) {
+    CRGB color = ColorFromPalette(palettes[currentPaletteIndex], beat8(speed) - (x * horizontalHues));
+
+    for (uint8_t y = 0; y < MatrixHeight; y++) {
+      leds[XY(x, y)] = color;
+    }
+  }
+}
+
+void verticalGradientPalette() {
+  uint8_t verticalHues = 256 / MatrixHeight;
+
+  for (uint8_t y = 0; y < MatrixHeight; y++) {
+    CRGB color = ColorFromPalette(gCurrentPalette, beat8(speed) + (y * verticalHues));
+
+    for (uint8_t x = 0; x < MatrixWidth; x++) {
+      leds[XY(x, y)] = color;
+    }
+  }
+}
+
+void diagonalGradientPalette() {
+  uint8_t verticalHues = 256 / MatrixHeight;
+
+  for (uint8_t y = 0; y < MatrixHeight; y++) {
+    for (uint8_t x = 0; x < MatrixWidth; x++) {
+      CRGB color = ColorFromPalette(gCurrentPalette, beat8(speed) - ((x - y) * verticalHues));
+      leds[XY(x, y)] = color;
+    }
+  }
+}
+
+void horizontalGradientPalette() {
+  uint8_t horizontalHues = 256 / MatrixWidth;
+
+  for (uint8_t x = 0; x < MatrixWidth; x++) {
+    CRGB color = ColorFromPalette(gCurrentPalette, beat8(speed) - (x * horizontalHues));
+
+    for (uint8_t y = 0; y < MatrixHeight; y++) {
+      leds[XY(x, y)] = color;
+    }
+  }
+}
+
 void rainbowWithGlitter()
 {
   // built-in FastLED rainbow, plus some random sparkly glitter
@@ -1110,6 +1300,46 @@ void pride()
   }
 }
 
+void pride2()
+{
+  static uint16_t sPseudotime = 0;
+  static uint16_t sLastMillis = 0;
+  static uint16_t sHue16 = 0;
+
+  uint8_t sat8 = beatsin88( 87, 220, 250);
+  uint8_t brightdepth = beatsin88( 341, 96, 224);
+  uint16_t brightnessthetainc16 = beatsin88( 203, (25 * 256), (40 * 256));
+  uint8_t msmultiplier = beatsin88(147, 23, 60);
+
+  uint16_t hue16 = sHue16;//gHue * 256;
+  uint16_t hueinc16 = beatsin88(113, 1, 3000);
+
+  uint16_t ms = millis();
+  uint16_t deltams = ms - sLastMillis ;
+  sLastMillis  = ms;
+  sPseudotime += deltams * msmultiplier;
+  sHue16 += deltams * beatsin88( 400, 5, 9);
+  uint16_t brightnesstheta16 = sPseudotime;
+
+  for (uint8_t x = 0; x < MatrixWidth; x++) {
+    hue16 += hueinc16;
+    uint8_t hue8 = hue16 / 256;
+
+    brightnesstheta16  += brightnessthetainc16;
+    uint16_t b16 = sin16( brightnesstheta16  ) + 32768;
+
+    uint16_t bri16 = (uint32_t)((uint32_t)b16 * (uint32_t)b16) / 65536;
+    uint8_t bri8 = (uint32_t)(((uint32_t)bri16) * brightdepth) / 65536;
+    bri8 += (255 - brightdepth);
+
+    CRGB newcolor = CHSV( hue8, sat8, bri8);
+
+    for (uint8_t y = 0; y < MatrixHeight; y++) {
+      nblend(leds[XY(x, y)], newcolor, 64);
+    }
+  }
+}
+
 void radialPaletteShift()
 {
   for (uint8_t i = 0; i < NUM_LEDS; i++) {
@@ -1249,6 +1479,56 @@ void colorwaves( CRGB* ledarray, uint16_t numleds, CRGBPalette16& palette)
   }
 }
 
+void colorWaves2()
+{
+  static uint16_t sPseudotime = 0;
+  static uint16_t sLastMillis = 0;
+  static uint16_t sHue16 = 0;
+
+  // uint8_t sat8 = beatsin88( 87, 220, 250);
+  uint8_t brightdepth = beatsin88( 341, 96, 224);
+  uint16_t brightnessthetainc16 = beatsin88( 203, (25 * 256), (40 * 256));
+  uint8_t msmultiplier = beatsin88(147, 23, 60);
+
+  uint16_t hue16 = sHue16;//gHue * 256;
+  uint16_t hueinc16 = beatsin88(113, 300, 1500);
+
+  uint16_t ms = millis();
+  uint16_t deltams = ms - sLastMillis ;
+  sLastMillis  = ms;
+  sPseudotime += deltams * msmultiplier;
+  sHue16 += deltams * beatsin88( 400, 5, 9);
+  uint16_t brightnesstheta16 = sPseudotime;
+
+  for (uint8_t x = 0; x < MatrixWidth; x++) {
+    hue16 += hueinc16;
+    uint8_t hue8 = hue16 / 256;
+    uint16_t h16_128 = hue16 >> 7;
+    if ( h16_128 & 0x100) {
+      hue8 = 255 - (h16_128 >> 1);
+    } else {
+      hue8 = h16_128 >> 1;
+    }
+
+    brightnesstheta16  += brightnessthetainc16;
+    uint16_t b16 = sin16( brightnesstheta16  ) + 32768;
+
+    uint16_t bri16 = (uint32_t)((uint32_t)b16 * (uint32_t)b16) / 65536;
+    uint8_t bri8 = (uint32_t)(((uint32_t)bri16) * brightdepth) / 65536;
+    bri8 += (255 - brightdepth);
+
+    uint8_t index = hue8;
+    //index = triwave8( index);
+    index = scale8( index, 240);
+
+    CRGB newcolor = ColorFromPalette(gCurrentPalette, index, bri8);
+
+    for (uint8_t y = 0; y < MatrixHeight; y++) {
+      nblend(leds[XY(x, y)], newcolor, 128);
+    }
+  }
+}
+
 // Alternate rendering function just scrolls the current palette
 // across the defined LED strip.
 void palettetest( CRGB* ledarray, uint16_t numleds, const CRGBPalette16& gCurrentPalette)