Fußballtipp – Projekte für Arduino und ESP32-Mikrocontroller

Im Seriellen Monitor sollen zufällig ausgewählte Spiele mit zufälligen Ergebnis „getippt“ werden, anschließend werden die Punkte vergeben.
Außerdem können die Gesamtpunkte jeder Mannschaft angezeigt werden.
So sieht es aus:

Für dieses Projekt brauchst du nur den Arduino.

Definiere die ⇒Arrays und die Variablen.

// die Mannschaften
// Größe der Arrays: muss als Konstante definiert werden
const byte AnzahlMannschaften = 18;

// Array wird benötigt, um zwei unterschiedliche Mannschaften zu bestimmen
int ZufallsZahlen[AnzahlMannschaften];

// Arrays für Punkte und Tore
int AnzahlPunkte[AnzahlMannschaften];
int AnzahlTore[AnzahlMannschaften];

// Array der Mannschaften
String Mannschaften[AnzahlMannschaften] =
{
  "Mainz 05", "RB Leipzig", "Arminia Bielefeld", "Union Berlin",
  "VFL Bochum", "VFL Wolfsburg", "Borussia Dortmund", "Bayern München",
  "Eintracht Frankfurt", "Hertha BSC", "Borussia Mönchengladbach",
  "1. FC Köln", "SC Freiburg", "Greuther Fürth",
  "Bayer Leverkusen", "FC Augsburg", "1899 Hoffenheim", "VFB Stuttgart"
};

// Anzahl der Tore Minimum/Maximum
int Minimum = 0;
int Maximum = 4;

// die Mannschaften

// Größe der Arrays: muss als Konstante definiert werden

const byte AnzahlMannschaften = 18;

// Array wird benötigt, um zwei unterschiedliche Mannschaften zu bestimmen

int ZufallsZahlen[AnzahlMannschaften];

// Arrays für Punkte und Tore

int AnzahlPunkte[AnzahlMannschaften];

int AnzahlTore[AnzahlMannschaften];

// Array der Mannschaften

String Mannschaften[AnzahlMannschaften] =

{

"Mainz 05", "RB Leipzig", "Arminia Bielefeld", "Union Berlin",

"VFL Bochum", "VFL Wolfsburg", "Borussia Dortmund", "Bayern München",

"Eintracht Frankfurt", "Hertha BSC", "Borussia Mönchengladbach",

"1. FC Köln", "SC Freiburg", "Greuther Fürth",

"Bayer Leverkusen", "FC Augsburg", "1899 Hoffenheim", "VFB Stuttgart"

};

// Anzahl der Tore Minimum/Maximum

int Minimum = 0;

int Maximum = 4;

Der setup-Teil zeigt das Menü und startet den Zufallsgenerator:

void setup()
{
  Serial.begin(9600);

  // auf serielle Verbindung warten
  while (!Serial);
  delay(1000);

  // Info
  Serial.println("Ergebnisse tippen: -> <s>");
 </s> Serial.println("Gesamtpunkte anzeigen: -> ");
  Serial.println("-------------------------------------------");

  // Zufallsgenerator starten
  randomSeed(analogRead(A0));<s><t>
}

void setup()

{

Serial.begin(9600);

// auf serielle Verbindung warten

while (!Serial);

delay(1000);

// Info

Serial.println("Ergebnisse tippen: -> <s>");

</s> Serial.println("Gesamtpunkte anzeigen: -> ");

Serial.println("-------------------------------------------");

// Zufallsgenerator starten

randomSeed(analogRead(A0));<s><t>

}

Der loop-Teil.

void loop()
{
  // auf serielle Eingabe warten
  while (Serial.available() > 0)
  {
    // Eingabe im Seriellen Monitor lesen
    char Zeichen = Serial.read();
    {
      // Spielpaarung ziehen
      if (Zeichen == 's')
      {
        // 2 unterschiedliche Mannschaften bestimmen
        for (int i = 0; i < 2; i++)
        {
          /*
            die Mannschaft 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
            ZufallsZahlen[i] = random(0, AnzahlMannschaften);
            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) 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 (ZufallsZahlen[i] == ZufallsZahlen[ii]) BereitsGezogen = true;
            }
          }
        }

        /*
          nach Aufruf der Funktion steht ein Array mit 2 Elementen zur Verfügung
          es beinhaltet die zufällig ausgewählten Mannschaften:
          ZufallsZahlen[0] und ZufallsZahlen[1]
          hiermit wird die Paarung des Spiels bestimmt
        */
        Serial.print(Mannschaften[ZufallsZahlen[0]]);
        Serial.print(" - " + Mannschaften[ZufallsZahlen[1]]);

        // Anzahl der Tore bestimmen
        AnzahlTore[ZufallsZahlen[0]] = random(Minimum, Maximum);
        AnzahlTore[ZufallsZahlen[1]] = random(Minimum, Maximum);

        // Sieger ermitteln: Sieger erhält 3 Punkte
        // Sieger 1. Mannschaft
        if (AnzahlTore[ZufallsZahlen[0]] > AnzahlTore[ZufallsZahlen[1]])
        {
          AnzahlPunkte[ZufallsZahlen[0]] = AnzahlPunkte[ZufallsZahlen[0]] + 3;
        }

        // Sieger 2. Mannschaft
        else if (AnzahlTore[ZufallsZahlen[0]] < AnzahlTore[ZufallsZahlen[1]])
        {
          AnzahlPunkte[ZufallsZahlen[1]] = AnzahlPunkte[ZufallsZahlen[1]] + 3;
        }

        // unentschieden: beide Mannschaften 1 Punkt
        else if (AnzahlTore[ZufallsZahlen[0]] == AnzahlTore[ZufallsZahlen[1]])
        {
          AnzahlPunkte[ZufallsZahlen[0]] = AnzahlPunkte[ZufallsZahlen[0]] + 1;
          AnzahlPunkte[ZufallsZahlen[1]] = AnzahlPunkte[ZufallsZahlen[1]] + 1;
        }

        // Ergebnis anzeigen
        Serial.print(" ");
        Serial.print(AnzahlTore[ZufallsZahlen[0]]);
        Serial.print(" : ");
        Serial.println(AnzahlTore[ZufallsZahlen[1]]);

        // Punkte anzeigen
        Serial.print(Mannschaften[ZufallsZahlen[0]]);
        Serial.println(": " + String(AnzahlPunkte[ZufallsZahlen[0]]) + " Punkt(e)");
        Serial.print(Mannschaften[ZufallsZahlen[1]]);
        Serial.println(": " + String(AnzahlPunkte[ZufallsZahlen[1]]) + " Punkt(e)");
      }

      // Gesamtpunkte anzeigen
      if (Zeichen == 't')
      {
        // Mannschaften nach Anzahl der Punkte sortieren
        ZahlenSortieren();
        Serial.println("-------------------------------------------");

        // Mannschaften in der Reihenfolge der Punkte anzeigen
        // die Mannschaft mit den meisten Punkte zuerst
        for (int i = AnzahlMannschaften - 1; i >= 0; i--)
        {
          Serial.print(Mannschaften[i]);
          Serial.println(": " + String(AnzahlPunkte[i]) + " Punkt(e)");
        }
        Serial.println("-------------------------------------------");
      }
    }
  }
}

100

101

102

103

104

105

106

107

108

void loop()

{

// auf serielle Eingabe warten

while (Serial.available() > 0)

{

// Eingabe im Seriellen Monitor lesen

char Zeichen = Serial.read();

{

// Spielpaarung ziehen

if (Zeichen == 's')

{

// 2 unterschiedliche Mannschaften bestimmen

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

{

die Mannschaft 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

ZufallsZahlen[i] = random(0, AnzahlMannschaften);

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) 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 (ZufallsZahlen[i] == ZufallsZahlen[ii]) BereitsGezogen = true;

}

nach Aufruf der Funktion steht ein Array mit 2 Elementen zur Verfügung

es beinhaltet die zufällig ausgewählten Mannschaften:

ZufallsZahlen[0] und ZufallsZahlen[1]

hiermit wird die Paarung des Spiels bestimmt

Serial.print(Mannschaften[ZufallsZahlen[0]]);

Serial.print(" - " + Mannschaften[ZufallsZahlen[1]]);

// Anzahl der Tore bestimmen

AnzahlTore[ZufallsZahlen[0]] = random(Minimum, Maximum);

AnzahlTore[ZufallsZahlen[1]] = random(Minimum, Maximum);

// Sieger ermitteln: Sieger erhält 3 Punkte

// Sieger 1. Mannschaft

if (AnzahlTore[ZufallsZahlen[0]] > AnzahlTore[ZufallsZahlen[1]])

{

AnzahlPunkte[ZufallsZahlen[0]] = AnzahlPunkte[ZufallsZahlen[0]] + 3;

}

// Sieger 2. Mannschaft

else if (AnzahlTore[ZufallsZahlen[0]] < AnzahlTore[ZufallsZahlen[1]])

{

AnzahlPunkte[ZufallsZahlen[1]] = AnzahlPunkte[ZufallsZahlen[1]] + 3;

}

// unentschieden: beide Mannschaften 1 Punkt

else if (AnzahlTore[ZufallsZahlen[0]] == AnzahlTore[ZufallsZahlen[1]])

{

AnzahlPunkte[ZufallsZahlen[0]] = AnzahlPunkte[ZufallsZahlen[0]] + 1;

AnzahlPunkte[ZufallsZahlen[1]] = AnzahlPunkte[ZufallsZahlen[1]] + 1;

}

// Ergebnis anzeigen

Serial.print(" ");

Serial.print(AnzahlTore[ZufallsZahlen[0]]);

Serial.print(" : ");

Serial.println(AnzahlTore[ZufallsZahlen[1]]);

// Punkte anzeigen

Serial.print(Mannschaften[ZufallsZahlen[0]]);

Serial.println(": " + String(AnzahlPunkte[ZufallsZahlen[0]]) + " Punkt(e)");

Serial.print(Mannschaften[ZufallsZahlen[1]]);

Serial.println(": " + String(AnzahlPunkte[ZufallsZahlen[1]]) + " Punkt(e)");

}

// Gesamtpunkte anzeigen

if (Zeichen == 't')

{

// Mannschaften nach Anzahl der Punkte sortieren

ZahlenSortieren();

Serial.println("-------------------------------------------");

// Mannschaften in der Reihenfolge der Punkte anzeigen

// die Mannschaft mit den meisten Punkte zuerst

for (int i = AnzahlMannschaften - 1; i >= 0; i--)

{

Serial.print(Mannschaften[i]);

Serial.println(": " + String(AnzahlPunkte[i]) + " Punkt(e)");

}

Serial.println("-------------------------------------------");

}

Für die „Tabelle“ wird die ⇒Funktion ZahlenSortieren benötigt.

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