Jeu TETRIS commandé par la carte Arduino

Arduino UNO 07-03-25

118 0

Plan du tutorial

1- Présenter le jeu Tetris

2- Description de notre jeu commandé par Arduino UNO

3- Matériel nécessaire

4- Câblage des composants du projet

5- Programme Arduino du jeu Tetris

Présenter le jeu Tetris

Tetris est un jeu de puzzle emblématique créé en 1984 par Alexey Pajitnov. Il consiste à empiler des formes géométriques appelées tétriminos, qui tombent du haut de l’écran vers le bas. Le but est d’organiser ces pièces de manière à compléter des lignes horizontales, qui disparaissent une fois remplies, libérant de l’espace et permettant de continuer à jouer.

Mécanismes du jeu

1- Les Tétriminos

Il existe 7 types de tétriminos (I, O, T, L, J, S, Z), chacun formé de 4 blocs.

Les formes peuvent être tournées et déplacées avant d'atteindre le bas de l'écran.

2- Déroulement de la partie

Une pièce apparaît en haut de l’écran et tombe progressivement.

Le joueur peut déplacer la pièce vers la gauche, la droite, la faire tourner ou accélérer sa chute.

Lorsque la pièce atteint le bas ou entre en collision avec une autre, elle se fige.

Une ligne complète disparaît, ce qui augmente le score et accélère le jeu.

3- Fin du jeu

La partie se termine lorsque les blocs empilés atteignent le haut de l’écran, empêchant l’apparition d’un nouveau tétrimino.

Description de notre jeu commandé par Arduino UNO

Ce projet consiste à recréer le jeu Tetris sur une carte Arduino UNO, avec une interface utilisateur.

1. Affichage et grille de jeu

L’écran LCD sert à afficher la grille de jeu sous forme de caractères ASCII ou de blocs personnalisés.

L’espace de jeu est limité par la taille de l’écran LCD.

Chaque tétrimino est représenté par des caractères ou des blocs définis en mémoire.

La grille est mise à jour en fonction des mouvements du joueur.

2. Contrôle des tétriminos avec le joystick

Le joystick analogique permet au joueur de déplacer et faire pivoter les tétriminos :

Déplacement gauche/droite → Déplacement horizontal des pièces.

Poussée vers le bas → Accélération de la descente du tétrimino.

Appui sur le bouton du joystick → Rotation du tétrimino.

Le joystick génère des valeurs analogiques (0-1023), qui sont converties en commandes pour déplacer les pièces.

3. Gestion de la chute des pièces et des collisions

Un tétrimino tombe progressivement de haut en bas.

Si un mouvement entraîne une collision avec une autre pièce ou avec le bas de l’écran, la pièce se fige.

Une nouvelle pièce apparaît en haut de l’écran.

4. Suppression des lignes complètes

Si une ligne complète est formée, elle disparaît et les lignes supérieures descendent.

Un son est joué via le buzzer pour signaler la suppression.

Le score augmente en fonction du nombre de lignes supprimées.

5. Fin de la partie (Game Over)

Si les pièces atteignent le haut de l’écran, la partie est terminée.

Un son d’échec est joué par le buzzer.

L’écran affiche un message "Game Over" et propose de redémarrer la partie.

Matériel nécessaire

Ce projet Tetris utilise plusieurs composants électroniques connectés à une carte Arduino UNO pour recréer une version du jeu. Voici une description détaillée de chaque composant et de son rôle dans le projet.

1. Carte Arduino UNO

Arduino Uno

L'Arduino UNO est le microcontrôleur principal qui exécute le programme du jeu. Il contrôle l'affichage sur l'écran LCD, lit les entrées du joystick et génère des sons avec le buzzer.

Rôle dans le jeu

- Gère le mouvement des tétriminos à partir des entrées du joystick.

- Met à jour l'affichage de la grille sur l'écran LCD.

- Joue des sons via le buzzer en fonction des événements du jeu.

- Contrôle la détection des collisions et l’effacement des lignes.

2. Afficheur LCD I2C

Pinouts of 1602 LCD display with I2C

Un écran LCD I2C 16x2 ou 20x4 est utilisé pour afficher la grille de jeu. Il fonctionne via le protocole I2C, ce qui simplifie le câblage et réduit le nombre de broches utilisées sur l’Arduino.

Rôle dans le jeu

- Affiche la grille de jeu et les tétriminos en mouvement.

- Indique des messages comme le score, "Game Over", etc.

- Permet d’utiliser des caractères personnalisés pour mieux représenter les blocs.

3. Manette (Joystick) analogique

Le joystick analogique permet au joueur de déplacer et faire pivoter les tétriminos. Il fonctionne avec deux potentiomètres pour capter les mouvements X et Y et un bouton poussoir intégré pour déclencher des actions.

Rôle dans le jeu

- Déplacement gauche/droite : via l’axe X.

- Descente rapide : en poussant vers le bas sur l’axe Y.

- Rotation des pièces : en appuyant sur le bouton du joystick.

4. Buzzer

Le buzzer permet de générer des sons pour enrichir l'expérience du jeu (déplacement des pièces, suppression de lignes, Game Over). On peut utiliser un buzzer actif (produisant un son fixe) ou un buzzer passif (permettant de jouer des mélodies avec tone()).

Rôle dans le jeu

Son aigu quand une pièce tourne.

Bip rapide lors de la suppression d’une ligne.

Son grave en cas de Game Over.

Plaque d’essai (Breadboard)

plaque d'essai

La plaque d’essai permet de connecter les composants sans soudure et d’organiser le câblage.

fils de connexion

Fils de connexion

Les fils Dupont relient les composants à l’Arduino.

Schéma de câblage du projet

Joystick :

VRx : Connecté à l'entrée analogique A2 de la carte Arduino UNO.

VRy : Connecté à l'entrée analogique A3 de la carte Arduino UNO.

SW : Connecté à l'entrée numérique D2 de la carte Arduino UNO pour le bouton-poussoir.

GND : Connecté à broche GND de la carte Arduino UNO.

VCC : Connecté à broche 3V3 de la carte Arduino UNO.

2. Afficheur LCD :

SDA : Connecté à l'entrée analogique A4 de la carte Arduino UNO.

SCL : Connecté à l'entrée analogique A5 de la carte Arduino UNO.

GND : Connecté à broche GND de la carte Arduino UNO.

VCC : Connecté à broche 5V de la carte Arduino UNO.

3. Buzzer :

Connecter la broche (+) du buzzer à la sortie numérique D3 de l'Arduino UNO.

Relier l'autre broche (-) à GND de l'Arduino UNO.

Programme Arduino du jeu Tetris

Ce programme crée une version simplifiée de du jeu Tetris utilisant un afficheur LCD I2C, une manette (joystick) et un buzzer.

Installer la bibilothèqueLiquidCrystal_I2C.h pour contrôler l’écran LCD I2C.

#include <LiquidCrystal_I2C.h>

// Initialisation de l'écran LCD I2C (adresse 0x27, écran 16x2)
LiquidCrystal_I2C lcd(0x27, 16, 2);

// Définition des broches du joystick
#define JOY_X A2  // Axe X (gauche/droite)
#define JOY_Y A3  // Axe Y (haut/bas)
#define JOY_BTN 3 // Bouton (rotation)

// Définition de la broche du buzzer
#define BUZZER 2

// Variables pour la position et l'affichage du tétrimino
int pieceX = 7; // Position initiale au centre
int pieceY = 0; // Position de départ en haut
bool gameOver = false;

// Fonction d'initialisation
void setup() {
    // Initialisation de l'écran LCD
    lcd.init();
    lcd.backlight();
    
    // Configuration des broches
    pinMode(JOY_BTN, INPUT_PULLUP);
    pinMode(BUZZER, OUTPUT);

    // Affichage du message de démarrage
    lcd.setCursor(3, 0);
    lcd.print("TETRIS Arduino");
    delay(2000);
    lcd.clear();
}

// Fonction principale
void loop() {
    if (gameOver) {
        afficherGameOver();
        return;
    }

    lcd.clear();
    dessinerGrille();
    afficherPiece(pieceX, pieceY);

    // Lecture des entrées du joystick
    int xValue = analogRead(JOY_X);
    int yValue = analogRead(JOY_Y);
    int buttonState = digitalRead(JOY_BTN);

    // Déplacement gauche
    if (xValue < 400) {
        pieceX = max(0, pieceX - 1);
        jouerSon(1000);
    }
    // Déplacement droite
    else if (xValue > 600) {
        pieceX = min(15, pieceX + 1);
        jouerSon(1000);
    }
    // Descente rapide
    if (yValue > 600) {
        pieceY++;
        jouerSon(1200);
    }
    // Rotation (bouton du joystick)
    if (buttonState == LOW) {
        // Rotation simplifiée (simulation)
        jouerSon(1500);
    }

    // Vérification de collision (simple simulation)
    if (pieceY >= 1) {
        pieceY = 0; // Remise à zéro
        gameOver = true; // Fin du jeu si accumulation
    }

    delay(300);
}

// Fonction pour dessiner la grille
void dessinerGrille() {
    for (int i = 0; i < 16; i++) {
        lcd.setCursor(i, 1);
        lcd.print("-");
    }
}

// Fonction pour afficher le tétrimino
void afficherPiece(int x, int y) {
    lcd.setCursor(x, y);
    lcd.print("#"); // Symbole représentant la pièce
}

// Fonction pour jouer un son
void jouerSon(int freq) {
    tone(BUZZER, freq, 100);
}

// Fonction d'affichage du Game Over
void afficherGameOver() {
    lcd.clear();
    lcd.setCursor(3, 0);
    lcd.print("GAME OVER!");
    jouerSon(500);
    delay(2000);
    lcd.clear();
    gameOver = false; // Réinitialisation
}

100

101

102

103

104

105

106

107

108

109

110

#include <LiquidCrystal_I2C.h>

// Initialisation de l'écran LCD I2C (adresse 0x27, écran 16x2)

LiquidCrystal_I2C lcd(0x27, 16, 2);

// Définition des broches du joystick

#define JOY_X A2 // Axe X (gauche/droite)

#define JOY_Y A3 // Axe Y (haut/bas)

#define JOY_BTN 3 // Bouton (rotation)

// Définition de la broche du buzzer

#define BUZZER 2

// Variables pour la position et l'affichage du tétrimino

int pieceX = 7; // Position initiale au centre

int pieceY = 0; // Position de départ en haut

bool gameOver = false;

// Fonction d'initialisation

void setup() {

// Initialisation de l'écran LCD

lcd.init();

lcd.backlight();

// Configuration des broches

pinMode(JOY_BTN, INPUT_PULLUP);

pinMode(BUZZER, OUTPUT);

// Affichage du message de démarrage

lcd.setCursor(3, 0);

lcd.print("TETRIS Arduino");

delay(2000);

lcd.clear();

}

// Fonction principale

void loop() {

if (gameOver) {

afficherGameOver();

return;

}

lcd.clear();

dessinerGrille();

afficherPiece(pieceX, pieceY);

// Lecture des entrées du joystick

int xValue = analogRead(JOY_X);

int yValue = analogRead(JOY_Y);

int buttonState = digitalRead(JOY_BTN);

// Déplacement gauche

if (xValue < 400) {

pieceX = max(0, pieceX - 1);

jouerSon(1000);

}

// Déplacement droite

else if (xValue > 600) {

pieceX = min(15, pieceX + 1);

jouerSon(1000);

}

// Descente rapide

if (yValue > 600) {

pieceY++;

jouerSon(1200);

}

// Rotation (bouton du joystick)

if (buttonState == LOW) {

// Rotation simplifiée (simulation)

jouerSon(1500);

}

// Vérification de collision (simple simulation)

if (pieceY >= 1) {

pieceY = 0; // Remise à zéro

gameOver = true; // Fin du jeu si accumulation

}

delay(300);

}

// Fonction pour dessiner la grille

void dessinerGrille() {

for (int i = 0; i < 16; i++) {

lcd.setCursor(i, 1);

lcd.print("-");

}

// Fonction pour afficher le tétrimino

void afficherPiece(int x, int y) {

lcd.setCursor(x, y);

lcd.print("#"); // Symbole représentant la pièce

}

// Fonction pour jouer un son

void jouerSon(int freq) {

tone(BUZZER, freq, 100);

}

// Fonction d'affichage du Game Over

void afficherGameOver() {

lcd.clear();

lcd.setCursor(3, 0);

lcd.print("GAME OVER!");

jouerSon(500);

delay(2000);

lcd.clear();

gameOver = false; // Réinitialisation

}

Explication du code :

Initialisation

- L’écran LCD I2C est configuré avec l’adresse 0x27.

- Les broches du joystick (A0, A1, D2) et du buzzer (D3) sont définies.

Affichage de la grille et des tétriminos

- dessinerGrille() affiche une ligne en bas pour représenter le sol.

- afficherPiece() place un caractère # pour représenter un tétrimino.

Contrôle du jeu avec le joystick

- Déplacement gauche/droite via l’axe X.

- Descente rapide via l’axe Y.

- Rotation des pièces avec le bouton du joystick.

Gestion de la collision et Game Over

Si un bloc atteint le bas, le jeu est réinitialisé après l'affichage de "Game Over".

Effets sonores

Le buzzer joue des sons pour chaque action (tone(BUZZER, fréquence, durée)).

0 commentaire

laisser un commentaire

Annuler la réponse

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Nom *

Email *

Message *

Passion de robotique

Tutoriels récents

Ouverture et fermeture d’une porte avec ESP32 et bouton poussoir

ESP32 06-04-25

Contrôler l’ouverture d’une porte avec Micro:bit et une carte magnétique RFID

Micro:bit 02-04-25

Ouvrir et fermer une porte d’une maison par Arduino

Arduino UNO 31-03-25

Commander à distance une porte en utilisant Micro:bit et une télécommande

Micro:bit 29-03-25

Contrôler une porte d’une maison par la carte Micro:bit

Micro:bit 26-03-25

Atelier robotique

Tutoriels populaires

Afficher la température et l’humidité mesurées par le capteur DHT11 connecté à Arduino sur l’afficheur LCD I2C

Arduino UNO 5107vues

Allumer une LED par la carte ESP32

ESP32 4734vues

Présentation de la carte ESP32

ESP32 4680vues

La carte ESP32 et l’afficheur LCD I2C 1602

ESP32 4403vues

Allumer une LED connectée à la carte ESP32 via WIFI

ESP32 Wifi 3770vues

Construction des robots

Tutoriels plus commentés

Echange des messages entre deux cartes Micro:bit via radio

Micro:bit 9 commentaires

Commander trois LEDs par la télécommande en utilisant le capteur KY-032 et la carte Micro:bit

Micro:bit 3 commentaires

Allumer une LED connectée à l’Arduino UNO via WIFI

Arduino UNO Wifi 3 commentaires

Afficher la température et l’humidité mesurées par le capteur DHT11 connecté à Arduino sur l’afficheur LCD I2C

Arduino UNO 3 commentaires

Création des jeux avec Micro:bit et MakeCode

Micro:bit 2 commentaires

Jeu TETRIS commandé par la carte Arduino

Plan du tutorial

1- Présenter le jeu Tetris

2- Description de notre jeu commandé par Arduino UNO

3- Matériel nécessaire

4- Câblage des composants du projet

5- Programme Arduino du jeu Tetris

Présenter le jeu Tetris

Description de notre jeu commandé par Arduino UNO

Matériel nécessaire

Schéma de câblage du projet

Programme Arduino du jeu Tetris

0 commentaire

laisser un commentaire

Annuler la réponse

Passion de robotique

Tutoriels récents

Atelier robotique

Tutoriels populaires

Construction des robots

Tutoriels plus commentés

Bras robotique

Categories

Maison intelligente

But de ce site web

Coordonnées

Articles populaires

Photos des articles