Published October 25, 2020 © GPL3+

Tetris Shield on an Arduino Mega

Nothing like a good old game of Tetris on overpowered hardware.

IntermediateShowcase (no instructions)20 hours4,738

Things used in this project

Hardware components

Arduino Mega 2560

LED Dot Matrix Display, Red

8x8

Texas Instruments Shift Register- Serial to Parallel

Resistor 100 ohm

SparkFun Pushbutton switch 12mm

Resistor 10k ohm

IC & Component Socket, 14 Contacts

Buzzer, Piezo

Digilent 6-pin Header & Gender Changer (5-pack)

PCBWay Custom PCB

Software apps and online services

KiCad

Arduino IDE

Hand tools and fabrication machines

Soldering iron (generic)

Solder Wire, Lead Free

Solder Flux, Soldering

Wire Stripper & Cutter, 18-10 AWG / 0.75-4mm² Capacity Wires

Story

For my final project, I was tasked to create a custom Arduino Mega shield that makes use of 1 shift register (74HC595) and an 8x8 LED matrix. Instead, I decided that I wanted to play Tetris on my Mega, so I added an additional shift register and LED matrix to be able to play a 16x8 version of Tetris!

Me playing for 20 seconds

This project was a very large multi-step project, where I would have to plan, design, and create everything on my own. I did these 4 steps to complete the entire project:

Design the entire schematic
Create the PCB
Solder components on to PCB
Code the Mega to play Tetris on it!

After these 4 steps, I would successfully would have finished the project, and this is what I followed to bring it to fruition.

So, time to create the schematic so that I can figure out where every component belongs! I used an open-source program called KiCad, which is a very beginner friendly and easily accessible program for what I needed to do. I also noted a few things to get this schematic finished:

Use pins 22-53 (the very back pins on the Mega) and select pins on the same port for easy inputs/outputs
Using 2 shift registers instead of one, meaning I would have to utilize 2 Slave Select pins in the SPI (Serial Peripheral Interface), 1 Master Out Slave In, and 1 Clock to control both of them
Create a custom LED Matrix component for the schematic (since it did not exist before!)

So, that is exactly what I did. I extracted a pin header with the exact 2x18 format that the Mega contained, so that I could wire everything to that. I made sure that the parallel outputs were all on Port A, for easy outputting. I did the same for the inputs. Since I figured out I was not going to be using the SPI.h library for this project, all I had to do now was connect all the pins I had left in any configuration to the shift register. This includes the slave select, clock, power, input, etc. Creating the LED Matrix was a piece of cake, just an 8x8 square with pin inputs on them. Then, I connected the 8 outputs of 1 shift register to an 8x8 matrix, and did the same for the other shift register. I placed current-limiting resistors for the LED matrix so the LEDs don't explode, and also connected pull-down resistors to the inputs I would be using to control my Tetris game! I also added a speaker just for fun. The final result is this:

Full Schematic

Next up, it was time to design the PCB! Looking at the schematic, I made sure that each symbol had a corresponding footprint so that each component would be accurately drawn on my PCB. This is when I also created a footprint for my 8x8 LED matrix, by taking down its dimensions, distance from pins, and custom designing the footprint. I generated the netlist from the schematic, so that when I opened the PCB viewer, I would see every component (in blue/yellow) and every connection (in white lines). It looked like this:

Ratsnest

Looking at this again gives me a headache. Anyways, after sorting and tinkering and rearranging and trying to fit everything into a PCB that is 12.5cmx4.5cm (for cost purposes), I finally came to the final design (move right to see less tracks):

1 / 4 • Red And Blue Traces!

It only utilizes 2 layers, with red going left to right and green going up and down. I also made use of multiple vias, because without them, this entire PCB would have been impossible within those dimensions. The yellow represents the final board shape, big yellow circles are where pin inserts would be, and everything that is blue just shows where the footprint would appear in real life. The real 8x8 LED matrix will be extruding a bit out of the PCB, so its silkscreen is not shown. Looking back, I can not believe I got this to work and I am very proud of myself! Yay!

Front and Back using 3D Viewer

After the designing process, it was finally time to get to manufacturing! I exported the gerber file, and used a website called pcbway.com to get it manufactured. When we got it, it looked even better in person than it did on the software. Unfortunately, I only have the soldered version, so here it is:

1 / 2 • Front

The pins on the back fit perfectly onto the Arduino Mega. This is my first time soldering a PCB, and I had a very straight forward time. I completed the shield! Now, all there is to do is to code it. It took a while, but it was just like coding regular Tetris. I put the code in the description, so you can check it out yourself.

One Last Picture!

And there it is! A fully completed and functional Tetris game on the Arduino Mega! This was a lot of fun creating, and it felt more like a personal project for me then a final project for school. I learned a lot from this project, and designing and creating this PCB was amazing. I think this is a very beginner friendly project, and with little knowledge or experience you can make something like this as well!

Code

Mega Tetris Code

#include <avr/wdt.h>
#define   SS1pin   48 // whatever number
#define   SS2pin   46 // whatever number
#define   dataPin     51
#define   clockPin    52

#define   moveLeftPin     35 
#define   moveRightPin    37
#define   rotatePin   33 
#define   fallFasterPin   39
#define   reset  31

#define   OE1              44
#define   OE2              42

#define   BOARD_WIDTH     8
#define   BOARD_HEIGHT    8

byte printBlocks[2][8] = {{
   B00000000, // x = 0
   B00000000, // x = 1
   B00000000, // x = 2
   B00000000, // x = 3 - block[x]; y = 7 + block[y] // bitSet(printBlocks[x], y 
   B00000000,
   B00000000,
   B00000000,
   B00000000,}
  ,{
   B00000000, // x = 0
   B00000000, // x = 1
   B00000000, // x = 2
   B00000000, // x = 3 - block[x]; y = 7 + block[y] // bitSet(printBlocks[x], y 
   B00000000,
   B00000000,
   B00000000,
   B00000000,}};
byte stationaryBlocks[2][8] = {{
   B00000000,
   B00000000, 
   B00000000,
   B00000000,
   B00000000,
   B00000000,
   B00000000,
   B00000000,}
   ,{
   B00000000, // x = 0
   B00000000, // x = 1
   B00000000, // x = 2
   B00000000, // x = 3 - block[x]; y = 7 + block[y] // bitSet(printBlocks[x], y 
   B00000000,
   B00000000,
   B00000000,
   B00000000,}};
byte losingBlocks[8] = {
   B00000000, // x = 0
   B00000000, // x = 1
   B01111100, // x = 2
   B00000100, // x = 3 - block[x]; y = 7 + block[y] // bitSet(printBlocks[x], y 
   B00000100,
   B00000100,
   B00000000,
   B00000000,
  };
unsigned long lastDebounceTime[4] = {0, 0, 0, 0};
unsigned long debounceTime[4] = {0, 0, 0, 0};
boolean currentMatrix = false; //False for top, true for bottom
byte rowNum = 0;
int8_t orientation = 1;
const byte Y = 1; 
const byte X = 0;
// 1, randBlock, 2, which rotation, 3, block placement, 4, coordinates 
int8_t blocks[7][4][4][2] = {   
  {
    //           (default rotation)
    //   o             o o                o
    // o x               x o            x o          o x
    // o                                o              o o
    {{-1, 1}, {-1, 0}, {0, 0}, {0, -1}},
    {{-1, -1}, {0, -1}, {0, 0}, {1, 0}},
    {{1, -1}, {1, 0}, {0, 0}, {0, 1}},
    {{1, 1}, {0, 1}, {0, 0}, {-1, 0}}
  }, {
    //
    // o                 o o           o
    // o x             o x             x o             x o
    //   o                               o           o o
    {{-1, -1}, {-1, 0}, {0, 0}, {0, 1}},
    {{1, -1}, {0, -1}, {0, 0}, {-1, 0}},
    {{1, 1}, {1, 0}, {0, 0}, {0, -1}},
    {{-1, 1}, {0, 1}, {0, 0}, {1, 0}}
  }, {
    //
    //   o             o                o o
    //   x             o x o            x           o x o
    // o o                              o               o
    {{-1, 1}, {0, 1}, {0, 0}, {0, -1}},
    {{-1, -1}, {-1, 0}, {0, 0}, {1, 0}},
    {{1, -1}, {0, -1}, {0, 0}, {0, 1}},
    {{1, 1}, {1, 0}, {0, 0}, {-1, 0}}
  }, {
    //
    // o o                o             o
    //   x            o x o             x           o x o
    //   o                              o o         o
    {{-1, -1}, {0, -1}, {0, 0}, {0, 1}},
    {{1, -1}, {1, 0}, {0, 0}, {-1, 0}},
    {{1, 1}, {0, 1}, {0, 0}, {0, -1}},
    {{-1, 1}, {-1, 0}, {0, 0}, {1, 0}}
  }, {
    //   o                              o
    //   o                              x
    //   x            o x o o           o          o o x o
    //   o                              o
    {{0, -2}, {0, -1}, {0, 0}, {0, 1}},
    {{2, 0}, {1, 0}, {0, 0}, {-1, 0}},
    {{0, 2}, {0, 1}, {0, 0}, {0, -1}},
    {{-2, 0}, {-1, 0}, {0, 0}, {1, 0}}
  }, {
    //
    //   o              o                o
    // o x            o x o              x o         o x o
    //   o                               o             o
    {{0, 1}, {-1, 0}, {0, 0}, {0, -1}},
    {{-1, 0}, {0, -1}, {0, 0}, {1, 0}},
    {{0, -1}, {1, 0}, {0, 0}, {0, 1}},
    {{1, 0}, {0, 1}, {0, 0}, {-1, 0}}
  }, {
    //
    // o o            o o               o o          o o
    // o x            o x               o x          o x
    //
    {{-1, 0}, {-1, -1}, {0, 0}, {0, -1}},
    {{-1, 0}, {-1, -1}, {0, 0}, {0, -1}},
    {{-1, 0}, {-1, -1}, {0, 0}, {0, -1}},
    {{-1, 0}, {-1, -1}, {0, 0}, {0, -1}}
  }
};

int randBlock = 0;

int8_t blockX = 3;
int8_t blockY = 15;

const byte MAX_Y = 15;
const byte MAX_X = 3;
unsigned long timeStart = 0;
unsigned long timeElapsed = 0;

int fallTime = 500;
int losingCounter = 0;

const byte MOVE_RIGHT = 1;
const byte MOVE_LEFT = 2;
const byte ROTATE = 3;
const byte FALL_FASTER = 4;
void setup() {
  // put your setup code here, to run once:
  Serial.begin(9600);
  DDRA = B11111111; // all pins are set as outputs
  pinMode(OE1, OUTPUT);
  pinMode(OE2, OUTPUT);
  digitalWrite(OE1, LOW);
  digitalWrite(OE2, LOW);
  pinMode(dataPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(SS1pin, OUTPUT);
  pinMode(SS2pin, OUTPUT);
  pinMode(moveLeftPin, INPUT);
  pinMode(moveRightPin, INPUT);
  pinMode(rotatePin, INPUT);
  pinMode(reset, INPUT);
  pinMode(fallFasterPin, INPUT);
  pinMode(A0, INPUT);
  randomSeed(analogRead(A0));
  createBlock();
  drawBlock(printBlocks);
}
void loop() {
  // put your main code here, to run repeatedly:
  timeStart = millis(); // check current time
  losingScreen();
  outputColumn();   // draw column
  outputRow();      // draw row
  copyStationary();           // copy printBlocks array into stationary blocks
  sidewardCollision();        // Check for sideward collision and correct for it.
  drawMatrixes();
  if((timeStart - timeElapsed) > fallTime){
    blockY--;                           // increment (move block by 1)
    if(downwardCollision()){                      // if collision
      blockY++;                         // move it back
      copyMatrixes();
      createBlock();                    // create a new block
    }
    timeElapsed = timeStart;    // set the timer once more
  }
  moveLeft();   // move left
  moveRight();  // move right
  rotate();     // rotate
  fallFaster(); // fall faster
  resetGame();     // reboot program
}
//---------------------------------------------------------|
//                      Output Functions                   |
//---------------------------------------------------------|
void outputRow(){
  if(currentMatrix)
    shiftData(SS2pin, round(pow(2, rowNum)));
  else if(!currentMatrix)
    shiftData(SS1pin, round(pow(2, rowNum)));
  rowNum++;
  if (rowNum > sizeof(printBlocks[0])){
    currentMatrix=!currentMatrix;
    rowNum = 0;
  }
}
void outputColumn(){
  if(currentMatrix)
    PORTA = ~printBlocks[0][rowNum];
  else if (!currentMatrix)
    PORTA = ~printBlocks[1][rowNum];
}
void shiftData(byte storage, byte data){
  digitalWrite(storage, LOW);
  shiftOut(dataPin, clockPin, LSBFIRST, data);
  digitalWrite(storage, HIGH);
  digitalWrite(storage, LOW);
  shiftOut(dataPin, clockPin, LSBFIRST, 0);
  digitalWrite(storage, HIGH);
}
//---------------------------------------------------------|
//                      Player Functions                   |
//---------------------------------------------------------|
void checkDebounce(byte dir){
  debounceTime[dir] = millis();
  if (debounceTime[dir] - lastDebounceTime[dir] > 200){
    if(dir == MOVE_LEFT)
      blockX++;
    else if(dir == MOVE_RIGHT)
      blockX--;
    else if(dir == ROTATE){
      orientation--;
      if (orientation == -1)
        orientation = 3;
    }
    else if(dir == FALL_FASTER){
      blockY--;
    }
    lastDebounceTime[dir] = debounceTime[dir];
    outputColumn();   // draw column
    outputRow();      // draw row
  }
} // checkDebounce function end 
//--------------------------------------------------------
void moveLeft(){
  if (digitalRead(moveLeftPin))
    checkDebounce(MOVE_LEFT);
}
void moveRight(){
  if (digitalRead(moveRightPin))
    checkDebounce(MOVE_RIGHT);
}
void rotate(){
  if(digitalRead(rotatePin)){
    checkDebounce(ROTATE);
  }
}
void fallFaster(){
  if(digitalRead(fallFasterPin))
    checkDebounce(FALL_FASTER);
}

void resetGame() {
  if(digitalRead(reset)){
    wdt_disable();
    wdt_enable(WDTO_15MS);
    while (1) {}
  }
}
//---------------------------------------------------------|
//                      Block Functions                    |
//---------------------------------------------------------|
void drawMatrixes(){
  drawBlock(printBlocks);     // draw the block to print blocks
  clearBlocks(stationaryBlocks);
}
void copyMatrixes(){
  drawBlock(stationaryBlocks);
//  for(int p = 0; p < 4; p++){
//    if(blockY+ blocks[randBlock][orientation][p][Y] > 7)
//      drawBlock(stationaryBlocks[0]);      // draw current block to the stationaryBlock array
//    else 
//      drawBlock(stationaryBlocks[1]);
//  }
}
void drawBlock(byte copyBlocks[2][8]){
  for(int p = 0; p < 4; p++){
    if(blockY+ blocks[randBlock][orientation][p][Y] > 7)
      bitSet(copyBlocks[0][blockX- blocks[randBlock][orientation][p][X]], blockY-8 + blocks[randBlock][orientation][p][Y]);
    else
      bitSet(copyBlocks[1][blockX- blocks[randBlock][orientation][p][X]], blockY + blocks[randBlock][orientation][p][Y]);
  }
}
void copyStationary(){
  // destination, source, numbytes
  for(int i = 0; i < 2; i++)
    memcpy(printBlocks[i], stationaryBlocks[i], 8);
 
}
void createBlock(){
  randBlock = random(7);
  orientation = 1;
  blockX = MAX_X;
  blockY = MAX_Y;
}
//--------------------------------------------------------
void clearBlocks(byte copyBlocks[2][8]){
  byte checkFullRow = 0;
  for(int q = 0; q < 2; q++){
    for(int i = 0; i < 7; i++){
      for(int j = 0; j < sizeof(copyBlocks[q]); j++){
        checkFullRow += bitRead(copyBlocks[q][j], i); 
      }
      if (checkFullRow == 8){
        checkFullRow = 0;
        for(int n = 0; n < 7; n++){
          bitWrite(copyBlocks[q][n], i, 0);
        }
        for(int j = i+1; j < 7; j++){
          for(int n = 0; n < sizeof(copyBlocks[q]); n++){
            bitWrite(copyBlocks[q][n], j-1, bitRead(copyBlocks[q][n], j));
            bitWrite(copyBlocks[q][n], j, 0);
          }
        }
      }
      checkFullRow = 0;
    } 
    checkFullRow = 0;
  }
}
//---------------------------------------------------------|
//                      Collision Functions                |
//---------------------------------------------------------|
boolean downwardCollision(){
  for(int p = 0; p < 4; p++){
    if(blockY + blocks[randBlock][orientation][p][Y] < 0)
      return true;
    if (blockY+ blocks[randBlock][orientation][p][Y] > 7){
      if(bitRead(stationaryBlocks[0][blockX- blocks[randBlock][orientation][p][X]], blockY-8 + blocks[randBlock][orientation][p][Y]))
        return true;
    } else{
      if(bitRead(stationaryBlocks[1][blockX- blocks[randBlock][orientation][p][X]], blockY + blocks[randBlock][orientation][p][Y]))
        return true;
    }
  }
  return false;
} // downwardCollision function end
//----------------------------------------------------------
void sidewardCollision(){
  for(int p = 0; p < 4; p++){
    // Checking for collision with walls
    if((blockX - blocks[randBlock][orientation][p][X]) >7){
      blockX--;
    }
    else if ((blockX - blocks[randBlock][orientation][p][X]) < 0){
      blockX++;    
    }
    // Checking for collision with other blocks
    if(blockY+ blocks[randBlock][orientation][p][Y] > 7){
      if (bitRead(stationaryBlocks[0][blockX-blocks[randBlock][orientation][p][X]], blockY-8 + blocks[randBlock][orientation][p][Y])){
        blockX--;
      }
      if (bitRead(stationaryBlocks[0][blockX-blocks[randBlock][orientation][p][X]], blockY-8 + blocks[randBlock][orientation][p][Y])){
        blockX+=2;
      }
    } else{
      if (bitRead(stationaryBlocks[1][blockX-blocks[randBlock][orientation][p][X]], blockY + blocks[randBlock][orientation][p][Y])){
        blockX--;
      }
      if (bitRead(stationaryBlocks[1][blockX-blocks[randBlock][orientation][p][X]], blockY + blocks[randBlock][orientation][p][Y])){
        blockX+=2;
      }
    }
  }
} // sidewardsCollision function end
//----------------------------------------------------------
void losingScreen(){
  for(int i = 0; i < 7; i++){
    losingCounter += bitRead(printBlocks[0][i], 7);
  } if (losingCounter > 6){
    memcpy(stationaryBlocks[0], losingBlocks, 8);
    memcpy(stationaryBlocks[1], losingBlocks, 8);
  } else{
    losingCounter = 0;
  }
  
}