아두이노 LED 매트릭스
LED 매트릭스 디스플레이, 또한 LED 디스플레이 또는 도트 매트릭스 디스플레이라고도 알려져 있으며, 널리 사용됩니다. 이 튜토리얼에서, 우리는 배울 예정입니다:
- LED 매트릭스
- 아두이노를 8x8 LED 매트릭스에 연결하는 방법
- 아두이노를 32x8 LED 매트릭스에 연결하는 방법
- 아두이노를 사용하여 LED 매트릭스에 텍스트, 숫자 및 애니메이션 효과를 표시하는 방법
그 후에는, 16x8 LED 매트릭스, 64x8 LED 매트릭스 등 다른 LED 매트릭스에 코드를 쉽게 적용할 수 있습니다.
준비물
| 1 | × | 아두이노 우노 R3 | 쿠팡 | 아마존 | |
| 1 | × | USB 2.0 타입 A-to-B 케이블 (USB-A PC용) | 쿠팡 | 아마존 | |
| 1 | × | USB 2.0 타입 C-to-B 케이블 (USB-C PC용) | 아마존 | |
| 1 | × | FC-16 LED Matrix 32x8 | 쿠팡 | 아마존 | |
| 1 | × | FC-16 LED Matrix 8x8 | 쿠팡 | 아마존 | |
| 1 | × | Generic LED Matrix 8x8 | 아마존 | |
| 1 | × | 점퍼케이블 | 쿠팡 | 아마존 | |
| 1 | × | DC 커넥터 전원 연결 잭 플러그 소켓 | 쿠팡 | 아마존 | |
| 1 | × | 5V Power Adapter for Arduino | 아마존 | |
| 1 | × | (추천) 아두이노 우노용 스크루 터미널 블록 쉴드 | 쿠팡 | 아마존 | |
| 1 | × | (추천) Sensors/Servo Expansion Shield for Arduino Uno | 쿠팡 | 아마존 | |
| 1 | × | (추천) 아두이노 우노용 브레드보드 쉴드 | 쿠팡 | 아마존 | |
| 1 | × | (추천) 아두이노 우노용 케이스 | 쿠팡 | 아마존 | |
| 1 | × | (추천) 아두이노 우노용 프로토타이핑 베이스 플레이트 & 브레드보드 키트 | 아마존 |
공개: 이 포스팅 에 제공된 일부 링크는 아마존 제휴 링크입니다. 이 포스팅은 쿠팡 파트너스 활동의 일환으로, 이에 따른 일정액의 수수료를 제공받습니다.
LED 매트릭스에 관하여
다양한 종류의 LED 매트릭스가 있습니다. 아두이노와 함께 MAX7219 기반 LED 매트릭스가 널리 사용됩니다. MAX7219 기반 LED 매트릭스는 다음과 같은 특징을 가지고 있습니다:
- LED 매트릭스의 기본 단위는 블록입니다.
- 각 블록은 8x8 LED 매트릭스(64 LED)와 MAX7219 드라이버가 있습니다.
- 두 가지 인기 있는 블록 형태가 있습니다: 일반 모듈과 FC-16 모듈.
- LED 매트릭스는 단일 블록 또는 여러 블록을 데이지 체인으로 구성할 수 있습니다.
- 사전 제작된 다중 블록 LED 매트릭스(예: 4-in-1, 8-in-1)를 구입할 수 있습니다.
- 원하는 크기의 LED 매트릭스를 형성하기 위해 여러 블록을 구입하고 배선할 수도 있습니다.
- Arduino 코드에서 사용하는 LED 매트릭스의 크기를 선언할 것입니다.
핀배치
LED 매트릭스는 하나 또는 여러 개의 블록으로 구성됩니다. 각 블록은 두 그룹의 핀을 포함합니다:
- 입력 핀 그룹:
- VCC: 5V에 연결됩니다.
- GND: GND에 연결됩니다.
- DIN은 데이터 핀이며, 아두이노의 SPI MOSI 핀에 연결하세요.
- CS: 칩 선택, 아두이노의 아무 디지털 핀에나 연결하세요.
- CLK: 클록 핀, 아두이노의 SPI CLK 핀에 연결하세요.
- 출력 핀 그룹:
- VCC: 다음 모듈의 VCC에 연결됩니다.
- GND: 다음 모듈의 GND에 연결됩니다.
- DOUT: 데이터 아웃, 다음 모듈의 DIN 핀에 연결됩니다.
- CS: 다음 모듈의 CS에 연결됩니다.
- CLK: 다음 모듈의 CLK에 연결됩니다.
선연결
LED 매트릭스가 단일 블록으로 구성된 경우:
- 입력 핀 그룹을 아두이노에 연결하세요
- 출력 핀 그룹은 연결하지 않도록 합니다
이 이미지는 Fritzing을 사용하여 만들어졌습니다. 이미지를 확대하려면 클릭하세요.
이 이미지는 Fritzing을 사용하여 만들어졌습니다. 이미지를 확대하려면 클릭하세요.
만약 LED 매트릭스가 사전에 여러 블록으로 조립되어 있다면:
- 입력 핀 그룹을 아두이노에 연결하세요.
- 출력 핀 그룹은 연결하지 마세요.
이 이미지는 Fritzing을 사용하여 만들어졌습니다. 이미지를 확대하려면 클릭하세요.
LED 매트릭스가 여러 블록으로 직접 만들어진 경우:
- 첫 번째 블록의 입력 핀 그룹을 Arduino에 연결하세요
- 각 블록의 출력 핀 그룹을 다음 블록의 입력 핀 그룹에 연결하세요
- 마지막 블록의 출력 핀 그룹은 연결하지 않아도 됩니다
이 이미지는 Fritzing을 사용하여 만들어졌습니다. 이미지를 확대하려면 클릭하세요.
이 이미지는 Fritzing을 사용하여 만들어졌습니다. 이미지를 확대하려면 클릭하세요.
디스플레이가 많은 전류를 소모하기 때문에(최대 밝기에서 최대 1A까지):
- 아두이노의 5V 핀에서 전력을 사용하지 마십시오.
- 대신 외부 5V 전원 공급 장치를 사용하십시오. 아두이노와 LED 매트릭스는 5V 전원 어댑터에서 전력을 공유할 수 있습니다.
Arduino는 SPI 핀을 통해 LED 매트릭스에 연결됩니다:
- 아두이노 우노에서는 핀 13(SCK)과 11(MOSI)을 사용해야 합니다. 다른 아두이노 보드를 사용하는 경우, 해당 SPI 핀의 동등한 핀을 확인하려면 공식 문서를 확인하세요.
- 핀 3(CS)은 어느 핀으로든 변경할 수 있습니다.
LED 매트릭스 프로그래밍 방법
LED 매트릭스를 제어하는 것은 쉽지 않습니다. 다행히도, 이를 쉽게 만들어주는 라이브러리가 있습니다. 아래에는 LED 매트릭스를 제어하기 위한 아두이노 코드를 작성하는 방법에 대한 단계별 안내가 있습니다.
라이브러리 포함:
cpp
#include <MD_Parola.h>
#include <MD_MAX72xx.h>
사용 중인 하드웨어를 지정하십시오: GENERIC_HW 또는 FC16_HW.
#define HARDWARE_TYPE MD_MAX72XX::FC16_HW
사용된 LED 블록의 수를 정의하세요. 예를 들어, 4-in-1 LED 매트릭스는 4개의 블록을 가집니다.
#define MAX_DEVICES 4
LED 매트릭스의 CS 핀에 연결되는 핀을 정의하십시오. 예를 들어, 핀 D3
#define CS_PIN 3
LED 매트릭스 디스플레이를 위한 MD_Parola 클래스의 새 인스턴스를 생성합니다.
cpp
MD_Parola ledMatrix = MD_Parola(HARDWARE_TYPE, CS_PIN, MAX_DEVICES);
설정() 함수에서 코드:
void setup() {
ledMatrix.begin(); // 객체를 초기화합니다
ledMatrix.setIntensity(0); // LED 매트릭스 디스플레이의 밝기를 설정합니다 (0에서 15까지)
ledMatrix.displayClear(); // led 매트릭스 디스플레이를 지웁니다
}
텍스트, 숫자 표시 및 애니메이션 효과 보기: 다음 부분 참조
아두이노 - LED 매트릭스 코드
아래 코드는 32x8 FC-16 LED 매트릭스 디스플레이(4 블록)용입니다. 하지만, 이 코드를 쉽게 8x8, 16x8, 64x8 등으로 조정할 수 있습니다.
/*
* 이 아두이노 코드는 newbiely.kr 에서 개발되었습니다
* 이 아두이노 코드는 어떠한 제한 없이 공개 사용을 위해 제공됩니다.
* 상세한 지침 및 연결도에 대해서는 다음을 방문하세요:
* https://newbiely.kr/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개의 블록
#define CS_PIN 3
// MD_Parola 클래스의 인스턴스 생성
MD_Parola ledMatrix = MD_Parola(HARDWARE_TYPE, CS_PIN, MAX_DEVICES);
void setup() {
ledMatrix.begin(); // 객체를 초기화합니다
ledMatrix.setIntensity(0); // LED 매트릭스 디스플레이의 밝기 설정 (0에서 15까지)
ledMatrix.displayClear(); // LED 매트릭스 디스플레이 지우기
}
void loop() {
ledMatrix.setTextAlignment(PA_LEFT);
ledMatrix.print("Left"); // 텍스트 표시
delay(2000);
ledMatrix.setTextAlignment(PA_CENTER);
ledMatrix.print("Center"); // 텍스트 표시
delay(2000);
ledMatrix.setTextAlignment(PA_RIGHT);
ledMatrix.print("Right"); // 텍스트 표시
delay(2000);
ledMatrix.setTextAlignment(PA_CENTER);
ledMatrix.setInvert(true);
ledMatrix.print("Invert"); // 텍스트 반전으로 표시
delay(2000);
ledMatrix.setInvert(false);
ledMatrix.print(1234); // 숫자 표시
delay(2000);
}
사용 방법
- 위의 배선도대로 Arduino를 LED 매트릭스에 연결하세요.
- USB 케이블을 사용하여 Arduino를 PC에 연결하세요.
- Arduino IDE의 왼쪽 바에서 Libraries 아이콘으로 이동하세요.
- “MD_Parola”를 검색한 다음, MD_Parola 라이브러리를 찾으세요.
- Install 버튼을 클릭하세요.
당신은 의존성을 위해 MD_MAX72XX 라이브러리를 설치하라는 요청을 받게 됩니다. Install All 버튼을 클릭하세요.
- 위의 코드를 복사하고 Arduino IDE로 열어주세요
- Arduino IDE에서 Upload 버튼을 클릭해서 아두이노에 코드를 업로드하세요
- LED 매트릭스 디스플레이를 확인하세요
아두이노 LED 매트릭스 코드 - 스크롤 텍스트
LED 매트릭스 디스플레이에 맞지 않을 정도로 긴 메시지를 출력하고 싶을 때는 스크롤 텍스트 효과 기술을 사용할 수 있습니다.
아래의 아두이노 코드는 LED 매트릭스 디스플레이에서 메시지를 스크롤하는 방법을 보여줍니다.
/*
* 이 아두이노 코드는 newbiely.kr 에서 개발되었습니다
* 이 아두이노 코드는 어떠한 제한 없이 공개 사용을 위해 제공됩니다.
* 상세한 지침 및 연결도에 대해서는 다음을 방문하세요:
* https://newbiely.kr/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개의 블록
#define CS_PIN 3
// MD_Parola 클래스의 인스턴스를 생성합니다
MD_Parola ledMatrix = MD_Parola(HARDWARE_TYPE, CS_PIN, MAX_DEVICES);
void setup() {
ledMatrix.begin(); // 객체를 초기화합니다
ledMatrix.setIntensity(0); // LED 매트릭스 디스플레이의 밝기를 설정합니다 (0에서 15까지)
ledMatrix.displayClear(); // led 매트릭스 디스플레이를 지웁니다
ledMatrix.displayScroll("Hello", PA_CENTER, PA_SCROLL_LEFT, 100);
}
void loop() {
if (ledMatrix.displayAnimate()) {
ledMatrix.displayReset();
}
}
더 많은 텍스트 효과를 원하시면, MD_Parola 라이브러리 설명서를 방문해 주세요.
동영상
비디오 제작은 시간이 많이 걸리는 작업입니다. 비디오 튜토리얼이 학습에 도움이 되었다면, YouTube 채널 을 구독하여 알려 주시기 바랍니다. 비디오에 대한 높은 수요가 있다면, 비디오를 만들기 위해 노력하겠습니다.
아래 동영상 데모는 아래 코드를 사용합니다:
/*
* 이 아두이노 코드는 newbiely.kr 에서 개발되었습니다
* 이 아두이노 코드는 어떠한 제한 없이 공개 사용을 위해 제공됩니다.
* 상세한 지침 및 연결도에 대해서는 다음을 방문하세요:
* https://newbiely.kr/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();
}
}
