Lot­to­zah­len mit WiFi

Lese­zeit: 10 Minu­ten
Lösung
Seite als PDF
Navi­ga­ti­on

In einem Web­for­mu­lar kön­nen Lot­to­zah­len ermit­telt und ange­zeigt wer­den. 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 untersucht.

So sieht es aus:

Benö­tig­te Bauteile:

  • RTC-Modul
  • Lei­tungs­dräh­te

Instal­lie­re mit dem Board­ver­wal­ter das pas­sen­de Board:

Ardui­no WiFi
Ardui­no MKR WiFi 1010
Ardui­no Nano 33 IoT

Nach dem Start des Pro­gramms wer­den die IP und die aktu­el­le Zeit im Seri­el­len Moni­tor angezeigt.

Ardui­no IDE 1.8x
Ardui­no IDE 2.x

Benö­tig­te Bibliotheken:

Ardui­no IDE 1.8x
Sketch → Biblio­thek ein­bin­den → Biblio­the­ken verwalten

Ardui­no IDE 2.x

Bin­de die benö­tig­ten Biblio­the­ken ein und lege die Varia­blen fest.:

# include <WiFiNINA.h>
# include <RTClib.h>

// Minimum/Maximum der Zufallszahlen
const byte Minimum  = 1;
const byte Maximum = 20;

// Anzahl der zu ziehenden Zahlen
const byte Anzahl = 6;

// Array für die gezogenen Zahlen
int LottoZahl[Anzahl];

// Array für die angekreuzten Zahlen
int SpielZahl[Anzahl];

int Durchlauf = 0;

byte EinTreffer = 0;
byte ZweiTreffer = 0;
byte DreiTreffer = 0;
byte VierTreffer = 0;
byte FuenfTreffer = 0;
byte SechsTreffer = 0;

// Bezeichnung des RTC-Moduls
RTC_DS3231 rtc;

// Router: Name des Routers
// Passwort: WLAN-Passwort
char Router[] = "FRITZ!Box 7590 LB";
char Passwort[] = "xxxxxx";

// festeIP = false -> IP-Adresse über DHCP vergeben
// festeIP = true -> IP festlegen
bool festeIP = false;

// feste IP
IPAddress ip(192, 168, 1, 200);

// Netzwerkstatus
int status = WL_IDLE_STATUS;
WiFiServer server(80);
WiFiClient client = server.available();

Der setup-Teil. Beach­te die Kommentare.

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

  // auf serielle Verbindung warten
  while (!Serial) {;}

  // RTC-Modul starten
  rtc.begin();

  /*
     wenn Datum und Zeit nicht korrekt -> Datum/Zeit setzen
     Jahr, Monat, Tag, Stunde, Minute, Sekunde
     rtc.adjust(DateTime(2021, 11, 3, 18, 38, 30));
  */

  if (festeIP) WiFi.config(ip);

  // Verbindung aufbauen
  if (WiFi.status() == WL_NO_MODULE)
  {
    Serial.println(F("Verbindungsaufbau gescheitert!"));
  }

  Serial.print("Verbindung aufbauen mit ");
  Serial.println(Router);
  while (status != WL_CONNECTED)
  {
    status = WiFi.begin(Router, Passwort);

    // Zeit für den Verbindungsaufbau
    // wenn die Verbindung nicht zustandekommt -> Zeit vergrößern
    delay(2000);
  }
  server.begin();

  // IP des Servers/des verbunden Computers anzeigen
  Serial.print("Server: ");
  Serial.println(WiFi.SSID());

  // IP des Arduinos anzeigen
  if (festeIP) Serial.print("Statische IP Adresse Arduino: ");
  else Serial.print("IP Adresse Arduino DHCP: ");
  Serial.println(WiFi.localIP());
  DateTime aktuell = rtc.now();
  char Datum[] = "DD.MM.YYYY";
  Serial.print(aktuell.toString(Datum));

  char Zeit[] = " Uhrzeit: hh:mm:ss";
  Serial.println(aktuell.toString(Zeit));
}
Download

Der loop-Teil. Beach­te die Kommentare.

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

  // auf Clienten warten ...
  client = server.available();
  if (client)
  {
    String SchaltungLesen;

    // solange der Client verbunden ist ...
    while (client.connected())
    {
      if (client.available())
      {
        // Anforderung vom Clienten lesen ...
        char Zeichen = client.read();

        // return (\n) gesendet
        if (Zeichen == '\n')
        {
          // wenn der String SchaltungLesen leer ist
          if (SchaltungLesen == "")
          {
            /*
              HTML-Seite aufbauen
              die folgenden Anweisungen müssen
              mit print oder println gesendet werden
              println "verschönert" den Quelltext
              (erzeugt einen Zeilenumbruch im Quelltext)
              " müssen mit \ maskiert werden " -> \"
            */
            // HTML-Seite aufbauen
            client.println("HTTP/1.1 200 OK");
            client.println("Content-type:text/html");

            // Leerzeile zwingend erforderlich
            client.println();

            client.println(F("<!doctype html>"));
            client.println(F("<html>"));

            client.println(F("<body>"));
            client.println("<h2>Lottozahlen mit WiFi ziehen (6 aus " + String(Maximum) + ")</h2>");
            client.println(F("<hr />"));

            client.println(F("<table><tr>"));

            // Button neue Ziehung
            client.print(F("<td><input style='font-size:14pt;"));
            client.print(F("font-weight:bold;"));
            client.print(F(" background-color:#7eff78;"));
            client.print(F(" width:200px; cursor:pointer;"));
            client.print(F(" border-radius:5px;border: 2px solid black;'"));
            client.print(F(" type='button'"));
            client.println(F(" onClick=\"location.href='WiFi.localIP()'\""));
            client.println(F(" value='neue Ziehung'>"));
            client.println(F("</td></tr></table>"));


            client.println(F("<hr />"));
            // Ziehung der "angekreuzten" Zahlen
            Ziehung();

            ZahlenSortieren(LottoZahl, 6);

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

            // Ziehung der Lottozahlen
            Ziehung();

            // Zahlen sortieren
            ZahlenSortieren(LottoZahl, 6);

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

            // String GezogeneZahlen aus den Elementen des Arrays LottoZahl
            // zusammensetzen
            for (int i = 0; i < Anzahl; i++)
            {
              GezogeneZahlen = GezogeneZahlen + LottoZahl[i] + " ";
            }
            DateTime aktuell = rtc.now();
            char Datum[] = "DD.MM.YYYY";
            client.println(aktuell.toString(Datum));

            char Zeit[] = " Uhrzeit: hh:mm:ss";
            client.println(aktuell.toString(Zeit));
            // Zeit schreiben
            Durchlauf ++;

            switch (Treffer)
            {
              case 1:
                EinTreffer ++;
                break;
              case 2:
                ZweiTreffer ++;
                break;
              case 3:
                DreiTreffer ++;
                break;
              case 4:
                VierTreffer ++;
                break;
              case 5:
                FuenfTreffer ++;
                break;
              case 6:
                SechsTreffer ++;
                break;
            }

            client.println(F("<br>---------------------------------------------------------"));

            client.println(F("<br><b>Gespielte Zahlen: </b>"));
            client.println(GespielteZahlen);

            client.println(F("<br>---------------------------------------------------------"));

            client.println(F("<br><b>Gezogene Zahlen: </b>"));
            client.println(GezogeneZahlen);

            client.println(F("<br>---------------------------------------------------------"));
            if (Treffer == 0) client.println(F("<br><b>keine Treffer!</b>"));

            // getroffene Zahlen anzeigen
            else
            {
              client.print("<br><b>" + String(Treffer));
              client.print(F(" Treffer: </b>"));
              client.print(AnzahlTreffer);
            }

            client.println(F("<hr>"));
            client.println(F("<h3 style='background-color:lightyellow'>Statistik:</h4>"));
            client.println(F("---------------------------------------------------------"));

            client.println("<br><b>Anzahl Ziehungen: </b>" + String(Durchlauf) + "<br>");
            client.println(F("<br><b>Anzahl der Treffer:</b>"));
            client.println(F("<br>---------------------------------------------------------"));

            client.println("<br><b>1 Treffer: </b>" + String(EinTreffer));
            String EinTrefferProzent = String(float(EinTreffer) / float(Durchlauf) * 100);
            EinTrefferProzent.replace(".", ",");
            client.println(" " + String(EinTrefferProzent) + "%");

            client.println("<br><b>2 Treffer: </b>" + String(ZweiTreffer));
            String ZweiTrefferProzent = String(float(ZweiTreffer) / float(Durchlauf) * 100);
            ZweiTrefferProzent.replace(".", ",");
            client.println(" " + String(ZweiTrefferProzent) + "%");

            client.println("<br><b>3 Treffer: </b>" + String(DreiTreffer));
            String DreiTrefferProzent = String(float(DreiTreffer) / float(Durchlauf) * 100);
            DreiTrefferProzent.replace(".", ",");
            client.println(" " + String(DreiTrefferProzent) + "%");

            client.println("<br><b>4 Treffer: </b>" + String(VierTreffer));
            String VierTrefferProzent = String(float(VierTreffer) / float(Durchlauf) * 100);
            VierTrefferProzent.replace(".", ",");
            client.println(" " + String(VierTrefferProzent) + "%");

            client.println("<br><b>5 Treffer: </b>" + String(FuenfTreffer));
            String FuenfTrefferProzent = String(float(FuenfTreffer) / float(Durchlauf) * 100);
            FuenfTrefferProzent.replace(".", ",");
            client.println(" " + String(FuenfTrefferProzent) + "%");

            client.println("<br><b>6 Treffer: </b>" + String(SechsTreffer));
            String SechsTrefferProzent = String(float(SechsTreffer) / float(Durchlauf) * 100);
            SechsTrefferProzent.replace(".", ",");
            client.println(" " + String(SechsTrefferProzent) + "%");

            client.println(F("<hr>"));

            // IPs anzeigen
            client.print(F("<b>Eigene IP: "));
            client.print(client.remoteIP());
            client.print(F("</b>"));
            if (festeIP) client.print(F("<br><b>statische IP Arduino: "));
            else client.print(F("<br><b>IP Adresse Arduino DHCP "));
            
            client.print(WiFi.localIP());
            client.print(F("</b>"));
            client.println(F("</body>"));
            client.println(F("</html>"));

            // HTTP-Antwort endet mit neuer Zeile
            client.println();

            // Seite vollständig geladen -> loop verlassen
            break;
          }

          // wenn Auswertung nicht leer ist -> Inhalt löschen
          else
          {
            Auswertung = "";
          }
        }

        // bei einem anderen Zeichen als return (\r)
        // -> Zeichen dem String Auswertung hinzufügen
        else if (Zeichen != '\r')
        {
          Auswertung += Zeichen;
        }
      }
    }
    client.stop();
  }
}

Die Metho­de Zah­len­Sor­tie­ren sor­tiert die Lot­to­zah­len auf­stei­gend der Grö­ße nach.

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

Die Funk­ti­on Zie­hung sorgt für die zufäl­li­ge Aus­wahl der Zahlen.

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

Startseite
Aufgaben A-Z
Suchen
Downloads
Fehlermeldungen
Seite als PDF

Ver­wand­te Aufgaben:


Letzte Aktualisierung: 16. Nov 2021 @ 11:21