FastLED lookup table example

#include<FastLED.h>

#define DATA_PIN    7
#define CLK_PIN     14
#define BRIGHTNESS  64  //3
#define LED_TYPE    LPD8806
#define COLOR_ORDER BRG
#define FRAMES_PER_SECOND  40

///////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////
//     adjust these values to reflect the dimensions of your lookup table
const uint8_t kMatrixWidth  = 12; //18
const uint8_t kMatrixHeight = 15; //25
const bool    kMatrixSerpentineLayout = true;

///////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////
//     here is the lookup table, nice an evenly spaced
uint8_t LEDvanLookUp[] = {
  144,   0,   0, 109, 110, 111, 112, 113, 114,   0,   0, 115,
  143,   0,   0,   0, 108, 107, 106, 105,   0,   0,   0, 116,
  142,   0,   0,  28,  29,  52,  53,  76,  77,   0,   0, 117,
  141,   0,   0,  27,  30,  51,  54,  75,  78,   0,   0, 118,
  140,   8,   9,  26,  31,  50,  55,  74,  79,  96,  97, 119,
  139,   7,  10,  25,  32,  49,  56,  73,  80,  95,  98, 120,
  138,   6,  11,  24,  33,  48,  57,  72,  81,  94,  99, 121,
  137,   5,  12,  23,  34,  47,  58,  71,  82,  93, 100, 122,
  136,   4,  13,  22,  35,  46,  59,  70,  83,  92, 101, 123,
  135,   3,  14,  21,  36,  45,  60,  69,  84,  91, 102, 124,
  134,   2,  15,  20,  37,  44,  61,  68,  85,  90, 103, 125,
  133,   1,  16,  19,  38,  43,  62,  67,  86,  89, 104, 126,
    0,   0,   0,  18,  39,  42,  63,  66,  87,   0,   0,   0,
    0,   0,   0,  17,  40,  41,  64,  65,  88,   0,   0,   0,
    0,   0,   0, 132, 131, 130, 129, 128, 127,   0,   0,   0
};

// This example combines two features of FastLED to produce a remarkable range of
// effects from a relatively small amount of code.  This example combines FastLED's
// color palette lookup functions with FastLED's Perlin/simplex noise generator, and
// the combination is extremely powerful.
//
// You might want to look at the "ColorPalette" and "Noise" examples separately
// if this example code seems daunting.
//
//
// The basic setup here is that for each frame, we generate a new array of
// 'noise' data, and then map it onto the LED matrix through a color palette.
//
// Periodically, the color palette is changed, and new noise-generation parameters
// are chosen at the same time.  In this example, specific noise-generation
// values have been selected to match the given color palettes; some are faster,
// or slower, or larger, or smaller than others, but there's no reason these
// parameters can't be freely mixed-and-matched.
//
// In addition, this example includes some fast automatic 'data smoothing' at
// lower noise speeds to help produce smoother animations in those cases.
//
// The FastLED built-in color palettes (Forest, Clouds, Lava, Ocean, Party) are
// used, as well as some 'hand-defined' ones, and some proceedurally generated
// palettes.


#define NUM_LEDS (kMatrixWidth * kMatrixHeight)
#define MAX_DIMENSION ((kMatrixWidth>kMatrixHeight) ? kMatrixWidth : kMatrixHeight)

// The leds
CRGB leds[kMatrixWidth * kMatrixHeight];

// The 16 bit version of our coordinates
static uint16_t x;
static uint16_t y;
static uint16_t z;

// 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.

uint16_t speed = 1; // 1 speed is set dynamically once we've started up

// 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 iwll be.  A value
// of 1 will be so zoomed in, you'll mostly see solid colors.

uint16_t scale = 14; // 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];

CRGBPalette16 currentPalette( LavaColors_p );
uint8_t       colorLoop = 0;

void setup() {
  delay(3000);
  FastLED.addLeds<LED_TYPE, DATA_PIN, CLK_PIN, COLOR_ORDER>(leds, NUM_LEDS).setCorrection(TypicalLEDStrip);
  LEDS.setBrightness(BRIGHTNESS);

  RainbowPalette();
  // Initialize our coordinates to some random values
  x = random16();
  y = random16();
  z = random16();
}

// Fill the x/y array of 8-bit noise values using the inoise8 function.
void fillnoise8() {
  // If we're runing at a low "speed", some 8-bit artifacts become visible
  // from frame-to-frame.  In order to reduce this, we can do some fast data-smoothing.
  // The amount of data smoothing we're doing depends on "speed".
  uint8_t dataSmoothing = 0;
  if ( speed < 50) {
    dataSmoothing = 200 - (speed * 4);
  }

  for (int i = 0; i < MAX_DIMENSION; i++) {
    int ioffset = scale * i;
    for (int j = 0; j < MAX_DIMENSION; j++) {
      int joffset = scale * j;

      uint8_t data = inoise8(x + ioffset, y + joffset, z);

      // 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 ( dataSmoothing ) {
        uint8_t olddata = noise[i][j];
        uint8_t newdata = scale8( olddata, dataSmoothing) + scale8( data, 256 - dataSmoothing);
        data = newdata;
      }

      noise[i][j] = data;
    }
  }

  z += speed * 1;

  // apply slow drift to X and Y, just for visual variation.

  x -= 10;
  y += 0;
}

void mapNoiseToLEDsUsingPalette()
{
  static uint8_t ihue = 0;

  for (int i = 0; i < kMatrixWidth; i++) {
    for (int j = 0; j < kMatrixHeight; j++) {
      // ONLY EXECUTE NOISE FUNCTION INSIDE PIXELS
      if ( i < kMatrixWidth ) {


        ///////////////////////////////////////////////////////////
        ///////////////////////////////////////////////////////////
        //     here is where the lookup table comes into play
        uint8_t lookUpNum = LEDvanLookUp[i + (j * kMatrixWidth)];
        //     make sure there is an LED in the lookup table index (greater than 0)
        if ( lookUpNum > 0 ) {


          // We use the value at the (i,j) coordinate in the noise
          // array for our brightness, and the flipped value from (j,i)
          // for our pixel's index into the color palette.
          uint8_t index = noise[j][i];
          uint8_t bri =   noise[i][j];

          // if this palette is a 'loop', add a slowly-changing base value
          if ( colorLoop) {
            index += ihue;
          }

          // brighten up, as the color palette itself often contains the
          // light/dark dynamic range desired
          if ( bri > 127 ) {
            bri = 255;
          } else {
            bri = dim8_raw( bri * 2);
          }

          CRGB color = ColorFromPalette( currentPalette, index, bri);

          ///////////////////////////////////////////////////////////
          ///////////////////////////////////////////////////////////
          // don't forget to subtract 1 to account for starting counting at 1 and not 0.
          leds[lookUpNum - 1] = color;


        }
      } else {
        // Nothing
      }
    }
  }

  ihue += 1;
}

void loop() {
  // generate noise data
  fillnoise8();

  // convert the noise data to colors in the LED array
  // using the current palette
  mapNoiseToLEDsUsingPalette();

  LEDS.show();
  FastLED.delay(1000 / FRAMES_PER_SECOND);
}

void RainbowPalette() {
  currentPalette = RainbowColors_p;
}

//
// Mark's xy coordinate mapping code.  See the XYMatrix for more information on it.
//
uint16_t XY( uint8_t x, uint8_t y)
{
  uint16_t i;
  if ( kMatrixSerpentineLayout == false) {
    i = (y * kMatrixWidth) + x;
  }
  if ( kMatrixSerpentineLayout == true) {
    if ( y & 0x01) {
      // Odd rows run backwards
      uint8_t reverseX = (kMatrixWidth - 1) - x;
      i = (y * kMatrixWidth) + reverseX;
    } else {
      // Even rows run forwards
      i = (y * kMatrixWidth) + x;
    }
  }
  return i;
}