Arduino Ideen

Details: Kategorie: Arduino neue Ideen; Erstellt: 07. April 2026; Zugriffe: 26

Hast du auch noch diese nostalgischen Erinnerungen an die alten Arcade-Automaten? Wir holen uns dieses Feeling heute direkt auf den Schreibtisch! In diesem Projekt kannst du eine voll spielbares Space Invaders auf einer 16x16 NeoPixel-Matte nachbauen. Mit einem Arduino, einem Joystick-Shield und ein bisschen Code verwandelst du einfache LEDs in ein spannendes Weltraum-Abenteuer.

Das Projekt: Was steckt dahinter?

Die Basis bildet eine WS2812B LED-Matrix. Da diese im Zick-Zack (U-Form) verkabelt ist, musst du den Arduino auch so progrogramieren, wie er die Koordinaten richtig berechnet, aber keine Sorge, das übernimmt der fertiger Code für dich. Das Spiel bietet alles, was man braucht: Einen animierten Startbildschirm mit einem flackernden Raumschiff, ein cleveres Power-Up-System und Gegner, die mit der Zeit immer schneller werden.

Die Verdrahtung: Schnell und einfach

Das Beste an diesem Setup ist die Einfachheit. Das Joystick-Shield musst du nur einstecken und die Pixel benötigen nur einen Datenpin und GND vom Arduino.

Arduino & Joystick-Shield: Einfach zusammenstecken. Das Shield nutzt Pin A0 und A1 für den Stick sowie die digitalen Pins 2, 3 und 4 für die Buttons.
NeoPixel Matrix: * DIN (Data In) kommt an Pin 9 des Arduinos.
- 5V & GND verbindest du am direkt mit einem externen 5V Netzteil (mindestens 2A, besser 5A).
- Ganz wichtig: Verbinde den GND des Netzteils auch mit dem GND des Arduinos, damit die Signale sauber ankommen!

Die Gameplay-Einstellungen

Ich habe das Spiel so ausbalanciert, dass es fordernd ist, aber fair bleibt. Du kannst das Gameplay aber jederzeit ändern, alle Wichtigen Einstellungen sind mit // beschrieben. Hier sind die Eckdaten deines Setups:

Helligkeit: Im Menü leuchten die LEDs dezent mit Stufe 35, im Spiel geben sie mit 55 ordentlich Gas.
Steuerung: Die Joystick-Empfindlichkeit steht auf 7, was dir präzise Bewegungen erlaubt.
Gegner-Flotte: Es starten 5 Schiffe gleichzeitig. Sie beginnen mit einer Geschwindigkeit von 900ms pro Schritt. Aber Vorsicht: Bei jedem Schritt nach unten werden sie 5ms schneller!
Power-Ups: * Blau (Permanent): Verbessert deine Latenz dauerhaft. Sammelst du 5 davon, feuerst du aus zwei Rohren, ab 10 sogar aus drei!
- Rot (Temporär): Aktiviert für 7 Sekunden den Turbo-Modus mit extrem hoher Schussrate.

Der Code des Spieles (Version 2.9)

Hier findest du den aktuellen Stand meines Codes. Er enthält bereits den animierten Startbildschirm, auf dem dein Schiff gemütlich hin- und herfliegt und seine Triebwerke zündet, während du auf den Start wartest.

// www.kreativekiste.de // 07.04.2026 // Version 2.9
// FINAL POLISH EDITION: Animated Start Screen

#include <FastLED.h>

// --- KONFIGURATION ---
const int DATA_PIN = 9;
const int NUM_LEDS = 256; 
const int BRIGHTNESS_GAME = 55; // Helligkeit im Spiel
const int BRIGHTNESS_MENU = 35; // Helligkeit im Menü 

//Joystick-Geschwindigkeit einstellen (0-10)
const int JOYSTICK_SENSITIVITY = 7; 

// Pins
const int PIN_JOY_X = A0; //Stick
const int PIN_JOY_Y = A1; // Stick
const int PIN_BTN_A = 2; // Feuer
const int PIN_BTN_B = 3; // Start
const int PIN_BTN_C = 4; // Reset

const int WIDTH = 16;
const int HEIGHT = 16;
CRGB leds[NUM_LEDS];

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

// --- GEGNER EINSTELLUNGEN (BALANCIERT) ---
const int MAX_ENEMIES = 5; // Schiffe gleichzeitig
unsigned long lastEnemyMove = 0;
int enemySpeed = 900;      // Startgeschwindigkeit

// --- SPIELER ---
int playerX = 7;
int playerY = 15;
const int PLAYER_Y_MIN = 12;
const int PLAYER_Y_MAX = 15;
unsigned long lastPlayerMove = 0;
int playerMoveDelay; 

// --- SCHUSS SYSTEM ---
unsigned long lastShotTime = 0;
int baseShotInterval = 600;      
const int MIN_BASE_INTERVAL = 250; 
const int TEMP_SHOT_INTERVAL = 150; 
unsigned long tempPuEndTime = 0;
bool tempPowerUpActive = false;
bool lastButtonState = HIGH; 

// Drei Slots für Schüsse ( Triple-Shot Upgrade)
int bulletX1 = -1, bulletY1 = -1; bool bulletActive1 = false;
int bulletX2 = -1, bulletY2 = -1; bool bulletActive2 = false;
int bulletX3 = -1, bulletY3 = -1; bool bulletActive3 = false;

// --- POWER-UP SYSTEM ---
enum PowerUpType { NONE, PERMANENT, TEMPORARY };
struct PowerUp {
  int x, y;
  PowerUpType type;
  bool active;
  unsigned long lastMove;
};
PowerUp drop;
const int DROP_SPEED = 180; // Fallgeschwindigkeit

// --- GEGNER STRUKTUR ---
struct EnemyShip {
  int x, y, w, h;
  bool active;
  bool shape[4][4];
};
EnemyShip enemies[MAX_ENEMIES];

// --- STATISTIK ---
long score = 0;
long killedPixels = 0;
long escapedPixels = 0;
long totalShots = 0; 
int blueCount = 0; 

// --- FUNKTIONEN ---
// Mapping für U-Form Matrix
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);
}

// LED sicher setzen (verhindert Abstürze)
void setSafeLed(int x, int y, CRGB color) {
  int idx = getIndex(x, y);
  if (idx != -1) leds[idx] = color;
}

// Neuen Gegner erzeugen
void spawnEnemy(int id) {
  enemies[id].w = random(1, 5);
  enemies[id].h = random(1, 5);
  enemies[id].x = random(0, WIDTH - enemies[id].w + 1);
  enemies[id].y = -random(2, 10); 
  enemies[id].active = true;
  for (int i = 0; i < 4; i++) {
    for (int j = 0; j < 4; j++) {
      enemies[id].shape[i][j] = (i < enemies[id].w && j < enemies[id].h);
    }
  }
}

// Kompletter Reset
void resetGame() {
  playerX = 7; playerY = PLAYER_Y_MAX;
  score = 0; killedPixels = 0; escapedPixels = 0; totalShots = 0; blueCount = 0;
  enemySpeed = 1000; baseShotInterval = 600; 
  bulletActive1 = false; bulletActive2 = false; bulletActive3 = false;
  tempPowerUpActive = false; drop.active = false; lastButtonState = HIGH;
  for (int i = 0; i < MAX_ENEMIES; i++) spawnEnemy(i);
  currentState = PLAYING;
  Serial.println(F("--- MISSION GESTARTET ---"));
}

void setup() {
  Serial.begin(9600);
  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);
  // Joystick Geschwindigkeit berechnen
  playerMoveDelay = map(JOYSTICK_SENSITIVITY, 0, 10, 200, 20); 
  randomSeed(analogRead(A5));
  FastLED.clear();
  FastLED.show();
}

void loop() {
  // Globaler Reset Button (C)
  if (digitalRead(PIN_BTN_C) == LOW) currentState = START;

  switch (currentState) {
    case START:
      FastLED.setBrightness(BRIGHTNESS_MENU);
      animateStartScreen(); // JETZT ANIMIERT
      if (digitalRead(PIN_BTN_B) == LOW) resetGame();
      break;

    case PLAYING:
      FastLED.setBrightness(BRIGHTNESS_GAME);
      handleInput();
      updateGame();
      drawGame();
      break;

    case GAME_OVER:
      FastLED.setBrightness(BRIGHTNESS_MENU);
      drawGameOver();
      if (digitalRead(PIN_BTN_B) == LOW) resetGame();
      break;
  }
  FastLED.show();
  delay(10); 
}

// --- EINGABE-BEHANDLUNG (WÄHREND DES SPIELS) ---
void handleInput() {
  // Joystick X (Links/Rechts)
  if (millis() - lastPlayerMove > playerMoveDelay) {
    int valX = analogRead(PIN_JOY_X);
    if (valX < 300 && playerX > 0) { playerX--; lastPlayerMove = millis(); }
    if (valX > 700 && playerX < WIDTH - 1) { playerX++; lastPlayerMove = millis(); }
  }
  
  // Joystick Y (Boost nach vorne)
  int valY = analogRead(PIN_JOY_Y);
  playerY = (valY < 300) ? PLAYER_Y_MIN : PLAYER_Y_MAX;

  // Schießen (Einzelschuss)
  bool currentButtonState = digitalRead(PIN_BTN_A);
  int currentInterval = tempPowerUpActive ? TEMP_SHOT_INTERVAL : baseShotInterval;
  
  if (currentButtonState == LOW && lastButtonState == HIGH) {
    // Nur schießen wenn kein Slot aktiv ist und Latenz vorbei ist
    if (!bulletActive1 && !bulletActive2 && !bulletActive3 && (millis() - lastShotTime > currentInterval)) {
      
      // Upgrade Logik
      if (blueCount >= 10) { 
        // TRIPLE (Flügel + Mitte)
        bulletActive1 = true; bulletX1 = playerX - 1; bulletY1 = playerY - 1;
        bulletActive2 = true; bulletX2 = playerX + 1; bulletY2 = playerY - 1;
        bulletActive3 = true; bulletX3 = playerX;     bulletY3 = playerY - 2;
        totalShots += 3;
      } 
      else if (blueCount >= 5) { 
        // DOUBLE (Flügel)
        bulletActive1 = true; bulletX1 = playerX - 1; bulletY1 = playerY - 1;
        bulletActive2 = true; bulletX2 = playerX + 1; bulletY2 = playerY - 1;
        totalShots += 2;
      } 
      else { 
        // SINGLE (Spitze)
        bulletActive1 = true; bulletX1 = playerX; bulletY1 = playerY - 2;
        totalShots++;
      }
      lastShotTime = millis();
    }
  }
  lastButtonState = currentButtonState;
}

// Hilfsfunktion für Schuss-Kollision
void checkCollision(int &bx, int &by, bool &active) {
  if (!active) return;
  by--;
  if (by < 0) { active = false; return; }
  for (int i = 0; i < MAX_ENEMIES; i++) {
    if (!enemies[i].active) continue;
    if (bx >= enemies[i].x && bx < enemies[i].x + enemies[i].w &&
        by >= enemies[i].y && by < enemies[i].y + enemies[i].h) {
      int lx = bx - enemies[i].x; int ly = by - enemies[i].y;
      if (enemies[i].shape[lx][ly]) {
        enemies[i].shape[lx][ly] = false; active = false;
        score += 10; killedPixels++;
        // Power-Up Drop Chance
        if (!drop.active && random(0, 100) < 25) {
          drop.x = bx; drop.y = by; drop.active = true; drop.lastMove = millis();
          drop.type = (random(0, 10) < 8) ? PERMANENT : TEMPORARY;
        }
        break;
      }
    }
  }
}

// --- SPIEL-LOGIK UPDATE ---
void updateGame() {
  if (tempPowerUpActive && millis() > tempPuEndTime) tempPowerUpActive = false;
  
  // Alle 3 Schuss-Slots prüfen
  checkCollision(bulletX1, bulletY1, bulletActive1);
  checkCollision(bulletX2, bulletY2, bulletActive2);
  checkCollision(bulletX3, bulletY3, bulletActive3);

  // Power-Up bewegen und einsammeln
  if (drop.active) {
    if (millis() - drop.lastMove > DROP_SPEED) {
      drop.y++; drop.lastMove = millis();
      if (drop.y >= HEIGHT) drop.active = false;
    }
    // Kollision mit Schiff (4 Pixel Form berücksichtigen)
    if (drop.active && ((drop.y == playerY && abs(drop.x - playerX) <= 1) || (drop.y == playerY-1 && drop.x == playerX))) {
      if (drop.type == PERMANENT) {
        blueCount++; if (baseShotInterval > MIN_BASE_INTERVAL) baseShotInterval -= 40;
        Serial.print(F("Dauer-Boost! Latenz: ")); Serial.println(baseShotInterval);
      } else {
        tempPowerUpActive = true; tempPuEndTime = millis() + 7000; 
        Serial.println(F("Turbo-Boost!"));
      }
      drop.active = false;
    }
  }

  // Gegner bewegen & Geschwindigkeit erhöhen
  if (millis() - lastEnemyMove > enemySpeed) {
    lastEnemyMove = millis();
    if (enemySpeed > 200) enemySpeed -= 5; // Wert für Beschleunigung der Schiffe

    for (int i = 0; i < MAX_ENEMIES; i++) {
      if (!enemies[i].active) continue;
      enemies[i].y++;
      // Gegner durchgekommen
      if (enemies[i].y >= HEIGHT) {
        for (int x=0; x<4; x++) for (int y=0; y<4; y++) if(enemies[i].shape[x][y]) { score -= 5; escapedPixels++; }
        spawnEnemy(i);
      }
      // Kollision Gegner mit Spieler-Pixeln
      for (int x=0; x<enemies[i].w; x++) {
        for (int y=0; y<enemies[i].h; y++) {
          if (enemies[i].shape[x][y]) {
            int px = enemies[i].x + x, py = enemies[i].y + y;
            // Prüfen ob Gegner-Pixel Form des Spielers berührt
            if ((py == playerY && abs(px - playerX) <= 1) || (py == playerY-1 && px == playerX)) {
              showFinalStats(); currentState = GAME_OVER;
            }
          }
        }
      }
    }
  }
}

// Statistik am Ende ausgeben
void showFinalStats() {
  Serial.println(F("\n--- AUSWERTUNG ---"));
  Serial.print(F("Punkte: ")); Serial.println(score);
  Serial.print(F("Blaue Power-Ups: ")); Serial.println(blueCount);
  Serial.print(F("Treffer (Pixel): ")); Serial.println(killedPixels);
  Serial.print(F("Schuesse gesamt: ")); Serial.println(totalShots);
  Serial.print(F("Entkommen (Pixel): ")); Serial.println(escapedPixels);
  Serial.println(F("------------------"));
}

// --- ANIMIERTER STARTBILDSCHIRM ---
void animateStartScreen() {
  FastLED.clear();
  
  // Statische Variablen
  static unsigned long lastAnimUpdate = 0;
  static int animFrame = 0;
  static int startBulletY = -1;
  static unsigned long lastMenuFire = 0;
  
  // Schiff-Position berechnen (langsame Sinus-Bewegung)
  float moveValue = sin(millis() / 1000.0); // Wert zwischen -1 und 1
  // Umrechnen auf Spalten 3 bis 12 (damit das 7-breite Schiff Platz hat)
  int cx = map(moveValue * 100, -100, 100, 3, 12); 
  int cy = 11; // Vertikale Position des Schiffs im Menü
  
  // --- Zeichne Menü-Schiff ---
  
  // 1. Spitze (Weiß)
  setSafeLed(cx, cy-2, CRGB::White);
  
  // 2. Cockpit/Oberer Rumpf (Hellblau)
  setSafeLed(cx, cy-1, CRGB::SkyBlue);
  setSafeLed(cx-1, cy-1, CRGB::SkyBlue);
  setSafeLed(cx+1, cy-1, CRGB::SkyBlue);
  
  // 3. Basis/Flügel (Dunkelblau)
  for(int i=-2; i<=2; i++) setSafeLed(cx+i, cy, CRGB::DarkBlue);
  
  // 4. Triebwerke (Rot mit Zufalls-Flackern)
  CRGB engineColor = CRGB::Red;
  // Zufällige Helligkeitsschwankung für Flacker-Effekt
  if(random(0,5) == 1) engineColor %= 64; 
  
  setSafeLed(cx-1, cy+1, engineColor);
  setSafeLed(cx+1, cy+1, engineColor);

  // --- Menü-Feuer Animation ---
  if (millis() - lastAnimUpdate > 50) { // Animations-Takt (20 FPS)
    lastAnimUpdate = millis();
    animFrame++;
    
    // Kugel bewegen
    if (startBulletY != -1) {
      startBulletY--;
      if (startBulletY < 0) startBulletY = -1; // Kugel löschen
    }
    
    // Automatisches Feuern (alle 1,5 Sekunden)
    if (millis() - lastMenuFire > 1500 && startBulletY == -1) {
      startBulletY = cy - 3; // Startpunkt über der Spitze
      lastMenuFire = millis();
    }
  }
  
  // Zeichne Menü-Kugel (Gelb)
  if (startBulletY != -1) {
    setSafeLed(cx, startBulletY, CRGB::Yellow);
  }
}

// Game Over: Ganze Matrix Rot
void drawGameOver() { FastLED.clear(); for(int i=0; i<NUM_LEDS; i++) leds[i] = CRGB::Red; }

// --- SPIEL GRAFIK ZEICHNEN ---
void drawGame() {
  FastLED.clear();
  
  // Spieler zeichnen (. über ...)
  setSafeLed(playerX, playerY, CRGB::Green);     // Mitte Basis
  setSafeLed(playerX-1, playerY, CRGB::Green);   // Links Basis
  setSafeLed(playerX+1, playerY, CRGB::Green);   // Rechts Basis
  setSafeLed(playerX, playerY-1, CRGB::Green);   // Spitze

  // Schüsse zeichnen (Gelb)
  if (bulletActive1) setSafeLed(bulletX1, bulletY1, CRGB::Yellow);
  if (bulletActive2) setSafeLed(bulletX2, bulletY2, CRGB::Yellow);
  if (bulletActive3) setSafeLed(bulletX3, bulletY3, CRGB::Yellow);
  
  // Power-Up zeichnen (Blau/Rot)
  if (drop.active) setSafeLed(drop.x, drop.y, (drop.type == PERMANENT) ? CRGB::Blue : CRGB::Red);

  // Gegner zeichnen (Violett)
  for (int i = 0; i < MAX_ENEMIES; i++) {
    if (!enemies[i].active) continue;
    for (int x = 0; x < enemies[i].w; x++) {
      for (int y = 0; y < enemies[i].h; y++) {
        if (enemies[i].shape[x][y]) {
          setSafeLed(enemies[i].x + x, enemies[i].y + y, CRGB::Purple);
        }
      }
    }
  }
}

Power für deine Pixel: Warum ein gutes Netzteil die halbe Miete ist

Eines vorab: Deine LEDs sind kleine Gourmets sie hassen instabile Spannungen. Ein stabilisiertes 5V Schaltnetzteil ist für dieses Projekt absolute Pflicht. Während der Arduino Uno prima über USB läuft, würde er bei der Versorgung von 256 (oder später 1024) LEDs kläglich aufgeben.

Hier sind die drei goldenen Regeln für deine Stromversorgung:

Die 5A-Marke: Mit einem 5A Netzteil bist du für die 16x16 Matte perfekt aufgestellt. Rein rechnerisch könnte eine einzige Matte bei vollem Weiß und 100% Helligkeit zwar über 15A ziehen, aber da der Code mit moderaten Farben und einer Helligkeit von etwa 20% arbeitet, kommst du mit 5A locker und sicher durch jedes Match.
Vermeide die "rote Seuche": Wenn die Spannung am Ende der LED-Kette abfällt (Spannungsabfall), verfärben sich die eigentlich weißen oder blauen Pixel plötzlich schmutzig-rot. Bei den späteren vier Panelen solltest du den Strom daher an mehreren Punkten einspeisen (Power Injection), anstatt ihn nur durch das erste Panel zu jagen.
Ganz wichtig – Gemeinsames GND: Verbinde immer den Minuspol (GND) deines externen Netzteils mit dem GND-Pin des Arduinos. Ohne diese gemeinsame Basis weiß der Datenpin nicht, gegen welches Potenzial er schalten soll, und deine Matrix verwandelt sich in ein wild flackerndes Chaos.

Selbst mit dieser minimalen Helligkeit und wenigen Pixel komme ich auf 1,4 Watt.

Kontakt

Ronnie

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