Lottozahlen - Anzeige auf einem LCD – Projekte für Arduino und ESP32-Mikrocontroller

Inhalt

8 Minuten

Ziel des Projekts

Der Arduino „spielt“ für dich 6 Zahlen. Anschließend werden die Lottozahlen gezogen, aufsteigend sortiert und auf die Anzahl der übereinstimmenden Zahlen untersucht. Das Ergebnis wird auf einem LCD angezeigt.

Die Hardware

⇒I²C

Die Helligkeit kann mit einem Potentiometer auf der Rückseite des LCDs eingestellt werden.

Benötigte Bauteile

Taster
4-zeiliges LCD mit I²C-Schnittstelle
Leitungsdrähte

Der Schaltplan

(Fahre mit der Maus über das Bild, um die Bezeichnungen der Bauteile zu sehen)

Benötigte Bibliotheken

Die Ansteuerung von Hardware kann sehr bequem über ⇒Bibliotheken erledigt werden. Das LCD wird mit der Bibliothek LCDIC2 angesteuert.

Die Bibliothek Bounce2 hilft das sogenannte ⇒Prellen des Tasters zu verhindern.

Das Programm

Bibliotheken und Variable

Im Kopf des Programms werden verschiedene ⇒Arrays und ⇒Variable verwendet.

die Arrays für die angekreuzten und gespielten Lottozahlen:
Spielzahl[] und Lottozahl[]
Anzahl der zu ziehenden Zahlen (6)
Anzahl der möglichen Zahlen: Minimum (1) und Maximum (49)

#include "LCDIC2.h"
#include "Bounce2.h"

// 4‑zeiliges LCD
LCDIC2 lcd(0x27, 20, 4);

int Taster = 7;

// "Prallverhinderer" für den Taster starten
Bounce TasteStart = Bounce();

// 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;

#include "LCDIC2.h"

#include "Bounce2.h"

// 4‑zeiliges LCD

LCDIC2 lcd(0x27, 20, 4);

int Taster = 7;

// "Prallverhinderer" für den Taster starten

Bounce TasteStart = Bounce();

// 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;

Der setup-Teil

void setup() 
{
  // LCD starten
  lcd.begin();

  // Cursor “verstecken”
  lcd.setCursor(false);

  pinMode(Taster, INPUT_PULLUP);

  // Instanzen des Objekts Bounce für den Taster zuordnen
  // Zeitintervall einstellen
  TasteStart.attach(Taster);
  TasteStart.interval(20);
 
  // Cursor “verstecken”
  lcd.setCursor(false);

  // Info anzeigen
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Lottozahlen");
  lcd.setCursor(0, 2);
  lcd.print("Start -> Taste");
}

void setup()

{

// LCD starten

lcd.begin();

// Cursor “verstecken”

lcd.setCursor(false);

pinMode(Taster, INPUT_PULLUP);

// Instanzen des Objekts Bounce für den Taster zuordnen

// Zeitintervall einstellen

TasteStart.attach(Taster);

TasteStart.interval(20);

// Cursor “verstecken”

lcd.setCursor(false);

// Info anzeigen

lcd.clear();

lcd.setCursor(0, 0);

lcd.print("Lottozahlen");

lcd.setCursor(0, 2);

lcd.print("Start -> Taste");

}

Der loop-Teil

Der loop-Teil beginnt mit dem Zurücksetzen der Strings und der Anzahl der Treffer, dem Lesen des Tasters und der Ziehung der Zahlen.

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

  if (TasteStart.update()) 
  {
    if (TasteStart.read() == LOW) 
    {
      // Zufallsgenerator starten
      randomSeed(analogRead(0));

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

void loop()

{

String GespielteZahlen = "";

String GezogeneZahlen = "";

String AnzahlTreffer = "";

int Treffer = 0;

if (TasteStart.update())

{

if (TasteStart.read() == LOW)

{

// Zufallsgenerator starten

randomSeed(analogRead(0));

// Ziehung der "angekreuzten" Zahlen

Ziehung();

Anschließend wird das Array der gespielten Zahlen aufsteigend sortiert und das Array als String (GespielteZahlen) zusammengesetzt und ausgegeben.

      ZahlenSortieren(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];
      }

ZahlenSortieren(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 Ziehung der Zahlen und das Sortieren der Zahlen) wird für die eigentlichen Lottozahlen wiederholt..

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

// Ziehung der Lottozahlen

Ziehung();

ZahlenSortieren(LottoZahl, 6);

Jetzt soll die Anzahl der Treffer ermittelt werden:

// 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++;
          }
        }
      }

// 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 Anzeige wird aus den Elementen des Arrays LottoZahl ein String „zusammengebaut“ (GezogeneZahlen).

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

// String GezogeneZahlen aus den Elementen des Arrays LottoZahl

// zusammensetzen

for (int i = 0; i < Anzahl; i++)

{

GezogeneZahlen = GezogeneZahlen + LottoZahl[i] + " ";

}

Die Anzeige auf dem LCD:

      // Anzeige LCD
      lcd.clear();
      lcd.setCursor(0, 0);
      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);
    }
  }
}

// Anzeige LCD

lcd.clear();

lcd.setCursor(0, 0);

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);

}

Die Funktionen

Für die Bestimmung der Spielzahlen und die Ziehung der Lottozahlen wird jeweils eine ⇒Funktion verwendet:

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 Zahlen         
        (außer der gerade gezogenen) Zahlen 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];
 }

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 Zahlen

(außer der gerade gezogenen) Zahlen 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];

}

Die Lottozahlen werden mit ZahlenSortieren() aufsteigend sortiert:

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;
      }
    }
  }
}

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;

}

Lottozahlen – Anzeige auf einem LCD

Ziel des Projekts

Die Hardware

Benötigte Bauteile

Der Schaltplan

Benötigte Bibliotheken

Das Programm

Bibliotheken und Variable

Der setup-Teil

Der loop-Teil

Die Funktionen

Ähnliche Projekte

Ziel des Projekts

Die Hardware

Benötigte Bauteile

Der Schaltplan

Benö­tig­te Biblio­theken

Das Programm

Bibliotheken und Variable

Der setup-Teil

Der loop-Teil

Die Funktionen

Ähnliche Projekte

Benötigte Bibliotheken