Arduino Ideen

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

Wer erinnert sich nicht an den kleinen Vogel, der Millionen von Smartphone-Nutzern weltweit in den Wahnsinn getrieben hat? Mit Flappy Pixel bringen wir dieses legendäre Spielprinzip auf den Arduino und deine 8x32 Neopixel-Matrix. Es ist die perfekte Übung für deine Reaktionsgeschwindigkeit und zeigt, wie man mit einer präzisen Physik-Simulation echten Spielspaß auf nur 256 Pixeln erzeugt.

Eines von 60 Highlights aus meiner Neopixel-Spielesammlung!

Das Spielprinzip

Das Ziel von Flappy Pixel ist so simpel wie herausfordernd: Du steuerst einen einzelnen, leuchtenden Pixel durch schmale Lücken in herannahenden Säulen. Während die Schwerkraft deinen Pixel unaufhörlich Richtung Boden zieht, musst du ihn durch gezielte Impulse in der Luft halten. Berührst du eine Säule, die Decke oder den Boden, heißt es: Game Over!

Gameplay & Features

Damit das Spiel auf dem kompakten 8x32 Display nicht nur machbar, sondern richtig motivierend ist, habe ich einige Profi-Features eingebaut:

Micro-Flap-Physik: Da uns nur 8 Pixel in der Höhe zur Verfügung stehen, wurde die Steuerung extrem fein kalibriert. Ein kurzer Tastendruck lässt den Pixel nur ein kleines Stück steigen, sodass du ihn mit schnellen Klicks präzise auf einer Linie halten kannst.
Warten auf den Start: Keine Hektik beim Spielstart! Nach dem Drücken des Start-Buttons schwebt dein Pixel friedlich in der Mitte des Bildschirms. Erst dein allererster "Flap" aktiviert die Schwerkraft und setzt die Säulen in Bewegung.
Variable Säulen: Die Lücken in den Säulen erscheinen in unterschiedlichen Höhen, was dich zwingt, ständig zwischen Steigen und Sinken abzuwägen.
Terminal Velocity: Um den Frustfaktor gering zu halten, habe ich eine maximale Fallgeschwindigkeit eingebaut. So stürzt dein Pixel nie unkontrolliert ab, sondern bleibt immer beherrschbar.

Verdrahtung: Arduino, Matrix und Taster

Komponente	Pin am Arduino	Beschreibung
8x32 Neopixel Matrix	D9	Dateneingang (DIN)
Button A	D2	Flügel-Schlag (Flap)
Button B	D3	Start / Restart
Stromversorgung	5V / GND	Externes Netzteil verwenden!

Hinweis zur Hardware: Auch hier ist der Arduino Uno R4 die beste Wahl. Durch seinen größeren Arbeitsspeicher und die höhere Taktrate läuft die Physik-Berechnung des "Pixel" absolut flüssig, was bei diesem Spiel entscheidend für den Highscore ist.

Der Arduino Code für Flappy Pixel

// www.kreativekiste.de // 10.04.2026 // Version 1.3
// FLAPPY Pixel

#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_BTN_A = 2; // FLÜGELSCHLAG (Flap)
const int PIN_BTN_B = 3; // START / RESET

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

float dotY = 3.5;         
float dotVelocity = 0;

// Physik für präzises Schweben
const float gravity = 0.08;       
const float flapPower = -0.45;    
const float maxFallSpeed = 0.6;   

const int dotX = 6;              

int score = 0;

// --- FEINTUNING DER GESCHWINDIGKEIT ---
float gameSpeed = 0.32; // Vorher 0.4 - Ein kleiner Ticken langsamer
bool lastBtnState = HIGH;        
bool gameStarted = false; 

// --- SÄULEN (Hindernisse) ---
const int MAX_PILLARS = 3; 
struct Pillar {
  float x;
  int gapTop;   
  int gapSize;  
  bool active;
  bool passed;  
};
Pillar pillars[MAX_PILLARS];

// --- 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(int s) {
  FastLED.clear();
  int tens = (s / 10) % 10;
  int units = s % 10;
  drawDigit(tens, 12, 1, CRGB::White);
  drawDigit(units, 16, 1, CRGB::White);
}

// --- SPIEL-FUNKTIONEN ---

void spawnPillar(int i) {
  float maxX = 31;
  for(int j=0; j<MAX_PILLARS; j++) {
    if(pillars[j].active && pillars[j].x > maxX) {
      maxX = pillars[j].x;
    }
  }
  
  pillars[i].x = maxX + random(12, 18); 
  pillars[i].gapSize = 3; 
  pillars[i].gapTop = random(1, HEIGHT - pillars[i].gapSize); 
  
  pillars[i].active = true;
  pillars[i].passed = false;
}

void initGame() {
  dotY = 3.5;
  dotVelocity = 0;
  score = 0;
  gameSpeed = 0.32; // Auch hier beim Neustart den neuen Wert setzen
  lastBtnState = digitalRead(PIN_BTN_A);
  gameStarted = false; 
  
  for(int i=0; i<MAX_PILLARS; i++) pillars[i].active = false;
  spawnPillar(0); 
  
  currentState = PLAYING;
  FastLED.setBrightness(BRIGHTNESS_GAME);
}

void drawPillars() {
  for(int i=0; i<MAX_PILLARS; i++) {
    if (!pillars[i].active) continue;
    int px = round(pillars[i].x);
    
    if (px >= 0 && px < WIDTH) {
      for(int y=0; y<HEIGHT; y++) {
        if(y < pillars[i].gapTop || y >= pillars[i].gapTop + pillars[i].gapSize) {
          setSafeLed(px, y, CRGB::Green); 
        }
      }
    }
  }
}

void updatePhysics() {
  bool currentBtnState = digitalRead(PIN_BTN_A);

  if (currentBtnState == LOW && lastBtnState == HIGH) {
    dotVelocity = flapPower; 
    gameStarted = true; 
  }
  lastBtnState = currentBtnState;

  if (gameStarted) {
    dotVelocity += gravity;
    
    if (dotVelocity > maxFallSpeed) {
      dotVelocity = maxFallSpeed;
    }
    
    dotY += dotVelocity;

    if (dotY < 0 || dotY >= HEIGHT) {
      currentState = GAME_OVER;
    }

    int rdY = round(dotY);
    for(int i=0; i<MAX_PILLARS; i++) {
      if(!pillars[i].active) {
        spawnPillar(i);
        continue;
      }
      
      pillars[i].x -= gameSpeed;
      int px = round(pillars[i].x);

      if (px == dotX) {
        if (rdY < pillars[i].gapTop || rdY >= pillars[i].gapTop + pillars[i].gapSize) {
          currentState = GAME_OVER;
        }
      }

      if (px < dotX && !pillars[i].passed) {
        score++;
        pillars[i].passed = true;
        // NEU: Sanfterer Anstieg der Geschwindigkeit (vorher +0.05, jetzt +0.03)
        if(score > 0 && score % 10 == 0) gameSpeed = min(0.7f, gameSpeed + 0.03f); 
      }

      if (pillars[i].x < -1) {
        pillars[i].active = false;
      }
    }
  }
}

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

    case PLAYING:
      updatePhysics();
      FastLED.clear();
      drawPillars();
      setSafeLed(dotX, round(dotY), CRGB::Cyan); 
      break;

    case GAME_OVER:
      displayScore(score);
      if (digitalRead(PIN_BTN_B) == LOW) currentState = START;
      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);
  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.