Arduino Ideen

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

Schnall dich an, denn jetzt wird es rasant! Mit dem Highway Racer verwandeln wir die 8x32 Neopixel-Matrix in eine vierspurige Autobahn. Dieses Spiel fängt den klassischen Retro-Arcade-Vibe perfekt ein: Du steuerst dein Fahrzeug durch den dichten Verkehr, weichst langsameren Autos aus und kämpfst um den ultimativen Highscore. Ein absolutes Muss für alle, die Action und schnelle Reflexe auf dem Arduino lieben!

Eines von 60 Highlights aus meiner Neopixel-Spielesammlung!

Das Spielprinzip

Du bist auf einer endlosen Autobahn unterwegs und musst dem stetig dichter werdenden Verkehr ausweichen. Die Straße scrollt automatisch an dir vorbei. Schaffst du es, ein anderes Auto erfolgreich zu überholen, bekommst du einen Punkt. Ein Crash mit dem Heck eines anderen Fahrzeugs beendet die Spritztour sofort.

Gameplay & Features

Dieses Spiel nutzt nicht nur die Breite der Matrix voll aus, sondern fordert auch dein Multitasking am Joystick:

Vierspurige Action: Die Matrix ist in vier klare Fahrspuren unterteilt. Mit der horizontalen Joystick-Bewegung wechselst du blitzschnell von Spur zu Spur.
Vor und Zurück: Du bist nicht auf eine Position festgenagelt! Mit der vertikalen Achse deines Joysticks kannst du auf deiner Spur Gas geben (weiter nach rechts fahren) oder bremsen (dich nach links zurückfallen lassen), um dir mehr Reaktionszeit zu verschaffen.
Dynamische Schwierigkeit: Alle 8 Sekunden zieht das Spiel das Tempo an. Die Autos kommen schneller auf dich zu und die Abstände zwischen den Fahrzeugen werden gnadenlos kürzer.
Lichthupe: Ein cooles optisches Detail! Drückst du den Button A, leuchten die Scheinwerfer deines blauen Flitzers auf.
Crash-Animation: Wenn es kracht, blitzt die gesamte Matrix rot auf, bevor dir dein finaler Highscore präsentiert wird.

Verdrahtung: Arduino, Matrix und Joystickshield

Komponente	Pin am Arduino	Beschreibung
8x32 Matrix	D9	Dateneingang (DIN)
Joystick Y-Achse (im Code X)	A1	Spurwechsel (Hoch/Runter steuern)
Joystick X-Achse (im Code Y)	A0	Vor / Zurück auf der eigenen Spur
Button A	D2	Lichthupe (Scheinwerfer aktivieren)
Button B	D3	Start / Match nach Game Over neu starten
Stromversorgung	5V / GND	Wichtig: Externes Netzteil verwenden, da viele Pixel leuchten!

Der Arduino Code für das Racer Spiel

// www.kreativekiste.de // 10.04.2026
// HIGHWAY RACER
//
// Steuerung:
//   Joystick Y (A1) → Spurwechsel (hoch / runter)
//   Joystick X (A0) → Vor / Zurück (±10 Pixel)
//   Button A (Pin 2) → Lichthuppe (Scheinwerfer)
//   Button B (Pin 3) → Start / Neustart

#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_X = A1;
const int PIN_JOY_Y = A0;
const int PIN_BTN_A = 2;   // Lichthuppe
const int PIN_BTN_B = 3;   // Start / Reset

// --- 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;
}

// --- SPIELKONSTANTEN ---
const int NUM_LANES      = 4;
const int LANE_H         = HEIGHT / NUM_LANES; // 2
const int CAR_W          = 3;
const int CAR_H          = 2;
const int PLAYER_START_X = 4;
const int PLAYER_MIN_X   = 2;
const int PLAYER_MAX_X   = 12;
const int MAX_TRAFFIC    = 6;

const int JOY_CENTER = 512;
const int JOY_DEAD   = 180;

// Farben
const CRGB COL_LANE   = CRGB(30, 25, 0);
const CRGB COL_PLAYER = CRGB(0, 100, 255);
const CRGB COL_HL_ON  = CRGB(255, 255, 150);
const CRGB COL_HL_OFF = CRGB(120, 100, 30);
const CRGB COL_CAR    = CRGB(200, 50, 0);
const CRGB COL_TAIL   = CRGB(160, 0, 0);
const CRGB COL_SCORE  = CRGB(255, 200, 0);

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

struct TrafficCar {
  float x;
  int   lane;
  bool  active;
  bool  passed;
};

int         playerX    = PLAYER_START_X;
int         playerLane = 1;
bool        headlight  = false;
int         score      = 0;
float       gameSpeed  = 0.35;
const float SPEED_MAX  = 0.65; // ← HIER maximale Verkehrsgeschwindigkeit einstellen
TrafficCar  traffic[MAX_TRAFFIC];

// Joystick-Timing
unsigned long lastLaneMove = 0;
unsigned long lastXMove    = 0;
unsigned long lastSpawn    = 0;
unsigned long spawnMs      = 1400;

// Menü-Scrolling
int menuOff = 0;

// --- 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();
  drawDigit((s / 10) % 10, 12, 1, CRGB::White);
  drawDigit(s % 10,        16, 1, CRGB::White);
}

// --- STRASSE ---
void drawRoad() {
  for (int lane = 1; lane < NUM_LANES; lane++) {
    int y = lane * LANE_H - 1;
    for (int x = 0; x < WIDTH; x++) {
      if (((x + menuOff) / 4) % 2 == 0) setSafeLed(x, y, COL_LANE);
    }
  }
}

// --- SPIELER ---
void drawPlayer() {
  int y0 = playerLane * LANE_H;
  for (int dy = 0; dy < CAR_H; dy++)
    for (int dx = 0; dx < CAR_W; dx++)
      setSafeLed(playerX + dx, y0 + dy, COL_PLAYER);

  // Scheinwerfer (2 Pixel am Auto)
  CRGB hl = headlight ? COL_HL_ON : COL_HL_OFF;
  setSafeLed(playerX + CAR_W, y0,     hl);
  setSafeLed(playerX + CAR_W, y0 + 1, hl);

  // Lichthuppe: 3 Pixel Lichtkegel nach vorne, abnehmende Helligkeit
  if (headlight) {
    setSafeLed(playerX + CAR_W + 1, y0,     CRGB(180, 160, 80));
    setSafeLed(playerX + CAR_W + 1, y0 + 1, CRGB(180, 160, 80));
    setSafeLed(playerX + CAR_W + 2, y0,     CRGB(80, 70, 30));
    setSafeLed(playerX + CAR_W + 2, y0 + 1, CRGB(80, 70, 30));
    setSafeLed(playerX + CAR_W + 3, y0,     CRGB(30, 25, 10));
    setSafeLed(playerX + CAR_W + 3, y0 + 1, CRGB(30, 25, 10));
  }
}

// --- VERKEHR ---
void drawTraffic() {
  for (int i = 0; i < MAX_TRAFFIC; i++) {
    if (!traffic[i].active) continue;
    int y0 = traffic[i].lane * LANE_H;
    int tx = round(traffic[i].x);
    for (int dy = 0; dy < CAR_H; dy++) {
      setSafeLed(tx - 1, y0 + dy, COL_TAIL);
      for (int dx = 0; dx < CAR_W; dx++)
        setSafeLed(tx + dx, y0 + dy, COL_CAR);
    }
  }
}

// --- KOLLISION ---
bool checkCollision() {
  int px1 = playerX;
  int px2 = playerX + CAR_W;
  for (int i = 0; i < MAX_TRAFFIC; i++) {
    if (!traffic[i].active)            continue;
    if (traffic[i].lane != playerLane) continue;
    int tx = round(traffic[i].x);
    if (px1 <= tx + CAR_W && px2 >= tx - 1) return true;
  }
  return false;
}

// --- SPAWN ---
void spawnTraffic() {
  for (int i = 0; i < MAX_TRAFFIC; i++) {
    if (!traffic[i].active) {
      traffic[i].active = true;
      traffic[i].passed = false;
      traffic[i].lane   = random(NUM_LANES);
      traffic[i].x      = WIDTH - 1;
      lastSpawn = millis();
      return;
    }
  }
}

// --- EINGABE ---
void handleInput() {
  int joyX = analogRead(PIN_JOY_X); // A1 = horizontal = Spurwechsel
  int joyY = analogRead(PIN_JOY_Y); // A0 = vertikal   = Vor / Zurück

  // Spurwechsel: kontinuierlich, solange Joystick gedrückt
  if (millis() - lastLaneMove > 90) {
    if (joyX > JOY_CENTER + JOY_DEAD && playerLane > 0) {
      playerLane--;
      lastLaneMove = millis();
    } else if (joyX < JOY_CENTER - JOY_DEAD && playerLane < NUM_LANES - 1) {
      playerLane++;
      lastLaneMove = millis();
    }
  }

  // Vor / Zurück: kontinuierlich
  if (millis() - lastXMove > 80) {
    if (joyY > JOY_CENTER + JOY_DEAD) {
      playerX = min(PLAYER_MAX_X, playerX + 1); // vor
      lastXMove = millis();
    } else if (joyY < JOY_CENTER - JOY_DEAD) {
      playerX = max(PLAYER_MIN_X, playerX - 1); // zurück
      lastXMove = millis();
    }
  }

  headlight = (digitalRead(PIN_BTN_A) == LOW);
}

// --- GAME OVER ANIMATION ---
void gameOverAnim() {
  for (int f = 0; f < 5; f++) {
    fill_solid(leds, NUM_LEDS, CRGB::Red);
    FastLED.show(); delay(120);
    FastLED.clear();
    FastLED.show(); delay(80);
  }
  delay(300);
  displayScore(score);
  FastLED.show();
  delay(1500);
}

// --- INIT ---
void initGame() {
  playerX    = PLAYER_START_X;
  playerLane = 1;
  score      = 0;
  gameSpeed  = 0.35;
  spawnMs    = 1400;
  lastSpawn  = millis();
  menuOff    = 0;
  for (int i = 0; i < MAX_TRAFFIC; i++) traffic[i].active = false;
  FastLED.setBrightness(BRIGHTNESS_GAME);
  currentState = PLAYING;
}

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

// --- LOOP ---
void loop() {

  // ---- START-BILDSCHIRM ----
  if (currentState == START) {
    FastLED.clear();
    // Auto in der Mitte (Spur 1, X-Mitte)
    int sy0 = 1 * LANE_H;
    int sx  = PLAYER_START_X;
    for (int dy = 0; dy < CAR_H; dy++)
      for (int dx = 0; dx < CAR_W; dx++)
        setSafeLed(sx + dx, sy0 + dy, COL_PLAYER);
    setSafeLed(sx + CAR_W, sy0,     COL_HL_OFF);
    setSafeLed(sx + CAR_W, sy0 + 1, COL_HL_OFF);
    FastLED.setBrightness(BRIGHTNESS_MENU);
    FastLED.show();
    delay(40);
    if (digitalRead(PIN_BTN_B) == LOW) { delay(200); initGame(); }
    return;
  }

  // ---- GAME OVER ----
  if (currentState == GAME_OVER) {
    displayScore(score);
    FastLED.show();
    if (digitalRead(PIN_BTN_B) == LOW) { delay(200); currentState = START; }
    delay(20);
    return;
  }

  // ---- SPIELEND ----
  handleInput();

  // Verkehr bewegen + überholte Autos zählen
  for (int i = 0; i < MAX_TRAFFIC; i++) {
    if (!traffic[i].active) continue;
    traffic[i].x -= gameSpeed;
    // Auto wurde vom Spieler überholt → Score +1
    if (!traffic[i].passed && traffic[i].x + CAR_W < playerX) {
      traffic[i].passed = true;
      score++;
    }
    if (traffic[i].x < -2) traffic[i].active = false;
  }

  // Spurmarken scrollen
  menuOff++;

  // Schwierigkeit steigern (unabhängig vom Score-Zähler)
  static unsigned long lastSpeedUp = 0;
  if (millis() - lastSpeedUp > 8000) {
    if (gameSpeed < SPEED_MAX) gameSpeed += 0.01;
    if (spawnMs   > 600)       spawnMs   -= 40;
    lastSpeedUp = millis();
  }

  // Kollision
  if (checkCollision()) {
    gameOverAnim();
    currentState = GAME_OVER;
    delay(20);
    return;
  }

  // Spawn
  if (millis() - lastSpawn > spawnMs) spawnTraffic();

  // Zeichnen
  FastLED.clear();
  drawRoad();
  drawTraffic();
  drawPlayer();
  FastLED.show();
  delay(20);
}

Kontakt

Ronnie

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