Bemerkung

Hallo und willkommen in der SunFounder Raspberry Pi & Arduino & ESP32 Enthusiasten-Gemeinschaft auf Facebook! Tauchen Sie tiefer ein in die Welt von Raspberry Pi, Arduino und ESP32 mit anderen Enthusiasten.

Warum beitreten?

• Expertenunterstützung: Lösen Sie Nachverkaufsprobleme und technische Herausforderungen mit Hilfe unserer Gemeinschaft und unseres Teams.

• Lernen & Teilen: Tauschen Sie Tipps und Anleitungen aus, um Ihre Fähigkeiten zu verbessern.

• Exklusive Vorschauen: Erhalten Sie frühzeitigen Zugang zu neuen Produktankündigungen und exklusiven Einblicken.

• Spezialrabatte: Genießen Sie exklusive Rabatte auf unsere neuesten Produkte.

• Festliche Aktionen und Gewinnspiele: Nehmen Sie an Gewinnspielen und Feiertagsaktionen teil.

👉 Sind Sie bereit, mit uns zu erkunden und zu erschaffen? Klicken Sie auf [ hier ] und treten Sie heute bei!

SPIEL - Pong

Dies ist ein einfaches Pong-Spiel, das mit einem OLED-Display und einem Arduino-Board entwickelt wurde. Im Pong-Spiel treten Spieler gegen den Computer an, indem sie einen vertikalen Schläger steuern, um einen hüpfenden Ball zurückzuprallen. Das Ziel ist es, zu verhindern, dass der Ball an der Kante Ihres Schlägers vorbeigeht, sonst erzielt der Gegner Punkte.

Die Spielmechanik kann in folgende Teile unterteilt werden:

1. Ballbewegung - Der Ball bewegt sich in seiner aktuellen Richtung mit einer festgelegten Geschwindigkeit. Jedes Mal, wenn der Ball mit einem Schläger kollidiert, nimmt seine Geschwindigkeit zu, was das Spiel herausfordernder macht.

2. Schlägerbewegung - Wird verwendet, um die Bewegung des Balls zu blockieren, der Schläger kann sich nach oben oder unten bewegen. Spieler steuern ihren eigenen Schläger mit Knöpfen, während der Schläger des Computers automatisch der Position des Balls folgt.

3. Punktzahl - Immer wenn der Ball über den linken oder rechten Rand des Bildschirms hinausgeht, erzielt der entsprechende Spieler oder CPU Punkte.

Benötigte Komponenten

Für dieses Projekt benötigen wir die folgenden Komponenten.

Es ist definitiv praktisch, ein ganzes Kit zu kaufen, hier ist der Link:

Name	ARTIKEL IN DIESEM KIT	LINK
Elite Explorer Kit	300+	Elite Explorer Kit

Sie können sie auch einzeln über die untenstehenden Links kaufen.

KOMPONENTENBESCHREIBUNG	KAUF-LINK
Arduino Uno R4 WiFi	-
Steckbrett	KAUFEN
Jumperkabel	KAUFEN
Widerstand	KAUFEN
OLED-Display-Modul	KAUFEN
Knopf	KAUFEN
Stromversorgungsmodul	-

Verdrahtung

Schaltplan

Code

Bemerkung

• Sie können die Datei 12_pong_oled.ino direkt unter dem Pfad elite-explorer-kit-main\fun_project\12_pong_oled öffnen.

• Oder kopieren Sie diesen Code in die Arduino IDE.

Bemerkung

Um die Bibliothek zu installieren, verwenden Sie den Arduino-Bibliotheksmanager und suchen Sie nach „Adafruit SSD1306“ und „Adafruit GFX“ und installieren Sie diese.

12_pong_oled.ino

/*
  This code creates a basic Pong game using an Arduino Uno, an OLED display, 
  and buttons. Players use the buttons to control a vertical paddle and bounce 
  back a moving ball to prevent it from passing their paddle. Scoring happens 
  when the ball goes off the screen edges.

  Board: Arduino Uno R4 
  Component: OLED Display Module and Button
  Library: https://github.com/adafruit/Adafruit_SSD1306 (Adafruit SSD1306 by Adafruit)  
           https://github.com/adafruit/Adafruit-GFX-Library (Adafruit GFX Library by Adafruit) 
*/


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

#define UP_BUTTON 3
#define DOWN_BUTTON 2

#define SCREEN_WIDTH 128  // OLED display width, in pixels
#define SCREEN_HEIGHT 64  // OLED display height, in pixels

// Declaration for an SSD1306 display connected to I2C (SDA, SCL pins)
#define OLED_RESET 4  // Reset pin # (or -1 if sharing Arduino reset pin)
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

// ball set
const unsigned long BALL_RATE = 16;
int ball_x = 64, ball_y = 32;
int ball_speed = 1; 
int8_t ball_dir_x = 1, ball_dir_y = 1;

//flash rate
unsigned long ball_update;
unsigned long paddle_update;

// paddle set
const unsigned long PADDLE_RATE = 33;
const uint8_t PADDLE_HEIGHT = 16;
const uint8_t CPU_X = 12;
int8_t cpu_y = 16;
const uint8_t PLAYER_X = 115;
int8_t player_y = 16;
int paddle_speed = 3;

// score
uint8_t player_score = 0;
uint8_t cpu_score = 0;


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

  randomSeed(analogRead(A0));
  ball_dir_x = random(0, 2) * 2 - 1;
  ball_dir_y = random(0, 2) * 2 - 1;

  display.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  display.display();

  pinMode(UP_BUTTON, INPUT);
  pinMode(DOWN_BUTTON, INPUT);

  unsigned long start = millis();

  display.clearDisplay();
  drawCourt();

  while (millis() - start < 2000)
    ;

  displayScore();
  display.display();

  ball_update = millis();
  paddle_update = ball_update;
}

void loop() {
  bool update = false;
  unsigned long time = millis();

  static bool up_state = false;
  static bool down_state = false;

  /* check if the button pressed */
  up_state |= (digitalRead(UP_BUTTON) == LOW);
  down_state |= (digitalRead(DOWN_BUTTON) == LOW);

  /* refresh the ball */
  if (time > ball_update) {
    int new_x = ball_x + ball_dir_x * ball_speed;
    int8_t new_y = ball_y + ball_dir_y * ball_speed;

    // Check if it hits the horizontal walls.
    if (new_y <= 0 || new_y >= SCREEN_HEIGHT - 1) {
      ball_dir_y = -ball_dir_y;
      new_y += ball_dir_y + ball_dir_y * ball_speed;
      displayScore();
    }

    // Check if it hits the CPU paddle
    if (crossesCpuPaddle(ball_x, new_x, ball_y)) {
      ball_dir_x = -ball_dir_x;
      new_x = CPU_X + 1;// move the ball's position to the left edge of the paddle
      ball_speed++;     // speeds up
    }

    // Check if it hits the player paddle
    if (crossesPlayerPaddle(ball_x, new_x, ball_y)) {
      ball_dir_x = -ball_dir_x;
      new_x = PLAYER_X - 1; // move the ball's position to the right edge of the paddle
      ball_speed++;         // speeds up
    }

    // Check if it hits the vertical walls
    if (new_x <= 0 || new_x >= SCREEN_WIDTH - 1) {
      if (new_x <= 1) {
        player_score++;
      }
      if (new_x >= 126) {
        cpu_score++;
      }
      /* reset ball */
      displayScore();
      ball_speed = 1;  // reset speed
      new_x = 64; // reset position
      // new_y = 32;
      ball_dir_x = (ball_dir_x > 0) ? -1 : 1;     // reset direction
      ball_dir_y = (random(0, 2) == 0) ? 1 : -1;  // reset direction
    }

    display.drawPixel(ball_x, ball_y, BLACK);
    display.drawPixel(new_x, new_y, WHITE);
    ball_x = new_x;
    ball_y = new_y;

    ball_update += BALL_RATE; // next refresh time
    update = true;
  }

  /* refresh paddles */
  if (time > paddle_update) {
    paddle_update += PADDLE_RATE; // next refresh time

    // CPU paddle
    display.drawFastVLine(CPU_X, cpu_y, PADDLE_HEIGHT, BLACK); //clear paddle
    const uint8_t half_paddle = PADDLE_HEIGHT >> 1;
    if (cpu_y + half_paddle > ball_y) {
      cpu_y -= paddle_speed;
    }
    if (cpu_y + half_paddle < ball_y) {
      cpu_y += paddle_speed;
    }
    // constraint position
    if (cpu_y < 1) cpu_y = 1;
    if (cpu_y + PADDLE_HEIGHT > 63) cpu_y = 63 - PADDLE_HEIGHT;
    display.drawFastVLine(CPU_X, cpu_y, PADDLE_HEIGHT, WHITE); //show paddle

    // Player paddle
    display.drawFastVLine(PLAYER_X, player_y, PADDLE_HEIGHT, BLACK); //clear paddle
    if (up_state) {
      player_y -= paddle_speed;
    }
    if (down_state) {
      player_y += paddle_speed;
    }
    up_state = down_state = false;
    // constraint position
    if (player_y < 1) player_y = 1;
    if (player_y + PADDLE_HEIGHT > 63) player_y = 63 - PADDLE_HEIGHT;
    display.drawFastVLine(PLAYER_X, player_y, PADDLE_HEIGHT, WHITE); //show paddle
    update = true;
  }

  if (update)
    display.display();
}

bool crossesPlayerPaddle(uint8_t old_x, uint8_t new_x, uint8_t ball_y) {
  return old_x < PLAYER_X && new_x >= PLAYER_X && ball_y >= player_y && ball_y <= player_y + PADDLE_HEIGHT;
}

bool crossesCpuPaddle(uint8_t old_x, uint8_t new_x, uint8_t ball_y) {
  return old_x > CPU_X && new_x <= CPU_X && ball_y >= cpu_y && ball_y <= cpu_y + PADDLE_HEIGHT;
}

void drawCourt() {
  display.drawRect(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, WHITE);
}

void displayScore() {
  display.fillRect(SCREEN_WIDTH / 2 - 20, 10, 60, 10, BLACK);// clear
  
  display.setCursor(SCREEN_WIDTH / 2 - 20, 10);  
  display.setTextSize(1);
  display.setTextColor(WHITE);

  display.print(cpu_score);
  display.print(" - ");
  display.print(player_score);
}

Wie funktioniert des?

Die Programmstruktur kann in die folgenden fünf Teile unterteilt werden:

1. Notwendige Bibliotheken importieren - Verwendet zur Steuerung des OLED-Bildschirms und zum Lesen von Tasteneingaben.

2. Konstanten und globale Variablen definieren:

   Definitionen für OLED-Bildschirmbreite und -höhe. Definitionen für Tasten und OLED-Reset-Pins. Position, Geschwindigkeit, Größe und Richtung des Balls und der Schläger. Punktzahlen für Spieler und CPU.

3. Initialisierung:

   Initialisieren Sie die serielle Kommunikation, den OLED-Bildschirm und zeigen Sie die anfängliche Oberfläche an. Stellen Sie Tasten als Eingänge ein und verbinden Sie Pull-up-Widerstände. Zeichnen Sie das Spielfeld.

4. Hauptschleife:

   Lesen Sie die Zustände der Tasten. Bewegen Sie den Ball basierend auf der eingestellten Aktualisierungsrate. Erkennen Sie Kollisionen zwischen dem Ball und den Schlägern oder Wänden und passen Sie die Richtung und Geschwindigkeit des Balls entsprechend an. Aktualisieren Sie den Bildschirm mit Punktzahlen basierend auf Punktereignissen. Aktualisieren Sie die Positionen der Schläger.

5. Zusätzliche Funktionen:

   crossesPlayerPaddle und crossesCpuPaddle - Wird verwendet, um zu erkennen, ob der Ball mit dem Schläger des Spielers oder der CPU kollidiert.

   drawCourt - Zeichnet das Spielfeld auf dem OLED-Bildschirm.

   displayScore - Zeigt die Punktzahlen des Spielers und der CPU auf dem Bildschirm an.