Wür­fel­spiel mit einer vier­stel­li­gen Anzeige

Lese­zeit: 8 Minu­ten

Wür­fel­spiel Seri­el­ler Monitor

Navi­ga­ti­on

Das 7- Seg­ment Dis­play hat 4 Stel­len mit je 7 Seg­men­ten wobei nach 2 Stel­len ein Dop­pel­punkt dar­ge­stellt wer­den kann. Somit ergibt sich eine Anzei­ge von Zah­len­wer­ten von 0000 bis 9999.
Die Anschlüs­se:
CLK → belie­bi­ger digi­ta­ler Pin
DIO → belie­bi­ger digi­ta­ler Pin
VCC → 5 V
GND → Ground

Als Ers­tes musst du die Biblio­thek TM1637 installieren.

Sketch → Biblio­thek ein­bin­den → Biblio­the­ken verwalten

Das Pro­gramm simu­liert ein Wür­fel­spiel für zwei Spie­ler. Jeder Spie­ler ver­fügt über einen Tas­ter. Wird die­ser gedrückt, wird die Sum­me der bis dahin gewür­fel­ten Zah­len ange­zeigt.

Nach sechs Wür­fen ermit­telt das Pro­gramm den Sie­ger und zeigt die Sum­me der gewür­fel­ten Zah­len an.

So sieht es aus:

ers­ter Spie­lerPunk­te­standzwei­ter Spie­lerPunk­te­standAnzei­ge des Sie­gers Sum­me

Benö­tig­te Bauteile:

  • 2 Tas­ter
  • 7-Segment-Anzeige
  • Lei­tungs­dräh­te

Baue die Schal­tung auf.
(Fah­re mit der Maus über das Bild, um die Bezeich­nun­gen der Bau­tei­le zu sehen)

Jedes der vier Zei­chen besteht aus 7 Seg­men­ten. Damit kön­nen alle Zif­fern und auch eini­ge Buch­sta­ben dar­ge­stellt werden.

Die Buch­sta­ben müs­sen in einem 7- Seg­ment Dis­play ➨Array dar­ge­stellt werden:

Bei­spiel:

// Array für StoP 
const byte STOP[] =  
{ 
  SEG_A | SEG_F | SEG_G | SEG_C | SEG_D, // S 
  SEG_F | SEG_E | SEG_G | SEG_D,         // t 
  SEG_E | SEG_G | SEG_C | SEG_D,         // o 
  SEG_E | SEG_F | SEG_A | SEG_B | SEG_G, // P 
}; 

Auf Tas­ter­druck star­tet ein Count­down von 10 bis 0. Am Ende zeigt das Dis­play „StoP“:

Metho­de Para­me­ter
setBrightness(int)0-15 → Hel­lig­keit des Dis­plays setzen
clear()Anzei­ge löschen
showNumberDec(int, bool, int, int)int → Zahl, die ange­zeigt wird
false/true → füh­ren­de 0 verbergen/anzeigen
int → Posi­ti­on 1-4 (1 → links, 4 → rechts)
int → Posi­ti­on der nie­der­wer­tigs­ten Ziffer
0 → ganz links, 3 → rechts, 
die bei­den letz­ten Para­me­ter sind optio­nal, wer­den sie weg­ge­las­sen, erfolgt die Anzei­ge ganz rechts
showNumberDecEx(int, int, bool, int, int)int → Zahl, die ange­zeigt wird
int → 64 → Dop­pel­punkt anzeigen
oder hexa­de­zi­mal 0×40
false/true → füh­ren­de 0 verbergen/anzeigen
int → Posi­ti­on 1-4 (1 → links, 4 → rechts)
int → Posi­ti­on der nie­der­wer­tigs­ten Ziffer
0 → ganz links, 3 → rechts
die bei­den letz­ten Para­me­ter sind optio­nal, wer­den sie weg­ge­las­sen, erfolgt die Anzei­ge ganz rechts
setSegments(Daten_Array)zeigt das unter Daten_Array defi­nier­te Array an
// Bibliothek einbinden 
# include <TM1637Display.h> 

// Pins für das Display definieren 
int CLK =  2; 
int DIO = 3; 

// Pin für den Taster 
int TASTER = 7; 

// Name und Pins für das Display festlegen 
TM1637Display Anzeige(CLK, DIO);

// Array für die Anzeige LOS 
const byte LOS[] =  
{   SEG_F | SEG_E | SEG_D,                          // L  
    SEG_A | SEG_F | SEG_E | SEG_D | SEG_C | SEG_B,  // O 
    SEG_A | SEG_F | SEG_G | SEG_C | SEG_D,          // S  
    0 | 0 | 0 | 0 | 0 | 0 | 0,                      // leer 
}; 

// Array für die Anzeige StoP  
const byte STOP[] =  
{ 
  SEG_A | SEG_F | SEG_G | SEG_C | SEG_D, // S  
  SEG_F | SEG_E | SEG_G | SEG_D,         // t 
  SEG_E | SEG_G | SEG_C | SEG_D,         // o 
  SEG_E | SEG_F | SEG_A | SEG_B | SEG_G, // P 
}; 

void setup() 
{ 
  pinMode(TASTER, INPUT_PULLUP); 

  // Anzeige löschen 
  Anzeige.clear(); 

  // Helligkeit des Displays setzen (1-15) 
  Anzeige.setBrightness(2); 

  // LOS anzeigen 
  Anzeige.setSegments(LOS); 
} 

void loop() 
{ 
  int Tasterlesen = digitalRead(TASTER); 
  if (Tasterlesen == LOW) 
  { 
    Anzeige.clear(); 
    for (int i = 10; i >= 0; i--) 
    { 
      Anzeige.showNumberDec(i, false, 4, 0); 
      delay(1000); 
    }  
    Anzeige.setSegments(STOP); 
    delay(3000); 
  } 
  Anzeige.setSegments(LOS); 
} 

Der Kopf für das Spiel muss mit den Arrays für die Mel­dun­gen ergänzt werden:

// Array für SP-1 
byte SPIELER1[] = 
{ 
  SEG_A | SEG_F | SEG_G | SEG_C | SEG_D, // S 
  SEG_E | SEG_F | SEG_A | SEG_B | SEG_G, // P 
  SEG_G,                                 // - 
  SEG_B | SEG_C,                         // 1
 }; 

// Array für SP-2 
byte SPIELER2[] = 
{ 
  SEG_A | SEG_F | SEG_G | SEG_C | SEG_D, // S 
  SEG_E | SEG_F | SEG_A | SEG_B | SEG_G, // P 
  SEG_G,                                 // - 
  SEG_A | SEG_B | SEG_G | SEG_E | SEG_D, // 2 
}; 

// Array für SIEG 
byte SIEG[] = 
{ 
  SEG_A | SEG_F | SEG_G | SEG_C | SEG_D,         // S 
  SEG_B | SEG_C,                                 // I 
  SEG_A | SEG_F | SEG_G | SEG_E | SEG_D,         // E 
  SEG_A | SEG_F | SEG_E | SEG_D | SEG_C | SEG_G, // G 
}; 

// Array für UNENTSCHIEDEN 
byte UNENTSCHIEDEN[] = 
{ 
  SEG_G | SEG_D,        // = 
}; 

Außer­dem müs­sen noch die Defi­ni­ti­on der Tas­ter, die Varia­blen für die erziel­ten Punk­te, die Anzahl der gespiel­ten Run­den und die Rei­hen­fol­ge der Spie­ler hin­zu­ge­fügt werden:

// die Taster 
int TASTER1 = 6; 
int TASTER2 = 7; 

// Summe der Augen der beiden Spieler 
int SummeSpieler1; 
int SummeSpieler2; 

// Anzahl der Runden, Start mit 1 
int Runde = 1; 

int Zahl; 
int TasterStatus; 

// Reihenfolge der Spieler festlegen, Spieler1 startet 
bool StartSpieler1 = true; 
bool StartSpieler2 = false; 

Im setup-Teil wird zusätz­lich der ➨Zufalls­ge­ne­ra­tor gestartet.

Der loop-Teil. Beach­te die Kommentare.

void loop() 
{ 
  int Minimum = 1; 
  int Maximum = 7; 

  // 6 Runden spielen 
  while (Runde < 7) 
  { 
    // Spieler 1 ist an der Reihe StartSpieler1 → true 
    if (StartSpieler1) 
    { 
      TasterStatus = digitalRead(TASTER1); 
      if (TasterStatus == LOW) 
      { 
        // Wechsel → Spieler2 ist an der Reihe 
        StartSpieler1 = !StartSpieler1; 
        StartSpieler2 = !StartSpieler2; 

        delay(200); 
        Anzeige.setBrightness(2); 
        Anzeige.clear(); 
 
        // Aufruf der Funktion ZufallsZahl 
        SummeSpieler1 = SummeSpieler1 + ZufallsZahl(Minimum, Maximum); 
        /* 
          Punkte anzeigen  
          showNumberDecEx(Zahl, Doppelpunkt anzeigen 
          (64 oder hexadezimal 0x40), 
          false/true(führende 0 verbergen/anzeigen),  
          Position (1-4), 0 (rechtsbündig)) 
        */ 
        Anzeige.showNumberDecEx(SummeSpieler2, 64, true, 4, 0); 
        Anzeige.showNumberDecEx(SummeSpieler1, 64, true, 2, 0); 
        delay(2000);  
        Anzeige.setSegments(SPIELER2); 
      } 
    } 

    // Spieler 2 ist an der Reihe StartSpieler2 → true 
    if (StartSpieler2) 
    { 
      TasterStatus = digitalRead(TASTER2); 
      if (TasterStatus == LOW) 
      { 
        // Wechsel → Spieler1 ist an der Reihe 
        StartSpieler1 = !StartSpieler1; 
        StartSpieler2 = !StartSpieler2; 

        delay(200); 
        Anzeige.setBrightness(2); 
        Anzeige.clear(); 

        // Aufruf der Funktion ZufallsZahl 
        SummeSpieler2 = SummeSpieler2 + ZufallsZahl(Minimum, Maximum); 
        Anzeige.showNumberDecEx(SummeSpieler2, 64, true, 4, 0); 
        Anzeige.showNumberDecEx(SummeSpieler1, 64, true, 2, 0); 
        delay(2000); 
        Anzeige.setSegments(SPIELER1); 

        // nur bei Spieler2 Runde hochzählen, Spieler1 hat angefangen 
        Runde ++; 
      } 
    } 
  } 

  // unentschieden   
  if (SummeSpieler1 == SummeSpieler2) 
  { 
    Anzeige.clear(); 
    Anzeige.setSegments(UNENTSCHIEDEN, 1 , 2); 
    delay(2000); 
    Anzeige.setSegments(SPIELER1); 

    // alle Werte zurücksetzen 
    Runde = 1; 
    SummeSpieler1 = 0; 
    SummeSpieler2 = 0; 
  } 

  // Sieger Spieler1 
  if (SummeSpieler1 > SummeSpieler2) 
  { 
    Anzeige.setSegments(SIEG); 
    delay(2000); 
    Anzeige.setSegments(SPIELER1); 
    delay(2000); 
    Anzeige.showNumberDec(SummeSpieler1, false); 
    delay(2000); 
    Anzeige.setSegments(SPIELER1); 
 
    // alle Werte zurücksetzen 
    Runde = 1; 
    SummeSpieler1 = 0; 
    SummeSpieler2 = 0; 
  } 

  // Sieger Spieler2 
  if (SummeSpieler1 < SummeSpieler2) 
  { 
    Anzeige.setSegments(SIEG); 
    delay(2000); 
    Anzeige.setSegments(SPIELER2); 
    delay(2000); 
    Anzeige.showNumberDec(SummeSpieler2, false); 
    delay(2000); 
    Anzeige.setSegments(SPIELER1); 

    // alle Werte zurücksetzen 
    Runde = 1; 
    SummeSpieler1 = 0; 
    SummeSpieler2 = 0; 
  }
} 

Jetzt fehlt nur noch die ➨Funk­ti­on ZufallsZahl.

int ZufallsZahl()
{
  Zahl =  random(Minimum, Maximum);
  return Zahl;
}


Ver­wand­te Aufgaben:


    Letzte Aktualisierung: 22. Nov 2020 @ 15:08