Arduino Reaktionsspiel – Tutorial in 3 Schritten

Ein Reaktionsspiel mit dem Arduino zu erstellen, ist eine super Übung, um die Welt der Spieleentwicklung zu entdecken. Denn schließlich ist das Konzipieren eigener Games der Traum vieler Coding-Anfänger. Die ganz großen Videospiele werden allerdings von riesigen Entwicklerteams mit mächtigen Frameworks erstellt. Das braucht eine Menge Zeit. Jedoch kann man in kurzer Zeit die Grundprinzipien eines Spiels, wie zum Beispiel die Event-Schleife, mit einem einfachen Reaktionsspiel kennenlernen.

Arduino Reaktionsspiel – Was ist das? 

Beim Arduino Reaktionsspiel handelt es sich um ein Schnelligkeitsspiel, bei dem die Spieler zwei LEDs beobachten. Wenn die richtige Lampe plötzlich blinkt, muss der Taster betätigt werden. Der schnellere Spieler erhält dabei einen Punkt. Wird der Taster jedoch beim Aufleuchten der falschen LED gedrückt, wird dem Spieler ein Punkt abgezogen. Wer als Erstes zehn Punkte erreicht, hat das Spiel gewonnen. Dabei ist die Grundidee des Spiels schon sehr alt. Umso beeindruckender ist es, dass es sich bis heute einer großen Beliebtheit erfreut. Das liegt wohl daran, dass die Grundversion des Spiels leicht zu erstellen ist und nach individuellen Wünschen erweitert werden kann. Zudem eignet sich das einfache Projekt hervorragend, um den Einstieg in Arduino zu meistern. Indes erfährst Du auf spielerische Art und Weise, wie das Micro-Board aufgebaut ist, ohne dass Du spezielle technische Vorkenntnisse haben musst.

Du siehst: Coding kann unglaublich viel Spaß machen. Wenn Du alle gängigen Coding-Handgriffe beherrschen möchtest, dann ist unser Computerkurs genau das Richtige. Denn hier lernen junge Tüftler alle wichtigen Anwendungen.

Diese Bauteile benötigst Du

Du möchtest ein Reaktionsspiel mit dem Arduino erstellen? Doch Du weißt nicht, welche Materialien man dafür benötigt? Dann lies unbedingt weiter, denn wir haben für Dich alle Bauteile übersichtlich zusammengestellt. Dabei findest Du die meisten Materialien im Baumarkt oder kannst sie ganz einfach im Internet bestellen. Folgende Bauteile benötigst Du, um Deinen Arduino in ein aufregendes Reaktionsspiel zu verwandeln.

• Vier LEDs in verschiedenen Farben
• Zwei Mikrotaster
• 4 x 1kΩ Widerstand
• 2 x 10kΩ Widerstand
• Ein Arduino UNO
• Ein Breadboard mit Verbindungskabeln

Bevor Du mit dem Coden startest, musst Du zuerst die einzelnen Bauteile anbringen. Dabei spielt beim Verbauen die Farbe der Leuchtdioden keine Rolle. Allerdings solltest Du darauf achten, wie rum Du sie anbringst. Daher solltest Du die LEDs vorm Anschließen genau unter die Lupe nehmen. Denn ein Bein ist deutlich länger als das andere und wird unter echten Tüftlern auch Anode genannt. Dieses musst Du am Pluspol anbringen. Das kürzere Bein hingegen, die sogenannte Kathode, wird mit dem Minuspol verbunden. In Abbildung 3 erkennst Du sie an dem kleinen Knick. Anschließend sind beide LEDs befestigt.

Danach musst Du die Widerstände am Board anbringen. Achte beim Verbauen darauf, dass diese unterschiedliche Werte aufweisen (1KΩ und 10KΩ). Dabei erkennt man den sogenannten 1KΩ-Widerstand an der Abfolge braun (1. Stelle = 1), schwarz (2. Stelle = 0) und rot (Multiplikator 100Ω). Der 10KΩ Widerstand hat dagegen die Ringfarben braun, schwarz und orange. Nimm Dir bei diesem Schritt etwas Zeit, denn damit später alles funktioniert, müssen die Widerstände richtig eingesetzt sein. Wenn Du hierbei Hilfe benötigst, gibt es im Internet tolle Rechner, die nach Eingabe der Farben den Widerstandswert anzeigen. Das Anbringen der beiden Mikrotaster hingegen ist super unkompliziert. Dabei besitzen sie zwei Anschlüsse, die Du am Board einfach befestigst.

In 3 Schritten das Arduino Reaktionsspiel erstellen

Du möchtest sofort mit Deinem Projekt starten? Dann erklären wir Dir als Nächstes, wie Du in Windeseile Dein eigenes Reaktionsspiel erstellst. Doch bevor Du mit dem Tüfteln startest, solltest Du zuerst den Arduino Download durchführen. Wenn Du Dich erstmal langsam ans Coden herantrauen möchtest, dann ist Scratch genau die richtige Wahl oder Du schaust Dir mal unseren Artikel Arduino mBlock an. Dort findest Du ein einfaches Projekt in sechs Schritten erklärt. Doch jetzt verraten wir Dir erstmal, wie Du in nur drei Schritten mit dem Arduino ein Reaktionsspiel erstellst. Bist Du startklar? Dann beginnen wir nun mit dem Tüfteln!

1. Aufbau der Schaltung 

Die meisten Bauteile sind nun am Board befestigt. Bevor wir aber den Code des Games erstellen, müssen wir uns noch um die Schaltung kümmern. Diese kannst Du dabei ganz ohne Löten zusammenstecken. Abbildung 2 zeigt Dir, wie das genau funktioniert.

Die Schaltung sieht durch die vielen bunten Kabel ziemlich kompliziert aus. Aber keine Sorge! Das Einrichten ist super einfach. Dabei werden die äußeren Spannungsleisten des Breadboards vom Arduino mit Spannung versorgt. Am Minuspol werden die LEDs jeweils über einen Vorwiderstand angeschlossen und anschließend mit einem schaltbaren Ausgang verbunden. Wenn Du alles richtig verbaut hast, leuchtet die LED. Dabei wird der Taster einfach mit dem Plus- und Minuspol verbunden. Abbildung 3 zeigt die Darstellung nochmal im Detail:

2. Das Board anschließen 

Alles ist befestigt? Perfekt! Dann geht es jetzt ans Eingemachte. Damit das Spiel auch richtig funktioniert, musst Du als Nächstes das Board anschließen. Dabei wird nach dem Start der Entwicklungsumgebung zunächst der Anschluss-Port ausgewählt. Dafür muss das Board über ein USB-Kabel mit dem PC verbunden sein. Ist das der Fall, wählst Du anschließend unter Werkzeuge > Port den Arduino UNO aus.

Du möchtest wissen, ob Dir beim Einrichten ein Fehler unterlaufen ist? Die Verbindung kannst Du ganz einfach überprüfen, indem Du in den Einstellungen die Kategorie Werkzeuge aufrufst und anschließend auf den Reiter Boardinformationen klickst. Anschließend werden alle Daten angezeigt. Wenn alles funktioniert, geht es nun ans Coden.

3. Den Code des Geschicklichkeitsspiels einrichten

Die Bauteile sind befestigt? Die Schaltung steht? Wunderbar! Dann können wir als Nächstes mit der Erstellung des Codes beginnen. Indes greifen wir hierfür auf die sogenannte Arduino-Software Sketch zurück. Dabei ist nach dem Start in der Entwicklungsumgebung bereits ein Sketch geöffnet. Wie Du siehst, besteht er aus den Routinen setup() und loop():

In den geschweiften Klammern kannst Du nun den Code für Dein Game erstellen. Dabei wird dieser in der Routine setup() nur einmal beim Start ausgeführt. Dagegen wird der Code in loop() immer wieder in einer Endlosschleife wiederholt. Klingt ganz schön kompliziert, oder? Damit Dir bei der Erstellung kein Fehler unterläuft, haben wir den Code für das Reaktionsspiel im Folgenden aufgelistet. Indes ist er nicht sehr anspruchsvoll, aber recht umfangreich. Daher empfehlen wir Anfängern, den ihn zu kopieren und in die IDE einzufügen:

#define PIN_LED_GOOD 8
#define PIN_LED_BAD  9
#define GAME_STATE_RUNNING 1
#define GAME_STATE_NOT_RUNNING 2
#define PLAYER_1 0
#define PLAYER_2 1
#define PLAYER_AMOUNT 2

const byte pinButtons[PLAYER_AMOUNT] = {2, 3};
const byte pinLeds[PLAYER_AMOUNT] = {10, 11};

byte gameState;
byte ledState;
byte score[PLAYER_AMOUNT];

unsigned long lastButtonClick[PLAYER_AMOUNT];
unsigned long lastLedChange;
unsigned long nextLedStateChange;

void setup() {
  randomSeed(analogRead(0));

  pinMode(PIN_LED_GOOD, OUTPUT);
  pinMode(PIN_LED_BAD, OUTPUT);

  for (byte i=0; i<PLAYER_AMOUNT; i++) {
    pinMode(pinLeds[i], OUTPUT);
    pinMode(pinButtons[i], INPUT);
    lastButtonClick[i] = millis();
  }
  gameState = GAME_STATE_NOT_RUNNING;
}

void loop() {
  switch(gameState) {
    case GAME_STATE_NOT_RUNNING:
      if (isButtonPressed(PLAYER_1) || isButtonPressed(PLAYER_2)) {
        initGame();
      }
      break;
    case GAME_STATE_RUNNING:
      toggleLedState();
      if (isButtonPressed(PLAYER_1)) {
        checkGameState(PLAYER_1);
      }
      if (isButtonPressed(PLAYER_2)) {
        checkGameState(PLAYER_2);
      }
      break;
  }
}

void initGame() {
  gameState = GAME_STATE_RUNNING;
  setNextLedChange();
  ledState = 0;

  digitalWrite(PIN_LED_GOOD, LOW);
  digitalWrite(PIN_LED_BAD, LOW);
  for (byte i=0; i<PLAYER_AMOUNT; i++) {
    digitalWrite(pinLeds[i], LOW);
    lastButtonClick[i] = millis();
    score[i] = 0;
  }
}

void setNextLedChange() {
  lastLedChange = millis();
  nextLedStateChange = random(1200, 2500);
}

bool isButtonPressed(byte playerId) {
  if (millis() – lastButtonClick[playerId] < 300) {
    return false;
  }
  if (digitalRead(pinButtons[playerId]) == HIGH) {
    lastButtonClick[playerId] = millis();
    return true;
  }
  return false;
}

void toggleLedState() {
  if (ledState == PIN_LED_GOOD) {
    return;
  }
  if ((millis() – lastLedChange) < nextLedStateChange) {
    return;
  }
  if (ledState == PIN_LED_BAD) {
    digitalWrite(PIN_LED_BAD, LOW);
    setNextLedChange();
  }

  if (random(0, 100) > 50) {
    ledState = PIN_LED_GOOD;
    digitalWrite(PIN_LED_GOOD, HIGH);
    digitalWrite(PIN_LED_BAD, LOW);
  } else {
    ledState = PIN_LED_BAD;
    digitalWrite(PIN_LED_GOOD, LOW);
    digitalWrite(PIN_LED_BAD, HIGH);
    setNextLedChange();
  }
}

void checkGameState(byte playerId) {
  switch(ledState) {
    case PIN_LED_GOOD:
      digitalWrite(PIN_LED_GOOD, LOW);
      score[playerId]++;
      if (score[playerId] >= 10) {
        gameState = GAME_STATE_NOT_RUNNING;
        for(byte i=0; i<10; i++) {
          digitalWrite(pinLeds[playerId], HIGH);
          delay(250);
          digitalWrite(pinLeds[playerId], LOW);
          delay(250);
        }
        return;
      }
      break;
    case PIN_LED_BAD:
      digitalWrite(PIN_LED_BAD, LOW);
      if (score[playerId] > 0) {
        score[playerId]–;
      }
      break;
  }

  ledState = 0;
  setNextLedChange();
}

Nach der Definition der Konstanten und Variablen werden in der setup()-Methode zunächst die beiden mittleren LEDs als Ausgangs-Pins markiert. Danach werden in der for-Schleife für jeden Spieler eine LED und ein Button festgelegt. Außerdem wird der letzte Klick-Zeitpunkt auf die aktuelle Zeit (in Millisekunden) gesetzt. In der Loop-Funktion wird mittels des switch-Ausdrucks unterschieden, ob das Spiel läuft oder nicht. Im ersteren Fall wird es initialisiert, wenn einer der Spieler den Button gedrückt hat. Dabei wird der Status auf Running gesetzt, alle LEDs ausgeschaltet und der Punktestand zurückgesetzt.

In der Hauptroutine loop() überprüfen wir zunächst den Status der LEDs. Indes verwendest Du hierfür den Befehl toggleLedState(). Anschließend wird mit dem Kommando isButtonPressed() überprüft, ob einer der beiden Spieler seinen Taster gedrückt hat. Ist das der Fall, wird die LED ausgeschaltet. Zudem erhöht oder reduziert sich der Score des Spielers. Im Fall eines Siegs blinkt die Lampe des entsprechenden Spielers. Wenn Du den Inhalt der ganzen Funktion verinnerlicht hast, kannst Du beim Coden nur noch die Funktionsnamen verwenden. Das funktioniert natürlich nur, wenn die Funktionsnamen gut gewählt sind.

Wow, Du hast soeben Dein eigenes Reaktionsspiel mit dem Arduino erstellt. Das war doch gar nicht mal so schwer, oder? Wenn Du auf der Suche nach weiteren spannenden DIYs bist, dann lass Dich doch von der Vielfalt unserer Arduino Projekte inspirieren. Also, auf die Bauteile, fertig, los! Wir wünschen Dir dabei ganz viel Spaß!

FAQs zum Arduino Reaktionsspiel