Portable RGB Animation Display

#include <Arduino.h>
#include <FastLED.h>

// ---------------------------------------------------------------------------
// 16x16 WS2812B RGB Matrix animation driver for ESP32 DevKit v1
//
// Power: single-cell LiPo -> PowerBoost 1000 -> 5V rail. The boost delivers
// ~1A, so software brightness is capped and FastLED's power manager keeps the
// panel under a safe current budget. Data goes out GPIO4 through a 330 ohm
// series resistor into DIN.
// ---------------------------------------------------------------------------

#define LED_DATA_PIN   4
#define MATRIX_WIDTH   16
#define MATRIX_HEIGHT  16
#define NUM_LEDS       (MATRIX_WIDTH * MATRIX_HEIGHT)

// Global brightness cap. Full white on 256 pixels could pull ~15A; we never go
// there. 40/255 keeps colorful animations well under the PowerBoost 1A budget.
#define BRIGHTNESS         40

// Hard current ceiling handed to FastLED's power manager (mA). Keeps the
// PowerBoost 1000 (1A) safe with margin for the ESP32 itself.
#define MAX_POWER_MA       850
#define SUPPLY_VOLTAGE     5


// Forward declarations
uint16_t xyToIndex(uint8_t x, uint8_t y);
inline void setPixel(uint8_t x, uint8_t y, const CRGB &c);
void animPlasma(uint32_t t);
void animFire();
void animComet(uint32_t t);
void animRipple(uint32_t t);

CRGB leds[NUM_LEDS];

// Serpentine mapping: row 0 left->right, row 1 right->left, ...
// Matches common WS2812B 16x16 flexible panels. If your panel scans straight
// (progressive) rows, set SERPENTINE to false.
#define SERPENTINE true

uint16_t xyToIndex(uint8_t x, uint8_t y) {
  if (x >= MATRIX_WIDTH || y >= MATRIX_HEIGHT) return 0;
  uint16_t i;
  if (SERPENTINE && (y & 0x01)) {
    uint8_t reverseX = (MATRIX_WIDTH - 1) - x;
    i = (uint16_t)y * MATRIX_WIDTH + reverseX;
  } else {
    i = (uint16_t)y * MATRIX_WIDTH + x;
  }
  return i;
}

inline void setPixel(uint8_t x, uint8_t y, const CRGB &c) {
  leds[xyToIndex(x, y)] = c;
}

// ---------------------------------------------------------------------------
// Animations
// ---------------------------------------------------------------------------

// 1) Flowing rainbow plasma — smooth, full-panel color field.
void animPlasma(uint32_t t) {
  for (uint8_t y = 0; y < MATRIX_HEIGHT; y++) {
    for (uint8_t x = 0; x < MATRIX_WIDTH; x++) {
      uint8_t v = sin8(x * 16 + (t >> 3))
                + sin8(y * 16 - (t >> 4))
                + sin8((x + y) * 12 + (t >> 2));
      uint8_t hue = v + (t >> 4);
      setPixel(x, y, CHSV(hue, 220, 255));
    }
  }
}

// 2) Fire — heat-diffusion fire rising from the bottom edge.
static uint8_t heat[MATRIX_WIDTH][MATRIX_HEIGHT];
void animFire() {
  for (uint8_t x = 0; x < MATRIX_WIDTH; x++) {
    for (uint8_t y = 0; y < MATRIX_HEIGHT; y++) {
      uint8_t cooldown = random8(0, 40);
      heat[x][y] = (heat[x][y] > cooldown) ? heat[x][y] - cooldown : 0;
    }
    // Drift heat upward (y is unsigned, so iterate downward carefully).
    for (uint8_t y = MATRIX_HEIGHT - 1; y >= 1; y--) {
      uint8_t below2 = (y >= 2) ? heat[x][y - 2] : heat[x][y - 1];
      heat[x][y] = (heat[x][y - 1] + below2) / 2;
      if (y == 1) break; // guard against unsigned wrap-around
    }
    if (random8() < 120) {
      heat[x][0] = qadd8(heat[x][0], random8(160, 255));
    }
    for (uint8_t y = 0; y < MATRIX_HEIGHT; y++) {
      CRGB color = HeatColor(heat[x][MATRIX_HEIGHT - 1 - y]);
      setPixel(x, y, color);
    }
  }
}

// 3) Bouncing color comet with fading trails.
void animComet(uint32_t t) {
  fadeToBlackBy(leds, NUM_LEDS, 40);
  uint8_t x = beatsin8(20, 0, MATRIX_WIDTH - 1, 0, 0);
  uint8_t y = beatsin8(14, 0, MATRIX_HEIGHT - 1, 0, 64);
  setPixel(x, y, CHSV((t >> 3), 255, 255));
  if (x > 0) setPixel(x - 1, y, CHSV((t >> 3), 255, 120));
  if (x < MATRIX_WIDTH - 1) setPixel(x + 1, y, CHSV((t >> 3), 255, 120));
  if (y > 0) setPixel(x, y - 1, CHSV((t >> 3), 255, 120));
  if (y < MATRIX_HEIGHT - 1) setPixel(x, y + 1, CHSV((t >> 3), 255, 120));
}

// 4) Expanding concentric rings from the center.
void animRipple(uint32_t t) {
  fadeToBlackBy(leds, NUM_LEDS, 60);
  const float cx = (MATRIX_WIDTH - 1) / 2.0f;
  const float cy = (MATRIX_HEIGHT - 1) / 2.0f;
  float phase = (t % 3000) / 3000.0f * 10.0f;
  for (uint8_t y = 0; y < MATRIX_HEIGHT; y++) {
    for (uint8_t x = 0; x < MATRIX_WIDTH; x++) {
      float dx = x - cx;
      float dy = y - cy;
      float dist = sqrtf(dx * dx + dy * dy);
      float wave = sinf(dist - phase);
      if (wave > 0.6f) {
        uint8_t hue = (uint8_t)(dist * 20) + (t >> 4);
        uint8_t val = (uint8_t)(wave * 255);
        setPixel(x, y, CHSV(hue, 255, val));
      }
    }
  }
}

// Scene scheduler.
#define SCENE_COUNT   4
#define SCENE_MS      9000UL

void setup() {
  Serial.begin(115200);
  delay(200);
  Serial.println(F("16x16 WS2812B matrix starting..."));

  FastLED.addLeds<WS2812B, LED_DATA_PIN, GRB>(leds, NUM_LEDS)
         .setCorrection(TypicalLEDStrip);
  FastLED.setBrightness(BRIGHTNESS);
  FastLED.setMaxPowerInVoltsAndMilliamps(SUPPLY_VOLTAGE, MAX_POWER_MA);
  FastLED.clear(true);
}

void loop() {
  uint32_t now = millis();
  uint8_t scene = (now / SCENE_MS) % SCENE_COUNT;

  switch (scene) {
    case 0: animPlasma(now); break;
    case 1: animFire();      break;
    case 2: animComet(now);  break;
    case 3: animRipple(now); break;
  }

  FastLED.show();
  // ~62 FPS animation cadence.
  FastLED.delay(16);
}