Arduino Ideen

Details: Kategorie: Arduino neue Ideen; Erstellt: 12. April 2026; Zugriffe: 8

Tetris ist der absolute König der Puzzlespiele und auf einer 8x32 LED-Matrix fallen die Steine wie von einem Hochhaus, gut das Joystick, die Steine ultimativ schnell beschleunigt. In diesem Projekt zeige ich dir, wie du den Klassiker hochkant auf dein Display bringst, inklusive Highscore-Anzeige und Helligkeitssteuerung ABER Vorsicht, das Spiel ist wird nur auf 8 Pixeln Breite gespielt🕹️.

Eines von 60 Highlights aus meiner Neopixel-Spielesammlung!

Arduino Tetris auf 8x32 NeoPixel, geht das?

Das klassische Tetris-Feld ist normalerweise 10 Pixel breit. Ich nutze hier 8 Spalten, was das Spiel deutlich rasanter macht. Durch die enorme Höhe von 32 Pixeln ist genug Platz für ein fettes Highscore-Display, das sogar dreistellige Ergebnisse (über 99 gelöschte Linien) problemlos anzeigen kann. Nimmst du diese Herausforderung an?

Die Features im Überblick

Vertikaler Modus: Keine Lust auf Umbauen? Stell deine Matrix einfach hochkant auf (Kabelanschluss unten). Der Code erledigt die Rotation für dich!
Hardware-Schutz: Damit deine Augen nicht "durchbrennen", habe ich die auf 60 Limitiert.
Dynamic Speed: Je mehr Linien du löschst, desto schneller fallen die Steine.
Arcade-Steuerung: Präziser Joystick-Drop und Button-Rotation für das echte Spielhallen-Gefühl.

Die Verdrahtung

Für das volle Erlebnis nutzt du am besten ein Joystick-Shield oder baust dir dein eigenes Pult mit vier Tastern.

Komponente	Pin am Arduino	Beschreibung
8x32 Matrix	D9	Dateneingang (DIN)
Joystick X-Achse	A0	Steine nach links/rechts bewegen
Joystick Y-Achse	A1	Soft Drop: Stein schnell nach unten jagen
Button A	D2	Stein rotieren
Button B	D3	Helligkeit erhöhen (nur im Startmenü)
Button C	D4	Start / Reset
Button D	D5	Helligkeit verringern (nur im Startmenü)

Bedienungsanleitung

Start: Nach dem Einschalten siehst du ein gelbes "GO". Hier kannst du mit Button B und D die Helligkeit anpassen.
Loslegen: Drücke Button C, um die Steine fallen zu lassen.
Action: Nutze den Joystick für die Bewegung. Der Soft Drop (Joystick ziehen) ist extra schnell eingestellt, damit du keine Zeit verlierst!
Game Over: Wenn das Feld voll ist, blitzt die Matrix rot auf und zeigt dir deinen Score vertikal untereinander an. Mit Button C landest du wieder im Startmenü.

Der Arduino Code für das Hochhaus Tetris Spiel

// www.kreativekiste.de // 12.04.2026 // Version 1.5
// 8x32 TETRIS 

#include <FastLED.h>

// --- KONFIGURATION ---
const int DATA_PIN = 9;
const int NUM_LEDS = 256; 
int currentBrightness = 20; 
const int MAX_BRIGHTNESS = 60; // Hard-Limit zum Schutz der Hardware

// Einstellbare Fallgeschwindigkeit beim Drücken des Joysticks (in Millisekunden)
// Je kleiner die Zahl, desto schneller rast der Block nach unten!
const int SOFT_DROP_SPEED = 40; 

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

// Pins (Dein Arcade Layout)
const int PIN_JOY_X = A0;    
const int PIN_JOY_Y = A1;    
const int PIN_BTN_A = 2; // Rotieren
const int PIN_BTN_B = 3; // Heller (Startbildschirm)
const int PIN_BTN_C = 4; // Start / Reset während Spiel
const int PIN_BTN_D = 5; // Dunkler (Startbildschirm)

// --- SPIEL-STATUS ---
enum GameState { START, PLAYING, GAMEOVER_RED, GAMEOVER_SCORE };
GameState currentState = START;

// --- TETRIS DATEN ---
uint8_t board[WIDTH][HEIGHT] = {0}; 
int score = 0;

const uint16_t shapes[7][4] = {
  { 0x0F00, 0x2222, 0x00F0, 0x4444 }, // I
  { 0x0660, 0x0660, 0x0660, 0x0660 }, // O
  { 0x0E40, 0x4C40, 0x4E00, 0x4640 }, // T
  { 0x06C0, 0x8C40, 0x06C0, 0x8C40 }, // S
  { 0x0C60, 0x4C80, 0x0C60, 0x4C80 }, // Z
  { 0x0E20, 0x44C0, 0x8E00, 0xC880 }, // J
  { 0x0E80, 0xC440, 0x2E00, 0x88C0 }  // L
};

CRGB pieceColors[8] = {
  CRGB::Black,
  CRGB::Cyan, CRGB::Yellow, CRGB::Purple, CRGB::Green, CRGB::Red, CRGB::Blue, CRGB::Orange
};

int currentPiece, currentRot, currentX, currentY;
unsigned long lastFall = 0;
unsigned long lastMove = 0; // Für Links/Rechts
unsigned long lastSoftDrop = 0; // Separater Timer für den Joystick-Drop
int fallSpeed = 300; 

// --- MATRIX HILFSFUNKTIONEN ---
int getIndex(int logicalX, int logicalY) {
  if (logicalX < 0 || logicalX >= WIDTH || logicalY < 0 || logicalY >= HEIGHT) return -1;
  int physX = logicalY; 
  int physY = logicalX; 
  if (physX % 2 == 0) return (physX * 8) + physY;
  else return (physX * 8) + (7 - physY);
}

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

// --- ZEICHENFUNKTIONEN ---
void drawDigit(int num, int offsetX, int offsetY, 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(offsetX + (i % 3), offsetY - (i / 3), color);
    }
  }
}

void drawGO(int y) {
  for(int i=0; i<3; i++) { setSafeLed(1+i, y+4, CRGB::Yellow); setSafeLed(1+i, y, CRGB::Yellow); }
  setSafeLed(1, y+3, CRGB::Yellow); setSafeLed(1, y+2, CRGB::Yellow); setSafeLed(3, y+2, CRGB::Yellow);
  setSafeLed(1, y+1, CRGB::Yellow); setSafeLed(3, y+1, CRGB::Yellow);
  for(int i=0; i<3; i++) { setSafeLed(5+i, y+4, CRGB::Yellow); setSafeLed(5+i, y, CRGB::Yellow); }
  for(int i=1; i<4; i++) { setSafeLed(5, y+i, CRGB::Yellow); setSafeLed(7, y+i, CRGB::Yellow); }
}

// --- SPIEL LOGIK ---
bool canMove(int cx, int cy, int rot, int piece) {
  uint16_t shape = shapes[piece][rot];
  for(int i=0; i<16; i++) {
    if(shape & (1 << (15 - i))) {
      int px = cx + (i % 4);
      int py = cy - (i / 4); 
      if(px < 0 || px >= WIDTH || py < 0) return false; 
      if(py < HEIGHT && board[px][py] != 0) return false; 
    }
  }
  return true;
}

void spawnPiece() {
  currentPiece = random(0, 7);
  currentRot = 0;
  currentX = 2; 
  currentY = 31; 
  if (!canMove(currentX, currentY, currentRot, currentPiece)) currentState = GAMEOVER_RED;
}

void initGame() {
  memset(board, 0, sizeof(board));
  score = 0;
  fallSpeed = 300;
  currentState = PLAYING;
  spawnPiece();
}

void clearLines() {
  for(int y=0; y<HEIGHT; y++) {
    bool full = true;
    for(int x=0; x<WIDTH; x++) { if(board[x][y] == 0) full = false; }
    if(full) {
      score++; 
      fallSpeed = max(80, fallSpeed - 8); 
      for(int yy=y; yy<HEIGHT-1; yy++) {
        for(int x=0; x<WIDTH; x++) board[x][yy] = board[x][yy+1];
      }
      for(int x=0; x<WIDTH; x++) board[x][HEIGHT-1] = 0;
      y--; 
    }
  }
}

void lockPiece() {
  uint16_t shape = shapes[currentPiece][currentRot];
  for(int i=0; i<16; i++) {
    if(shape & (1 << (15 - i))) {
      int px = currentX + (i % 4);
      int py = currentY - (i / 4);
      if(py >= 0 && py < HEIGHT) board[px][py] = currentPiece + 1; 
    }
  }
  clearLines();
  spawnPiece();
}

// --- UPDATE & DRAW ---
void handleStartScreen() {
  FastLED.clear();
  drawGO(15); 
  FastLED.show();
  if (digitalRead(PIN_BTN_B) == LOW) { currentBrightness = min(MAX_BRIGHTNESS, currentBrightness + 2); FastLED.setBrightness(currentBrightness); delay(30); }
  if (digitalRead(PIN_BTN_D) == LOW) { currentBrightness = max(2, currentBrightness - 2); FastLED.setBrightness(currentBrightness); delay(30); }
  if (digitalRead(PIN_BTN_C) == LOW) { initGame(); delay(200); }
}

void updateGame() {
  if (digitalRead(PIN_BTN_C) == LOW) { initGame(); delay(200); return; }
  
  // Joystick X-Achse (Links/Rechts) mit normalem Cooldown (120ms)
  if (millis() - lastMove > 120) {
    int joyX = analogRead(PIN_JOY_X);
    if (joyX < 400 && canMove(currentX - 1, currentY, currentRot, currentPiece)) { currentX--; lastMove = millis(); }
    if (joyX > 600 && canMove(currentX + 1, currentY, currentRot, currentPiece)) { currentX++; lastMove = millis(); }
  }

  // Joystick Y-Achse (Soft Drop) mit NEUEM, schnellem Timer
  if (millis() - lastSoftDrop > SOFT_DROP_SPEED) {
    int joyY = analogRead(PIN_JOY_Y);
    if (joyY < 400 && canMove(currentX, currentY - 1, currentRot, currentPiece)) { 
      currentY--; 
      lastSoftDrop = millis(); 
      lastFall = millis(); // Setzt den normalen Schwerkraft-Timer zurück
    }
  }

  // Rotieren
  static bool lastBtnA = HIGH;
  bool btnA = (digitalRead(PIN_BTN_A) == LOW);
  if (btnA && !lastBtnA) {
    int nextRot = (currentRot + 1) % 4;
    if (canMove(currentX, currentY, nextRot, currentPiece)) currentRot = nextRot;
  }
  lastBtnA = btnA;
  
  // Normale Schwerkraft
  if (millis() - lastFall > fallSpeed) {
    if (canMove(currentX, currentY - 1, currentRot, currentPiece)) currentY--;
    else lockPiece();
    lastFall = millis();
  }
}

void drawGame() {
  FastLED.clear();
  for(int x=0; x<WIDTH; x++) {
    for(int y=0; y<HEIGHT; y++) { if(board[x][y] > 0) setSafeLed(x, y, pieceColors[board[x][y]]); }
  }
  uint16_t shape = shapes[currentPiece][currentRot];
  for(int i=0; i<16; i++) {
    if(shape & (1 << (15 - i))) setSafeLed(currentX + (i % 4), currentY - (i / 4), pieceColors[currentPiece + 1]);
  }
  FastLED.show();
}

// --- HAUPTPROGRAMM ---
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_BTN_C, INPUT_PULLUP); pinMode(PIN_BTN_D, INPUT_PULLUP);
  randomSeed(analogRead(A5)); 
  FastLED.setBrightness(currentBrightness);
}

void loop() {
  switch (currentState) {
    case START:
      handleStartScreen();
      break;

    case PLAYING:
      updateGame();
      if (currentState == PLAYING) drawGame(); 
      break;

    case GAMEOVER_RED:
      fill_solid(leds, NUM_LEDS, CRGB::Red);
      FastLED.show();
      delay(1000);
      currentState = GAMEOVER_SCORE;
      break;

    case GAMEOVER_SCORE:
      FastLED.clear();
      drawDigit((score / 100) % 10, 2, 25, CRGB::White);
      drawDigit((score / 10) % 10, 2, 17, CRGB::White);
      drawDigit(score % 10, 2, 9, CRGB::White);
      FastLED.show();
      if (digitalRead(PIN_BTN_C) == LOW) { currentState = START; delay(200); }
      break;
  }
  delay(10);
}

Damit du das Spiel perfekt auf dein eigenes Gefühl abstimmen kannst, zeige ich dir hier genau, an welchen Stellschrauben du im Code drehen musst um die Geschwindigkeiten anzupassen.

1. Die Start-Geschwindigkeit
Ganz oben im Bereich der Konfiguration findest du diese Zeile:

const int SOFT_DROP_SPEED = 40; // Joystick-Fallgeschwindigkeit in ms
- Was sie macht: Das ist das Tempo, mit dem die Steine zu Beginn des Spiels ganz von alleine fallen.
- Anpassung: Wenn dir 300 ms noch zu langsam sind, stelle den Wert kleiner (z. B. auf 200). Willst du es gemütlicher, stelle ihn höher (z. B. auf 400).

2. Der "Soft Drop" (Joystick nach unten)
Diese Variable ist neu und steuert nur die Reaktion auf deinen Joystick:

const int SOFT_DROP_SPEED = 40; // Joystick-Fallgeschwindigkeit in ms
- - Was sie macht: Sobald du den Joystick nach unten ziehst, wird die normale Fallgeschwindigkeit ignoriert und dieser Wert genutzt.
  - Anpassung: Mit 40 ms rasen die Blöcke förmlich nach unten. Wenn dir das zu hektisch ist, erhöhe den Wert auf 80 oder 100.

3. Der automatische Speed-Up (Level-System)
Damit es nicht langweilig wird, erhöht der Arduino das Tempo jedes Mal, wenn du eine Reihe löschst. Das passiert in der Funktion clearLines():

fallSpeed = max(80, fallSpeed - 8);
- Was sie macht: * Die -8 bestimmt, um wie viele Millisekunden das Spiel pro gelöschter Reihe schneller wird.
  - Die 80 ist die absolute Geschwindigkeitsgrenze (das "Limit"). Schneller als 80 ms wird das Spiel niemals, damit es noch spielbar bleibt.
  - Anpassung: Wenn das Spiel schneller "anziehen" soll, ändere die - 8 in eine - 15.

ACHTUNG!!!🕹️

Wenn du den Code anpasst, ändere immer nur einen Wert dieser Zeiten und teste kurz, wie sich das Spielgefühl verändert. So findest du am schnellsten dein persönliches "Arcade-Setup"!

Kontakt

Ronnie

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