Knif­fel - EEPROM verwenden

Lese­zeit: 7 Minu­ten

---

---

---

Das Pro­gramm wür­felt mit fünf Wür­feln. Anschlie­ßend wer­den die Wür­fe ausgewertet:

• die Anzahl der Würfelvorgänge
• die Augen­zahl jedes Wurfs
• die Sum­me der Augenzahlen
• Anzahl von Drei­er­pasch, Vie­rer­pasch und Knif­fel als abso­lu­ter Wert und als Prozentsatz

Die ermit­tel­ten Wer­te wer­den gespei­chert.
Beim Pro­gramm­start sol­len die gespei­cher­ten Wer­te aus­ge­le­sen und abge­fragt wer­den, ob die gespei­cher­ten Wer­te gelöscht wer­den sollen.

So sieht es aus:

Das EEPROM (Elec­tri­cal­ly Erasable Pro­gramma­ble Read-Only Memo­ry] ist eine klei­ne „Fest­plat­te“ beim Ardui­no. Aller­dings fasst sie nur 1024 Byte. Der Inhalt bleibt nach dem Aus­schal­ten erhalten. 

Jeder Spei­cher­platz ist 1 Byte groß und kann des­halb nur eine 1 Byte gro­ße ➨Varia­ble oder einen Teil einer ande­ren Varia­blen auf­neh­men.
Der Inhalt bleibt nach dem Aus­schal­ten erhalten.

➨Wei­te­re Informationen

Für das Pro­gramm ist der Typ byte am bes­ten geeig­net, weil er nur 1 Byte bean­sprucht und genau einen Spei­cher­platz belegt. Er umfasst die Zah­len von 0 bis 255.
Für das Spei­chern von Wür­fel­au­gen reicht er voll­kom­men aus.

Bei­spiel Spei­chern und Lesen von Zufallszahlen:

// eingebaute Bibliothek einbinden 
# include "EEPROM.h"

byte Zufallszahl; 
byte MaxWuerfeln = 5; 

// Maximum muss 7 sein 
// Zufallszahl wird immer nach unten gerundet 
int Minumum = 1; 
int Maximum = 7; 

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

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

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

  // Zufallszahlen schreiben  
  for (int i = 0; i < MaxWuerfeln; i ++) 
  { 
    Zufallszahl = random(Minumum, Maximum); 
    EEPROM.write(i, Zufallszahl);   
  } 

  // Zufallszahlen lesen  
  for (int i = 0; i < MaxWuerfeln; i ++) 
  {  
    Serial.println(EEPROM[i]); 
  } 
} 

void loop() 
{ 
  // bleibt leer, Programm wird nur einmal ausgeführt 
}

Jedem Befehl muss EEPROM. vor­an­ge­stellt werden:

Benö­tig­te Bauteile:

• Tas­ter
• 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 die Biblio­thek EEPROM ein und defi­nie­re die Variablen:

# include "EEPROM.h"

byte Zufallszahl;
byte MaxWuerfeln = 5;

int Minumum = 1;
int Maximum = 7;

int TASTER = 8;
int TasterLesen;

Im set­up-Teil wird das EEPROM aus­ge­le­sen und gefragt, ob die bis­he­ri­ge Sta­tis­tik gelöscht wer­den soll.

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

  // auf serielle Verbindung warten
  while (!Serial) {;}
 
  pinMode(TASTER, INPUT_PULLUP);  
  randomSeed(analogRead(0)); 
  /* 
    Überblick Statistik  
    Speicherstelle EEPROM  
    0 -> Anzahl der Spiele   
    1 -> Anzahl Dreierpasch   
    2 -> Anzahl Viererpasch  
    3 -> Anzahl Kniffel  
  */ 
  
  Serial.print("Anzahl bisheriger Spiele: ");    
  Serial.println(EEPROM[0]); 
  Serial.print("Anzahl Dreierpasch: "); 
  Serial.println(EEPROM[1]); 
  Serial.print("Anzahl Viererpasch: ");
  Serial.println(EEPROM[2]); 
  Serial.print("Anzahl Kniffel: ");    
  Serial.println(EEPROM[3]);  

  /*   
    Abfrage ob die bisherigen Daten 
    aus dem EEPROM gelöscht werden sollen  
    Umlaute ersetzen: ö -> \u00f6 
  */ 

  Serial.println("---------------------------------------");    
  Serial.println("Bisherige Statistik l\u00f6schen (j/n)?");     
  Serial.println("---------------------------------------");
}

Im loop-Teil wird zunächst die Ant­wort auf die Fra­ge „Bis­he­ri­ge Sta­tis­tik löschen“ verarbeitet ...

void loop()
{
  // auf serielle Eingabe warten
  while (Serial.available() > 0)
  {
    // solange lesen, bis return char(13) eingegeben wurde
    String Eingabe = Serial.readStringUntil('\n');

    // das letzte Zeichen ist return = \n → soll entfernt werden (-1)
    Eingabe = Eingabe.substring(0, Eingabe.length() - 1);

    // die ersten 5 Speicherstellen mit 0 überschreiben
    if (Eingabe == "j")
    {
      for (int i = 0; i < 5; ++i)
      {
        EEPROM.write(i, 0);
      }
      Serial.println("Statistik gel\u00f6scht!");
    }
    else Serial.println("Statistik bleibt erhalten!");
    Serial.println("Bitte zum W\u00fcrfeln Taster dr\u00fccken!");
  }

Sta­tis­tik löschen und die gespei­cher­ten Wer­te lesen:

  byte Summe = 0;
  int AnzahlEins = 0;
  int AnzahlZwei = 0;
  int AnzahlDrei = 0;
  int AnzahlVier = 0;
  int AnzahlFuenf = 0;
  int AnzahlSechs = 0;

  // Werte aus EEPROM lesen
  byte AnzahlSpiele = EEPROM[0];
  byte DreierPasch = EEPROM[1];
  byte ViererPasch = EEPROM[2];
  byte Kniffel = EEPROM[3];

Nach­dem der Tas­ter gedrückt wur­de, wer­den in einer for-Schlei­fe die Zufalls­zah­len gebil­det und mit switch auf die Anzahl der Ein­sen, Zwei­en … untersucht.

  TasterLesen = digitalRead(TASTER);
  delay(200);

  if (TasterLesen == LOW)
  {
    AnzahlSpiele ++;
    Serial.println("W\u00fcrfele ...");
    for (int i = 0; i  < MaxWuerfeln; i++)
    {
      Zufallszahl = random(Minumum, Maximum);

      // Anzahl der einsen, zweien ... zählen
      // wird für die Auswertung benötigt
      switch (Zufallszahl)
      {
        case 1:
          AnzahlEins ++;
          break;

        case 2:
          AnzahlZwei ++;
          break;

        case 3:
          AnzahlDrei ++;
          break;

        case 4:
          AnzahlVier ++;
          break;

        case 5:
          AnzahlFuenf ++;
          break;

        case 6:
          AnzahlSechs ++;
          break;
      }
      Serial.println(Zufallszahl);

      // Summe berechnen
      Summe += Zufallszahl;
    }

    // Summe anzeigen
    Serial.println("-----------------------------");
    Serial.print("Summe:  ");
    Serial.println(Summe);

Aus­wer­tung und Spei­chern:
Die Anzahl wird erhöht und in die ent­spre­chen­de Spei­cher­stel­le geschrieben:

   /*
      Auswertung Dreierpasch
      Anzahl wird um 1 erhöht und in die Speicherstelle 1 geschrieben
    */
    if (AnzahlEins == 3)
    {
      Serial.println("Dreierpasch 1");
      DreierPasch ++;
      EEPROM.update(1, DreierPasch);
    }
    if (AnzahlZwei == 3)
    {
      Serial.println("Dreierpasch 2");
      DreierPasch ++;
      EEPROM.update(1, DreierPasch);
    }

    if (AnzahlDrei == 3)
    {
      Serial.println("Dreierpasch 3");
      DreierPasch ++;
      EEPROM.update(1, DreierPasch);
    }

    if (AnzahlVier == 3)
    {
      Serial.println("Dreierpasch 4");
      DreierPasch ++;
      EEPROM.update(1, DreierPasch);
    }

    if (AnzahlFuenf == 3)     
    {
      Serial.println("Dreierpasch 5");
      DreierPasch ++;
      EEPROM.update(1, DreierPasch);
    }

    if (AnzahlSechs == 3)
    {
      Serial.println("Dreierpasch 6");
      DreierPasch ++;
      EEPROM.update(1, DreierPasch);
    }


    /*
      Auswertung Viererpasch
      Anzahl wird um 1 erhöht und in die Speicherstelle 2 geschrieben
    */
    if (AnzahlEins == 4)
    {
      Serial.println("Viererpasch 1");
      ViererPasch ++;
      EEPROM.update(2, ViererPasch);
    }

    if (AnzahlZwei == 4)
    {
      Serial.println("Viererpasch 2");
      ViererPasch ++;
      EEPROM.update(2, ViererPasch);
    }

    if (AnzahlDrei == 4)
    {
      Serial.println("Viererpasch 3");
      ViererPasch ++;
      EEPROM.update(2, ViererPasch);
    }

    if (AnzahlVier == 4)
    {
      Serial.println("Viererpasch 4");
      ViererPasch ++;
      EEPROM.update(2, ViererPasch);
    }

    if (AnzahlFuenf == 4)
    {
      Serial.println("Viererpasch 5");
      ViererPasch ++;
      EEPROM.update(2, ViererPasch);
    }

    if (AnzahlSechs == 4)
    {
      Serial.println("Viererpasch 6");
      ViererPasch ++;
      EEPROM.update(2, ViererPasch);
    }

    /*
      Auswertung Kniffel
      wenn AnzahlEins == 5 oder (||) AnzahlZwei = 5 ...
      keine Auswertung mit welcher Zahl der Kniffel gewürfelt wurde
      Anzahl wird um 1 erhöht und in die Speicherstelle 2 geschrieben
    */
    if (AnzahlEins == 5 || AnzahlZwei == 5 || AnzahlDrei == 5 || AnzahlVier == 5 || AnzahlFuenf == 5 || AnzahlSechs == 5)
    {
      Serial.println("Kniffel");
      Kniffel ++;
      EEPROM.update(3, Kniffel);
    }

Jetzt muss noch die Anzahl bis­he­ri­ger Spie­le in den Spei­cher geschrie­ben wer­den, der Spei­cher gele­sen und ange­zeigt werden.

    // Anzahl der Spiele in Speicherstelle 0 schreiben und anzeigen
    EEPROM.update(0, AnzahlSpiele);
    Serial.println("-----------------------------");
    Serial.print("Anzahl bisheriger Spiele: ");
    Serial.println(EEPROM[0]);

    // Anzahl der bisherigen Dreier- Vierpasch und Kniffel anzeigen
    Serial.print("Anzahl Dreierpasch: ");
    Serial.print(EEPROM[1]);
    Serial.print("  ");
    String PaschDrei = String(float(EEPROM[1]) / float(EEPROM[0]) * 100);
    PaschDrei.replace(".", ",");
    Serial.println(PaschDrei + " %");

    Serial.print("Anzahl Viererpasch: ");
    Serial.print(EEPROM[2]);
    Serial.print("  ");
    String PaschVier = String(float(EEPROM[2]) / float(EEPROM[0]) * 100);
    PaschVier.replace(".", ",");
    Serial.println(PaschVier + " %");

    Serial.print("Anzahl Kniffel: ");
    Serial.print(EEPROM[3]);
    Serial.print("  ");
    String KniffelAnzahl = String(float(EEPROM[3]) / float(EEPROM[0]) * 100);
    KniffelAnzahl.replace(".", ",");
    Serial.println(KniffelAnzahl + " %");
    Serial.println("-----------------------------");
  }
}

---

---

Ver­wand­te Aufgaben:

• DHT11/DHT22 - Wet­ter­da­ten aufzeichnen
• Lot­to­zah­len mit einem Ethernet-Shield
• Lot­to­zah­len auf eine SD-Kar­­te schreiben
• Lot­to­zah­len mit Zeit­stem­pel anzei­gen und auf einer SD-Kar­­te speichern
• DHT11/DHT22 - Wet­ter­sta­ti­on LAN Daten speichern

---

Letzte Aktualisierung: 15. Jul 2023 @ 11:12