Arduino - LED-Matrix
LED-Matrixanzeigen, auch bekannt als LED-Display oder Dot-Matrix-Display, sind weit verbreitet. In diesem Tutorial lernen wir:
- LED-Matrix
- Wie man Arduino mit einer 8×8-LED-Matrix verbindet
- Wie man Arduino mit einer 32×8-LED-Matrix verbindet
- Wie man Arduino an die LED-Matrix anschließt, um Text, Zahlen und animierte Effekte anzuzeigen
Danach kannst du den Code leicht an andere LED-Matrizen anpassen, z. B. eine 16×8-LED-Matrix, eine 64×8-LED-Matrix ...
Erforderliche Hardware
Oder Sie können die folgenden Kits kaufen:
| 1 | × | DIYables STEM V3 Starter-Kit (Arduino enthalten) | |
| 1 | × | DIYables Sensor-Kit (18 Sensoren/Displays) |
Offenlegung: Einige der in diesem Abschnitt bereitgestellten Links sind Amazon-Affiliate-Links. Wir können eine Provision für Käufe erhalten, die über diese Links getätigt werden, ohne zusätzliche Kosten für Sie. Wir schätzen Ihre Unterstützung.
Über LED-Matrix
Es gibt viele Arten von LED-Matrizen. Mit Arduino ist die MAX7219-basierte LED-Matrix weit verbreitet. Die MAX7219-basierte LED-Matrix hat die folgenden Merkmale:
- Eine Basiseinheit einer LED-Matrix ist ein Block.
- Jeder Block verfügt über eine 8x8-LED-Matrix (64 LEDs) und einen MAX7219-Treiber.
- Es gibt zwei beliebte Blockformen: das Standardmodul und das FC-16-Modul.
- Eine LED-Matrix kann aus einem einzelnen Block oder mehreren Blöcken in einer Daisy-Kette bestehen.
- Sie können eine vorkonfigurierte LED-Matrix mit mehreren Blöcken kaufen (z. B. 4-in-1, 8-in-1).
- Sie können auch mehrere Blöcke kaufen und sie verdrahten, um eine LED-Matrix in der gewünschten Größe zu bilden.
- Sie geben die Größe der LED-Matrix, die Sie verwenden, im Arduino-Code an.
Pinbelegung
Eine LED-Matrix wird aus einem einzelnen oder mehreren Blöcken gebildet. Jeder Block enthält zwei Gruppen von Pins:
- Eingangs-Pin-Gruppe:
- VCC: mit 5V verbunden.
- GND: mit GND verbunden.
- DIN ist der Datenpin, verbinde ihn mit dem SPI-MOSI-Pin des Arduino.
- CS: Chip Select, verbinde ihn mit einem beliebigen digitalen Pin des Arduino.
- CLK: Taktpin, verbinde ihn mit dem SPI-CLK-Pin des Arduino.
- Ausgangs-Pin-Gruppe:
- VCC: verbindet sich mit dem VCC des nächsten Moduls.
- GND: verbindet sich mit dem GND des nächsten Moduls.
- DOUT: Datenausgang, verbindet sich mit dem DIN-Pin des nächsten Moduls.
- CS: verbindet sich mit CS des nächsten Moduls.
- CLK: verbindet sich mit CLK des nächsten Moduls.
Verdrahtungsdiagramm
Wenn die LED-Matrix aus einem einzigen Block besteht:
- Verbinde die Gruppen der Eingangspins mit dem Arduino
- Lass die Gruppe der Ausgangspins unverbunden
Dieses Bild wurde mit Fritzing erstellt. Klicken Sie, um das Bild zu vergrößern.
Dieses Bild wurde mit Fritzing erstellt. Klicken Sie, um das Bild zu vergrößern.
Wenn die LED-Matrix aus mehreren vorgefertigten Blöcken besteht:
- Verbinde die Eingangs-Pin-Gruppen mit dem Arduino.
- Lass die Gruppe der Ausgangspins unverbunden.
Dieses Bild wurde mit Fritzing erstellt. Klicken Sie, um das Bild zu vergrößern.
Wenn die LED-Matrix von Ihnen selbst aus mehreren Blöcken besteht:
- Verbinden Sie die Gruppen der Eingangspins des ersten Blocks mit dem Arduino
- Verbinden Sie die Gruppen der Ausgangspins jedes Blocks mit den Gruppen der Eingangspins des nächsten Blocks
- Lassen Sie die Gruppe der Ausgangspins des letzten Blocks unverbunden
Dieses Bild wurde mit Fritzing erstellt. Klicken Sie, um das Bild zu vergrößern.
Dieses Bild wurde mit Fritzing erstellt. Klicken Sie, um das Bild zu vergrößern.
Da das Display viel Strom zieht (bis zu 1 A bei maximaler Helligkeit):
- Verwenden Sie nicht die Stromversorgung vom 5-V-Pin des Arduino.
- Verwenden Sie stattdessen eine externe 5-V-Stromversorgung. Arduino und LED-Matrix können die Stromversorgung von einem 5-V-Netzadapter gemeinsam nutzen.
Weil Arduino eine LED-Matrix über SPI-Pins anschließt:
- Pin 13 (SCK) und 11 (MOSI) am Arduino Uno müssen verwendet werden. Wenn Sie ein anderes Arduino-Board verwenden, prüfen Sie die offizielle Dokumentation auf entsprechende SPI-Pins.
- Pin 3 (CS) kann auf jeden beliebigen Pin geändert werden.
Wie man eine LED-Matrix programmiert
Es ist nicht einfach, die LED-Matrix zu steuern. Glücklicherweise gibt es Bibliotheken, die das erleichtern. Im Folgenden finden Sie eine Schritt-für-Schritt-Anleitung, wie man Arduino-Code schreibt, um die LED-Matrix zu steuern.
- Bibliotheken einbinden:
#include <MD_Parola.h>
#include <MD_MAX72xx.h>
- Geben Sie an, welche Hardware verwendet wird: GENERIC_HW oder FC16_HW.
#define HARDWARE_TYPE MD_MAX72XX::FC16_HW
- Bestimmen Sie, wie viele LED-Blöcke verwendet werden. Zum Beispiel hat eine 4-in-1-LED-Matrix vier Blöcke.
#define MAX_DEVICES 4
- Definieren Sie den Pin, der mit dem CS-Pin der LED-Matrix verbunden ist. Zum Beispiel Pin D3.
#define CS_PIN 3
- Erstelle eine neue Instanz der MD_Parola-Klasse für das LED-Matrix-Display.
MD_Parola ledMatrix = MD_Parola(HARDWARE_TYPE, CS_PIN, MAX_DEVICES);
- Code in der setup()-Funktion:
void setup() {
ledMatrix.begin(); // Objekt initialisieren
ledMatrix.setIntensity(0); // Helligkeit der LED-Matrixanzeige einstellen (von 0 bis 15)
ledMatrix.displayClear(); // LED-Matrixanzeige löschen
}
- Text anzeigen, Zahl anzeigen und animierte Effekte zeigen: Siehe den nächsten Teil
Arduino - LED-Matrix-Code
Der untenstehende Code ist für eine 32×8 FC-16 LED-Matrixanzeige (4 Blöcke). Sie können ihn jedoch leicht auf 8×8, 16×8, 64×8... anpassen.
/*
* Dieser Arduino Code wurde von newbiely.de entwickelt
* Dieser Arduino Code wird der Öffentlichkeit ohne jegliche Einschränkung zur Verfügung gestellt.
* Für vollständige Anleitungen und Schaltpläne besuchen Sie bitte:
* https://newbiely.de/tutorials/arduino/arduino-led-matrix
*/
#include <MD_Parola.h>
#include <MD_MAX72xx.h>
#define HARDWARE_TYPE MD_MAX72XX::FC16_HW
#define MAX_DEVICES 4 // 4 blocks
#define CS_PIN 3
// create an instance of the MD_Parola class
MD_Parola ledMatrix = MD_Parola(HARDWARE_TYPE, CS_PIN, MAX_DEVICES);
void setup() {
ledMatrix.begin(); // initialize the object
ledMatrix.setIntensity(15); // set the brightness of the LED matrix display (from 0 to 15)
ledMatrix.displayClear(); // clear LED matrix display
}
void loop() {
ledMatrix.setTextAlignment(PA_LEFT);
ledMatrix.print("Left"); // display text
delay(2000);
ledMatrix.setTextAlignment(PA_CENTER);
ledMatrix.print("Center"); // display text
delay(2000);
ledMatrix.setTextAlignment(PA_RIGHT);
ledMatrix.print("Right"); // display text
delay(2000);
ledMatrix.setTextAlignment(PA_CENTER);
ledMatrix.setInvert(true);
ledMatrix.print("Invert"); // display text inverted
delay(2000);
ledMatrix.setInvert(false);
ledMatrix.print(1234); // display number
delay(2000);
}
Schnelle Schritte
- Verbinde Arduino mit der LED-Matrix gemäß dem oben gezeigten Verdrahtungsdiagramm.
- Verbinde Arduino über ein USB-Kabel mit dem PC.
- Navigiere zum Bibliotheken-Symbol in der linken Leiste der Arduino IDE.
- Suche “MD_Parola”, dann finde die MD_Parola-Bibliothek.
- Klicke auf die Installieren-Schaltfläche.
- Sie werden aufgefordert, die MD_MAX72XX-Bibliothek als Abhängigkeit zu installieren. Klicken Sie auf die Schaltfläche Alle installieren.
- Kopieren Sie den obigen Code und öffnen Sie ihn mit der Arduino-IDE.
- Klicken Sie auf die Upload-Schaltfläche in der Arduino-IDE, um den Code auf den Arduino hochzuladen.
- Sehen Sie die LED-Matrixanzeige.
Arduino LED-Matrix-Code – scrollender Text
Wenn Sie eine lange Nachricht drucken möchten, die zu lang ist, um auf einem LED-Matrix-Display zu passen, können Sie den Scroll-Text-Effekt verwenden.
Der nachstehende Arduino-Code zeigt, wie man eine Nachricht auf dem LED-Matrix-Display scrollt.
/*
* Dieser Arduino Code wurde von newbiely.de entwickelt
* Dieser Arduino Code wird der Öffentlichkeit ohne jegliche Einschränkung zur Verfügung gestellt.
* Für vollständige Anleitungen und Schaltpläne besuchen Sie bitte:
* https://newbiely.de/tutorials/arduino/arduino-led-matrix
*/
#include <MD_Parola.h>
#include <MD_MAX72xx.h>
#define HARDWARE_TYPE MD_MAX72XX::FC16_HW
#define MAX_DEVICES 4 // 4 blocks
#define CS_PIN 3
// create an instance of the MD_Parola class
MD_Parola ledMatrix = MD_Parola(HARDWARE_TYPE, CS_PIN, MAX_DEVICES);
void setup() {
ledMatrix.begin(); // initialize the object
ledMatrix.setIntensity(15); // set the brightness of the LED matrix display (from 0 to 15)
ledMatrix.displayClear(); // clear led matrix display
ledMatrix.displayScroll("Hello, DIYables", PA_CENTER, PA_SCROLL_LEFT, 100);
}
void loop() {
if (ledMatrix.displayAnimate()) {
ledMatrix.displayReset();
}
}
Für weitere Texteffekte besuchen Sie bitte MD_Parola Library Reference.
Video Tutorial
Wir erwägen die Erstellung von Video-Tutorials. Wenn Sie Video-Tutorials für wichtig halten, abonnieren Sie bitte unseren YouTube-Kanal , um uns zu motivieren, die Videos zu erstellen.
Die folgende Video-Demo verwendet den folgenden Code:
/*
* Dieser Arduino Code wurde von newbiely.de entwickelt
* Dieser Arduino Code wird der Öffentlichkeit ohne jegliche Einschränkung zur Verfügung gestellt.
* Für vollständige Anleitungen und Schaltpläne besuchen Sie bitte:
* https://newbiely.de/tutorials/arduino/arduino-led-matrix
*/
#include <MD_MAX72xx.h>
#include <SPI.h>
// ============================================================
// MAX7219
// ============================================================
#define HARDWARE_TYPE MD_MAX72XX::FC16_HW
#define MAX_DEVICES 4
#define CS_PIN 9
MD_MAX72XX mx =
MD_MAX72XX(HARDWARE_TYPE, CS_PIN, MAX_DEVICES);
// ============================================================
// BUTTONS
// ============================================================
#define BTN_LEFT 2
#define BTN_RIGHT 3
#define BTN_ROTATE 4
#define BUZZER_PIN 6
// ============================================================
// GAME BOARD
// ============================================================
#define BOARD_W 8
#define BOARD_H 32
bool board[BOARD_H][BOARD_W];
// ============================================================
// TIMING
// ============================================================
unsigned long lastFallTime = 0;
const unsigned long NORMAL_FALL = 700;
const unsigned long SOFT_DROP_FALL = 80;
#define LONG_PRESS_TIME 400
// ============================================================
// SCORE
// ============================================================
unsigned long score = 0;
unsigned int lines = 0;
unsigned int level = 1;
unsigned long highScore = 0;
// ============================================================
// GAME STATE
// ============================================================
bool gameOver = false;
bool gameStarted = false;
// ============================================================
// TETROMINO DEFINITIONS
// ============================================================
struct Point {
int x;
int y;
};
struct Tetromino {
Point block[4];
uint8_t color;
};
Tetromino pieces[7] = {
// I
{
{{0,0}, {1,0}, {2,0}, {3,0}},
0
},
// O
{
{{0,0}, {1,0}, {0,1}, {1,1}},
1
},
// T
{
{{1,0}, {0,1}, {1,1}, {2,1}},
2
},
// L
{
{{0,0}, {0,1}, {0,2}, {1,2}},
3
},
// J
{
{{1,0}, {1,1}, {1,2}, {0,2}},
4
},
// S
{
{{1,0}, {2,0}, {0,1}, {1,1}},
5
},
// Z
{
{{0,0}, {1,0}, {1,1}, {2,1}},
6
}
};
// ============================================================
// CURRENT PIECE
// ============================================================
int currentPiece;
int currentX;
int currentY;
int rotationState = 0;
// ============================================================
// BUTTON STATE
// ============================================================
bool lastLeftState = HIGH;
bool lastRightState = HIGH;
bool lastRotateState = HIGH;
unsigned long rotatePressTime = 0;
bool softDrop = false;
bool rotateHandled = false;
// ============================================================
// DISPLAY COORDINATE MAPPING
// ============================================================
void setPixel(int x, int y, bool state) {
if (x < 0 || x >= BOARD_W ||
y < 0 || y >= BOARD_H) {
return;
}
// Reverse vertical direction
int physicalColumn = (BOARD_H - 1) - y;
int physicalRow = x;
mx.setPoint(
physicalRow,
physicalColumn,
state
);
}
// ============================================================
// CLEAR DISPLAY
// ============================================================
void clearDisplay() {
mx.clear();
}
// ============================================================
// DRAW BOARD
// ============================================================
void drawBoard() {
clearDisplay();
// Draw fixed blocks
for (int y = 0; y < BOARD_H; y++) {
for (int x = 0; x < BOARD_W; x++) {
if (board[y][x]) {
setPixel(
x,
y,
true
);
}
}
}
// Draw falling piece
drawCurrentPiece();
}
// ============================================================
// GET ROTATED BLOCK POSITION
// ============================================================
Point getRotatedPoint(
Point p,
int rotation
) {
Point r;
switch (rotation % 4) {
case 0:
r.x = p.x;
r.y = p.y;
break;
case 1:
r.x = -p.y;
r.y = p.x;
break;
case 2:
r.x = -p.x;
r.y = -p.y;
break;
case 3:
r.x = p.y;
r.y = -p.x;
break;
}
return r;
}
// ============================================================
// CHECK COLLISION
// ============================================================
bool checkCollision(
int pieceX,
int pieceY,
int rotation
) {
for (int i = 0; i < 4; i++) {
Point p = getRotatedPoint(
pieces[currentPiece].block[i],
rotation
);
int x = pieceX + p.x;
int y = pieceY + p.y;
// Left / Right wall
if (x < 0 || x >= BOARD_W) {
return true;
}
// Bottom
if (y >= BOARD_H) {
return true;
}
// Existing block
if (y >= 0 && board[y][x]) {
return true;
}
}
return false;
}
// ============================================================
// DRAW CURRENT PIECE
// ============================================================
void drawCurrentPiece() {
for (int i = 0; i < 4; i++) {
Point p = getRotatedPoint(
pieces[currentPiece].block[i],
rotationState
);
int x = currentX + p.x;
int y = currentY + p.y;
if (x >= 0 && x < BOARD_W &&
y >= 0 && y < BOARD_H) {
setPixel(
x,
y,
true
);
}
}
}
// ============================================================
// RANDOM PIECE
// ============================================================
void spawnPiece() {
currentPiece = random(0, 7);
rotationState = 0;
currentX = 3;
currentY = 0;
// I piece
if (currentPiece == 0) {
currentX = 2;
}
// Game over if piece cannot spawn
if (checkCollision(
currentX,
currentY,
rotationState)) {
gameOver = true;
if (score > highScore) {
highScore = score;
}
soundGameOver();
}
}
// ============================================================
// LOCK PIECE
// ============================================================
void lockPiece() {
for (int i = 0; i < 4; i++) {
Point p = getRotatedPoint(
pieces[currentPiece].block[i],
rotationState
);
int x = currentX + p.x;
int y = currentY + p.y;
if (x >= 0 && x < BOARD_W &&
y >= 0 && y < BOARD_H) {
board[y][x] = true;
}
}
soundLock();
// Check completed lines
clearLines();
// New piece
spawnPiece();
lastFallTime = millis();
}
// ============================================================
// CLEAR LINES
// ============================================================
void clearLines() {
int cleared = 0;
for (int y = BOARD_H - 1; y >= 0; y--) {
bool full = true;
for (int x = 0; x < BOARD_W; x++) {
if (!board[y][x]) {
full = false;
break;
}
}
if (full) {
cleared++;
// Move rows down
for (int yy = y; yy > 0; yy--) {
for (int x = 0; x < BOARD_W; x++) {
board[yy][x] =
board[yy - 1][x];
}
}
// Clear top row
for (int x = 0; x < BOARD_W; x++) {
board[0][x] = false;
}
// Check same row again
y++;
}
}
// Scoring
if (cleared > 0) {
lines += cleared;
switch (cleared) {
case 1:
score += 100 * level;
break;
case 2:
score += 300 * level;
break;
case 3:
score += 500 * level;
break;
case 4:
score += 800 * level;
break;
}
// Increase level every 10 lines
level =
(lines / 10) + 1;
soundLineClear(cleared);
}
}
// ============================================================
// MOVE LEFT
// ============================================================
void moveLeft() {
if (gameOver) {
return;
}
if (!checkCollision(
currentX - 1,
currentY,
rotationState)) {
currentX--;
drawBoard();
soundLeft();
}
}
// ============================================================
// MOVE RIGHT
// ============================================================
void moveRight() {
if (gameOver) {
return;
}
if (!checkCollision(
currentX + 1,
currentY,
rotationState)) {
currentX++;
drawBoard();
soundRight();
}
}
// ============================================================
// ROTATE
// ============================================================
void rotatePiece() {
if (gameOver) {
return;
}
int newRotation =
(rotationState + 1) % 4;
// Normal rotation
if (!checkCollision(
currentX,
currentY,
newRotation)) {
rotationState =
newRotation;
drawBoard();
return;
}
// Wall kick LEFT
if (!checkCollision(
currentX - 1,
currentY,
newRotation)) {
currentX--;
rotationState =
newRotation;
drawBoard();
return;
}
// Wall kick RIGHT
if (!checkCollision(
currentX + 1,
currentY,
newRotation)) {
currentX++;
rotationState =
newRotation;
drawBoard();
return;
}
}
// ============================================================
// MOVE DOWN
// ============================================================
bool moveDown() {
if (gameOver) {
return false;
}
if (!checkCollision(
currentX,
currentY + 1,
rotationState)) {
currentY++;
return true;
}
// Cannot move further
lockPiece();
return false;
}
// ============================================================
// SOFT DROP
// ============================================================
void handleSoftDrop() {
if (gameOver) {
return;
}
static unsigned long lastSoftDrop = 0;
if (millis() - lastSoftDrop >=
SOFT_DROP_FALL) {
lastSoftDrop = millis();
if (moveDown()) {
score += 1;
}
drawBoard();
}
}
// ============================================================
// NORMAL FALL
// ============================================================
void handleNormalFall() {
if (gameOver) {
return;
}
unsigned long fallSpeed;
fallSpeed =
NORMAL_FALL -
((level - 1) * 50);
if (fallSpeed < 100) {
fallSpeed = 100;
}
if (millis() - lastFallTime >=
fallSpeed) {
lastFallTime = millis();
moveDown();
drawBoard();
}
}
// ============================================================
// BUTTON HANDLING
// ============================================================
void handleButtons() {
bool leftState =
digitalRead(BTN_LEFT);
bool rightState =
digitalRead(BTN_RIGHT);
bool rotateState =
digitalRead(BTN_ROTATE);
// ==========================================================
// LEFT
// ==========================================================
if (leftState == LOW &&
lastLeftState == HIGH) {
moveLeft();
}
// ==========================================================
// RIGHT
// ==========================================================
if (rightState == LOW &&
lastRightState == HIGH) {
moveRight();
}
// ==========================================================
// ROTATE BUTTON PRESSED
// ==========================================================
if (rotateState == LOW &&
lastRotateState == HIGH) {
rotatePressTime = millis();
rotateHandled = false;
}
// ==========================================================
// ROTATE BUTTON HELD
// ==========================================================
if (rotateState == LOW) {
if (!rotateHandled &&
millis() - rotatePressTime >=
LONG_PRESS_TIME) {
rotateHandled = true;
softDrop = true;
}
}
// ==========================================================
// ROTATE BUTTON RELEASED
// ==========================================================
if (rotateState == HIGH &&
lastRotateState == LOW) {
unsigned long pressDuration =
millis() - rotatePressTime;
// Short press = ROTATE
if (pressDuration <
LONG_PRESS_TIME &&
!rotateHandled) {
rotatePiece();
soundRotate();
}
// Stop soft drop
softDrop = false;
}
lastLeftState =
leftState;
lastRightState =
rightState;
lastRotateState =
rotateState;
}
// ============================================================
// START MUSIC
// ============================================================
//
// Arcade-style startup melody.
//
// Không dùng tone liên tục.
// Mỗi nốt kết thúc trước khi nốt tiếp theo bắt đầu.
// ============================================================
void playStartMusic() {
clearDisplay();
// ----------------------------------------------------------
// Intro LED sweep
// ----------------------------------------------------------
for (int y = 0; y < BOARD_H; y++) {
for (int x = 0; x < BOARD_W; x++) {
setPixel(
x,
y,
true
);
}
// Melody notes during sweep
if (y == 0) {
tone(BUZZER_PIN, 523, 100);
}
if (y == 4) {
tone(BUZZER_PIN, 659, 100);
}
if (y == 8) {
tone(BUZZER_PIN, 784, 100);
}
if (y == 12) {
tone(BUZZER_PIN, 1047, 150);
}
if (y == 18) {
tone(BUZZER_PIN, 784, 100);
}
if (y == 22) {
tone(BUZZER_PIN, 1047, 100);
}
if (y == 26) {
tone(BUZZER_PIN, 1319, 180);
}
delay(18);
}
delay(100);
clearDisplay();
// ----------------------------------------------------------
// READY melody
// ----------------------------------------------------------
tone(BUZZER_PIN, 784, 120);
delay(150);
tone(BUZZER_PIN, 988, 120);
delay(150);
tone(BUZZER_PIN, 1175, 120);
delay(150);
tone(BUZZER_PIN, 1568, 250);
delay(300);
clearDisplay();
noTone(BUZZER_PIN);
}
// ============================================================
// LEFT SOUND
// ============================================================
void soundLeft() {
tone(
BUZZER_PIN,
650,
70
);
}
// ============================================================
// RIGHT SOUND
// ============================================================
void soundRight() {
tone(
BUZZER_PIN,
850,
70
);
}
// ============================================================
// ROTATE SOUND
// ============================================================
void soundLock() {
tone(BUZZER_PIN, 450, 120);
delay(130);
tone(BUZZER_PIN, 300, 100);
}
// ============================================================
// ROTATE SOUND
// ============================================================
void soundRotate() {
tone(
BUZZER_PIN,
1200,
100
);
}
// ============================================================
// LINE CLEAR SOUND
// ============================================================
void soundLineClear(int count) {
if (count == 1) {
tone(
BUZZER_PIN,
1000,
120
);
delay(150);
tone(
BUZZER_PIN,
1400,
160
);
}
else if (count == 2) {
tone(
BUZZER_PIN,
1000,
100
);
delay(120);
tone(
BUZZER_PIN,
1300,
100
);
delay(120);
tone(
BUZZER_PIN,
1700,
180
);
}
else {
tone(
BUZZER_PIN,
1200,
100
);
delay(120);
tone(
BUZZER_PIN,
1500,
100
);
delay(120);
tone(
BUZZER_PIN,
1800,
100
);
delay(120);
tone(
BUZZER_PIN,
2200,
250
);
}
}
// ============================================================
// GAME OVER SOUND
// ============================================================
void soundGameOver() {
tone(
BUZZER_PIN,
700,
180
);
delay(210);
tone(
BUZZER_PIN,
500,
180
);
delay(210);
tone(
BUZZER_PIN,
350,
220
);
delay(250);
tone(
BUZZER_PIN,
220,
450
);
delay(500);
noTone(BUZZER_PIN);
}
// ============================================================
// GAME OVER ANIMATION
// ============================================================
void gameOverAnimation() {
for (int i = 0; i < 4; i++) {
drawBoard();
delay(250);
clearDisplay();
delay(250);
}
}
// ============================================================
// RESET GAME
// ============================================================
void resetGame() {
for (int y = 0; y < BOARD_H; y++) {
for (int x = 0; x < BOARD_W; x++) {
board[y][x] = false;
}
}
score = 0;
lines = 0;
level = 1;
gameOver = false;
spawnPiece();
lastFallTime =
millis();
drawBoard();
}
// ============================================================
// SETUP
// ============================================================
void setup() {
Serial.begin(115200);
// Buttons
pinMode(
BTN_LEFT,
INPUT_PULLUP
);
pinMode(
BTN_RIGHT,
INPUT_PULLUP
);
pinMode(
BTN_ROTATE,
INPUT_PULLUP
);
// Buzzer
pinMode(
BUZZER_PIN,
OUTPUT
);
// MAX7219
mx.begin();
mx.control(
MD_MAX72XX::INTENSITY,
5
);
mx.control(
MD_MAX72XX::UPDATE,
true
);
mx.clear();
// Random seed
randomSeed(
analogRead(A0)
);
// ==========================================================
// START MUSIC
// ==========================================================
playStartMusic();
// ==========================================================
// START GAME
// ==========================================================
resetGame();
gameStarted = true;
}
// ============================================================
// MAIN LOOP
// ============================================================
void loop() {
if (!gameStarted) {
return;
}
// ==========================================================
// GAME OVER
// ==========================================================
if (gameOver) {
gameOverAnimation();
delay(500);
// Restart
resetGame();
return;
}
// ==========================================================
// INPUT
// ==========================================================
handleButtons();
// ==========================================================
// SOFT DROP
// ==========================================================
if (softDrop) {
handleSoftDrop();
}
else {
handleNormalFall();
}
}