Arduino Project

Arduino Tetris Game with MAX7219 LED Matrix V2

Course Introduction

In this project, we use a MAX7219 32x8 Dot Matrix module, a joystick, and an Arduino board to play a classic Tetris game.

The falling blocks are controlled using the joystick for left, right, down, and rotation.

Note

If this is your first time working with an Arduino project, we recommend downloading and reviewing the basic materials first.

1.1 Install Arduino IDE(Important)
1.2 Introduction of Arduino IDE

Required Components

In this project, we need the following components:

SN	COMPONENT INTRODUCTION	QUANTITY	PURCHASE LINK
1	Arduino UNO R4 Minima	1	BUY
2	USB Type-C cable	1	×
3	Breadboard	1	BUY
4	Wires	Several	BUY
5	Joystick Module	1	BUY
6	MAX7219 Dot Matrix Module	1	BUY

Wiring

6.webp__PID:c9127fdc-9c3f-48b1-aed4-5f59fe97cb3e

Common Connections:

MAX7219 Dot Matrix Module
CLK: Connect to 5 on the Arduino.
CS: Connect to 3 on the Arduino.
DIN: Connect to 6 on the Arduino.
GND: Connect to breadboard’s negative power bus.
VCC: Connect to breadboard’s red power bus.

Joystick Module
SW: Connect to 2 on the Arduino.
VRY: Connect to A1 on the Arduino.
VRX: Connect to A0 on the Arduino.
GND: Connect to breadboard’s negative power bus.
VCC: Connect to breadboard’s red power bus.

Writing the Code

Note
You can copy this code into Arduino IDE.
To install the library, use the Arduino Library Manager and search for LedControl and install it.
Don’t forget to select the board(Arduino UNO R4 Minima/WIFI) and the correct port before clicking the Upload button.

#include <LedControl.h>  // Library for driving MAX7219 LED matrices

// MAX7219 wiring pins
#define DIN_PIN     6    // Data input
#define CLK_PIN     5    // Clock pin
#define CS_PIN      3    // Chip select
#define NUM_MODULES 4    // Number of 8×8 modules in cascade

LedControl lc(DIN_PIN, CLK_PIN, CS_PIN, NUM_MODULES);

// Joystick and button pins
#define VRx A0  // Joystick X-axis (left/right)
#define VRy A1  // Joystick Y-axis (up/down)
#define SW  2   // Push-button switch for rotation

// Display dimensions
const int SCREEN_W = 8;
const int SCREEN_H = SCREEN_W * NUM_MODULES;

// Playfield buffer
uint8_t field[SCREEN_H];

// Timing control
unsigned long lastDrop = 0;
unsigned long dropInterval = 500;
unsigned long lastMove = 0;
const unsigned long moveInterval = 200;
const unsigned long refreshInterval = 33;
unsigned long lastRefresh = 0;

// Previous frame buffer
uint8_t prevBuf[NUM_MODULES][SCREEN_W];

// Current falling block
struct Block {
  const int (*shape)[2];
  int len;
  int x, y;
  int rotation;
  char type;
} current;

// Tetris shapes
const int I_SHAPE[2][4][2] = {
  {{0,0},{0,1},{0,2},{0,3}},
  {{-1,1},{0,1},{1,1},{2,1}}
};

const int O_SHAPE[1][4][2] = {
  {{0,0},{1,0},{0,1},{1,1}}
};

const int T_SHAPE[4][4][2] = {
  {{1,0},{0,1},{1,1},{2,1}},
  {{1,0},{1,1},{1,2},{0,1}},
  {{0,1},{1,1},{2,1},{1,2}},
  {{1,0},{1,1},{1,2},{2,1}}
};

const int L_SHAPE[4][4][2] = {
  {{0,0},{0,1},{0,2},{1,2}},
  {{0,0},{1,0},{2,0},{0,1}},
  {{0,0},{1,0},{1,1},{1,2}},
  {{2,0},{0,1},{1,1},{2,1}}
};

const int J_SHAPE[4][4][2] = {
  {{1,0},{1,1},{1,2},{0,2}},
  {{0,0},{0,1},{1,1},{2,1}},
  {{0,0},{1,0},{0,1},{0,2}},
  {{0,0},{1,0},{2,0},{2,1}}
};

const int S_SHAPE[2][4][2] = {
  {{1,0},{2,0},{0,1},{1,1}},
  {{1,0},{1,1},{2,1},{2,2}}
};

const int Z_SHAPE[2][4][2] = {
  {{0,0},{1,0},{1,1},{2,1}},
  {{2,0},{1,1},{2,1},{1,2}}
};

// GAME OVER letter patterns
static const uint8_t PAT_G[8] = {0x3C,0x42,0x40,0x4E,0x42,0x42,0x3C,0x00};
static const uint8_t PAT_A[8] = {0x18,0x24,0x42,0x7E,0x42,0x42,0x42,0x00};
static const uint8_t PAT_M[8] = {0x42,0x66,0x5A,0x5A,0x42,0x42,0x42,0x00};
static const uint8_t PAT_E[8] = {0x7E,0x40,0x5C,0x40,0x40,0x40,0x7E,0x00};
static const uint8_t PAT_O[8] = {0x3C,0x42,0x42,0x42,0x42,0x42,0x3C,0x00};
static const uint8_t PAT_V[8] = {0x42,0x42,0x42,0x42,0x42,0x24,0x18,0x00};
static const uint8_t PAT_R[8] = {0x7C,0x42,0x42,0x7C,0x48,0x44,0x42,0x00};

void clearAll() {
  for (int m = 0; m < NUM_MODULES; m++) {
    lc.clearDisplay(m);
  }
}

bool readButton() {
  if (digitalRead(SW) == LOW) {
    delay(20);

    if (digitalRead(SW) == LOW) {
      while (digitalRead(SW) == LOW);
      return true;
    }
  }

  return false;
}

const uint8_t* letterPattern(char c) {
  switch (c) {
    case 'G': return PAT_G;
    case 'A': return PAT_A;
    case 'M': return PAT_M;
    case 'E': return PAT_E;
    case 'O': return PAT_O;
    case 'V': return PAT_V;
    case 'R': return PAT_R;
    default: return PAT_E;
  }
}

void gameOverSequence() {
  // Flash all LEDs three times
  for (int i = 0; i < 3; i++) {
    clearAll();
    delay(500);

    for (int m = 0; m < NUM_MODULES; m++) {
      for (int r = 0; r < SCREEN_W; r++) {
        lc.setRow(m, r, 0xFF);
      }
    }

    delay(500);
  }

  // Display GAME
  const char* w1 = "GAME";

  for (int seg = 0; seg < 4; seg++) {
    const uint8_t* pat = letterPattern(w1[seg]);
    uint8_t rot[8] = {};

    for (int y = 0; y < 8; y++) {
      for (int x = 0; x < 8; x++) {
        if (pat[y] & (1 << x)) {
          int nx = 7 - y;
          int ny = x;
          rot[ny] |= (1 << nx);
        }
      }
    }

    int module = NUM_MODULES - 1 - seg;

    for (int row = 0; row < 8; row++) {
      lc.setRow(module, row, rot[row]);
    }
  }

  delay(1000);

  // Display OVER
  const char* w2 = "OVER";

  for (int seg = 0; seg < 4; seg++) {
    const uint8_t* pat = letterPattern(w2[seg]);
    uint8_t rot[8] = {};

    for (int y = 0; y < 8; y++) {
      for (int x = 0; x < 8; x++) {
        if (pat[y] & (1 << x)) {
          int nx = 7 - y;
          int ny = x;
          rot[ny] |= (1 << nx);
        }
      }
    }

    int module = NUM_MODULES - 1 - seg;

    for (int row = 0; row < 8; row++) {
      lc.setRow(module, row, rot[row]);
    }
  }

  delay(1000);

  // Wait for button press to restart
  while (digitalRead(SW) != LOW) {
    delay(10);
  }

  while (digitalRead(SW) == LOW) {
    delay(10);
  }
}

void spawnBlock() {
  int r = random(7);
  int sx = SCREEN_W / 2 - 2;

  current.rotation = 0;

  switch (r) {
    case 0:
      current = {I_SHAPE[0], 4, sx, 0, 0, 'I'};
      break;

    case 1:
      current = {O_SHAPE[0], 4, sx, 0, 0, 'O'};
      break;

    case 2:
      current = {T_SHAPE[0], 4, sx, 0, 0, 'T'};
      break;

    case 3:
      current = {L_SHAPE[0], 4, sx, 0, 0, 'L'};
      break;

    case 4:
      current = {J_SHAPE[0], 4, sx, 0, 0, 'J'};
      break;

    case 5:
      current = {S_SHAPE[0], 4, sx, 0, 0, 'S'};
      break;

    case 6:
      current = {Z_SHAPE[0], 4, sx, 0, 0, 'Z'};
      break;
  }
}

void resetGame() {
  memset(field, 0, sizeof(field));
  clearAll();

  for (int m = 0; m < NUM_MODULES; m++) {
    for (int r = 0; r < SCREEN_W; r++) {
      prevBuf[m][r] = 0;
    }
  }

  spawnBlock();

  lastDrop = millis();
  lastRefresh = millis();
}

void writeBuffer() {
  uint8_t buf[NUM_MODULES][SCREEN_W] = {};

  // Draw fixed blocks
  for (int y = 0; y < SCREEN_H; y++) {
    uint8_t row = field[y];

    if (!row) {
      continue;
    }

    int mod = NUM_MODULES - 1 - (y / SCREEN_W);
    int bit = 1 << (7 - (y % SCREEN_W));

    for (int x = 0; x < SCREEN_W; x++) {
      if (row & (1 << x)) {
        buf[mod][x] |= bit;
      }
    }
  }

  // Draw falling block
  for (int i = 0; i < current.len; i++) {
    int xx = current.x + current.shape[i][0];
    int yy = current.y + current.shape[i][1];

    if (xx < 0 || xx >= SCREEN_W || yy < 0 || yy >= SCREEN_H) {
      continue;
    }

    int mod = NUM_MODULES - 1 - (yy / SCREEN_W);
    int bit = 1 << (7 - (yy % SCREEN_W));

    buf[mod][xx] |= bit;
  }

  // Update changed rows only
  for (int m = 0; m < NUM_MODULES; m++) {
    for (int r = 0; r < SCREEN_W; r++) {
      if (buf[m][r] != prevBuf[m][r]) {
        lc.setRow(m, r, buf[m][r]);
        prevBuf[m][r] = buf[m][r];
      }
    }
  }
}

bool checkCollision(int nx, int ny) {
  for (int i = 0; i < current.len; i++) {
    int xx = nx + current.shape[i][0];
    int yy = ny + current.shape[i][1];

    if (xx < 0 || xx >= SCREEN_W || yy >= SCREEN_H) {
      return true;
    }

    if (yy >= 0 && (field[yy] & (1 << xx))) {
      return true;
    }
  }

  return false;
}

void placeBlock() {
  for (int i = 0; i < current.len; i++) {
    int xx = current.x + current.shape[i][0];
    int yy = current.y + current.shape[i][1];

    if (yy >= 0 && yy < SCREEN_H) {
      field[yy] |= (1 << xx);
    }
  }

  // Clear full rows
  for (int y = 0; y < SCREEN_H; y++) {
    if (field[y] == 0xFF) {
      for (int j = y; j > 0; j--) {
        field[j] = field[j - 1];
      }

      field[0] = 0;
    }
  }
}

void rotateBlock() {
  int limit =
    (current.type == 'I' ||
     current.type == 'S' ||
     current.type == 'Z') ? 2 :
    (current.type == 'O' ? 1 : 4);

  int nr = (current.rotation + 1) % limit;

  const int (*ns)[2] = nullptr;

  if (current.type == 'I') {
    ns = I_SHAPE[nr];
  }
  else if (current.type == 'O') {
    ns = O_SHAPE[0];
  }
  else if (current.type == 'T') {
    ns = T_SHAPE[nr];
  }
  else if (current.type == 'L') {
    ns = L_SHAPE[nr];
  }
  else if (current.type == 'J') {
    ns = J_SHAPE[nr];
  }
  else if (current.type == 'S') {
    ns = S_SHAPE[nr];
  }
  else if (current.type == 'Z') {
    ns = Z_SHAPE[nr];
  }

  Block bak = current;

  current.shape = ns;
  current.rotation = nr;

  if (checkCollision(current.x, current.y)) {
    current = bak;
  }
}

void setup() {
  pinMode(SW, INPUT_PULLUP);
  randomSeed(analogRead(0));

  for (int m = 0; m < NUM_MODULES; m++) {
    lc.shutdown(m, false);
    lc.setIntensity(m, 8);
    lc.clearDisplay(m);

    for (int r = 0; r < SCREEN_W; r++) {
      prevBuf[m][r] = 0;
    }
  }

  resetGame();
}

void loop() {
  unsigned long now = millis();

  // Joystick left/right
  int ax = analogRead(VRx);

  if (now - lastMove > moveInterval) {
    if (ax < 400 && !checkCollision(current.x + 1, current.y)) {
      current.x++;
      lastMove = now;
    }
    else if (ax > 600 && !checkCollision(current.x - 1, current.y)) {
      current.x--;
      lastMove = now;
    }
  }

  // Rotate
  if (readButton()) {
    rotateBlock();
  }

  // Joystick down = faster drop
  int ay = analogRead(VRy);

  dropInterval =
    700 - constrain(map(ay, 512, 1023, 0, 690), 0, 690);

  // Automatic drop
  if (now - lastDrop > dropInterval) {
    lastDrop = now;

    if (!checkCollision(current.x, current.y + 1)) {
      current.y++;
    }
    else {
      bool hitTop = false;

      for (int i = 0; i < current.len; i++) {
        if (current.y + current.shape[i][1] == 0) {
          hitTop = true;
          break;
        }
      }

      if (hitTop) {
        gameOverSequence();
        resetGame();
        return;
      }
      else {
        placeBlock();
        spawnBlock();
      }
    }
  }

  // Refresh display
  if (now - lastRefresh >= refreshInterval) {
    writeBuffer();
    lastRefresh = now;
  }
}

Recover password

Create my account

Arduino Project

Arduino Tetris Game with MAX7219 LED Matrix V2

Course Introduction

Required Components

Wiring

Common Connections:

Writing the Code

Arduino Project

Arduino Tetris Game with MAX7219 LED Matrix V2

Course Introduction

Required Components

Wiring

Common Connections:

Writing the Code

Subscribe to our newsletter