Ziel des Projekts
Das Programm würfelt mit fünf Würfeln. Anschließend werden die Würfe ausgewertet:
- die Anzahl der Würfelvorgänge
- die Augenzahl jedes Wurfs
- die Summe der Augenzahlen
- Anzahl von Dreierpasch, Viererpasch und Kniffel als absoluter Wert und als Prozentsatz
Die ermittelten Werte werden gespeichert.
Beim Programmstart sollen die gespeicherten Werte ausgelesen und abgefragt werden, ob die gespeicherten Werte gelöscht werden sollen.
Die Hardware
Das EEPROM (Electrically Erasable Programmable Read-Only Memory] ist eine kleine „Festplatte“ beim Arduino. Allerdings fasst sie nur 1024 Byte. Der Inhalt bleibt nach dem Ausschalten erhalten.
Jeder Speicherplatz ist 1 Byte groß und kann deshalb nur eine 1 Byte große ⇒Variable oder einen Teil einer anderen Variablen aufnehmen.
Der Inhalt bleibt nach dem Ausschalten erhalten.
Für das Programm ist der Typ byte am besten geeignet, weil er nur 1 Byte beansprucht und genau einen Speicherplatz belegt. Er umfasst die Zahlen von 0 bis 255.
Für das Speichern von Würfelaugen reicht er vollkommen aus.
Beispiel Speichern und Lesen von Zufallszahlen:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 |
// 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(A0)); // 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. vorangestellt werden:
| Schlüsselwort | Aktion |
|---|---|
| write(Speicherplatz, Wert) | beschreibt einen Speicherplatz nur für 1 Byte große Variable (byte, char) |
| update(Speicherplatz, Wert) | aktualisiert den Wert eines Speicherplatzes Im Unterschied zu write() wird der Wert nur geschrieben, wenn er sich vom bisherigen Wert unterscheidet. nur für 1 Byte große Variable (byte, char) |
| read(Speicherplatz, Wert) | liest den Wert an einem Speicherplatz nur für 1 Byte große Variable (byte, char) |
| put(Speicherplatz, Wert) | schreibt den Wert ungeachtet der Größe der Variable anwendbar für alle Variablen |
| get(Speicherplatz, Wert) | liest den Wert ungeachtet der Größe der Variable anwendbar für alle Variablen |
| length() | zeigt die Größe des EEPROMs an |
Benötigte Bauteile
- Taster
- Leitungsdrähte
Der Schaltplan
(Fahre mit der Maus über das Bild, um die Bezeichnungen der Bauteile zu sehen)
Das Programm
Bibliothek und Variable
Binde die Bibliothek EEPROM ein und definiere die Variablen:
|
1 2 3 4 5 6 7 8 9 10 |
#include "EEPROM.h" byte Zufallszahl; byte MaxWuerfeln = 5; int Minumum = 1; int Maximum = 7; int TASTER = 8; int TasterLesen; |
Der setup-Teil
Im setup-Teil wird das EEPROM ausgelesen und gefragt, ob die bisherige Statistik gelöscht werden soll.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 |
void setup() { Serial.begin(9600); // auf serielle Verbindung warten while (!Serial) {;} pinMode(TASTER, INPUT_PULLUP); randomSeed(analogRead(A0)); /* Ü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("---------------------------------------"); } |
Der loop-Teil
Im loop-Teil wird zunächst die Antwort auf die Frage „Bisherige Statistik löschen“ verarbeitet …
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
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!"); } |
Statistik löschen und die gespeicherten Werte lesen:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
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]; |
Nachdem der Taster gedrückt wurde, werden in einer for-Schleife die Zufallszahlen gebildet und mit switch auf die Anzahl der Einsen, Zweien … untersucht.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 |
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); |
Auswertung und Speichern:
Die Anzahl wird erhöht und in die entsprechende Speicherstelle geschrieben:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 |
/* 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 bisheriger Spiele in den Speicher geschrieben werden, der Speicher gelesen und angezeigt werden.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |
// 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("-----------------------------"); } } |
Ähnliche Projekte
- Laplace-Versuch
- LED-Matrix Würfeln
- Lottozahlen – Anzeige auf einem LCD
- Lottozahlen mit einem Ethernet-Shield
- Lottozahlen mit WiFi und NTP
- Lottozahlen – Anzeige auf einem OLED-Display
- Lottozahlen auf eine SD-Karte schreiben
- Lottozahlen mit Zeitstempel anzeigen und auf einer SD-Karte speichern
- Schneckenrennen im Seriellen Monitor
- Würfeln einstellige 7-Segment-Anzeige und Fernbedienung
Letzte Aktualisierung: