Knif­fel - EEPROM verwenden

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

  // 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 setup-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); 
  pinMode(TASTER, INPUT_PULLUP);  
  randomSeed(analogRead(0)); 
  /* 
    Überblick Statistik  
    Speicherstelle EEPROM  
    0 -> Anzahl der Spiele   
    1 -> Anzahl Dreierpasch   
    2 -> Anzahl Viererpasch  
    3 -> Anzahl Kniffel  
  */ 

  // kurze Pause, damit der Startbildschirm korrekt dargestellt wird
  delay(500);
  
  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()
{
  // Variable definieren
  byte Zufallszahl;
 
  // auf serielle Eingabe warten
  while (Serial.available() > 0)
  {
    // solange lesen, bis return \n eingegeben wurde
    String Eingabe = Serial.readStringUntil("\n");

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

    // die ersten 4 Speicherstellen mit 0 überschreiben
    if (Eingabe == "j")
    {
      for (int i = 0; i < 4; ++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:

  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-Schleife die Zufalls­zah­len gebil­det und mit switch auf die Anzahl der Ein­sen, Zwei­en … untersucht.

  TasterLesen = digitalRead(TASTER);
  delay(200);
  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:
        . . . 
        . . .

       case 5:
         . . . 
         . . . 

       case 6:
        . . . 
        . . .
    }

    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:

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

    if (AnzahlZwei == 3)     {
      Serial.println("Dreierpasch 2");
      DreierPasch ++;
      EEPROM.update(1, DreierPasch);
    }
    . . .
    . . .
    
    // Viererpasch
    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);
    }
    . . .
    . . .

    /*
      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.println(EEPROM[1]);
    
    Serial.print("Anzahl Viererpasch: ");
    Serial.println(EEPROM[2]);
    
    Serial.print("Anzahl Kniffel: ");
    Serial.println(EEPROM[3]);
  }
}

Mit eini­gen zusätz­li­chen Zei­len wird die Sta­tis­tik erweitert:

    Serial.print(float(EEPROM[1]) / float(EEPROM[0]) * 100);
    Serial.println(" %"); 

    Serial.print(float(EEPROM[1]) / float(EEPROM[0]) * 100);
    Serial.println(" %"); 
    . . .
    . . . 

Ver­wand­te Aufgaben:

• DHT22 - Wet­ter­da­ten aufzeichnen
• Lot­to­zah­len mit einem Ethernet-Shield
• Lot­to­zah­len auf eine SD-Karte schreiben
• Lot­to­zah­len mit Zeits­tem­pel anzei­gen und auf einer SD-Karte speichern
• Wet­ter­sta­ti­on: Tem­pe­ra­tur und Luft­feuch­tig­keit spei­chern und im Brow­ser anzeigen

Letzte Aktualisierung: 4. Apr 2021 @ 20:13