| Spieluhr mit Arduino
Natürlich ist bei einem Spiel eine Spieluhr, bekannt auch unter dem Begriff Schachuhr, keinesfalls unbedingt notwendig. Wozu sich selbst dem Stress
aussetzen, wenn es gemütlich auch geht? Wer jedoch etwas schneller das Endergebnis erfahren möchte oder ganz einfach etwas Pfeffer in die Suppe geben möchte,
der ist mit einer Spieluhr gut bedient. Mit einer Spieluhr wird bei Denkspielen wie Schach, Dame oder auch einfach Wolf und Schafe die Zeit für einen Zug begrenzt.
Die Spieler müssen sich hier etwas anstrengen, schneller agieren und sind, um das Spiel nicht zu verlieren, gezwungen, in der vorgegebenen Zeit einen Zug auf dem
Spielbrett zu absolvieren. Eine Spieluhr kann auch als eine Art Countdowns verstanden werden. Lässt man zu, dass der Countdown abläuft, ist das Spiel
verloren. Arduino Die RGB-Matrix, die an der Schaltung teilnimmt, hat ziemlich viele Anschlüsse. Deswegen muss man sich nach einem Mikrocontroller mit einer ausreichenden
Anzahl an Anschlüssen umschauen. Eine Aufgabe für Arduino Mega. Der Mikrocontroller kann problemlos die Ansteuerung der Matrix übernehmen und stellt noch eine
Reihe weiterer Pins, die für andere Funktionen verwendet werden können, zur Verfügung. Dabei handelt es sich um eine vorgefertigte Mini-Platine, die neben dem
Mikrocontroller weitere Komponenten enthält, die die Handhabung sehr erleichtern. Bei der Herstellung der Platine wurde die SMD-Technologie
verwendet. Matrix Mit 4096 RGB-Leuchtdioden bietet diese Matrix einiges an Anzeige-Möglichkeiten an. In unserer Schaltung ist sie richtig unterfordert. Da es sich bei
dieser Ausführung um so viele Leuchtdioden handelt, muss man vor dem Einschalten für eine starke Stromquelle sorgen. Ein USB-Anschluss reicht hier nicht aus. Je
nachdem, wie viele Leuchtdioden gerade zum Leuchten gebracht wurden, werden hier 4 bis 5 Ampere gebraucht. Signalgeber Als akustischer Signalgeber kommt in der Schaltung ein aktiver Summer zum Einsatz. Das kleine Gerät, das wirklich viel Krach machen kann, benötigt lediglich
einen Anschluss von 5 VDC. Für die Ansteuerung des kleinen Lautsprechers sorgt die im Gerät integrierte Elektronik. So konzipierte Krachmacher gehören zu der Familie
der aktiven Summer. Schaltplan
In der Ausführung einer Spieluhr bekommt jeder Spieler seinen eigenen „Fertig“-Taster. Sobald er mit seinem Zug fertig ist, muss er den Taster betätigen.
Daraufhin wird seine Zeitzählung unterbrochen und die seines Gegners gestartet. Neben einer entsprechenden Anzeige auf der Matrix gibt es zu jedem Taster eine
Info-Leuchtdiode. Sie wird jeweils bei dem Spieler eingeschaltet, der gerade am Zug ist. Schafft ein Spieler in der vorgegebenen Zeit, in dem Beispiel sind es
10 Sekunden, nicht, einen Zug auszuführen, wird das Spiel beendet und es erklingt ein Signalton. Man kann ein Resett durchführen, indem man beide Taster gleichzeitig
gedrückt hält. Testschaltung Programm// *********************************************************************************************// Spieluhr mit Arduino und mit RGB Matrix 64x64 // Eine Schaltung mit Arduino Mega // Arduino IDE 2.3.2 // ********************************************************************************************* #include "RGBmatrixPanel.h" // Matrix - Bibliothek #define CLK 11 // Pins für Matrix-Anschlüsse #define OE 9 #define LAT 10 #define A A0 #define B A1 #define C A2 #define D A3 #define E A4 RGBmatrixPanel matrix(A, B, C, D, E, CLK, LAT, OE, false, 64); int Taster_Spieler_Blau = 2; // Taster Spieler Blau fertig int Taster_Spieler_Gelb = 3; // Taster Spieler Gelb fertig int LED_Gelb = 4; // Ausgang Leuchtdiode Gelb int LED_Blau = 5; // Ausgang Leuchtdiode Blau int Summer = 6; // Ausgang Summer (Akustisches Signal) int Spiel_Status = 0; // Spiel-Modus Aktuell: // 0 - Spiel noch nicht begonnen // 1 - Blau hat verloren // 2 - Gelb hat verloren // 3 - Blau ist am Zug // 4 - Gelb ist am Zug bool Blinkpunkt_on_off = true; // Umschalt-Merker Blinkpunkt unsigned long Millis_Aktuell, Millis_Alt_1, Millis_Alt_2; int X = 30, Y = 23; // Start-Koordinaten Blinkpunkt // ********************************************************************************************* void setup() { matrix.begin(); delay(500); pinMode(Taster_Spieler_Blau, INPUT_PULLUP); // Taster Blau als Pullup pinMode(Taster_Spieler_Gelb, INPUT_PULLUP); // Taster Gelb als Pullup pinMode(LED_Gelb, OUTPUT); // Pin 4 als Ausgang pinMode(LED_Blau, OUTPUT); // Pin 5 als Ausgang pinMode(Summer, OUTPUT); // Pin 6 als Ausgang matrix.drawRect(1, 1, 62, 62, matrix.Color333(0, 7, 0)); // Außen Rahmen grün Zeitbalken(); // Zeitbalken aufbauen Blinkpunkt(); // Blinkpunkt platzieren Millis_Alt_1 = Millis_Alt_2 = millis(); // Millisekunden aktuell festhalten Smiles(31, 11, 1); // Smiles Mitte } // ********************************************************************************************* void loop() { Millis_Aktuell = millis(); // Millisekunden aktuell if (Millis_Aktuell > Millis_Alt_1 + 200) { // Ein-Aus-Frequenz Blinkpunkt 200ms Blinkpunkt(); // Blinkpunkt anzeigen Millis_Alt_1 = Millis_Aktuell; // Millis_Alt_1 neu belegen } if (Millis_Aktuell > Millis_Alt_2 + 1000) { // Zeitbasis = 1000 ms = 1 Sek. if (Spiel_Status > 2) { // Es wird gespielt Millis_Alt_2 = Millis_Aktuell; // Zeit festhalten Linie_loeschen(); // Zeitbalken löschen Y = Y + 3; // Y-Koordinate neu berechnen if (Y == 53) { // Letzter Balken erreicht = Spielende Spiel_Status = Spiel_Status - 2; // Spiel-Modus-Wechsel, Spiel beendet } } } if (digitalRead(Taster_Spieler_Gelb) == LOW && (Spiel_Status == 4 or Spiel_Status == 0)) { // Gelb ist fertig / Blau ist am Zug Millis_Alt_2 = millis(); // Zeitzählung Blinkpunkt_on_off = true; // Blinkpunkt löschen Blinkpunkt(); // -- " -- Spiel_Status = 3; // Spielmodus = Blau am Zug X = 11; // Startkoordinaten Blinkpunkt Y = 23; Blinkpunkt(); Zeitbalken(); // Zeitbalken neu zeichnen digitalWrite(LED_Gelb, LOW); // Info-LEDs umschalten digitalWrite(LED_Blau, HIGH); } if (digitalRead(Taster_Spieler_Blau) == LOW && (Spiel_Status == 3 or Spiel_Status == 0)) { // Blau ist fertig / Gelb ist am Zug Millis_Alt_2 = millis(); // Zeitzählung Blinkpunkt_on_off = true; // Blinkpunkt löschen Blinkpunkt(); // -- " -- Spiel_Status = 4; // Spielmodus = Gelb am Zug X = 38; // Startkoordinaten Blinkpunkt Y = 23; Blinkpunkt(); Zeitbalken(); // Zeitbalken neu zeichnen digitalWrite(LED_Blau, LOW); // Info-LEDs umschalten digitalWrite(LED_Gelb, HIGH); } if (digitalRead(Taster_Spieler_Blau) == LOW && (digitalRead(Taster_Spieler_Gelb) == LOW)) { // Spiel RESET matrix.fillRect(0, 0, matrix.width(), matrix.height(), matrix.Color333(0, 0, 0)); matrix.drawRect(1, 1, 62, 62, matrix.Color333(0, 7, 0)); // Außen Rahmen grün Zeitbalken(); // Zeitbalken neu zeichnen X = 30, Y = 23; // Blinkpunkt Koordinaten Blinkpunkt(); // Blinkpunkt platzieren Smiles(31, 11, 1); // Smiles Mitte Spiel_Status = 0; // Spiel läuft zur Zeit nicht digitalWrite(LED_Blau, LOW); // Info-LEDs aus digitalWrite(LED_Gelb, LOW); delay(1000); // Wartezeit } if (Spiel_Status == 1) { // Blau hat verloren X = 15; Y = 35; // Blinkpunkt Koordinaten Smiles_loeschen (31, 11); // Smiles Mitte löschen Smiles(16, 20, 2); // Smiles traurig Summer_Ein_Aus (); // Summer aktivieren } if (Spiel_Status == 2) { // Gelb hat verloren X = 45; Y = 35; // Blinkpunkt Koordinaten Smiles_loeschen (31, 11); // Smiles Mitte löschen Smiles(46, 20, 2); // Smiles traurig Summer_Ein_Aus (); // Summer aktivieren } } // ********************************************************************************************* void Zeitbalken() { for (int i = 1; i < 11; i++) { // Zeitbalken Blau zeichnen int Y = 20 + (i * 3); matrix.drawRect(11, Y, 10, 2, matrix.Color333(0, 0, 7)); } for (int i = 1; i < 11; i++) { // Zeitbalken Gelb zeichnen int Y = 20 + (i * 3); matrix.drawRect(41, Y, 10, 2, matrix.Color333(7, 7, 0)); } } // ********************************************************************************************* void Blinkpunkt() { int Xp = X; int Yp = Y; // Zwischenkoordinaten if (Spiel_Status == 3) { // Blinkpunkt bei Blau Xp = 22; } if (Spiel_Status == 4) { // Blinkpunkt bei Gelb Xp = 38; } Blinkpunkt_on_off = not Blinkpunkt_on_off; // Umschaltung if (Spiel_Status == 1 or Spiel_Status == 2) { Blinkpunkt_on_off = true; } if (Blinkpunkt_on_off) { matrix.drawRect(Xp, Yp, 2, 2, matrix.Color333(7, 0, 0)); } // Blinkpunkt Ein else {matrix.drawRect(Xp, Yp, 2, 2, matrix.Color333(0, 0, 0));} // Blinkpunkt Aus } // ********************************************************************************************* void Linie_loeschen() { if (Spiel_Status == 3) { // Blau ist am Zug matrix.drawRect(11, Y, 10, 2, matrix.Color333(0, 0, 0)); // Zeitbalken Löschen matrix.drawRect(22, Y, 2, 2, matrix.Color333(0, 0, 0)); // Blinkpunkt Löschen } if (Spiel_Status == 4) { // Gelb ist am Zug matrix.drawRect(41, Y, 10, 2, matrix.Color333(0, 0, 0)); // Zeitbalken Löschen matrix.drawRect(38, Y, 2, 2, matrix.Color333(0, 0, 0)); // Blinkpunkt Löschen } } // ********************************************************************************************* void Smiles(int X, int Y, int Form) { // 1 - Start // 2 - Verloren matrix.drawCircle(X, Y, 5, matrix.Color333(0, 7, 7)); matrix.fillRect(X - 2, Y - 2, 2, 2, matrix.Color333(0, 7, 7)); matrix.fillRect(X + 1, Y - 2, 2, 2, matrix.Color333(0, 7, 7)); switch (Form) { case 1: { matrix.drawLine(X - 1, Y + 3, X + 1, Y + 3, matrix.Color333(0, 7, 7)); matrix.drawPixel(X - 2, Y + 2, matrix.Color333(0, 7, 7)); matrix.drawPixel(X + 2, Y + 2, matrix.Color333(0, 7, 7)); break; } case 2: { matrix.drawLine(X - 1, Y + 1, X + 1, Y + 1, matrix.Color333(0, 7, 7)); matrix.drawPixel(X - 2, Y + 2, matrix.Color333(0, 7, 7)); matrix.drawPixel(X + 2, Y + 2, matrix.Color333(0, 7, 7)); break; } } } // ********************************************************************************************* void Smiles_loeschen(int X, int Y) { matrix.fillRect(X-5, Y-5, 11, 11, matrix.Color333(0, 0, 0)); } // ********************************************************************************************* void Summer_Ein_Aus () { Blinkpunkt(); digitalWrite(Summer, HIGH); // Summer Ein delay (1000); // Wartezeit digitalWrite(Summer, LOW); // Summer Aus delay (3000); // Wartezeit } // ********************************************************************************************* Um die Spieler auseinander zu halten werden sie im Programm als „Blau“ und „Gelb“ bezeichnet. In der Testschaltung befindet sich der „Blaue“ auf der
linken Seite, die rechte Seite ist für den „Gelben“ vorgesehen.
|
Google-Suche auf MEINE-SCHALTUNG.de : |