Lot­to­zah­len - Anzei­ge auf einem LCD

Lese­zeit: 7 Minu­ten
Navi­ga­ti­on

Der Ardui­no „spielt“ für dich 6 Zah­len. Anschlie­ßend wer­den die Lot­to­zah­len gezo­gen, auf­stei­gend sor­tiert und auf die Anzahl der über­ein­stim­men­den Zah­len unter­sucht. Das Ergeb­nis wird auf einem LCD ange­zeigt.

LCD

So soll die Anzei­ge aus­se­hen:

Benö­tig­te Bau­tei­le:

  • Berüh­rungs­sen­sor
  • LCD 1602
  • 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)

Bin­de zunächst die benö­tig­ten Biblio­the­ken ein und defi­nie­re die Varia­blen:

# include <LiquidCrystal_I2C.h> 
# include <ArduinoSort.h> 
/* 
  Bibliothek ArduinoSort  
  Download: https://github.com/emilv/ArduinoSort/releases    
  Installieren: Sketch → Bibliothek einbinden → Zip-Bibliothek   
  hinzufügen
*/ 
LiquidCrystal_I2C lcd(0x27, 20, 4); 
int SENSOR = 8; 

// Array für die angekreuzten Zahlen 
int SpielZahl[6]; // Array für die gespielten Zahlen und die Lottozahlen int LottoZahl[6]; // Minimum/Maximum der Zufallszahlen int Minimum = 1; int Maximum = 49; // Anzahl der zu ziehenden Zahlen int Anzahl = 6; int SensorLesen;

Für die Bestim­mung der Spiel­zah­len und die Zie­hung der Lot­to­zah­len wird jeweils eine Funk­ti­on ver­wen­det:

int Ziehung() 
{  
  for (int i = 0; i < Anzahl; i ++)   
  {   
    /*  
      die Lottozahl gilt solange als bereits gezogen    
      bis in der for-Schleife nachgewiesen wird, dass sie neu ist         
      und BereitsGezogen den Wert false hat   
    */ 
    bool BereitsGezogen = true;    
    while (BereitsGezogen)   
    {    
      // Zahl ziehen    
      LottoZahl[i] = random(Minimum, Maximum);  
      BereitsGezogen = false;       
      /*      
        Zufallszahl mit den bereits gezogenen Zahlen vergleichen          
        i wird in der ersten for-Schleife hochgezählt  
        alle bisherigen Zahlen (ii) werden mit den bisher gezogenen             
        (außer der gerade gezogenen) verglichen (ii < i)         
        ist sie identisch, erhält BereitsGezogen den Wert true 
        es wird erneut eine Zufallszahl bestimmt  
        wenn die Zahl neu ist, (BereitsGezogen hat noch den Wert false)   
        wird die while-Schleife verlassen und die nächste Zahl   
        gezogen  
      */ 
      for (int ii = 0; ii < i; ii ++)   
      {
         if (LottoZahl[i] == LottoZahl[ii]) BereitsGezogen = true;       
      }
    }
  }
  /*
     das Array mit den Zahlen wird an das Hauptprogramm zurückgegeben 
     beim ersten Aufruf sind es die gespielten Zahlen
     beim zweiten Aufruf die gezogenen Lottozahlen
  */
   return LottoZahl[Anzahl];
 }

Der setup-Teil:

void setup()
{
  pinMode(SENSOR, INPUT);

  // bei Verwendung eines Tasters:
  // pinMode(SENSOR, INPUT_PULLUP);

  // Zufallsgenerator starten
  randomSeed(analogRead(0));

  // LCD einschalten
  lcd.init();
  lcd.backlight();
}

Der loop-Teil beginnt mit dem Zurück­set­zen der Strings und der Anzahl der Tref­fer, dem Lesen des Berüh­rungs­sen­sors und der Zie­hung der Zah­len.

void loop()
{
  String GespielteZahlen = "";
  String GezogeneZahlen = "";
  String AnzahlTreffer = "";
  int Treffer = 0;

  SensorLesen = digitalRead(SENSOR);

  // bei Verwendung eines Tasters:
  // if (SensorLesen == LOW)
  if (SensorLesen == HIGH)
  {
    delay(200);

    // Ziehung der "angekreuzten" Zahlen
    Ziehung();

Anschlie­ßend wird das Array der gespiel­ten Zah­len mit­hil­fe der Biblio­thek Ardui­no­Sort auf­stei­gend sor­tiert und das Array als String (Gespiel­te­Zah­len) zusam­men­ge­setzt und aus­ge­ge­ben.

    sortArray(LottoZahl, 6);
    for (int i = 0; i < Anzahl; i ++)
    {
      GespielteZahlen = GespielteZahlen + LottoZahl[i] + " ";      
      /*
        für den späteren Vergleich wird
        dem Array SpielZahl (die „gespielten“ Zahlen)   
        das identische Element des Arrays LottoZahl zugewiesen
      */ 
      SpielZahl[i] = LottoZahl[i];
    }

Die Zie­hung der Zah­len und das Sor­tie­ren der Zah­len) wird für die eigent­li­chen Lot­to­zah­len wie­der­holt..

    // Ziehung der Lottozahlen
    Ziehung();
    sortArray(LottoZahl, 6); 

Jetzt soll die Anzahl der Tref­fer ermit­telt wer­den:

    // Vergleichen der Elemente der Arrays SpielZahl und LottoZahl
    for (int i = 0; i < Anzahl; i++) 
    { 
      for (int ii = 0; ii < Anzahl; ii++) 
      {
        // Übereinstimmung gefunden -> Treffer um 1 erhöhen
        // AnzahlTreffer: String für übereinstimmende Zahlen erzeugen
        if (SpielZahl[i] == LottoZahl[ii])
        {
          AnzahlTreffer = AnzahlTreffer + SpielZahl[i] + " ";
          Treffer ++;
        }
      }
    }

Für die Anzei­ge wird aus den Ele­men­ten des Arrays Lot­to­Zahl ein String „zusam­men­ge­baut“ (Gezo­ge­ne­Zah­len).

    // String GezogeneZahlen aus den Elementen des Arrays LottoZahl
    // zusammensetzen
    for (int i = 0; i < Anzahl; i++)
    {
      GezogeneZahlen = GezogeneZahlen + LottoZahl[i] + " ";
    }

Die Anzei­ge auf dem LCD:

    // Anzeige LCD
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.noCursor();
    lcd.print("Lottozahlen");
    lcd.setCursor(0, 1);
    lcd.print(GespielteZahlen);

    // Anzeige LCD lcd.setCursor(0, 2);
    lcd.print(GezogeneZahlen);
    lcd.setCursor(0, 3); 

    // keine Treffer 
    if (Treffer == 0) lcd.print("keine Treffer!");
    
    // getroffene Zahlen anzeigen
    else lcd.print("Treffer: " + AnzahlTreffer);
  }
}

Du kannst statt der Biblio­thek Ardui­no­Sort auch das Sor­tier­ver­fah­ren bub­ble­Sort ver­wen­den .

void ZahlenSortieren(int Zahlen[], int Groesse)
{
  // unsortierten Bereich des Arrays durchlaufen
  for (int i = 0; i < (Groesse - 1); i++) 
  { 
    // bei jedem Durchlauf wird das jeweils letzte Element weggelassen 
    for (int ii = 0; ii < (Groesse - (i + 1)); ii++) 
    {
      /* 
        wenn die aktuelle Zahl größer als die nachfolgende Zahl ist   
        -> aktuelle Zahl temporär speichern
        -> Zahlen vertauschen
        -> temporäre Zahl der nachfolgenden Zahl zuweisen
      */
      if (Zahlen[ii] > Zahlen[ii + 1])
      {
        int zwischengespeicherteZahl = Zahlen[ii];
        Zahlen[ii] = Zahlen[ii + 1];
        Zahlen[ii + 1] = zwischengespeicherteZahl;
      }
    }
  }
}

Anschlie­ßend musst du den Auf­ruf ...

sortArray(LottoZahl, 6);

... durch

ZahlenSortieren(LottoZahl, 6);

... erset­zen.



Ver­wand­te Auf­ga­ben:


Letzte Aktualisierung: 23. Aug 2020 @ 19:57