Steuerung mit Balluff


Google-Suche auf MEINE-SCHALTUNG.de :





Online Rechner

Chronik

Dauerkalender


Memory Game mit Arduino

Memory-Spiele sind allgemein bekannt und in vielen Ausführungen erhältlich. Zu den bekanntesten gehört wohl das von der Firma Ravensburger vertriebene Kärtchen-Spiel, indem man sich verdeckte Bilder merken muss.
In unserem Versuch wird es darum gehen, sich einen Farbcode, der von aufleuchtenden bunten Lämpchen gebildet wird, zu merken. Anschließen muss durch Betätigen den dazugehörenden Tastern der Code wiederholt werden. Zum Überlegen steht dem Spieler nur eine begrenzte Zeit zur Verfügung. Wird innerhalb von 3 Sekunden keine Taste betätigt, wird das Ratespiel beendet.
Das Spielbrett besteht aus fünf Leuchtdrucktastern mit unterschiedlichen Farben.
Die Aufgabe wird von dem Mikrocontroller Arduino Nano gestellt. Zu gegebenem Zeitpunkt bestimmt er mit seinem internen Zufallsgenerator einen Farbcode, den er anschließend dem Spieler als die zu lösende Aufgabe präsentiert. Dazu leuchten die farbigen Lämpchen in der von dem Mikrocontroller bestimmter Reihenfolge kurz auf. Jetzt muss der Spieler in der richtigen Reihenfolge die dazugehörigen Taster betätigen. Stimmen die farbigen Muster der Aufgabe und der Antwort überein, hat der Spieler die Runde gewonnen. Diese Tatsache wird durch das Aufleuchten des grünen Lämpchens signalisiert. Andernfalls leuchtet das rote Lämpchen auf.

Arduino Nano

Arduino Nano

Der Mikrocontroller stellt uns gerade ausreichende Anzahl von digitalen Ein- und Ausgängen zur Verfügung, um die hier gestellte Aufgabe zu bewältigen. Es werden fünf Taster mit fünf Leuchten direkt an seine Pins angeschlossen. Dazu werden zehn Anschlüsse benötigt. Den elften Pin (Nr. 12) beansprucht für sich ein kleiner Summer, der für ein wenig Akustik sorgt. Ein unverdrahteter analoger Eingang liefert beim Einschalten einen undefinierten Wert, der als Startwert für den Zufallsgenerator des Mikrocontrollers dient. Für das Programm, das lediglich 12% des Programmspeichers beansprucht, stehen über 30000 Bytes zur Verfügung. Ebenso beanspruchen die globalen Variablen lediglich 12% des dynamischen Speichers.

Summer

Summer

Bei dem Krachmacher handelt es sich um einen aktiven Summer. Es ist ein Lautsprecher, der mit eigener Elektronik ausgestattet ist. Um einen Piepton zu erzeugen, reicht es, den Summer mit Spannung zu versorgen. Der Summer arbeitet mit 5 VDC.

Spannungsregler

Spannungsregler


Die Schaltung arbeitet mit 5 VDC. Da die angeschlossene Batterie 9 V liefert, muss diese Spannung runtergeregelt werden. Der hier eingesetzte Spannungsregler basiert auf dem Chip LM2596. Die Ausgangsspannung kann mithilfe eines Poti eingestellt werden.

Taster mit Leuchten

Taster mit Leuchten


Um Aufgaben zu stellen und Antworten zu sammeln, kommen fünf Taster mit Leuchtmelder zum Einsatz. Die Taster verfügen über einen Wechsleranschluss. Die Meldeleuchten, da der Stromverbrauch sehr niedrig ist, können direkt an die Ausgänge des Mikrocontrollers angeschlossen werden.

Schaltplan

Schaltplan


Testschaltung

Testschaltung



Testschaltung Front


Programm (Sketch)

// *******************************************************************************************
// Memory Game mit Arduino Nano
// Arduino IDE 2.3.3
// *******************************************************************************************

int Summer = 12;
int Taster [] =  { 11, 10, 9, 8, 7 };                     // Anschluß-Pins für Taster
int Leuchte [] = { 6, 5, 4, 3, 2 };                       // Anschluß-Pins für Leuchten
                                                          // Position 0: Gelb
                                                          // Position 1: Grün
                                                          // Position 2: Rot
                                                          // Position 3: Weiß
                                                          // Position 4: Blau

int Spiel_Level = 1;                                      // 4 Spiellevel möglich
int Level_Tiefe [] = { 3, 4, 5, 6 };                      // Anzahl der Frage-Lichter pro level
int Level_Zeit [] = { 1000, 700, 500, 300 };              // Tempo der Anzeige in ms
int Fragen_Reihe [6];                                     // Aufgabe

unsigned long MillisAktuell;                              // Variablen für Zeitmessung
unsigned long MillisAlt;

// *******************************************************************************************

void setup() {

    for (int i=0; i<5; i++) {                             // Pins Deklaration
        pinMode(Taster [i], INPUT_PULLUP);
        pinMode(Leuchte [i], OUTPUT);
    }
    pinMode(Summer, OUTPUT);                              // Aktiver Summer
    randomSeed(analogRead(0));                            // Stratwert für Zufallsgenerator
}

// *******************************************************************************************

void loop () {                                            // Hauptprogramm

    // Pause zwischen zwei Aufgaben ----------------------------------------------------------
    Leuchten_blinken ();                                  // Spielpause
    Leuchten_AUS ();                                      // Alle Leuchten AUS
    MillisAlt = millis();
                                       
    // ---------------------------------------------------------------------------------------
    // Bestimmung des Spiellevels, 4 Spiellevels stehen zur Verfügung (1 -:- 4)

    LEVEL_BESTIMMUNG:                                     
        if (digitalRead(Taster [0]) == LOW) {            // Einstellung mit gelbem Taster 
            Spiel_Level++;                               // Spiellevel erhöhen
            MillisAlt = millis();
            if (Spiel_Level > 4) {                       // Spiellevel zu hoch
                Spiel_Level = 1;       
                Leuchten_AUS ();                         // Leuchten aus                   
            }
            delay (200);                                 // Prellen abwarten
        }
        for (int i=0; i<Spiel_Level; i++) {              // Level aktuell anzeigen
            digitalWrite (Leuchte [i+1], HIGH);
        }            
        MillisAktuell = millis();                        // Kein Tasterdruck in 3s = Abbruch
        if (MillisAktuell - MillisAlt < 3000) {
            goto LEVEL_BESTIMMUNG;                       // sonst weitere Eingaben
        } 
        Leuchten_AUS ();                                 // Leuchetn aus
        delay (2000);
        digitalWrite (Summer, HIGH);                     // Summer Ein
        delay (200);
        digitalWrite (Summer, LOW);                      // Summer Aus
        delay (1000);

    // ---------------------------------------------------------------------------------------
    // Die Aufgabe für den Spieler wird via Zufall zusammengestellt --------------------------

    for (int i = 0; i < Level_Tiefe [Spiel_Level-1]; i++) {
        ZUFALL:
            int Zufallszahl = random (5);                // Zufallsszahl 0-:-4
            if (i > 0 && Zufallszahl == Fragen_Reihe [i-1]) {
                goto ZUFALL;
            }
            Fragen_Reihe [i] = Zufallszahl;
    }

    // ---------------------------------------------------------------------------------------
    // Zusammengestellte Aufgabe anzeigen ----------------------------------------------------

    for (int i = 0; i < Level_Tiefe [Spiel_Level-1]; i++) {
        digitalWrite (Leuchte [Fragen_Reihe [i]], HIGH);
        delay (Level_Zeit [Spiel_Level-1]);
        Leuchten_AUS ();
    }

    // ---------------------------------------------------------------------------------------
    // Auf Spielerantwort warten -------------------------------------------------------------

    int Versuch_Nr = 0;
    MillisAlt = millis();
    AUF_ANTWORT_WARTEN:
        if (digitalRead(Taster [Fragen_Reihe [Versuch_Nr]]) == LOW) {          
            Versuch_Nr++;
            MillisAlt = millis();
            delay (200);                                 // Wartezeit 
        }
        MillisAktuell = millis();                        // 3 Sek. für Eingabe
        if (MillisAktuell - MillisAlt > 3000) {
            goto SPIEL_ENDE;                             // Sonst Abbruch
        }       
        if (Versuch_Nr < Level_Tiefe[Spiel_Level-1]) {
            goto AUF_ANTWORT_WARTEN;
        } 

    // ---------------------------------------------------------------------------------------
    // Ergebnisse ----------------------------------------------------------------------------

    SPIEL_ENDE:
    int Blink_Farbe = 2;                                 // Aufgabe nicht gelöst (ROT)                           
    if (Versuch_Nr == Level_Tiefe[Spiel_Level-1]) {        // Richtige Antwort
        Blink_Farbe = 1;                                 // Farbe Grün
    }    
    for (int i=1; i<50; i++) {                           // Grüne Leuchte blinkt
        digitalWrite (Leuchte [Blink_Farbe], HIGH);      
        digitalWrite (Summer, HIGH);      
        delay(50);
        digitalWrite (Leuchte [Blink_Farbe], LOW);
        if (Blink_Farbe == 1)  { digitalWrite (Summer, LOW); };
        delay(50);
    }
    digitalWrite (Summer, LOW);
    delay(3000);
}

// *******************************************************************************************

void Leuchten_blinken () {                               // Lichteffekte für Pausezeit

    for (int i=0; i<200; i++) {
      int Zufall_Leuchte = random (5);                  
      bool OUT_Zustand = digitalRead(Leuchte [Zufall_Leuchte]);
      digitalWrite (Leuchte [Zufall_Leuchte], not OUT_Zustand);
      delay (30);
    }
}

// *******************************************************************************************

void Leuchten_AUS () {                                   // Alle Leuchten AUS

    for (int i=0; i<5; i++) {
      digitalWrite (Leuchte [i], LOW);
    }
}

// *******************************************************************************************

Das Programm besteht grundsätzlich aus fünf Teilen, die nacheinander abgearbeitet werden.

Teil 1: Unterbrechung
Das Teil, das als Unterbrechung oder Pause definiert werden kann, signalisiert dem Spieler, dass der Hauptablauf beendet wurde und das Spiel gleich fortgesetzt wird. In dem Teil werden die Leuchten zufällig zum Leuchten gebracht. Das Lichtspektakel dauert ca. sechs Sekunden.

Teil 2: Spiellevel
Gleich nach der Pause zeigt das Programm an, welcher Spiellevel aktuell aktiv ist. Die Anzeige dauert drei Sekunden lang. Danach, wenn der gelbe Leveltaster nicht betätigt wird, beginnt die dritte Phase des Spiels. Wenn während der Phase der gelbe Taster gedrückt wird, wird der Level erhöht. Es stehen insgesamt vier Spiellevel zur Verfügung. Sie werden durch die Variablen Level_Tiefe und Level_Zeit definiert. Im dritten Level z.B. betragen die Level_Tiefe 5 und Level_Zeit 500. Das bedeutet, dass in dem Level jeder Farbcode aus fünf Farben besteht (fünf farbige Leuchten in bestimmter Reihenfolge). Beim Zeigen der Aufgabe beträgt die Dauer der Anzeige und Pause dazwischen 500 ms.

Teil 3: Aufgabebildung
Sobald der Spiellevel feststeht, beginnt das Programm die neue Aufgabe zusammenzustellen. Welche Farben nacheinander folgen, bestimmt der Zufallsgenerator. Jede neu definierte Farbenreihe wird in der Variable Fragen_Reihe () festgehalten.

Teil 4: Die Aufgabe
Schließlich wird die neue Aufgabe dem Spieler präsentiert. Die Leuchten mit gewählten Farben werden nacheinander ein- und ausgeschaltet.

Teil 5 Die Antwort
Schließlich ist der Spieler an der Reihe. Er muss jetzt die den farbigen Leuchten zugeordnete Taster in richtiger Reihenfolge betätigen. Wenn ihm das gelingt, meldet sich die grüne Meldeleuchte. Andernfalls leuchtet die rote Meldeleuchte auf.

Kurzvideo

Kurzvideo


Weitere Themen:


Google-Suche auf MEINE-SCHALTUNG.de :


Home Impressum Datenschutz