Independence Day Tribute V2

Project

ESP32

Independence Day Tribute V2

Wiring Schematic

ARDUINO / C++

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <math.h>

#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64
#define OLED_RESET -1
#define OLED_ADDR 0x3C

#define SDA_PIN 21
#define SCL_PIN 22

#define YELLOW_TOP 0
#define YELLOW_BOTTOM 15
#define BLUE_TOP 16
#define BLUE_BOTTOM 63

Adafruit_SSD1306 display(
  SCREEN_WIDTH,
  SCREEN_HEIGHT,
  &Wire,
  OLED_RESET
);

// ============================================================
// CONFIG
// ============================================================

#define PARTICLE_COUNT 70
#define STAR_COUNT 28
#define TRAIL_COUNT 18

struct Particle {
  float x;
  float y;
  float vx;
  float vy;
  int life;
  int maxLife;
  bool active;
};

struct Star {
  int x;
  int y;
  int phase;
};

struct TrailPoint {
  int x;
  int y;
  bool active;
};

Particle particles[PARTICLE_COUNT];
Star stars[STAR_COUNT];
TrailPoint rocketTrail[TRAIL_COUNT];

// ============================================================
// SAFE DRAWING
// ============================================================

void safePixel(int x, int y) {
  if (
    x >= 0 &&
    x < SCREEN_WIDTH &&
    y >= 0 &&
    y < SCREEN_HEIGHT
  ) {
    display.drawPixel(x, y, SSD1306_WHITE);
  }
}

void yellowPixel(int x, int y) {
  if (
    x >= 0 &&
    x < SCREEN_WIDTH &&
    y >= YELLOW_TOP &&
    y <= YELLOW_BOTTOM
  ) {
    display.drawPixel(x, y, SSD1306_WHITE);
  }
}

void bluePixel(int x, int y) {
  if (
    x >= 0 &&
    x < SCREEN_WIDTH &&
    y >= BLUE_TOP &&
    y <= BLUE_BOTTOM
  ) {
    display.drawPixel(x, y, SSD1306_WHITE);
  }
}

void safeLine(
  int x1,
  int y1,
  int x2,
  int y2
) {
  display.drawLine(
    x1,
    y1,
    x2,
    y2,
    SSD1306_WHITE
  );
}

void blueLine(
  int x1,
  int y1,
  int x2,
  int y2
) {
  int steps = max(
    abs(x2 - x1),
    abs(y2 - y1)
  );

if (steps == 0) {
    bluePixel(x1, y1);
    return;
  }

for (int i = 0; i <= steps; i++) {
    float t = (float)i / steps;

int x =
      x1 +
      (x2 - x1) * t;

int y =
      y1 +
      (y2 - y1) * t;

bluePixel(x, y);
  }
}

void yellowLine(
  int x1,
  int y1,
  int x2,
  int y2
) {
  int steps = max(
    abs(x2 - x1),
    abs(y2 - y1)
  );

if (steps == 0) {
    yellowPixel(x1, y1);
    return;
  }

for (int i = 0; i <= steps; i++) {
    float t = (float)i / steps;

int x =
      x1 +
      (x2 - x1) * t;

int y =
      y1 +
      (y2 - y1) * t;

yellowPixel(x, y);
  }
}

// ============================================================
// DISPLAY
// ============================================================

void showFrame(int frameDelay) {
  display.display();
  delay(frameDelay);
}

void clearFrame() {
  display.clearDisplay();
}

// ============================================================
// TEXT HELPERS
// ============================================================

void centeredText(
  const char *text,
  int y,
  int size = 1
) {
  display.setTextColor(
    SSD1306_WHITE
  );

display.setTextSize(
    size
  );

int16_t x1;
  int16_t y1;

uint16_t w;
  uint16_t h;

display.getTextBounds(
    text,
    0,
    0,
    &x1,
    &y1,
    &w,
    &h
  );

int x =
    (SCREEN_WIDTH - w) / 2;

display.setCursor(
    x,
    y
  );

display.print(
    text
  );
}

void yellowTitle(
  const char *text
) {
  centeredText(
    text,
    4,
    1
  );
}

void blueCenteredText(
  const char *text,
  int y,
  int size = 1
) {
  if (y < BLUE_TOP) {
    y = BLUE_TOP;
  }

centeredText(
    text,
    y,
    size
  );
}

// ============================================================
// INITIALIZE STARS
// ============================================================

void initializeStars() {
  for (
    int i = 0;
    i < STAR_COUNT;
    i++
  ) {
    stars[i].x =
      random(
        2,
        126
      );

stars[i].y =
      random(
        BLUE_TOP + 1,
        BLUE_BOTTOM - 2
      );

stars[i].phase =
      random(
        0,
        20
      );
  }
}

void drawSpaceStars(
  int frame
) {
  for (
    int i = 0;
    i < STAR_COUNT;
    i++
  ) {
    int blink =
      (frame +
       stars[i].phase) % 18;

if (blink < 4) {
      bluePixel(
        stars[i].x,
        stars[i].y
      );

if (blink == 0) {
        bluePixel(
          stars[i].x - 1,
          stars[i].y
        );

bluePixel(
          stars[i].x + 1,
          stars[i].y
        );
      }
    }
  }
}

// ============================================================
// PARTICLE ENGINE
// ============================================================

void clearParticles() {
  for (
    int i = 0;
    i < PARTICLE_COUNT;
    i++
  ) {
    particles[i].active =
      false;

particles[i].life =
      0;
  }
}

int findFreeParticle() {
  for (
    int i = 0;
    i < PARTICLE_COUNT;
    i++
  ) {
    if (
      !particles[i].active
    ) {
      return i;
    }
  }

return -1;
}

void createParticle(
  float x,
  float y,
  float vx,
  float vy,
  int life
) {
  int index =
    findFreeParticle();

if (index < 0) {
    return;
  }

particles[index].x =
    x;

particles[index].y =
    y;

particles[index].vx =
    vx;

particles[index].vy =
    vy;

particles[index].life =
    life;

particles[index].maxLife =
    life;

particles[index].active =
    true;
}

void updateParticles(
  bool gravity,
  int zone
) {
  for (
    int i = 0;
    i < PARTICLE_COUNT;
    i++
  ) {
    if (
      !particles[i].active
    ) {
      continue;
    }

particles[i].x +=
      particles[i].vx;

particles[i].y +=
      particles[i].vy;

if (gravity) {
      particles[i].vy +=
        0.035;
    }

particles[i].life--;

int x =
      (int)particles[i].x;

int y =
      (int)particles[i].y;

if (
      particles[i].life <= 0 ||
      x < -5 ||
      x > 132 ||
      y < -5 ||
      y > 68
    ) {
      particles[i].active =
        false;

continue;
    }

if (zone == 1) {
      yellowPixel(
        x,
        y
      );
    }

else if (zone == 2) {
      bluePixel(
        x,
        y
      );
    }

else {
      safePixel(
        x,
        y
      );
    }
  }
}

// ============================================================
// FIREWORK TYPE 1 - ROUND BURST
// ============================================================

void spawnRoundBurst(
  int cx,
  int cy,
  bool yellowOnly
) {
  int count =
    random(
      18,
      38
    );

for (
    int i = 0;
    i < count;
    i++
  ) {
    float angle =
      random(
        0,
        628
      ) / 100.0;

float speed =
      random(
        50,
        180
      ) / 100.0;

float vx =
      cos(angle) *
      speed;

float vy =
      sin(angle) *
      speed;

if (
      yellowOnly &&
      vy > 0
    ) {
      vy *=
        -0.35;
    }

createParticle(
      cx,
      cy,
      vx,
      vy,
      random(
        10,
        24
      )
    );
  }
}

// ============================================================
// FIREWORK TYPE 2 - STAR BURST
// ============================================================

void spawnStarBurst(
  int cx,
  int cy,
  bool yellowOnly
) {
  int arms =
    random(
      6,
      11
    );

for (
    int i = 0;
    i < arms;
    i++
  ) {
    float angle =
      i *
      2.0 *
      PI /
      arms;

for (
      int j = 0;
      j < 4;
      j++
    ) {
      float speed =
        0.6 +
        j * 0.35;

float vx =
        cos(angle) *
        speed;

float vy =
        sin(angle) *
        speed;

if (
        yellowOnly &&
        vy > 0
      ) {
        vy *=
          -0.25;
      }

createParticle(
        cx,
        cy,
        vx,
        vy,
        random(
          12,
          25
        )
      );
    }
  }
}

// ============================================================
// FIREWORK TYPE 3 - CROSS BURST
// ============================================================

void spawnCrossBurst(
  int cx,
  int cy,
  bool yellowOnly
) {
  for (
    int arm = 0;
    arm < 8;
    arm++
  ) {
    float angle =
      arm *
      PI /
      4.0;

for (
      int j = 0;
      j < 5;
      j++
    ) {
      float speed =
        0.5 +
        j *
        0.25;

float vx =
        cos(angle) *
        speed;

float vy =
        sin(angle) *
        speed;

if (
        yellowOnly &&
        vy > 0
      ) {
        vy *=
          -0.3;
      }

createParticle(
        cx,
        cy,
        vx,
        vy,
        random(
          10,
          22
        )
      );
    }
  }
}

// ============================================================
// RANDOM FIREWORK SPAWNER
// ============================================================

void spawnRandomFirework(
  int x,
  int y,
  bool yellowOnly
) {
  clearParticles();

int style =
    random(
      0,
      3
    );

if (style == 0) {
    spawnRoundBurst(
      x,
      y,
      yellowOnly
    );
  }

if (style == 1) {
    spawnStarBurst(
      x,
      y,
      yellowOnly
    );
  }

if (style == 2) {
    spawnCrossBurst(
      x,
      y,
      yellowOnly
    );
  }
}

// ============================================================
// INTRO FIREWORK
// ============================================================

void sceneIntroFirework() {
  for (
    int burst = 0;
    burst < 2;
    burst++
  ) {
    int x =
      random(
        15,
        113
      );

int y =
      random(
        4,
        11
      );

spawnRandomFirework(
      x,
      y,
      true
    );

for (
      int frame = 0;
      frame < 16;
      frame++
    ) {
      clearFrame();

updateParticles(
        false,
        1
      );

if (
        burst == 1 ||
        frame > 7
      ) {
        centeredText(
          "INDIA",
          30,
          2
        );
      }

showFrame(
        28
      );
    }
  }
}

// ============================================================
// 15 AUGUST - INDEPENDENCE DAY
// ============================================================

void sceneIndependenceDay() {
  for (int frame = 0; frame < 80; frame++) {
    clearFrame();

if (frame > 4) {
      yellowTitle("15 AUGUST");
    }

if (frame > 12) {
      centeredText("INDEPENDENCE", 26, 1);
    }

if (frame > 24) {
      centeredText("DAY", 40, 2);
    }

if (frame > 38) {
      drawChakra(64, 58, 7 + (frame % 3), frame * 0.16);
    }

showFrame(26);
  }
}

// ============================================================
// YEAR JOURNEY
// ============================================================

void drawYearTransition(
  const char *text,
  int offset
) {
  centeredText(
    text,
    29 + offset,
    2
  );
}

void sceneYears() {
  int yearList[] = {
    1947,
    1960,
    1980,
    2000,
    2010,
    2020,
    2026
  };

for (
    int i = 0;
    i < 7;
    i++
  ) {
    for (
      int frame = 0;
      frame < 7;
      frame++
    ) {
      clearFrame();

char year[6];

sprintf(
        year,
        "%d",
        yearList[i]
      );

int offset =
        6 - frame;

drawYearTransition(
        year,
        offset
      );

showFrame(
        22
      );
    }
  }
}

// ============================================================
// ROCKET BODY
// ============================================================

void drawDetailedRocket(
  int x,
  int y,
  int flameFrame
) {
  display.fillTriangle(
    x,
    y - 13,
    x - 7,
    y + 1,
    x + 7,
    y + 1,
    SSD1306_WHITE
  );

display.fillRect(
    x - 7,
    y,
    14,
    18,
    SSD1306_WHITE
  );

display.drawRect(
    x - 5,
    y + 3,
    10,
    8,
    SSD1306_BLACK
  );

display.fillCircle(
    x,
    y + 7,
    3,
    SSD1306_WHITE
  );

display.fillCircle(
    x,
    y + 7,
    1,
    SSD1306_BLACK
  );

display.fillTriangle(
    x - 7,
    y + 10,
    x - 13,
    y + 19,
    x - 7,
    y + 18,
    SSD1306_WHITE
  );

display.fillTriangle(
    x + 7,
    y + 10,
    x + 13,
    y + 19,
    x + 7,
    y + 18,
    SSD1306_WHITE
  );

int flameLength =
    8 +
    (flameFrame % 5);

for (
    int i = 0;
    i < flameLength;
    i++
  ) {
    int spread =
      1 +
      i / 4;

bluePixel(
      x +
      random(
        -spread,
        spread + 1
      ),
      y + 19 + i
    );
  }

blueLine(
    x - 3,
    y + 18,
    x,
    y + 18 + flameLength
  );

blueLine(
    x + 3,
    y + 18,
    x,
    y + 18 + flameLength
  );
}

// ============================================================
// LAUNCH PAD
// ============================================================

void drawLaunchPad(
  int shake
) {
  int baseY =
    60;

blueLine(
    25,
    baseY,
    104,
    baseY
  );

blueLine(
    36,
    60,
    44,
    48
  );

blueLine(
    92,
    60,
    84,
    48
  );

blueLine(
    38 + shake,
    48,
    44 + shake,
    26
  );

blueLine(
    44 + shake,
    26,
    50 + shake,
    48
  );

blueLine(
    84 - shake,
    48,
    90 - shake,
    26
  );

blueLine(
    90 - shake,
    26,
    96 - shake,
    48
  );
}

// ============================================================
// ROCKET SMOKE
// ============================================================

void drawSmoke(
  int frame
) {
  for (
    int i = 0;
    i < 14;
    i++
  ) {
    int x =
      64 +
      random(
        -22,
        23
      );

int y =
      59 -
      random(
        0,
        frame / 2 + 2
      );

if (
      y >= BLUE_TOP
    ) {
      bluePixel(
        x,
        y
      );

if (
        i % 3 == 0
      ) {
        bluePixel(
          x + 1,
          y
        );
      }
    }
  }
}

// ============================================================
// ROCKET TRAIL
// ============================================================

void clearRocketTrail() {
  for (
    int i = 0;
    i < TRAIL_COUNT;
    i++
  ) {
    rocketTrail[i].active =
      false;
  }
}

void addRocketTrail(
  int x,
  int y
) {
  for (
    int i = TRAIL_COUNT - 1;
    i > 0;
    i--
  ) {
    rocketTrail[i] =
      rocketTrail[i - 1];
  }

rocketTrail[0].x =
    x;

rocketTrail[0].y =
    y;

rocketTrail[0].active =
    true;
}

void drawRocketTrail() {
  for (
    int i = 0;
    i < TRAIL_COUNT;
    i++
  ) {
    if (
      rocketTrail[i].active
    ) {
      if (
        rocketTrail[i].y >=
        BLUE_TOP
      ) {
        bluePixel(
          rocketTrail[i].x,
          rocketTrail[i].y
        );
      }
    }
  }
}

// ============================================================
// HERO ROCKET LAUNCH
// ============================================================

void sceneRocketLaunch() {
  clearRocketTrail();

// IGNITION

for (
    int frame = 0;
    frame < 24;
    frame++
  ) {
    clearFrame();

yellowTitle("ROCKET");

int shake =
      frame > 10 ?
      random(-1, 2) :
      0;

drawLaunchPad(
      shake
    );

drawDetailedRocket(
      64 + shake,
      39,
      frame
    );

if (
      frame > 7
    ) {
      drawSmoke(
        frame
      );
    }

showFrame(
      28
    );
  }

// LIFTOFF

for (
    int frame = 0;
    frame < 40;
    frame++
  ) {
    clearFrame();

drawSpaceStars(
      frame
    );

int x =
      64 +
      sin(
        frame *
        0.12
      ) * 2;

int y =
      40 -
      frame *
      1.6;

addRocketTrail(
      x,
      y + 22
    );

drawRocketTrail();

drawDetailedRocket(
      x,
      y,
      frame
    );

if (
      frame < 18
    ) {
      drawLaunchPad(
        0
      );

drawSmoke(
        20
      );
    }

showFrame(
      26
    );
  }

// SPACE EXIT

for (
    int frame = 0;
    frame < 20;
    frame++
  ) {
    clearFrame();

drawSpaceStars(
      frame + 50
    );

int x =
      64 +
      sin(
        frame *
        0.2
      ) * 4;

int y =
      -10 +
      frame;

if (
      frame < 12
    ) {
      drawDetailedRocket(
        x,
        y,
        frame
      );
    }

showFrame(
      24
    );
  }
}

// ============================================================
// SATELLITE BODY
// ============================================================

void drawSatelliteBody(
  int cx,
  int cy,
  float rotation
) {
  display.fillRect(
    cx - 5,
    cy - 5,
    11,
    11,
    SSD1306_WHITE
  );

display.drawRect(
    cx - 3,
    cy - 3,
    7,
    7,
    SSD1306_BLACK
  );

int panelOffset =
    (int)(
      sin(
        rotation
      ) * 2
    );

display.drawRect(
    cx - 22,
    cy - 6 + panelOffset,
    14,
    12,
    SSD1306_WHITE
  );

display.drawRect(
    cx + 8,
    cy - 6 - panelOffset,
    14,
    12,
    SSD1306_WHITE
  );

blueLine(
    cx - 8,
    cy,
    cx - 5,
    cy
  );

blueLine(
    cx + 6,
    cy,
    cx + 8,
    cy
  );

blueLine(
    cx,
    cy - 5,
    cx,
    cy - 11
  );

bluePixel(
    cx,
    cy - 12
  );
}

// ============================================================
// EARTH HORIZON
// ============================================================

void drawEarthHorizon(
  int offset
) {
  for (
    int x = 0;
    x < SCREEN_WIDTH;
    x++
  ) {
    float distance =
      x -
      64;

int curve =
      58 -
      sqrt(
        max(
          0.0,
          38.0 * 38.0 -
          distance *
          distance
        )
      ) / 4;

int y =
      curve +
      offset;

if (
      y >= BLUE_TOP &&
      y <= BLUE_BOTTOM
    ) {
      bluePixel(
        x,
        y
      );

if (
        x % 7 == 0
      ) {
        bluePixel(
          x,
          y - 1
        );
      }
    }
  }
}

// ============================================================
// ORBIT PATH
// ============================================================

void drawOrbitPath(
  int cx,
  int cy,
  int frame
) {
  for (
    int i = 0;
    i < 64;
    i++
  ) {
    float angle =
      i *
      2 *
      PI /
      64;

int x =
      cx +
      cos(angle) *
      52;

int y =
      cy +
      sin(angle) *
      17;

if (
      y >= BLUE_TOP &&
      y <= BLUE_BOTTOM
    ) {
      if (
        (i + frame) % 3 != 0
      ) {
        bluePixel(
          x,
          y
        );
      }
    }
  }
}

// ============================================================
// SIGNAL WAVES
// ============================================================

void drawSignalWaves(
  int x,
  int y,
  int frame
) {
  for (
    int r = 5;
    r <= 18;
    r += 5
  ) {
    int animatedR =
      r +
      (
        frame %
        5
      );

for (
      int angle = -50;
      angle <= 50;
      angle += 4
    ) {
      float a =
        angle *
        PI /
        180.0;

int px =
        x +
        cos(a) *
        animatedR;

int py =
        y +
        sin(a) *
        animatedR;

bluePixel(
        px,
        py
      );
    }
  }
}

// ============================================================
// HERO SATELLITE ORBIT
// ============================================================

void sceneSatelliteOrbit() {
  for (
    int frame = 0;
    frame < 80;
    frame++
  ) {
    clearFrame();

yellowTitle("SATELLITE");

drawSpaceStars(
      frame
    );

drawEarthHorizon(
      frame % 3
    );

drawOrbitPath(
      64,
      40,
      frame
    );

float angle =
      frame *
      0.09;

int satX =
      64 +
      cos(angle) *
      50;

int satY =
      39 +
      sin(angle) *
      16;

drawSatelliteBody(
      satX,
      satY,
      angle
    );

if (
      frame % 12 < 8
    ) {
      drawSignalWaves(
        satX,
        satY,
        frame
      );
    }

showFrame(
      24
    );
  }
}

// ============================================================
// NATIONAL FLAG
// ============================================================

void drawFlag(
  int x,
  int y,
  int width,
  int height,
  float wave
) {
  int stripe =
    height / 3;

for (
    int i = 0;
    i < width;
    i++
  ) {
    int offset =
      (int)(
        sin(
          i *
          0.19 +
          wave
        ) * 2
      );

blueLine(
      x + i,
      y + offset,
      x + i,
      y + stripe + offset
    );

blueLine(
      x + i,
      y + stripe * 2 + offset,
      x + i,
      y + height + offset
    );
  }

int cx =
    x +
    width / 2;

int cy =
    y +
    stripe +
    stripe / 2;

display.drawCircle(
    cx,
    cy,
    4,
    SSD1306_WHITE
  );

for (
    int i = 0;
    i < 12;
    i++
  ) {
    float a =
      i *
      2 *
      PI /
      12.0 +
      wave;

blueLine(
      cx,
      cy,
      cx +
      cos(a) * 4,
      cy +
      sin(a) * 4
    );
  }
}

void drawBird(
  int x,
  int y
) {
  if (
    y < BLUE_TOP ||
    y > 60
  ) {
    return;
  }

blueLine(
    x,
    y,
    x + 3,
    y - 2
  );

blueLine(
    x + 3,
    y - 2,
    x + 6,
    y
  );
}

// ============================================================
// FLAG SCENE
// ============================================================

void sceneFlag() {
  for (
    int frame = 0;
    frame < 70;
    frame++
  ) {
    clearFrame();

yellowTitle(
      "OUR NATIONAL FLAG"
    );

blueLine(
      17,
      16,
      17,
      62
    );

drawFlag(
      18,
      20,
      76,
      30,
      frame *
      0.15
    );

int birdX =
      122 -
      frame *
      2;

int birdY =
      47 +
      (
        int
      )(
        sin(
          frame *
          0.22
        ) * 3
      );

drawBird(
      birdX,
      birdY
    );

if (
      frame > 16
    ) {
      drawBird(
        birdX + 15,
        birdY + 5
      );
    }

showFrame(
      24
    );
  }
}

// ============================================================
// ATOMIC ENERGY
// ============================================================

void drawAtomicOrbit(
  int cx,
  int cy,
  float rotation,
  int width,
  int height
) {
  for (
    int step = 0;
    step < 80;
    step++
  ) {
    float a =
      step *
      2 *
      PI /
      80.0;

float x1 =
      cos(a) *
      width;

float y1 =
      sin(a) *
      height;

float x2 =
      x1 *
      cos(rotation) -
      y1 *
      sin(rotation);

float y2 =
      x1 *
      sin(rotation) +
      y1 *
      cos(rotation);

bluePixel(
      cx +
      x2,
      cy +
      y2
    );
  }
}

void drawAtomicEnergy(
  int frame
) {
  int cx = 64;
  int cy = 40;

for (
    int orbit = 0;
    orbit < 3;
    orbit++
  ) {
    float rotation =
      frame *
      0.08 +
      orbit *
      PI /
      3;

drawAtomicOrbit(
      cx,
      cy,
      rotation,
      19,
      8
    );
  }

int pulse =
    2 +
    (
      frame %
      4
    );

display.fillCircle(
    cx,
    cy,
    pulse,
    SSD1306_WHITE
  );
}

void sceneAtomicEnergy() {
  for (
    int frame = 0;
    frame < 42;
    frame++
  ) {
    clearFrame();

yellowTitle("ATOMIC ENERGY");

drawAtomicEnergy(
      frame
    );

showFrame(
      25
    );
  }
}

// ============================================================
// MOON SURFACE
// ============================================================

void drawMoonSurface(
  int frame
) {
  for (
    int x = 0;
    x < SCREEN_WIDTH;
    x++
  ) {
    int wave =
      (
        int
      )(
        sin(
          x *
          0.16 +
          frame *
          0.03
        ) * 2
      );

int y =
      55 +
      wave;

bluePixel(
      x,
      y
    );

if (
      x % 5 == 0
    ) {
      bluePixel(
        x,
        y - 1
      );
    }
  }

display.drawCircle(
    24,
    51,
    3,
    SSD1306_WHITE
  );

display.drawCircle(
    98,
    53,
    4,
    SSD1306_WHITE
  );
}

// ============================================================
// LANDER
// ============================================================

void drawMoonLander(
  int x,
  int y,
  int frame
) {
  display.fillTriangle(
    x,
    y - 7,
    x - 7,
    y + 5,
    x + 7,
    y + 5,
    SSD1306_WHITE
  );

display.drawRect(
    x - 4,
    y - 2,
    8,
    7,
    SSD1306_BLACK
  );

blueLine(
    x - 5,
    y + 5,
    x - 9,
    y + 10
  );

blueLine(
    x + 5,
    y + 5,
    x + 9,
    y + 10
  );

blueLine(
    x - 9,
    y + 10,
    x - 11,
    y + 10
  );

blueLine(
    x + 9,
    y + 10,
    x + 11,
    y + 10
  );

if (
    frame % 3 == 0
  ) {
    bluePixel(
      x,
      y - 10
    );
  }
}

// ============================================================
// MOON LANDING
// ============================================================

void sceneMoonMission() {
  for (
    int frame = 0;
    frame < 60;
    frame++
  ) {
    clearFrame();

yellowTitle("MOON MISSION");

drawSpaceStars(
      frame
    );

drawMoonSurface(
      frame
    );

int y =
      20 +
      frame /
      2;

if (
      y > 43
    ) {
      y = 43;
    }

drawMoonLander(
      64,
      y,
      frame
    );

if (
      frame > 42
    ) {
      for (
        int i = 0;
        i < 9;
        i++
      ) {
        bluePixel(
          64 +
          random(
            -15,
            16
          ),
          54 +
          random(
            -3,
            3
          )
        );
      }
    }

showFrame(
      24
    );
  }
}

// ============================================================
// BLUE FIREWORK CELEBRATION
// ============================================================

void sceneBlueCelebration() {
  for (
    int burst = 0;
    burst < 4;
    burst++
  ) {
    int x =
      random(
        15,
        114
      );

int y =
      random(
        24,
        48
      );

spawnRandomFirework(
      x,
      y,
      false
    );

for (
      int frame = 0;
      frame < 22;
      frame++
    ) {
      clearFrame();

updateParticles(
        true,
        2
      );

showFrame(
        24
      );
    }
  }
}

// ============================================================
// ASHOKA CHAKRA
// ============================================================

void drawChakra(
  int cx,
  int cy,
  int radius,
  float rotation
) {
  display.drawCircle(
    cx,
    cy,
    radius,
    SSD1306_WHITE
  );

display.drawCircle(
    cx,
    cy,
    radius - 2,
    SSD1306_WHITE
  );

display.fillCircle(
    cx,
    cy,
    2,
    SSD1306_WHITE
  );

for (
    int i = 0;
    i < 24;
    i++
  ) {
    float angle =
      i *
      2.0 *
      PI /
      24.0 +
      rotation;

int x =
      cx +
      cos(angle) *
      radius;

int y =
      cy +
      sin(angle) *
      radius;

blueLine(
      cx,
      cy,
      x,
      y
    );
  }
}

// ============================================================
// JAI HIND SCENE
// ============================================================

void sceneJaiHind() {
  for (
    int frame = 0;
    frame < 70;
    frame++
  ) {
    clearFrame();

yellowTitle(
      "JAI HIND"
    );

int radius;

if (
      frame < 22
    ) {
      radius =
        2 +
        frame;
    }
    else {
      radius =
        20;
    }

if (
      radius > 20
    ) {
      radius =
        20;
    }

drawChakra(
      64,
      40,
      radius,
      frame *
      0.16
    );

showFrame(
      24
    );
  }
}

// ============================================================
// EMOTIONAL TRIBUTE
// ============================================================

void sceneTributeMessage() {
  for (
    int frame = 0;
    frame < 70;
    frame++
  ) {
    clearFrame();

if (
      frame > 6
    ) {
      centeredText(
        "NOT JUST A",
        20,
        1
      );
    }

if (
      frame > 20
    ) {
      centeredText(
        "NATION",
        32,
        2
      );
    }

if (
      frame > 40
    ) {
      centeredText(
        "OUR HOME.",
        53,
        1
      );
    }

showFrame(
      26
    );
  }
}

// ============================================================
// VANDE MATARAM
// ============================================================

void sceneVandeMataram() {
  for (
    int frame = 0;
    frame < 65;
    frame++
  ) {
    clearFrame();

yellowTitle(
      "VANDE MATARAM"
    );

int radius =
      15 +
      (
        int
      )(
        sin(
          frame *
          0.18
        ) * 2
      );

drawChakra(
      64,
      41,
      radius,
      frame *
      0.17
    );

if (
      frame > 18 &&
      frame % 8 == 0
    ) {
      int x =
        random(
          12,
          116
        );

int y =
        random(
          23,
          54
        );

for (
        int i = 0;
        i < 8;
        i++
      ) {
        float a =
          i *
          PI /
          4.0;

bluePixel(
          x +
          cos(a) * 4,
          y +
          sin(a) * 4
        );
      }
    }

showFrame(
      24
    );
  }
}

// ============================================================
// HAPPY INDEPENDENCE DAY
// ============================================================

void sceneHappyIndependenceDay() {
  for (int frame = 0; frame < 90; frame++) {
    clearFrame();

if (frame > 3) {
      yellowTitle("15 AUGUST");
    }

if (frame > 12) {
      centeredText("HAPPY", 25, 1);
    }

if (frame > 24) {
      centeredText("INDEPENDENCE", 37, 1);
    }

if (frame > 38) {
      centeredText("DAY", 49, 1);
    }

if (frame > 45) {
      drawChakra(112, 53, 9, frame * 0.18);
    }

showFrame(26);
  }
}

// ============================================================
// FINAL TRIBUTE SYMBOL
// ============================================================

void drawLifeTronixSignature(
  int frame
) {
  int cx = 64;
  int cy = 38;

int radius =
    3 +
    frame / 5;

if (
    radius > 11
  ) {
    radius = 11;
  }

display.drawCircle(
    cx,
    cy,
    radius,
    SSD1306_WHITE
  );

for (
    int i = 0;
    i < 10;
    i++
  ) {
    float angle =
      i *
      2 *
      PI /
      10.0 +
      frame *
      0.06;

int x1 =
      cx +
      cos(angle) *
      radius;

int y1 =
      cy +
      sin(angle) *
      radius;

int x2 =
      cx +
      cos(angle) *
      (
        radius +
        6
      );

int y2 =
      cy +
      sin(angle) *
      (
        radius +
        6
      );

blueLine(
      x1,
      y1,
      x2,
      y2
    );

bluePixel(
      x2,
      y2
    );
  }

display.fillCircle(
    cx,
    cy,
    2,
    SSD1306_WHITE
  );
}

// ============================================================
// FINAL TRIBUTE
// ============================================================

void sceneFinalTribute() {
  for (
    int frame = 0;
    frame < 80;
    frame++
  ) {
    clearFrame();

if (
      frame > 4
    ) {
      yellowTitle(
        "A TRIBUTE TO INDIA"
      );
    }

if (
      frame > 16
    ) {
      drawLifeTronixSignature(
        frame
      );
    }

if (
      frame > 30
    ) {
      centeredText(
        "BY",
        48,
        1
      );
    }

if (
      frame > 38
    ) {
      centeredText(
        "LIFETRONIX",
        56,
        1
      );
    }

showFrame(
      26
    );
  }
}

// ============================================================
// FINAL FIREWORK OUTRO
// ============================================================

void sceneFinalFireworks() {
  for (
    int burst = 0;
    burst < 3;
    burst++
  ) {
    int x =
      random(
        20,
        108
      );

int y =
      random(
        22,
        45
      );

spawnRandomFirework(
      x,
      y,
      false
    );

for (
      int frame = 0;
      frame < 20;
      frame++
    ) {
      clearFrame();

if (
        frame < 12
      ) {
        yellowTitle(
          "VANDE MATARAM"
        );
      }

updateParticles(
        true,
        2
      );

showFrame(
        25
      );
    }
  }
}

// ============================================================
// SETUP
// ============================================================

void setup() {
  Serial.begin(
    115200
  );

Wire.begin(
    SDA_PIN,
    SCL_PIN
  );

if (
    !display.begin(
      SSD1306_SWITCHCAPVCC,
      OLED_ADDR
    )
  ) {
    while (true) {
      delay(10);
    }
  }

randomSeed(
    micros() +
    esp_random()
  );

clearParticles();

clearRocketTrail();

initializeStars();

display.clearDisplay();

display.display();
}

// ============================================================
// MAIN LOOP
// ============================================================

void loop() {

// INDEPENDENCE DAY

sceneIntroFirework();

sceneIndependenceDay();

sceneYears();

// INDIA'S JOURNEY

sceneFlag();

// ACHIEVEMENTS

sceneRocketLaunch();

sceneSatelliteOrbit();

sceneAtomicEnergy();

sceneMoonMission();

// CELEBRATION

sceneBlueCelebration();

sceneJaiHind();

sceneVandeMataram();

// GREETING AND TRIBUTE

sceneHappyIndependenceDay();

sceneTributeMessage();

sceneFinalTribute();

sceneFinalFireworks();

delay(1800);
}

Independence Day Tribute V2

Project Overview

The ESP32 Independence Tribute V2 teaches advanced techniques for creating elaborate multi-scene animations with complex particle systems and sophisticated graphics on small OLED displays using I2C communication.

This project celebrates India’s Independence Day with an elaborate animated tribute displayed on a 128×64 SSD1306 OLED featuring patriotic scenes including rocket launches, satellite orbits, atomic energy symbols, and moon missions. The sequence includes fireworks effects, rotating Ashoka Chakra animations, and emotional patriotic messages creating a comprehensive tribute experience.

When you run the project, the OLED displays a complete cinematic animation sequence starting with festive fireworks followed by India’s technological achievements. Each scene showcases different aspects of national pride including space exploration, atomic science, and cultural symbols with smooth transitions and dynamic visual effects.

Key Features: I2C communication between ESP32 and OLED displays, multi-scene animation sequence with precise timing control, advanced particle system for fireworks effects, complex graphics including rockets, satellites, and chakra symbols, rotating astronomical animations, color-coded display zones with yellow header and blue content areas, lightweight code optimized for microcontroller platforms.

Components Required

To build this project, collect these specific items from your kit and ensure each component is in good working condition.

ESP32 Development Board x 1, SSD1306 OLED Display (128×64) x 1, Breadboard x 1, Jumper Wires x 4, USB Cable x 1.

Circuit Connections

Step 1: Connect Ground Rail for Shared Reference

Connect the ESP32 GND ground pin directly to the negative rail of your breadboard to establish a shared ground connection for your entire circuit and all connected electronic components throughout the system.

Step 2: Place and Position OLED Display Module

Position the SSD1306 OLED display module carefully near the top edge of your breadboard for convenient access and proper alignment with all jumper wire connections during the assembly process to ensure success.

Step 3: Connect VCC Power Pin to Supply

Connect the OLED VCC power pin directly to the ESP32 3.3V output pin to provide the correct voltage level and adequate power supply for the small OLED display module operation and functionality.

Step 4: Connect Ground Pin for Return Path

Connect the OLED GND ground pin to the breadboard negative rail to complete the power circuit and establish the electrical return path for all current flowing through connected components on the breadboard.

Step 5: Connect SDA Data Pin for I2C

Connect the OLED SDA serial data pin to ESP32 GPIO pin 21 to enable I2C protocol serial data transmission between the ESP32 microcontroller and the OLED display device communication successfully.

Step 6: Connect SCL Clock Pin for Timing

Connect the OLED SCL serial clock pin to ESP32 GPIO pin 22 to provide I2C timing synchronization that coordinates precise data transmission between all connected I2C devices on the bus system.

Step 7: Verify All Connections Before Upload

Double-check all four display pins for correct connections and secure jumper wire placement before uploading any code to your ESP32 microcontroller board to prevent connectivity problems during operation and testing.

Important: The SSD1306 OLED display uses the I2C protocol, a two-wire communication standard where the SDA pin transmits data and the SCL pin provides essential timing synchronization for reliable data transfer.

Software Requirements

Before uploading code to your ESP32, install the following software components, libraries, and drivers on your development system.

Arduino IDE : Download and install the latest version from the official Arduino website for code development, editing, and uploading to your microcontroller board.

ESP32 Board Package : Add the ESP32 board package to Arduino IDE by accessing Boards Manager and searching for ESP32 with proper version selection.

Adafruit GFX Library : Install this library using Arduino IDE Library Manager to access graphics drawing functions and text rendering capabilities for display output.

Adafruit SSD1306 : Install this library for complete SSD1306 OLED display control, initialization, and I2C communication protocol implementation.

CH340 USB Driver : Download and install the CH340 USB driver for your specific operating system to enable ESP32 board serial communication with your computer.

Verify Installation : Open Arduino IDE, select your ESP32 board from Tools menu, and confirm the COM port shows your connected microcontroller device.

How the Project Code Works

Initialize Particle System and Animation Resources

The setup function configures I2C communication and initializes the SSD1306 OLED display with proper addressing settings. The particle system arrays are populated with initial values while star arrays and rocket trail systems are prepared for animation playback.

Create Multi-Scene Animation Sequence Framework

The loop function orchestrates a complete sequence of animation scenes including fireworks, rocket launches, satellite orbits, and atomic energy displays. Each scene function manages its own timing and rendering creating modular animation components that play in sequence.

Implement Advanced Particle Effects for Fireworks

The particle engine supports three distinct firework burst styles including round bursts, star bursts, and cross bursts with configurable particle counts and velocity distributions. Particles are updated with gravity effects and boundary checking ensuring safe rendering within display dimensions.

Render Complex Graphics with Safe Boundary Checking

Functions like drawDetailedRocket, drawSatelliteBody, and drawChakra create intricate graphics using line drawing primitives and geometric shapes. All drawing operations include boundary validation preventing pixels from rendering outside display boundaries.

Synchronize Multi-Component Animations with Precise Timing

The project manages numerous animated elements simultaneously including spinning chakras, orbiting satellites, traversing rockets, and blinking stars. Frame-based timing ensures smooth animation by controlling display updates at consistent intervals.

Expected Output

After uploading your code to the ESP32, connect the USB cable and observe the OLED display initialization process beginning.

The OLED displays an elaborate animated tribute beginning with festive yellow and blue fireworks effects followed by patriotic messages. Scenes progress through India’s technological achievements including a detailed rocket launch sequence with launch pad, ignition effects, and space exit animations.

The tribute sequence continues with satellite orbits around Earth, atomic energy illustrations, moon mission landers, Ashoka Chakra rotations, and emotional patriotic messages. The complete animation cycles continuously creating an engaging and inspiring Independence Day celebration.

Operational Troubleshooting

OLED Display Remains Blank or Unresponsive to Code :- Verify all four display pins connect to correct ESP32 GPIO pins as specified in the circuit diagram. Check VCC and GND connections for proper power supply with adequate current. Confirm the USB cable provides sufficient power and verify the I2C address matches your OLED model..

Complex Graphics Appear Corrupted or Partially Rendered on Screen :- Confirm both Adafruit GFX and SSD1306 libraries are correctly installed in your Arduino IDE folder. Verify boundary checking functions properly protect against out-of-bounds pixel rendering. Check that the I2C communication remains stable without timing violations during complex scene rendering.

Animation Timing Appears Incorrect or Scenes Transition Too Quickly :- Verify the scene timing constants define appropriate millisecond delays for each animation stage. Check that the showFrame function delay parameter controls animation speed correctly. Adjust timing constants to slow down or accelerate scene transitions as needed.

Particle Effects Do Not Display or Fireworks Animation Appears Missing :- Ensure the particle engine is initialized properly in the setup function without errors. Verify the particle creation and update functions are being called within scene rendering loops. Check that safe pixel drawing functions constrain particles within the proper display zones.

What You Learned

By finishing this project, you understand how to orchestrate complex multi-scene animation sequences with sophisticated graphics and particle systems on OLED displays. You have learned techniques for managing multiple animated elements simultaneously while maintaining smooth performance on resource-constrained microcontroller platforms.

You can apply advanced animation orchestration techniques to create elaborate visual experiences on embedded systems with limited memory and processing power. You have experienced how procedural graphics, particle effects, and careful timing synchronization create professional cinematic presentations on microcontroller devices.

WHAT'S NEXT?

Ready to Build More?

Explore more Lifetronix projects, improve your skills, and turn your ideas into real working prototypes.

Project

ESP32

Independence Day Tribute V2

Instagram

Youtube

Wiring Schematic

Independence Day Tribute V2

Project Overview

Components Required

Circuit Connections

Step 1: Connect Ground Rail for Shared Reference

Step 2: Place and Position OLED Display Module

Step 3: Connect VCC Power Pin to Supply

Step 4: Connect Ground Pin for Return Path

Step 5: Connect SDA Data Pin for I2C

Step 6: Connect SCL Clock Pin for Timing

Step 7: Verify All Connections Before Upload

Software Requirements

How the Project Code Works

Initialize Particle System and Animation Resources

Create Multi-Scene Animation Sequence Framework

Implement Advanced Particle Effects for Fireworks

Render Complex Graphics with Safe Boundary Checking

Synchronize Multi-Component Animations with Precise Timing

Expected Output

Operational Troubleshooting

What You Learned

WHAT'S NEXT?

Ready to Build More?