Das Keyestudio Max Board ist schon einige Zeit auf dem Markt erhältlich. In diesem Beitrag möchte ich dir diesen Mikrocontroller vorstellen und zeigen wie du das kleine Spiel “Fang den Regentropfen” auf diesen programmierst.
Der Preis mit knapp 25 € für diesen Mikrocontroller hat mich bisher eher abgeschreckt, da dieser zwar ein paar nette Features hat, aber wie ich finde dieses nun nichts Besonderes mehr sind. Auf aliexpress.com habe diesen jetzt für weit unter 20 € gefunden und das hat mich doch verleitet diesen zu kaufen.
Inhaltsverzeichnis
- Features des Keyestudio Max Board
- Pinout des Mikrocontrollers
- Einrichten des Keyestudio Max Board am PC
- Programmierung in der Arduino IDE
- Schritt 1 – importieren der benötigten Bibliotheken
- Schritt 2 – erzeugen der Objektinstanzen und Felder
- Schritt 3 – Funktion “setup” Konfigurieren der Matrix, Taster & Buzzer
- Schritt 4 – Funktion “loop” Auswerten der Taster und Bewegen eines Regentropfens
- Schritt 5 – Funktion “Bewegen der Leiste zum Fangen eines Regentropfens”
- Schritt 6 – Funktion “Bewegen eines Regentropfens”
- Schritt 7 – Anzeigen der gewonnenen Runden
- Schritt 8 – Aktualisieren der LED Matrix
Features des Keyestudio Max Board
Der Mikrocontroller im Format des normalen Arduino UNO R3 verfügt über nachfolgende Features:
- USB-Typ-C Buchse,
- DC / Batterie Anschluss (PH2.0),
- zwei Taster,
- zwei RGB LEDs,
- drei farbige SMD LEDs (gelb, grün, rot),
- einen Piezo Buzzer,
- ein Mikrofon,
- einen Fotowiderstand
- eine 8×16 rote LED Matrix
Pinout des Mikrocontrollers
Die vorhandenen Komponenten auf dem Board schränken jedoch die Verwendung der digitalen Pins ein. Daher werfen wir gleich mal einen Blick auf das Pinout, sodass wir die freien Pins im Blick haben.
| Komponente | Pin |
|---|---|
| 8×16 LED Matrix | I2C, A4 & A5 |
| Mikrofon | A7 |
| Fotowiderstand | A6 |
| Taster RECHTS | D2 |
| Taster LINKS | D3 |
| RGB LED LINKS | D4 |
| RGB LED RECHTS | D9 |
| SMD LED Rot | D8 |
| SMD LED Grün | D10 |
| SMD LED Gelb | D13 |
Über den 4fach DIP Schalter kann man sich zumindest vier der belegten digitalen Pins wieder “freischalten” und somit wie gewohnt über die Buchsenleisten abgreifen.
| Pin | |
|---|---|
| 1 | D3 |
| 2 | D4 |
| 3 | A5 |
| 4 | A4 |
Technische Daten des ATmega328P-PU
Auf dem Mikrocontroller arbeitet ein ATmega328P-PU welcher nachfolgende technische Daten hat:
| Mikrocontroller | ATmega328P-PU |
| Taktgeschwindigkeit | 16 MHz |
| Betriebsspannung | 5V |
| Eingangsspannung | 7 bis 12V DC |
| digitale Pins | 14, davon 6 als PWM |
| analoge Pins | 6 |
| max. Stromaufnahme an den Pins | 20 mA |
| max. Stromaufnahme an 3.3V | 50 mA |
| Speicher | 32 kB davon 0,5 kB für den Bootloader reserviert 2 kB SRAM 1 kB EEPROM |
| Schnittstellen | UART, I2C, SPI |
| Features | LED_BUILTIN an D13 |
Einrichten des Keyestudio Max Board am PC
Bevor wir mit der Programmierung beginnen können, müssen wir zunächst (soweit noch nicht geschehen) den passenden USB-SERIAL Treiber installieren. Auf dem Board ist ein CP2102 Chip verbaut, in meinem Fall ist dieser nicht installiert (erkennbar am gelben Dreieck im Icon) und ich muss diesen manuell nachinstallieren.
Von der Seite https://www.pololu.com/docs/0J7/all#2 kannst du dir den passenden Treiber als ZIP-Datei für Windows herunterladen.
Programmierung in der Arduino IDE
Die Programmierung erfolgt, wie zu erwarten ist am einfachsten in der Arduino IDE. Auf der offiziellen Seite zu diesem Mikrocontroller beim Hersteller findest du viele Beispiele zu den Features. Nachfolgend möchte ich dir gerne zeigen, wie du das bereits für das Arduino Plug and Make Kit vorgestellte Spiel “Fang den Regentropfen” programmierst.
Der Mikrocontroller bringt dazu zwei Taster, die 8×16 LED Matrix sowie den Piezo Buzzer, was dafür optimal ist. (Da alles am Mikrocontroller fest verbaut ist, entfällt hier ein Aufbau der Schaltung, was das ganze nochmal deutlich vereinfacht.)
Schritt 1 – importieren der benötigten Bibliotheken
Zunächst importieren wir die benötigten Bibliotheken. Die Bibliothek für das Ansteuern der LED Matrix bekommen wir vom DropBox Repository von Keyestudio https://fs.keyestudio.com/KS0500 leider musst du dich zuvor dort anmelden, um an diese Ressourcen zu gelangen.
Die Bounce2 Bibliothek findest du bequem im internen Bibliotheksverwalter, wenn du nach “Bounce2” suchst.
//Einbinden der benötigten Bibliotheken //zum ansteuern der 8x16 LED Matrix #include <Wire.h> #include "Keyestudio_LEDBackpack.h" #include "Keyestudio_GFX.h" //zum entprellen der Taster #include <Bounce2.h>
Schritt 2 – erzeugen der Objektinstanzen und Felder
Für das Spiel benötigen wir einpaar Objektinstanzen wie für die LED Matrix, die Taster etc.
Die Koordinaten des Regentropfens sowie der Leiste zum Fangen des selbigen lege ich als globale Variable an, somit muss ich diese nicht durch die Funktionen durchreichen.
//Objektinstanz von der Matrix erstellen Keyestudio_8x16matrix matrix = Keyestudio_8x16matrix(); //die beiden Taster sind an //den digitalen Pins D3 & D2 angeschlossen #define buttonLinksPin 3 #define buttonRechtsPin 2 //der Piezo Buzzer ist am digitalen Pin D9 angeschlossen #define buzzer 9 //Objektinstanzen für das entprellen //der Taster mit Bounce erstellen Bounce btnLinks = Bounce(); Bounce btnRechts = Bounce(); //Koordinale für die Leiste zum fangen des Punktes int16_t barXPos = 7; int16_t barYPos = 0; //Koordinate für den Regentropfen int16_t rainDropXPos = 0; int16_t rainDropYPos = 0; //Geschwindigkeit des Spieles //am Anfang legen wir diesen auf 400 fest //dieses repräsentiert einen Wert in Millisekunden long speed = 400; //Zeitpunkt der letzten Ausführung des bewegens eines //Regentropfens auf der LED Matrix long lastAction = -1l; int wonRounds = 0;
Schritt 3 – Funktion “setup” Konfigurieren der Matrix, Taster & Buzzer
In der Funktion setup starten wir zunächst die Kommunikation mit der LED Matrix und anschließend konfigurieren wir die beiden Taster so das diese über Bounce2 entprellt werden.
//beginnen der Kommunikation mit der LED Matrix //via I2C mit der Adresse 0x70 matrix.begin(0x70); //Konfigurieren des entprellens der Taster //verbinden des Pins des Tasters mit dem Objekt btnLinks.attach(buttonLinksPin, INPUT); btnLinks.interval(5); btnRechts.attach(buttonRechtsPin, INPUT); btnRechts.interval(5); //Pin des Piezo Buzzers als Ausgang definieren pinMode(buzzer, OUTPUT);
Damit das Spiel gleich startet, setzen wir den Regentropfen an eine Zufällige stelle und zeigen diesen an.
//eine Range für die Generierung einer Zufallszahl erstellen randomSeed(analogRead(0)); //setzen der Koordinaten für einen Regentropfen rainDropXPos = 7; rainDropYPos = generateRandomNumber(); //aktualisieren der LED Matrix updateMatrix();
Schritt 4 – Funktion “loop” Auswerten der Taster und Bewegen eines Regentropfens
In der Funktion “loop” aktualisieren wir die Taster und werden den jeweiligen Tastendruck aus.
//aktualisieren der Button Objekte
btnLinks.update();
btnRechts.update();
//Wenn der linke Taster losgelassen wurde, dann...
if (btnLinks.rose()) {
//die Leiste nach links bewegen
moveBar(-1);
//aktualisieren der LED Matrix
updateMatrix();
}
//Wenn der rechte Taster losgelassen wurde, dann...
if (btnRechts.rose()) {
//die Leiste nach rechts bewegen
moveBar(1);
//aktualisieren der LED Matrix
updateMatrix();
}
Am Ende prüfen wir ob die Zeit zwischen den Bewegungen des Regentropfens abgelaufen ist. Würden wir hier mit der Funktion delay arbeiten, so können man wärend der Pause keine der Tasten auswerten.
//ermitteln des Zeitpunktes für die nächste Ausführung
//der Bewegung des Regentropfens
long currentMillis = millis();
if (currentMillis > (lastAction + speed)) {
lastAction = currentMillis;
moveRainDrop();
updateMatrix();
}
Schritt 5 – Funktion “Bewegen der Leiste zum Fangen eines Regentropfens”
Wenn eine der beiden Tasten betätigt wurde, dann wird die Funktion moveBar ausgeführt. Zunächst wird ein Ton ausgegeben so das eine akkustische Rückmeldung erfolgt.
//Funktion zum bewegen der Leiste zum fangen des Regentropfens
//als Parameter wird die Richtung übergeben,
//ein Positiver Wert gilt nach rechts und ein negativer nach links
void moveBar(int direction) {
tone(buzzer, 300, 75);
if (direction > 0) {
if (barXPos < 15) {
barXPos++;
}
} else {
if (barXPos > 0) {
barXPos--;
}
}
}
Schritt 6 – Funktion “Bewegen eines Regentropfens”
Der Regentropfen wird von oben nach unten bewegt wobei unten die Zeile mit dem Index 0 ist und oben 7. Wenn die Zeile des Regentropfens 0 ist dann wird geprüft ob die Leiste sich an der selben Stelle befindet.
Wenn diese Runde gewonnen ist dann wird die Geschwindigkeit erhöht und eine neue Runde gestartet und der Wert für wonRounds um eins erhöht. Wenn jedoch die Runde verloren ist, dann werden die gewonnenen Runden angezeigt.
//Funktion zum bewegen des Regentropfens UND auswerten
//ob die Runde gewonnen oder verloren ist
void moveRainDrop() {
rainDropXPos--;
tone(buzzer, 600, 75);
bool startNewGame = false;
if (rainDropXPos == 0 && (barXPos == rainDropYPos)) {
tone(buzzer, 800, 75);
startNewGame = true;
speed -= 25;
wonRounds++;
} else if (rainDropXPos == 0 && (barXPos != rainDropYPos)) {
tone(buzzer, 250, 75);
startNewGame = true;
speed = 400;
displayWonRounds();
wonRounds = 0;
}
if (startNewGame) {
rainDropXPos = 7;
rainDropYPos = generateRandomNumber();
}
}
Schritt 7 – Anzeigen der gewonnenen Runden
Zum schreiben der gewonnenen Runden auf der LED Matrix muss zuvor diese gedreht und der Cursor an eine Position gesetzt werden. Dieses müssen wir jedoch nachdem anzeigen wieder zurücksetzen da dieses globale Einstellungen sind!
//Anzeigen der gewonnenen Runden auf der LED Matrix
void displayWonRounds() {
matrix.setTextSize(1);
matrix.setTextWrap(false);
matrix.setTextColor(LED_ON);
//drehen der Ausrichtung der Matrix
matrix.setRotation(1);
matrix.clear();
//setzen des Cursors an welchem der Text
//geschrieben wird
matrix.setCursor(6, 0);
matrix.print(String(wonRounds));
matrix.writeDisplay();
delay(1000);
//Zurücksetzen des Cursors & der Drehung der Matrix
matrix.setCursor(0, 0);
matrix.setRotation(0);
}
Schritt 8 – Aktualisieren der LED Matrix
Die Funktion zum anzeigen der LED Matrix ist recht easy denn hier müssen wir lediglich nur zwei Punkte anzeigen wo wir die Koordinaten kennen.
//Funktion zum zeichnen der Punke auf der LED Matrix
void updateMatrix() {
matrix.clear();
matrix.drawPixel(barYPos, barXPos, LED_ON);
matrix.drawPixel(rainDropXPos, rainDropYPos, LED_ON);
matrix.writeDisplay();
}