Learn Wiring and Coding of 5-Way Navigation Button in 3 Minutes

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

// OLED Screen Configuration (ZJY_M2420: 128x32)
#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 32
#define OLED_RESET -1
#define SCREEN_ADDRESS 0x3C // Change to 0x3D if not displaying
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

// 5-Way Key Pin Definitions
#define KEY_UP     2
#define KEY_DOWN   3
#define KEY_LEFT   4
#define KEY_RIGHT  5
#define KEY_SET    7
#define KEY_RST    8

// Game Constants (Optimized for Memory & Slow Speed)
#define GRID_SIZE 4
#define GRID_WIDTH (SCREEN_WIDTH / GRID_SIZE)
#define GRID_HEIGHT (SCREEN_HEIGHT / GRID_SIZE)
#define GAME_SPEED_INIT 500  // Slow initial speed (500ms, bigger = slower)
#define MAX_SNAKE_LENGTH 30
#define MAX_SPEED 200        // Slow max speed (200ms, not too fast)
#define SPEED_UP_STEP 2      // Small speed up step (slow difficulty increase)

// Game State Enumeration
enum GameState {
  GAME_READY,
  GAME_PLAYING,
  GAME_PAUSED,
  GAME_OVER
};
GameState currentState = GAME_READY;

// Snake Direction Enumeration
enum Direction {
  DIR_UP,
  DIR_DOWN,
  DIR_LEFT,
  DIR_RIGHT
};

// Snake Structure (Optimized)
struct SnakeSegment {
  uint8_t x;
  uint8_t y;
};
SnakeSegment snake[MAX_SNAKE_LENGTH];
uint8_t snakeLength = 3;
Direction currentDir = DIR_RIGHT;
Direction nextDir = DIR_RIGHT;

// Food Variables
uint8_t foodX, foodY;
uint8_t score = 0;
unsigned long gameTimer = 0;
uint16_t gameSpeed = GAME_SPEED_INIT;

// Key Debounce Variables
unsigned long lastKeyCheck = 0;
const unsigned long debounceDelay = 200;

// Initialize Game
void setup() {
  // Disable Serial Debug (Save memory)
  // Serial.begin(9600);

  // Initialize Key Pins
  pinMode(KEY_UP, INPUT_PULLUP);
  pinMode(KEY_DOWN, INPUT_PULLUP);
  pinMode(KEY_LEFT, INPUT_PULLUP);
  pinMode(KEY_RIGHT, INPUT_PULLUP);
  pinMode(KEY_SET, INPUT_PULLUP);
  pinMode(KEY_RST, INPUT_PULLUP);

  // Initialize OLED
  if (!display.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS)) {
    for (;;);
  }

  // Global smallest font
  display.setTextColor(SSD1306_WHITE);
  display.setTextSize(1);
  drawWelcomeScreen();
}

// Main Game Loop
void loop() {
  // Key Scan
  char pressedKey = '\0';
  if (millis() - lastKeyCheck >= debounceDelay) {
    pressedKey = scanKeys();
    lastKeyCheck = millis();
  }

  // Handle Game States
  switch (currentState) {
    case GAME_READY:
      handleReadyState(pressedKey);
      break;
    case GAME_PLAYING:
      handlePlayingState(pressedKey);
      break;
    case GAME_PAUSED:
      handlePausedState(pressedKey);
      break;
    case GAME_OVER:
      handleGameOverState(pressedKey);
      break;
  }
}

// Scan Pressed Key
char scanKeys() {
  if (digitalRead(KEY_UP) == LOW) return 'U';
  if (digitalRead(KEY_DOWN) == LOW) return 'D';
  if (digitalRead(KEY_LEFT) == LOW) return 'L';
  if (digitalRead(KEY_RIGHT) == LOW) return 'R';
  if (digitalRead(KEY_SET) == LOW) return 'S';
  if (digitalRead(KEY_RST) == LOW) return 'T';
  return '\0';
}

// Handle Ready State
void handleReadyState(char pressedKey) {
  if (pressedKey == 'S') {
    initGame();
    currentState = GAME_PLAYING;
    gameTimer = millis();
  }
}

// Handle Playing State
void handlePlayingState(char pressedKey) {
  handleKeyInput(pressedKey);

  if (millis() - gameTimer >= gameSpeed) {
    updateDirection();
    moveSnake();

    if (checkCollision()) {
      currentState = GAME_OVER;
      drawGameOverScreen();
      return;
    }

    if (snake[0].x == foodX && snake[0].y == foodY) {
      eatFood();
    }

    drawGameScreen();
    gameTimer = millis();
  }
}

// Handle Paused State
void handlePausedState(char pressedKey) {
  if (pressedKey == 'S') {
    currentState = GAME_PLAYING;
    gameTimer = millis();
    drawGameScreen();
  } else if (pressedKey == 'T') {
    currentState = GAME_READY;
    drawWelcomeScreen();
  }
}

// Handle Game Over State
void handleGameOverState(char pressedKey) {
  if (pressedKey == 'T') {
    currentState = GAME_READY;
    drawWelcomeScreen();
  }
}

// Initialize Game Parameters
void initGame() {
  // Reset Snake
  snakeLength = 3;
  currentDir = DIR_RIGHT;
  nextDir = DIR_RIGHT;
  snake[0].x = 5; snake[0].y = GRID_HEIGHT / 2;
  snake[1].x = 4; snake[1].y = GRID_HEIGHT / 2;
  snake[2].x = 3; snake[2].y = GRID_HEIGHT / 2;

  // Spawn Food
  spawnFood();

  // Reset Score and Slow Speed
  score = 0;
  gameSpeed = GAME_SPEED_INIT;

  drawGameScreen();
}

// Handle Key Input
void handleKeyInput(char pressedKey) {
  if (pressedKey == 'S') {
    if (currentState == GAME_PLAYING) {
      currentState = GAME_PAUSED;
      drawPausedScreen();
    }
    return;
  }

  // Direction Control
  if (pressedKey == 'U' && currentDir != DIR_DOWN) {
    nextDir = DIR_UP;
  } else if (pressedKey == 'D' && currentDir != DIR_UP) {
    nextDir = DIR_DOWN;
  } else if (pressedKey == 'L' && currentDir != DIR_RIGHT) {
    nextDir = DIR_LEFT;
  } else if (pressedKey == 'R' && currentDir != DIR_LEFT) {
    nextDir = DIR_RIGHT;
  }
}

// Update Direction
void updateDirection() {
  currentDir = nextDir;
}

// Move Snake
void moveSnake() {
  uint8_t prevX = snake[0].x;
  uint8_t prevY = snake[0].y;

  // Update Head
  switch (currentDir) {
    case DIR_UP:
      snake[0].y--;
      break;
    case DIR_DOWN:
      snake[0].y++;
      break;
    case DIR_LEFT:
      snake[0].x--;
      break;
    case DIR_RIGHT:
      snake[0].x++;
      break;
  }

  // Update Body
  for (uint8_t i = 1; i < snakeLength; i++) {
    uint8_t tempX = snake[i].x;
    uint8_t tempY = snake[i].y;
    snake[i].x = prevX;
    snake[i].y = prevY;
    prevX = tempX;
    prevY = tempY;
  }
}

// Check Collision
bool checkCollision() {
  // Wall Collision
  if (snake[0].x >= GRID_WIDTH || snake[0].y >= GRID_HEIGHT) {
    return true;
  }

  // Self Collision
  for (uint8_t i = 1; i < snakeLength; i++) {
    if (snake[0].x == snake[i].x && snake[0].y == snake[i].y) {
      return true;
    }
  }

  return false;
}

// Spawn Food
void spawnFood() {
  bool foodOnSnake;
  do {
    foodOnSnake = false;
    foodX = random(GRID_WIDTH);
    foodY = random(GRID_HEIGHT);

    for (uint8_t i = 0; i < snakeLength; i++) {
      if (snake[i].x == foodX && snake[i].y == foodY) {
        foodOnSnake = true;
        break;
      }
    }
  } while (foodOnSnake);
}

// Eat Food (Slow Speed Up)
void eatFood() {
  // Grow Snake
  if (snakeLength < MAX_SNAKE_LENGTH) {
    snake[snakeLength].x = snake[snakeLength - 1].x;
    snake[snakeLength].y = snake[snakeLength - 1].y;
    snakeLength++;
  }

  // Update Score
  score += 10;

  // Slow Speed Up (Only if faster than max slow speed)
  if (gameSpeed > MAX_SPEED) {
    gameSpeed -= SPEED_UP_STEP;
  }

  spawnFood();
}

// Draw Welcome Screen
void drawWelcomeScreen() {
  display.clearDisplay();

  display.setCursor(40, 8);
  display.print(F("Snake Game"));

  display.setCursor(15, 18);
  display.print(F("SET: Start/Pause"));
  display.setCursor(15, 28);
  display.print(F("RST: Reset Game"));

  display.display();
}

// Draw Game Screen
void drawGameScreen() {
  display.clearDisplay();

  // Draw Snake
  for (uint8_t i = 0; i < snakeLength; i++) {
    display.fillRect(snake[i].x * GRID_SIZE, snake[i].y * GRID_SIZE,
                     GRID_SIZE - 1, GRID_SIZE - 1, SSD1306_WHITE);
  }

  // Draw Food
  display.fillRect(foodX * GRID_SIZE, foodY * GRID_SIZE,
                   GRID_SIZE - 1, GRID_SIZE - 1, SSD1306_WHITE);

  // Draw Score
  display.setCursor(0, 0);
  display.print(F("Score: "));
  display.print(score);

  display.display();
}

// Draw Paused Screen
void drawPausedScreen() {
  display.clearDisplay();

  display.setCursor(50, 12);
  display.print(F("PAUSED"));

  display.setCursor(35, 22);
  display.print(F("SET to resume"));

  display.display();
}

// Draw Game Over Screen
void drawGameOverScreen() {
  display.clearDisplay();

  display.setCursor(45, 10);
  display.print(F("GAME OVER"));

  display.setCursor(35, 20);
  display.print(F("Final Score: "));
  display.print(score);

  display.display();
}