„Simon sagt!“ auf dem Arduino: Reaktionsspiel mit 6 Tastern

„Simon sagt – drück die Taste!“ Wer bei diesem Satz sofort an blinkende LEDs, piepsende Buzzer und schnelle Finger denkt, ist hier genau richtig! Dieses Arduino Reaktionsspiel bringt den Spielklassiker „Simon sagt!“ direkt auf deinen Basteltisch – als selbst gelötete Schaltung mit OLED-Display, Soundausgabe und sechs reaktionsfreudigen Tastern.

Ob du dein Gedächtnis trainieren willst oder einfach Spaß an bunten LEDs hast – dieses Projekt ist genau das Richtige für Technikfans, Maker und alle, die beim Programmieren gerne mal mitpfeifen, wenn der Buzzer piept.

In diesem Beitrag zeige ich dir, wie du dein eigenes Simon sagt! Arduino Reaktionsspiel Schritt für Schritt aufbaust – vom Löten über die Programmierung bis zum ersten Spielstart!

Inhaltsverzeichnis

• Ferienpass-Projekt mit Spaßfaktor: Programmieren, Löten und „Simon sagt!“
• Benötigte Bauteile für das Simon sagt! Arduino Reaktionsspiel
• Schaltungsaufbau: So wird alles verbunden
  • Pinbelegung – Simon sagt! Arduino Reaktionsspiel
• Layoutfehler entdeckt – aber halb so wild!
• Spielprinzip: So funktioniert das Simon sagt! Arduino Reaktionsspiel
• Programmierung Schritt für Schritt: Vom LED-Blinken bis zum fertigen Spiel
  • Schritt 1 – LEDs blinken, wechselblinken lassen
    • LED1 und LED2 im Wechsel blinken (Pins D3 und D2)
  • Schritt 2 – Taster abfragen und Reaktionen auslösen
    • Einfacher Taster T1 am Pin D8
  • Schritt 3 – Töne und Melodien mit dem Piezo-Buzzer erzeugen
    • Einfache Töne erzeugen
    • Eine kleine Tonleiter spielen
  • Schritt 4 – Text auf dem OLED-Display anzeigen und positionieren
    • Benötigte Bibliotheken
    • Text anzeigen & positionieren
    • Text aktualisieren
  • Schritt 5 – Das komplette Simon sagt! Arduino Reaktionsspiel zusammensetzen

Ferienpass-Projekt mit Spaßfaktor: Programmieren, Löten und „Simon sagt!“

Dieses Simon sagt! Arduino Reaktionsspiel ist nicht einfach irgendein Projekt – es ist das Ergebnis eines großartigen Ferienpass-Angebots im Jugendfreizeitzentrum Schöningen. Gemeinsam mit den teilnehmenden Kids haben wir zwei Tage lang gelötet, programmiert und natürlich: gespielt!

Ich versuche jedes Jahr, im Rahmen des Ferienpasses spannende Technikprojekte anzubieten, die nicht nur lehrreich sind, sondern auch richtig Spaß machen. In den letzten Jahren haben wir unter anderem:

• einen DIY OTTO Roboter zum Tanzen gebracht,
• einen LED-Würfel gebaut,
• einen leuchtenden Tannenbaum mit Sound entwickelt
• einen Wecker mit ESP32-C3 Super Mini,
• und sogar eine eigene Wetterstation aufgebaut und programmiert

Dieses Jahr stand ein besonders cooles Spiel auf dem Plan: „Simon sagt!“ – als einfaches, aber effektives Arduino Reaktionsspiel, das auf einer selbst gelöteten Platine zum Leben erweckt wurde. Die Kombination aus Tastern, LEDs, Buzzer und OLED-Display sorgte für viel Begeisterung – und leuchtende Augen nicht nur bei den LEDs.

Benötigte Bauteile für das Simon sagt! Arduino Reaktionsspiel

Die Platine für dieses Projekt wurde speziell für unseren Ferienpass-Workshop entworfen und enthält bereits alles, was du für dein eigenes Simon sagt! Arduino Reaktionsspiel brauchst. Im Gegensatz zu meinem früheren Beitrag mit dem M5Stamp Pico und einem 8-fach LED-Stripe, kommt hier ein klassischer Arduino Nano zum Einsatz – kombiniert mit diskreten LEDs, einem OLED-Display und 6 Tastern. Das Grundprinzip bleibt aber gleich!

Das brauchst du für den Aufbau:

• 1× Arduino Nano (oder kompatibler Klon)
• 6× Taster (12 × 12 mm, optional mit Kappe)
• 6× LEDs (verschiedene Farben möglich)
• 6× Vorwiderstände für LEDs (z. B. 220 Ω)
• 1× Piezo-Buzzer (aktiv oder passiv – je nach Code)
• 1× OLED-Display (SSD1306, 128×32, I2C)
• Diverse Widerstände für Taster (z. B. 10 kΩ Pull-Down/Pull-Up)
• 1× Platine (eigenes Design, optional als Einzelaufbau auf Breadboard)
• Breadboardkabel, Stiftleisten, Lötzubehör

💡 Hinweis zum OLED-Display:
In diesem Projekt verwende ich ein 0,96 Zoll großes I2C-OLED-Display in Weiß/Schwarz mit der Pinreihenfolge: GND, VCC, SCL, SDA (von links nach rechts, frontal auf die Pins blickend).
Es gibt jedoch auch Varianten mit VCC und GND vertauscht – bitte achte unbedingt auf die Aufschrift auf deinem Modul, bevor du es anschließt! Ein verpolter Anschluss kann das Display dauerhaft beschädigen.

Schaltungsaufbau: So wird alles verbunden

Damit dein Simon sagt! Arduino Reaktionsspiel auch wirklich reibungslos funktioniert, ist eine saubere Verdrahtung entscheidend – besonders bei 6 Tastern, 6 LEDs, einem OLED-Display und dem Buzzer.

Für alle, die das Projekt ohne eigene Platine nachbauen möchten, habe ich hier einen Fritzing-Schaltplan erstellt. Damit kannst du die Schaltung einfach auf einem Breadboard oder einer Lochrasterplatine aufbauen.

Wichtige Hinweise zur Verkabelung:

• Taster sind mit digitalen Eingängen des Arduino Nano verbunden
• LEDs hängen an eigenen Pins, jeweils mit einem Vorwiderstand (~220 Ω).
• Der Buzzer wird an einem PWM-fähigen Pin angeschlossen (z. B. D6 oder D9).
• Das OLED-Display nutzt den I2C-Bus (Standard: A4 = SDA, A5 = SCL beim Arduino Nano).
• Gemeinsame GND-Leitung nicht vergessen – das ist der Klassiker bei Fehlern. 😉

Hier der vollständige Aufbau als Fritzing-Grafik:

Pinbelegung – Simon sagt! Arduino Reaktionsspiel

Hinweise:

• Die Taster werden per INPUT_PULLUP eingelesen und sind bei Betätigung LOW.
• Alle LEDs benötigen Vorwiderstände (z. B. 220 Ω), um den Strom zu begrenzen.
• Das verwendete OLED-Display hat die Pinreihenfolge GND, VCC, SCL, SDA – bitte vorher prüfen, da es auch andere Varianten gibt.
• Der Piezo-Buzzer kann mit tone() direkt angesprochen werden.
• I2C-Pins (SDA = A4, SCL = A5) gelten für den klassischen Arduino Nano – bei anderen Boards ggf. abweichend.

Layoutfehler entdeckt – aber halb so wild!

An dieser Stelle muss ich kurz etwas zu Kreuze kriechen: Beim Entwurf der Platine für das Simon sagt! Arduino Reaktionsspiel ist mir ein kleiner, aber durchaus lösbarer Fehler unterlaufen.

Die Bohrungen für die LEDs sind etwas zu klein geraten – Standard-5 mm-LEDs passen mit ihren Beinchen nicht sauber durch die vorgesehenen Löcher.
Und bei den Widerständen habe ich versehentlich ein Footprint verwendet, das eigentlich für deutlich größere Leistungswiderstände gedacht ist – was dazu führt, dass die normalen Kohleschichtwiderstände etwas „in der Luft hängen“ oder viel Platz auf der Platine beanspruchen.

👉 Aber die gute Nachricht:
Mit etwas Bastelgeschick ließ sich das problemlos ausgleichen:

• Die LEDs können einfach leicht angewinkelt verlötet werden – funktioniert einwandfrei und sieht gar nicht so schlecht aus.
• Die Widerstände lassen sich wie gewohnt bestücken – es ist lediglich etwas mehr Draht sichtbar, was dem Ganzen aber keinen Abbruch tut.

Für Version 2 der Platine werde ich diese Punkte selbstverständlich anpassen, damit der Aufbau noch einfacher wird. Stay tuned!

Spielprinzip: So funktioniert das Simon sagt! Arduino Reaktionsspiel

Nach dem Einschalten des Mikrocontrollers begrüßt dich das Display freundlich – und dann geht’s auch schon los: Das Simon sagt! Arduino Reaktionsspiel fordert dein Gedächtnis und deine Reaktionsfähigkeit heraus!

So läuft das Spiel ab:

1. Begrüßung & Start: Auf dem OLED-Display erscheint eine kurze Begrüßung – danach beginnt das Spiel automatisch mit Runde 1.
2. Spielrunde 1: Im Display wird z. B. „Spielrunde 1“ angezeigt und eine zufällig gewählte LED leuchtet kurz auf. Deine Aufgabe: Drücke den richtigen Taster, der dieser LED zugeordnet ist.
3. Spielrunde 2: Sobald du die erste Eingabe richtig gemacht hast, folgt sofort die nächste Runde – nun mit zwei LEDs in Folge!
   Achte gut auf die Reihenfolge – und pass auf: Es kann auch passieren, dass zweimal dieselbe LED aufleuchtet! 😈
4. Und so weiter: Mit jeder Runde wird die Abfolge länger und schwieriger. Du musst dir also immer mehr Farben und Positionen merken und sie in der richtigen Reihenfolge über die Taster eingeben.
5. Fehlerhafte Eingabe – Spielende:
   Wenn du einen falschen Taster drückst, ist die Runde verloren.
   Zur Rückmeldung erscheinen im Display die Worte „Falsch!“, und alle LEDs blinken mehrmals auf. Danach startet das Spiel automatisch wieder mit Runde 1.

Ziel des Spiels:
Teste dein Erinnerungsvermögen – und finde heraus, wie viele Runden du durchhältst! Ideal für Kinder, Jugendliche und auch Erwachsene, die sich spielerisch mit Arduino-Programmierung und logischem Denken beschäftigen wollen.

Programmierung Schritt für Schritt: Vom LED-Blinken bis zum fertigen Spiel

Ein funktionierendes Simon sagt! Arduino Reaktionsspiel zu bauen, ist gar nicht so kompliziert – wenn man die einzelnen Funktionen Schritt für Schritt umsetzt. Genau das machen wir jetzt!

In den folgenden Abschnitten zeige ich dir, wie du:

1. LEDs einzeln blinken und im Wechsel steuern kannst,
2. Taster abfragst und auf ihre Zustände reagierst,
3. Töne und kleine Melodien über den Piezo-Buzzer erzeugst,
4. Texte auf dem OLED-Display anzeigst und positionierst,
5. und schließlich das komplette Spiel Simon sagt! zusammenfügst.

Jede Funktion wird dabei kurz erklärt und mit einfachem Beispielcode gezeigt – so kannst du alles nachbauen oder bei Bedarf an deine eigene Platine anpassen.

Schritt 1 – LEDs blinken, wechselblinken lassen

Bevor wir das komplette Simon sagt! Arduino Reaktionsspiel programmieren, starten wir mit dem Klassiker unter den Mikrocontroller-Einstiegen: LEDs blinken lassen. Das hilft dir, ein Gefühl für das Timing und die Pinsteuerung zu bekommen – und sieht nebenbei auch cool aus! 😄

#define led1 3  // LED1 an Pin D3

void setup() {
  pinMode(led1, OUTPUT);
}

void loop() {
  digitalWrite(led1, HIGH);  // LED einschalten
  delay(500);                // 500 ms warten
  digitalWrite(led1, LOW);   // LED ausschalten
  delay(500);                // 500 ms warten
}

Erklärung:

• pinMode(led1, OUTPUT) definiert den Pin als Ausgang.
• digitalWrite(led1, HIGH/LOW) schaltet die LED ein bzw. aus.
• Mit delay(500) warten wir jeweils eine halbe Sekunde.

LED1 und LED2 im Wechsel blinken (Pins D3 und D2)

Jetzt erweitern wir den Code: LED1 und LED2 sollen abwechselnd blinken – also immer genau dann, wenn die andere aus ist:

#define led1 3  // LED1 an Pin D3
#define led2 2  // LED2 an Pin D2

void setup() {
  pinMode(led1, OUTPUT);
  pinMode(led2, OUTPUT);
}

void loop() {
  digitalWrite(led1, HIGH);   // LED1 ein
  digitalWrite(led2, LOW);    // LED2 aus
  delay(500);

  digitalWrite(led1, LOW);    // LED1 aus
  digitalWrite(led2, HIGH);   // LED2 ein
  delay(500);
}

So entsteht ein Wechselblinken – perfekt für optisches Feedback in späteren Spielrunden.

Schritt 2 – Taster abfragen und Reaktionen auslösen

Damit unser Simon sagt! Arduino Reaktionsspiel auch auf deine Eingaben reagiert, müssen wir Taster abfragen und erkennen, ob (und wann) sie gedrückt werden. In diesem Schritt zeige ich dir, wie das funktioniert – ganz ohne Magie, nur mit ein bisschen Code. 😉

Einfacher Taster T1 am Pin D8

Wir starten mit einem einzelnen Taster, der an Pin D8 angeschlossen ist. Sobald der Taster gedrückt wird, soll die LED1 (an D3) aufleuchten.

#define taster1 8  // Taster an D8
#define led1 3     // LED1 an D3

void setup() {
  pinMode(taster1, INPUT);     // Taster als Eingang
  pinMode(led1, OUTPUT);       // LED als Ausgang
}

void loop() {
  if (digitalRead(taster1) == HIGH) {
    digitalWrite(led1, HIGH);  // LED leuchtet, solange der Taster gedrückt wird
  } else {
    digitalWrite(led1, LOW);   // LED aus, wenn nicht gedrückt
  }
}

Was passiert hier?

• Der Zustand des Tasters wird mit digitalRead() abgefragt.
• Wenn er gedrückt ist (HIGH), leuchtet die LED.
• Sobald du loslässt, geht die LED aus.

Tipp: Für dein späteres Spiel solltest du die Taster entprellen – das machen wir später mit der Bounce2-Library. Hier geht’s erstmal ums Grundprinzip.

Schritt 3 – Töne und Melodien mit dem Piezo-Buzzer erzeugen

Was wäre ein Simon sagt! Arduino Reaktionsspiel ohne akustisches Feedback? Genau – nur halb so spannend! In diesem Schritt zeigen wir dem Piezo-Buzzer, wie man Töne und sogar kleine Melodien ausgibt.

Einfache Töne erzeugen

Zunächst einmal schließen wir den Piezo-Buzzer an Pin A0 (oder jeden beliebigen digitalen PWM-fähigen Pin) an und geben einen einzelnen Ton aus:

#define buzzer A0  // Piezo-Buzzer an Pin A0

void setup() {
  pinMode(buzzer, OUTPUT);
}

void loop() {
 tone(buzzer, 440, 500);  // A-Ton (440 Hz) für 500 ms
 delay(1000);            // Pause
}

Tipp:
Wenn du die Funktion tone(pin, frequenz, dauer) verwendest, wird der Ton automatisch nach der angegebenen Dauer wieder abgeschaltet – du brauchst also kein noTone() und kein separates delay() mehr für den Ton selbst. Nur die Pause danach musst du ggf. noch einbauen.

Eine kleine Tonleiter spielen

Hier ein Beispiel für eine einfache Tonleiter von C4 bis C5, bei der wir die Tonlänge direkt mit angeben:

#define buzzer A0

int melody[] = {262, 294, 330, 349, 392, 440, 494, 523};  // C4 bis C5

void setup() {}

void loop() {
  for (int i = 0; i < 8; i++) {
    tone(buzzer, melody[i], 300);  // Ton 300 ms spielen
    delay(400);                    // 100 ms Pause nach jedem Ton
  }
  delay(1000);  // 1 Sekunde Pause nach der Tonleiter
}

Mit dieser Technik kannst du später jeder Taste einen eigenen Sound zuordnen – oder kleine Melodien beim Spielstart und Spielende abspielen.

Schritt 4 – Text auf dem OLED-Display anzeigen und positionieren

Das kleine OLED-Display (SSD1306, 0,96″) sorgt bei unserem Simon sagt! Arduino Reaktionsspiel nicht nur für einen coolen Look, sondern liefert auch wichtige Infos wie „Spielrunde 1“, „Richtig!“ oder „Game Over“. In diesem Schritt zeige ich dir, wie du Text auf dem Display anzeigst und positionierst.

Benötigte Bibliotheken

Um das Display korrekt anzusteuern, verwenden wir die Adafruit SSD1306 Library.
Öffne dazu den Bibliotheksverwalter in der Arduino IDE (unter Sketch → Bibliothek einbinden → Bibliotheken verwalten…) und suche nach:

Adafruit SSD1306

Wichtig:
Achte darauf, beim Installieren auch alle Abhängigkeiten (engl. Dependencies) mitzuinstallieren – insbesondere:

• Adafruit GFX Library
• Adafruit BusIO

Die IDE fragt dich beim Installieren automatisch, ob du diese mitinstallieren möchtest – bestätige das unbedingt.

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 32
#define OLED_RESET -1  // Kein Reset-Pin nötig
#define SCREEN_ADDRESS 0x3C  // Standardadresse für I2C-SSD1306

Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

void setup() {
  Wire.begin();
  display.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS);
  display.clearDisplay();
  display.setTextSize(1);
  display.setTextColor(SSD1306_WHITE);
  display.setCursor(0, 0);
  display.println("Simon sagt!");
  display.display();
}

Text anzeigen & positionieren

Mit setCursor(x, y) kannst du den Text gezielt platzieren:

display.setCursor(20, 16);  // Position mittig unten
display.println("Spielrunde 1");
display.display();

Text aktualisieren

Vor jeder neuen Anzeige solltest du das Display löschen, damit kein Text „überlappt“:

display.clearDisplay();
display.setCursor(0, 0);
display.println("Neue Runde!");
display.display();

Schritt 5 – Das komplette Simon sagt! Arduino Reaktionsspiel zusammensetzen

Hier kommt der komplette Beispielcode:

/***************************************************************
 * Simon sagt! Arduino Reaktionsspiel
 * -------------------------------------------------------------
 * Ziel ist es, sich eine LED-Sequenz zu merken und per Taster
 * korrekt nachzuspielen. Nach jeder erfolgreich absolvierten
 * Runde wird die Sequenz länger – und optional schneller.
 *
 * Draeger-IT.blog
 ***************************************************************/

#include <Bounce2.h>             // Entprellung der Taster
#include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h>        // Grafikfunktionen für OLED
#include <Adafruit_SSD1306.h>    // SSD1306 OLED Display
#include <Fonts/FreeSerif9pt7b.h>
#include <Fonts/FreeMono9pt7b.h>

// --- LED- und Tasterzuordnung ---
#define led1 3
#define taster1 8

#define led2 2
#define taster2 9

#define led3 4
#define taster3 10

#define led4 5
#define taster4 11

#define led5 6
#define taster5 12

#define led6 7
#define taster6 A1

#define buzzer A0  // Piezo-Buzzer

// --- OLED Display Setup ---
#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 32
#define OLED_RESET -1
#define SCREEN_ADDRESS 0x3C
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

// --- Taster vorbereiten mit Bounce2 ---
Bounce2::Button btn1 = Bounce2::Button();
Bounce2::Button btn2 = Bounce2::Button();
Bounce2::Button btn3 = Bounce2::Button();
Bounce2::Button btn4 = Bounce2::Button();
Bounce2::Button btn5 = Bounce2::Button();
Bounce2::Button btn6 = Bounce2::Button();

int ledPins[] = { led1, led2, led3, led4, led5, led6 };

int spielrunde = 1;

// 🕒 Startgeschwindigkeit (in ms)
int speed = 1000;       // Anfangswert: LED leuchtet 1 Sekunde
const int minSpeed = 250; // Untergrenze für max. Schwierigkeit

// --- Spielsequenz: Platz für bis zu 30 Runden ---
int nums[30];

// ---------- SETUP ----------
void setup() {
  Serial.begin(9600);

  // LEDs als Ausgang
  for (int i = 0; i < 6; i++) {
    pinMode(ledPins[i], OUTPUT);
  }

  // Taster initialisieren
  btn1.attach(taster1, INPUT_PULLUP);
  btn2.attach(taster2, INPUT_PULLUP);
  btn3.attach(taster3, INPUT_PULLUP);
  btn4.attach(taster4, INPUT_PULLUP);
  btn5.attach(taster5, INPUT_PULLUP);
  btn6.attach(taster6, INPUT_PULLUP);

  Bounce2::Button* buttons[] = { &btn1, &btn2, &btn3, &btn4, &btn5, &btn6 };
  for (int i = 0; i < 6; i++) {
    buttons[i]->interval(5);
    buttons[i]->setPressedState(LOW);
  }

  // OLED initialisieren
  display.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS);
  displaySplashScreen();
  delay(1000);
  displayRound();

  // Zufallsquelle initialisieren
  randomSeed(analogRead(0));
}

// ---------- DISPLAY-FUNKTIONEN ----------

// Startbildschirm mit Logo und Titel
void displaySplashScreen() {
  display.clearDisplay();
  display.setFont(&FreeMono9pt7b);
  display.setTextColor(SSD1306_WHITE);
  display.setCursor(4, 13);
  display.println(F("Simon sagt!"));
  display.setFont();
  display.setCursor(15, 22);
  display.println(F("Draeger-IT.blog"));
  display.drawRect(1, 1, 126, 31, WHITE);
  display.display();
}

// Zeige aktuelle Spielrunde
void displayRound() {
  display.clearDisplay();
  display.drawRect(1, 1, 126, 31, WHITE);
  display.setFont();
  display.setCursor(30, 5);
  display.println(F("Spielrunde"));
  display.setFont(&FreeMono9pt7b);
  display.setCursor(53, 28);
  display.println(String(spielrunde));
  display.display();
}

// ---------- SPIELABLAUF ----------

void loop() {
  // 1. Zufällige LED-Sequenz erzeugen und anzeigen
  for (int i = 0; i < spielrunde; i++) {
    int randNumber = random(6);
    nums[i] = randNumber;
    lightUp(ledPins[randNumber]);
    delay(speed);  // Wartezeit je Runde
  }

  // 2. Eingabephase
  for (int i = 0; i < spielrunde; i++) {
    int eingabe = warteAufEingabe();
    if (eingabe != nums[i]) {
      spielVerloren();
      return;
    }
  }

  // 3. Erfolgreiche Runde -> nächste Spielrunde, evtl. schneller
  spielrunde++;
  speed = max(minSpeed, speed - 50);  // Reduziere Geschwindigkeit
  displayRound();
  delay(1000);
}

// ---------- HILFSFUNKTIONEN ----------

// Warte auf gültige Tasteneingabe
int warteAufEingabe() {
  while (true) {
    btn1.update(); btn2.update(); btn3.update();
    btn4.update(); btn5.update(); btn6.update();

    if (btn1.pressed()) { lightUp(led1); playTone(); return 0; }
    if (btn2.pressed()) { lightUp(led2); playTone(); return 1; }
    if (btn3.pressed()) { lightUp(led3); playTone(); return 2; }
    if (btn4.pressed()) { lightUp(led4); playTone(); return 3; }
    if (btn5.pressed()) { lightUp(led5); playTone(); return 4; }
    if (btn6.pressed()) { lightUp(led6); playTone(); return 5; }
  }
}

// Animation bei Fehler
void spielVerloren() {
  display.clearDisplay();
  display.setCursor(20, 20);
  display.println(F("Falsch!"));
  display.display();

  for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 6; j++) digitalWrite(ledPins[j], HIGH);
    delay(300);
    for (int j = 0; j < 6; j++) digitalWrite(ledPins[j], LOW);
    delay(300);
  }

  // Rücksetzen des Spiels
  spielrunde = 1;
  speed = 1000;  // Reset auf Startgeschwindigkeit
  displayRound();
  delay(1000);
}

// LED kurz aufleuchten lassen
void lightUp(int pin) {
  digitalWrite(pin, HIGH);
  delay(250);
  digitalWrite(pin, LOW);
}

// Kurzer Piepton
void playTone() {
  tone(buzzer, 1000, 100);  // 100 ms Ton
}