Arduino Ideen

Details: Kategorie: Arduino neue Ideen; Erstellt: 10. April 2026; Zugriffe: 22

Wer eine LED-Matrix besitzt, kommt an diesem Meilenstein der Videospielgeschichte nicht vorbei. Pong war 1972 das erste weltweit erfolgreiche Videospiel und hat den Grundstein für alles gelegt, was wir heute zocken. Jetzt holen wir den Atari-Klassiker auf deinen Schreibtisch aber dieses Mal spielst du nicht gegen einen Freund, sondern trittst in einem rasanten Match direkt gegen deinen Arduino an!

Eines von 60 Highlights aus meiner Neopixel-Spielesammlung!

Das Spielprinzip

Das Prinzip ist weltbekannt: Zwei Schläger (Paddles), ein Ball und ein Spielfeld. Du kontrollierst den linken Schläger, der Arduino übernimmt den rechten. Der Ball prallt von den Wänden und Schlägern ab. Verpasst dein Gegner den Ball, bekommst du einen Punkt. Wer zuerst 3 Punkte erreicht, gewinnt das Match.

Gameplay & Features

Auf unserer 8x32 Matrix entfaltet Pong durch das extreme Breitbildformat eine ganz neue Dynamik. Wir haben das Spielprinzip mit ein paar modernen Features aufgewertet, damit es richtig fair und spannend bleibt:

Analoge Steuerung: Du steuerst deinen Schläger butterweich mit der Y-Achse (hoch/runter) deines Joysticks.
Die 6-Treffer-Regel: Der Ball startet gemütlich, wird aber mit jedem Treffer gegen einen Schläger etwas schneller. Nach genau 6 Ballberührungen ist die Höchstgeschwindigkeit erreicht. Das sorgt für einen fairen Einstieg in jeden Punkt und ein extrem schnelles, spannendes Finish.
Intelligenter Spielfluss: Wenn ein Punkt fällt, geht das Spiel nicht sofort hektisch weiter. Der Ball verschwindet, du siehst den aktuellen Score und kannst kurz durchatmen. Erst wenn du den Joystick drückst (Klick-Funktion), wird der Ball wieder freigegeben.
Blinkender Sieger: Wer zuerst 3 Punkte erreicht, hat das Match gewonnen! Um das gebührend zu feiern, fängt der Score des Gewinners auf dem Bildschirm an zu blinken.
Anti-Tunneling-Physik: Selbst bei maximaler Ballgeschwindigkeit erkennt der Code die Kollisionen extrem zuverlässig. Der Ball fliegt nie einfach so durch deinen Schläger hindurch.

Verdrahtung: Arduino, Matrix und Joystickshield

Komponente	Pin am Arduino	Beschreibung
8x32 Matrix	D9	Dateneingang (DIN)
Joystick Y-Achse	A1	Für die Hoch/Runter-Bewegung deines Schlägers
Joystick Klick	D8	Drücken des Sticks: Nächsten Ball nach einem Punkt anfordern
Button A	D2	Manueller Punkte-Reset während des Spiels
Button B	D3	Start / Komplettes Match nach Game Over neu starten
Stromversorgung	5V / GND	Wichtig: Externes Netzteil verwenden!

Pro-Tipp: Pong lebt von flüssigen 50 Bildern pro Sekunde. Der Arduino Uno R4 hat genug Power, um die Ballphysik, die KI und die 256 Pixel gleichzeitig ohne Ruckeln zu berechnen!

Der Arduino Code für das PONG Spiel

// www.kreativekiste.de // 10.04.2026 // Version 1.5
// PONG

#include <FastLED.h>

// --- KONFIGURATION ---
const int DATA_PIN = 9;
const int NUM_LEDS = 256; 
const int BRIGHTNESS_GAME = 5; 
const int BRIGHTNESS_MENU = 10;  

const int WIDTH = 32;
const int HEIGHT = 8;
CRGB leds[NUM_LEDS];

// Pins 
const int PIN_JOY_Y = A1; 
const int PIN_JOY_CLICK = 8; 
const int PIN_BTN_A = 2;     
const int PIN_BTN_B = 3;     

// --- SPIEL-LOGIK ---
enum GameState { START, PLAYING, SHOW_SCORE, GAME_OVER };
GameState currentState = START;

float playerY = 2.5;
float aiY = 2.5;
float ballX = 16.0;
float ballY = 3.5;

float baseSpeed = 0.25; 
const float maxSpeed = 1.2; 
float velX = -baseSpeed; 
float velY = 0.15;

int scorePlayer = 0;
int scoreAI = 0;
const int MAX_SCORE = 3;

// --- MATRIX HILFSFUNKTIONEN ---
int getIndex(int x, int y) {
  if (x < 0 || x >= WIDTH || y < 0 || y >= HEIGHT) return -1;
  if (x % 2 == 0) return (x * HEIGHT) + y;
  else return (x * HEIGHT) + (HEIGHT - 1 - y);
}

void setSafeLed(int x, int y, CRGB color) {
  int idx = getIndex(x, y);
  if (idx != -1) leds[idx] = color;
}

// --- ZAHLEN-DISPLAY ---
void drawDigit(int num, int x, int y, CRGB color) {
  const uint16_t digits[10] = {
    0x7B6F, 0x2492, 0x73E7, 0x73CF, 0x5BC9, 0x79CF, 0x79EF, 0x7249, 0x7BEF, 0x7B8F
  };
  for (int i = 0; i < 15; i++) {
    if (digits[num] & (1 << (14 - i))) {
      setSafeLed(x + (i % 3), y + (i / 3), color);
    }
  }
}

void displayScore(bool blinkWinner = false) {
  FastLED.clear();
  
  bool drawP1 = true;
  bool drawAI = true;

  // Blink-Logik (Zahl alle 300ms an/aus)
  if (blinkWinner) {
    bool blinkState = (millis() / 300) % 2 == 0;
    if (scorePlayer >= MAX_SCORE && !blinkState) drawP1 = false;
    if (scoreAI >= MAX_SCORE && !blinkState) drawAI = false;
  }

  // Spieler Score (Grün) links, AI Score (Rot) rechts
  if (drawP1) drawDigit(scorePlayer, 10, 1, CRGB::Green); 
  if (drawAI) drawDigit(scoreAI, 20, 1, CRGB::Red);       
}

// --- SPIEL-FUNKTIONEN ---

void resetBall(int direction) {
  ballX = 15.5;
  ballY = 3.5;
  velX = (direction > 0) ? baseSpeed : -baseSpeed; 
  velY = random(-20, 20) / 100.0; 
}

void initGame() {
  playerY = 2.5;
  aiY = 2.5;
  scorePlayer = 0;
  scoreAI = 0;
  resetBall(-1);
  currentState = PLAYING;
  FastLED.setBrightness(BRIGHTNESS_GAME);
}

void drawPaddles() {
  int py = round(playerY);
  for(int i=0; i<3; i++) setSafeLed(0, py + i, CRGB::Green);

  int ay = round(aiY);
  for(int i=0; i<3; i++) setSafeLed(31, ay + i, CRGB::Red);
}

void updatePhysics() {
  // Joystick Y-Achse
  int joyVal = analogRead(PIN_JOY_Y);
  if (joyVal > 600 && playerY > 0.0) playerY -= 0.3; 
  if (joyVal < 400 && playerY < 5.0) playerY += 0.3; 

  // Arduino Bewegung
  float aiSpeed = 0.25; 
  float aiCenter = aiY + 1.0;
  if (aiCenter < ballY - 0.5 && aiY < 5.0) aiY += aiSpeed;
  if (aiCenter > ballY + 0.5 && aiY > 0.0) aiY -= aiSpeed;

  ballX += velX;
  ballY += velY;

  // Banden-Kollision
  if (ballY <= 0 || ballY >= 7.0) {
    velY = -velY;
    ballY = constrain(ballY, 0.1, 6.9);
  }

  // Paddle Kollision Spieler
  if (ballX <= 1.0 && velX < 0) { 
    if (ballY >= playerY - 0.5 && ballY <= playerY + 2.5) {
      ballX = 1.0;
      float speedVal = abs(velX);
      speedVal += (0.05 / speedVal); 
      velX = min(speedVal, maxSpeed); 
      velY = (ballY - (playerY + 1.0)) * 0.3; 
    }
  }

  // Paddle Kollision AI
  if (ballX >= 30.0 && velX > 0) {
    if (ballY >= aiY - 0.5 && ballY <= aiY + 2.5) {
      ballX = 30.0;
      float speedVal = abs(velX);
      speedVal += (0.05 / speedVal);
      velX = -min(speedVal, maxSpeed); 
      velY = (ballY - (aiY + 1.0)) * 0.3;
    }
  }

  // Punkteprüfung
  if (ballX < -1.0) {
    scoreAI++;
    if (scoreAI >= MAX_SCORE) currentState = GAME_OVER;
    else currentState = SHOW_SCORE; 
  }
  if (ballX > 32.0) {
    scorePlayer++;
    if (scorePlayer >= MAX_SCORE) currentState = GAME_OVER;
    else currentState = SHOW_SCORE; 
  }

  // Manueller Reset während des Spiels (Button A)
  if (digitalRead(PIN_BTN_A) == LOW) initGame();
}

void loop() {
  switch (currentState) {
    case START:
      FastLED.clear();
      setSafeLed(15, 3, CRGB::White);
      setSafeLed(16, 4, CRGB::White);
      if (digitalRead(PIN_BTN_B) == LOW) initGame();
      break;

    case PLAYING:
      updatePhysics();
      FastLED.clear();
      for(int i=0; i<8; i+=2) setSafeLed(15, i, CRGB(10,10,10));
      drawPaddles();
      setSafeLed(round(ballX), round(ballY), CRGB::Cyan);
      break;

    case SHOW_SCORE:
      displayScore(false); // Normal anzeigen ohne Blinken
      if (digitalRead(PIN_JOY_CLICK) == LOW) {
        resetBall((scorePlayer > scoreAI) ? -1 : 1);
        currentState = PLAYING;
        delay(300); 
      }
      break;

    case GAME_OVER:
      displayScore(true); // Mit Blinken anzeigen
      // Reset Button B
      if (digitalRead(PIN_BTN_B) == LOW) initGame();
      break;
  }
  FastLED.show();
  delay(20); 
}

void setup() {
  FastLED.addLeds<WS2812B, DATA_PIN, GRB>(leds, NUM_LEDS);
  pinMode(PIN_BTN_A, INPUT_PULLUP);
  pinMode(PIN_BTN_B, INPUT_PULLUP);
  pinMode(PIN_JOY_CLICK, INPUT_PULLUP); 
  randomSeed(analogRead(A5));
  FastLED.setBrightness(BRIGHTNESS_MENU);
  FastLED.clear();
  FastLED.show();
}

Kontakt

Ronnie

schwäbischer tüftler und bastler, kraftsportler, neurodivers, 45 Jahre, 1 Frau, 5 Kinder und 1003 Ideen.