Ein kleines weiteres Einsteigerprojekt mit dem Arduino Plug and Make Kit ist Pixel Chaser. Du findest in diesem Kit alles, was du für den Aufbau des Spieles benötigst.
Für den Aufbau des Spieles benötigst du:
- einen Arduino UNO R4 WiFi,
- ein USB-Typ-C Datenkabel
- ein Buzzer Modul,
- ein 8fach LED Modul,
- ein 3fach Taster Modul,
- drei Qwiic Anschlusskabel
All diese Komponenten sind im Kit enthalten.
Inhaltsverzeichnis
- Wie funktioniert das Spiel – Pixel Chaser?
- Aufbau der Schaltung – Pixel Chaser mit dem Arduino Plug and Make Kit
- Programmieren in der Arduino IDE
Wie funktioniert das Spiel – Pixel Chaser?
Im Spiel “Pixel Chaser” sind acht LEDs in einer Linie angeordnet. Zu Beginn des Spiels wird eine der LEDs zufällig als Ziel ausgewählt und leuchtet rot auf. Eine andere LED bewegt sich kontinuierlich von links nach rechts und zurück entlang der Linie.
Der Spieler muss den richtigen Moment abpassen und die Taste A drücken, um die bewegende LED anzuhalten. Ziel ist es, die laufende LED genau über der roten LED zu stoppen.
Wenn der Spieler erfolgreich ist, erscheint ein lachender Smiley auf dem Display des Arduino UNO R4 WiFi, und ein positiver Ton wird abgespielt. Außerdem erhöht sich die Geschwindigkeit der laufenden LED, was das Spiel schwieriger macht. Verfehlt der Spieler das Ziel, wird ein trauriger Smiley angezeigt, begleitet von einem tiefen Ton. Danach beginnt das Spiel von vorne, und die Geschwindigkeit der LED wird auf den Anfangswert zurückgesetzt.
Aufbau der Schaltung – Pixel Chaser mit dem Arduino Plug and Make Kit
Der Aufbau des kleinen Einsteigerprojektes ist in drei wenigen Schritten erledigt. Da die Module über eine eindeutige Adresse verfügen kannst du diese auf der Modulino Base beliebig anordnen, du musst dich also nicht zu 100 % an diese Anleitung halten. Wichtig ist lediglich, dass diese mit dem Qwiic Kabel miteinander zum Arduino UNO R4 WiFi verbunden sind.
An den Modulino ist jeweils eine kleine, grüne SMD LED, diese sollte aufleuchten, sobald dein Mikrocontroller Strom bekommt. Dieses kannst du als Indikator nutzen, dass die Modulinos korrekt angeschlossen sind.
Programmieren in der Arduino IDE
Wie du die Modulinos des Arduino Plug and Make Kit in der Arduino IDE programmierst, habe ich dir bereits im ersten Beitrag Arduino Plug and Make Kit: Was ist drin und wie benutzt man es? gezeigt. Durch die I2C Adresse und der sehr einfachen Bibliothek ist die Programmierung besonders für Anfänger geeignet und mit wenig Codezeilen kann man schon beträchtliche Ergebnisse erzielen.
Für die Programmierung der Modulinos benötigst du die Bibliothek Modulino welche du über den Bibliotheksverwalter der Arduino IDE installieren kannst.
Nachfolgend das fertige Programm zum Download als ZIP-Datei.
Schritt 1 – Importieren der benötigten Bibliotheken
Im ersten _Schritt müssen wir die benötigten Bibliotheken dem Code hinzufügen.
//Bibliothek zum ansteuern der Modulinos des //Arduino Plug and Make Kit #include <Modulino.h> //Bibliothek zum ansteuern der LED Matrix des //Arduino UNO R4 WiFi #include "ArduinoGraphics.h" #include "Arduino_LED_Matrix.h"
Schritt 2 – Anlegen der Smileys für neutral, gewinn und verloren
Die Smileys kannst du auf zwei Wege erstellen, zum einen erstellst du dir ein mehrdimensionales Array mit 8×12 Felder oder du nutzt ganz bequem den LED Matrix Editor von Arduino.
Über diesen Editor kannst du mit der Maus dir ein entsprechendes Smiley zeichnen und dir den Code mit der Schaltfläche “</>” oben rechts herunterladen.
const uint32_t happy[] = {
0x31831,
0x80000404,
0x42081f0,
66
};
const uint32_t sad[] = {
0x31831,
0x80000001,
0xf0208404,
66
};
const uint32_t neutral[] = {
0x31831,
0x80000001,
0xf0000000,
66
};
Damit die Arrays den Code nicht unnötig lang machen, lagere ich diese in eine externe Datei “animation.h” aus und greife aus dem Code dann darauf zu.
//Einbinden der Datei "animation.h" mit den //Smileys #include "animation.h"
Schritt 3 – Aufleuchten einer zufälligen LED
Um einen zufälligen Wert zwischen 0 und 8 (ohne die 8 selbst) zu erzeugen, benutze ich die Funktion random mit dem Parameterwert 8.
Da die Range jedoch nur sehr gering ist, kann und wird es vorkommen, dass dieselbe Zahl mehrmals hintereinander kommen kann, daher packe ich den Code in eine While-Schleife und prüfe / handle dieses dort.
int catchPixelIndex = -1;
void activateRandomPixel() {
...
int lastCatchPixelIndex = catchPixelIndex;
while (lastCatchPixelIndex == catchPixelIndex) {
randomSeed(analogRead(0));
catchPixelIndex = random(8);
}
...
}
Schritt 4 – erzeugen eines Lauflichts
Das Lauflicht auf dem 8fach LED-Modul bewegt sich von links nach rechts und wieder zurück. Mit jeder abgeschlossenen Runde erhöht sich die Geschwindigkeit. Bei einer Niederlage wird die Geschwindigkeit jedoch wieder auf den Ausgangswert zurückgesetzt.
In diesem Fall wird die Pause im Lauflicht nicht durch den Aufruf der Funktion delay umgesetzt, sondern durch eine Überprüfung, ob die Zeit seit der letzten Aktion die festgelegte Pausenzeit überschritten hat. Wie dieses im Detail funktioniert, habe ich dir bereits im Beitrag Arduino: Ein Sketch ohne delay(ms) schreiben erläutert.
int runningPixel = -1;
int speed = 350;
long lastAction = -1;
bool movePixelReverse = false;
void loop() {
long currentMillis = millis();
if (currentMillis > (lastAction + speed)) {
lastAction = currentMillis;
movePixel();
}
...
}
void movePixel() {
leds.set(runningPixel, BLUE, 0);
if (!movePixelReverse) {
if (runningPixel < 8) {
runningPixel += 1;
} else {
runningPixel -= 1;
movePixelReverse = true;
}
} else {
if (runningPixel > 0) {
runningPixel -= 1;
} else {
runningPixel += 1;
movePixelReverse = false;
}
}
leds.set(runningPixel, BLUE, BRIGHTNESS);
leds.show();
leds.set(catchPixelIndex, RED, BRIGHTNESS);
leds.show();
}
Schritt 5 – Abfragen des Tasters
In der loop können wir nun bequem den Taster auslesen und reagieren, wenn dieser gedrückt wurde. Wenn beide Pixel übereinanderliegen, dann gilt dieses als Gewinn und es wird ein hoher Ton ausgegeben sowie ein lachender Smiley, zusätzlich wird die Geschwindigkeit des Lauflichtes erhöht, indem die Pause zwischen den Schritten um 25ms. verringert wird.
Sollte jedoch der Spieler nicht gewinnen, so wird ein trauriger Smiley angezeigt und ein tiefer Ton ausgeben. Die Geschwindigkeit des Lauflichtes wird wieder auf die Anfangsgeschwindigkeit gesetzt.
const int BUTTON_A = 0;
void testBtn() {
if (buttons.update()) {
if (buttons.isPressed(BUTTON_A)) {
if (runningPixel == catchPixelIndex) {
buzzer.tone(FREQ_WIN, 750);
matrix.loadFrame(happy);
speed -= 25;
} else {
buzzer.tone(FREQ_LOOSE, 750);
matrix.loadFrame(sad);
speed = DEFAULT_SPEED;
}
delay(600);
matrix.loadFrame(neutral);
activateRandomPixel();
}
}
}
Das fertige Programm
Hier nun das fertige Programm mit allen Kommentaren zum Quellcode.
//Bibliothek zum ansteuern der Modulinos des
//Arduino Plug and Make Kit
#include <Modulino.h>
//Bibliothek zum ansteuern der LED Matrix des
//Arduino UNO R4 WiFi
#include "ArduinoGraphics.h"
#include "Arduino_LED_Matrix.h"
//Einbinden der Datei "animation.h" mit den
//Smileys
#include "animation.h"
//Objektinstanz der LED Matrix
ArduinoLEDMatrix matrix;
//Objektinstanzen der Modulinos
ModulinoBuzzer buzzer;
ModulinoPixels leds;
ModulinoButtons buttons;
//Feld zum speichern des Indexes
//des Pixels welches angeklickt werden soll.
int catchPixelIndex = -1;
//Feld zum speichern des aktuellen aktiven
//Pixels im Lauflicht
int runningPixel = -1;
//Konstante für die identifikation der Taste "A"
const int BUTTON_A = 0;
//Konstante für die Helligkeit der LEDs
const int BRIGHTNESS = 20;
//Konstanten für die Töne
const int FREQ_WIN = 1200;
const int FREQ_LOOSE = 400;
//Konstante für die Standardgeschwindigkeit
//des Lauflichts
const int DEFAULT_SPEED = 350;
//aktuelle Geschwindigkeit des Lauflichts
int speed = DEFAULT_SPEED;
//Feld zum speichern der letzten Ausführung des Lauflichts
long lastAction = -1;
//Feld zum speichern der Richtung des Lauflichts
bool movePixelReverse = false;
void setup() {
//beginn der Kommunikation mit der LED Matrix des
//Arduino UNO R4 WiFi
matrix.begin();
//beginn der Kommunikation mit den Modulinos
Modulino.begin();
//Initialisieren der I2C Kommunikation mit den
//Modulino Sensoren/Aktoren
buzzer.begin();
leds.begin();
buttons.begin();
//am Taster Modul lediglich die LED am
//Taster "A" aktivieren.
buttons.setLeds(true, false, false);
//initial einen zufälligen Pixel aktivieren
activateRandomPixel();
//auf der LED Matrix ein neutrales Smiley anzeigen
matrix.loadFrame(neutral);
}
//Funktion zum aktivieren eines zufälligen Pixels
//an dem 8fach LED Modul.
void activateRandomPixel() {
//Wenn bereits ein Pixel gesetzt ist dann,...
if (catchPixelIndex > -1) {
//setzen der Helligkeit auf 0, damit wird,
//die LED deaktiviert
leds.set(catchPixelIndex, RED, 0);
}
//ermitteln einer neuen Zufallszahl,
//da bei einer Range von 0 bis 7 es vorkommen kann
//das mehrmals der gleiche Wert ermittelt wird,
//prüft die Schleife dieses und gibt bei
//einem Unterschied eine neue Zahl zurück.
int lastCatchPixelIndex = catchPixelIndex;
while (lastCatchPixelIndex == catchPixelIndex) {
randomSeed(analogRead(0));
catchPixelIndex = random(8);
}
//aktivieren des neuen Pixels
leds.set(catchPixelIndex, RED, BRIGHTNESS);
//anzeigen des neuen Pixels und löschen des alten
leds.show();
}
//Funktion zum prüfen und behandeln eines Tastendrucks am
//Button Modulino
void handleButton() {
//aktualisieren des Moduls
if (buttons.update()) {
//Wenn der Taster "A" betätigt wurde, dann...
if (buttons.isPressed(BUTTON_A)) {
//prüfen ob der aktuelle Pixel vom Lauflicht dem
//Pixel welches gefangen werden soll entspricht.
//Wenn dieses so ist, dann gilt die Runde als Gewonnen.
if (runningPixel == catchPixelIndex) {
//einen hellen Ton für die Dauer von 750ms. ausgeben.
buzzer.tone(FREQ_WIN, 750);
//ein lachenden Smiley anzeigen
matrix.loadFrame(happy);
//Die Geschwindigkeit des Lauflichts erhöhen.
//Der Wert Speed regelt die Pause innerhalb des Lauflichts.
speed -= 25;
} else {
//Wenn diese beiden Pixel nicht übereinander liegen
//gilt die Runde als verloren.
//Es wird ein tiefer Ton für die dauer von 750ms. ausgegeben.
buzzer.tone(FREQ_LOOSE, 750);
//Auf der LED Matrix wird ein trauriger Smiley angezeigt.
matrix.loadFrame(sad);
//Die Geschwindigkeit wird auf die Ausgangsgeschwindigkeit gesetzt.
speed = DEFAULT_SPEED;
}
//Eine Pause von 600ms.
//(Damit der Spieler das Smiley sieht.)
delay(600);
//anschließend das neutrale Smiley anzeigen
matrix.loadFrame(neutral);
//und eine neue Runde starten
activateRandomPixel();
}
}
}
void movePixel() {
leds.set(runningPixel, BLUE, 0);
if (!movePixelReverse) {
if (runningPixel < 8) {
runningPixel += 1;
} else {
runningPixel -= 1;
movePixelReverse = true;
}
} else {
if (runningPixel > 0) {
runningPixel -= 1;
} else {
runningPixel += 1;
movePixelReverse = false;
}
}
leds.set(runningPixel, BLUE, BRIGHTNESS);
leds.show();
leds.set(catchPixelIndex, RED, BRIGHTNESS);
leds.show();
}
void loop() {
long currentMillis = millis();
if (currentMillis > (lastAction + speed)) {
lastAction = currentMillis;
movePixel();
}
handleButton();
}