Lottozahlen auf eine SD-Karte schreiben - Programmieren mit Arduino

Lesezeit: 7 Minuten

Der Arduino „spielt“ für dich 6 Zahlen. Anschließend werden die Lottozahlen gezogen, aufsteigend sortiert und auf die Anzahl der übereinstimmenden Zahlen untersucht. Die Lottozahlen sollen mit einem SD-Kartenmodul auf eine SD-Karte gespeichert werden.

So sieht es aus:

Benötigte Bauteile:

Berührungssensor oder Taster
SD-Karten-Modul oder Datenlogger-Shield
Leitungsdrähte

Achte auf die Pin-Belegung des SD-Karten-Moduls!
Die SD-Karte muss mit FAT32 formatiert sein!

➨SD-Karten-Modul

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

Benötigte Bibliothek installieren:

Beim Programmstart soll abgefragt werden, ob die bisherige Datei gelöscht werden soll.

Binde die benötigten Bibliotheken ein und definiere die Variablen::

#include "SdFat.h"

// Bezeichnung der SD-Karte
SdFat SD;

// Bezeichnung der Textdatei
File ZiehungLotto;

// Datenpin für das SD-Kartenmodul
int DatenPin = 10;

// Daten-Logger-Shield
// int DatenPin = 10;

// Pin des Sensors
int SENSOR = 7;

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

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

// Minimum/Maximum der Zufallszahlen
int Minimum = 1;
int Maximum = 49;

// Anzahl der zu ziehenden Zahlen
int Anzahl = 6;

Im setup-Teil muss die SD-Karte gestartet werden und die Abfrage vorbereitet werden:

void setup()
{
  // Zufallsgenerator starten
  randomSeed(analogRead(0));

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

  // bei Verwendung eines Sensors
  // pinMode(SENSOR, INPUT);

  Serial.begin(9600);

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

  /*
    SD-Karte mit Angabe des Datenpins starten
    wenn die Intialisierung fehlschlägt
    - keine SD-Karte vorhanden
    - falsche Pinbelegung
    → es wird eine Fehlermeldung angezeigt
  */
  if (!SD.begin(DatenPin))
  {
    Serial.println(F("Initialisierung fehlgeschlagen!"));
  } 

  else Serial.println(F("Initialisierung abgeschlossen"));
  Serial.println("Datei Lottozahlen.txt löschen (j/n)?");
}

Verwende für Bestimmung der Spielzahlen und die Ziehung der Lottozahlen die Funktion ➨Ziehung.

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) 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 Funktion ZahlenSortieren() sortiert die Lottozahlen aufsteigend.

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

Der loop-Teil. Beachte die Kommentare.

void loop()
{
  // Serielle Eingabe "Datei löschen" lesen
  while (Serial.available() > 0) 
  {
    while (Serial.available() > 0)
    {
      char Eingabe = Serial.read();
      /*
        prüfen, ob die Datei existiert
        wenn ja → Datei Lottozahlen.txt löschen
      */
      if (Eingabe == 'j')
      {
        if (SD.exists("Lottozahlen.txt"))
        {
          // Datei entfernen
          SD.remove("Lottozahlen.txt");
          Serial.println(F("Datei Lottozahlen.txt entfernt!"));
        }
        else
        {
          Serial.println(F("Datei Lottozahlen.txt existiert nicht!"));
        }
      }
      
      else if (Eingabe == 'n')
      {
        Serial.println(F("Lottozahlen werden der Datei Lottozahlen.txt hinzugefügt!"));
      }
    }
  }

  // Variable zurücksetzen
  String AnzahlTreffer = "";
  String GespielteZahlen = "";
  String GezogeneZahlen = "";
  int Treffer = 0;

  int SensorLesen = digitalRead(SENSOR);
  
  // bei Verwendung eines Sensors
  // if (SensorLesen == HIGH)

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

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

    // Zahlen sortieren
    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();
    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] + " ";
    }

    /*
      O_CREAT -> Datei erstellen, wenn sie nicht existiert
      O_WRITE -> in die Datei schreiben
      O_AT_END -> Startposition zum Schreiben an das Ende der Datei setzen
    */
    ZiehungLotto = SD.open("Lottozahlen.txt",  O_CREAT | O_WRITE | O_AT_END);
    
    // wenn die Datei existiert
    if (ZiehungLotto)
    {
      Serial.println("Schreibe Zahlen in Lottozahlen.txt ... ");
      Serial.println("-----------------------------");

      // Daten in die Datei schreiben
      ZiehungLotto.println("Gespielte Zahlen");
      ZiehungLotto.println(GespielteZahlen);
      ZiehungLotto.println("-----------------------------");
      ZiehungLotto.println("Gezogene Zahlen");
      ZiehungLotto.println(GezogeneZahlen);
      ZiehungLotto.println("-----------------------------");

      // keine Treffer
      if (Treffer == 0) ZiehungLotto.println("keine Treffer!");

      // getroffene Zahlen anzeigen
      else ZiehungLotto.println("Treffer: " + AnzahlTreffer);
      ZiehungLotto.println("-----------------------------");

      // Datei schließen
      ZiehungLotto.close();
      Serial.println("Abgeschlossen.");
      Serial.println();
    }

    else
    {
      Serial.println("Datei Lottozahlen.txt konnte nicht gelesen werden");
    }

    // Datei zum Lesen öffnen (O_RDONLY) und Zahlen anzeigen
    ZiehungLotto = SD.open("Lottozahlen.txt", O_RDONLY);
    if (ZiehungLotto)
    {
      Serial.println("Lese Lottozahlen.txt ...");

      // solange sich Zeilen in der Datei befinden ...
      while (ZiehungLotto.available()) 
      {
        // ... werden sie gelesen und im Seriellen Monitor ausgegeben
        Serial.write(ZiehungLotto.read());
      }

      // Datei schließen
      ZiehungLotto.close();
    }

    else
    {
      Serial.println("Lottozahlen konnte nicht geöffnet werden");
    }
  }
}

Ver­wand­te Aufgaben:

Verwandte Aufgaben: