Jeu TETRIS contrôlé par la carte ESP32

ESP32 05-03-25

48 0

Plan du tutorial

1- Présenter le jeu Tetris

2- Fonctionnement du notre jeu

3- Matériel nécessaire

4- Câblage des composants du projet

5- Programme Micropython du jeu Tetris

Présenter le jeu Tetris

Tetris est un jeu vidéo de puzzle créé en 1984 par Alexey Pajitnov, un programmeur soviétique. Le principe du jeu repose sur l'empilement de formes géométriques appelées Tetriminos, qui tombent du haut de l'écran vers le bas. Ces Tetriminos sont constitués de quatre carrés assemblés selon différentes configurations.

L’objectif est d’assembler ces Tetriminos de manière à former des lignes horizontales complètes. Lorsqu’une ligne est complétée, elle disparaît et laisse de la place pour les nouvelles pièces. Le joueur doit éviter que les blocs s’empilent jusqu’en haut de l’écran, ce qui entraînerait une fin de partie.

Mécanique de jeu

Les Tetriminos tombent automatiquement mais peuvent être déplacés gauche/droite et tournés avant de toucher le bas de l’écran.

Plus le jeu progresse, plus la vitesse de chute des Tetriminos augmente, rendant le jeu plus difficile.

Le joueur marque des points en complétant des lignes, et un bonus est accordé pour plusieurs lignes supprimées en une seule fois (double, triple, Tetris pour 4 lignes d'un coup).

Fonctionnement du notre jeu

1- Génération des Tetriminos

Une pièce est générée en haut de la grille.

Elle est choisie aléatoirement parmi les 7 formes classiques du Tetris.

Elle commence à tomber progressivement.

2- Déplacement et Rotation

Le joueur peut déplacer la pièce avec le joystick.

En appuyant sur le bouton, il peut faire tourner la pièce.

Si la pièce heurte un bord ou une autre pièce, elle s’arrête.

3- Vérification des lignes complètes

Après chaque mouvement, le programme vérifie si une ligne complète est formée.

Une ligne complète disparaît et les pièces du dessus descendent.

Un score est mis à jour en fonction du nombre de lignes supprimées.

4- Augmentation de la difficulté

Avec le temps, la vitesse de chute augmente pour rendre le jeu plus difficile.

5- Fin du jeu

Si une nouvelle pièce ne peut pas être placée, la partie est terminée et un message "Game Over" s'affiche.

Matériel nécessaire

1. Carte ESP32

L'ESP32 est le cœur du système, il :

- Gère l’affichage du jeu sur l’écran LCD.

- Lit les entrées du joystick pour contrôler les pièces.

- Joue des sons via le buzzer.

- Effectue la logique du jeu : chute des pièces, collisions, suppression des lignes complètes.

2. Écran LCD I2C (16x2 ou 20x4)

Pinouts of 1602 LCD display with I2C

L’écran LCD affiche la grille de jeu et les pièces en mouvement.

3. Joystick (Module XY avec bouton)

Le joystick est utilisé pour contrôler les pièces :

- Déplacement gauche/droite (Axe X).

- Rotation des pièces (Bouton poussoir).

4. Buzzer

Le buzzer est utilisé pour jouer des sons lors d’événements du jeu :

- Pose d’une pièce.

- Effacement d’une ligne.

- Game Over.

5. Breadboard

plaque d'essai

Le Breadboard facilite le câblage des composants sans soudure.

6. Fils de connexion (Dupont)

Fils de connexion

Les de connexion permettent de relier l’ESP32 aux différents composants.

Schéma de câblage du projet

1- Joystick :

Connecter les axes X et Y aux entrées analogiques de la carte ESP32 (exemple : GPIO34 et GPIO35).

Connecter le bouton poussoir (si utilisé) à une entrée de la carte ESP32 (exemple GPIO33).

Connecter la broche 5V à la broche 3V3 de la carte ESP32.

Connecter la broche GND à la broche GND de la carte ESP32.

2- Afficheur LCD :

Si un module I2C est utilisé, connecter les broches :

SCL → GPIO22(ESP32)

SDA → GPIO21(ESP32)

VCC → 5V(ESP32)

GND → GND(ESP32)

3- Buzzer :

Connecter la broche (+) à la broche GPIO23 de la carte ESP32.

Connecter la broche (-) à la broche GND de la carte ESP32.

Programme Micropython du jeu Tetris

Voici un programme MicroPython simple (version 0) du jeu Tetris sur ESP32, utilisant un écran LCD I2C (16x2), un joystick pour le contrôle et un buzzer pour les effets sonores.

Remarques:

1- Ce programme utilise les bibliothèques i2c_lcd et lcd_api dédiées à l'écran LCD I2C pour la gestion de l'affichage.

2- N'oublier pas de flashez votre ESP32 avec MicroPython en utilisant Firmware esp32-20210902-v1.17.bin.

from machine import I2C, Pin, ADC
from lcd_api import LcdApi
from i2c_lcd import I2cLcd
import utime
import random

# Initialisation de l'I2C pour l'écran LCD
i2c = I2C(0, scl=Pin(22), sda=Pin(21), freq=400000)
lcd = I2cLcd(i2c, 0x27, 2, 16)  # LCD 16x2 à l'adresse 0x27

# Initialisation du joystick
joystick_x = ADC(Pin(34))  # Axe X
joystick_y = ADC(Pin(35))  # Axe Y
button = Pin(33, Pin.IN, Pin.PULL_UP)  # Bouton pour la rotation

joystick_x.atten(ADC.ATTN_11DB)  
joystick_y.atten(ADC.ATTN_11DB)

# Initialisation du buzzer
buzzer = Pin(23, Pin.OUT)

# Définition des pièces (simplifiées pour un affichage sur LCD 16x2)
pieces = [
    [[1, 1, 1], [0, 1, 0]],  # T
    [[1, 1, 0], [0, 1, 1]],  # Z
    [[0, 1, 1], [1, 1, 0]],  # S
    [[1, 1], [1, 1]],        # Carré
    [[1, 1, 1, 1]],          # Ligne
]

# Sélection aléatoire d'une pièce
def nouvelle_piece():
    return random.choice(pieces)

def lire_joystick():
    x = joystick_x.read()
    y = joystick_y.read()
    
    if x < 1500:
        return "Gauche"
    elif x > 2500:
        return "Droite"
    if y < 1500:
        return "Bas"
    if not button.value():
        return "Rotation"
    return "Neutre"

def bip_sonore():
    buzzer.on()
    utime.sleep(0.1)
    buzzer.off()

position_x = 3
position_y = 0
piece_actuelle = nouvelle_piece()

def deplacer_piece(direction):
    global position_x, position_y
    if direction == "Gauche" and position_x > 0:
        position_x -= 1
    elif direction == "Droite" and position_x < 12:
        position_x += 1
    elif direction == "Bas":
        position_y += 1
    elif direction == "Rotation":
        piece_actuelle[:] = list(zip(*piece_actuelle[::-1]))  # Rotation

    afficher_grille()

def afficher_grille():
    lcd.clear()
    for y, ligne in enumerate(piece_actuelle):
        for x, val in enumerate(ligne):
            if val == 1:
                lcd.move_to(position_x + x, position_y + y)
                lcd.putchar('█')  # Utilisation d'un bloc pour représenter une pièce

def verifier_lignes():
    global position_y
    if position_y >= 1:  # Simulation de suppression de ligne
        bip_sonore()  # Son lorsqu'une ligne est supprimée
        lcd.clear()
        lcd.putstr("Ligne supprimée!")
        utime.sleep(1)
        position_y = 0  # Réinitialisation de la position

lcd.clear()
lcd.putstr("TETRIS sur ESP32")
utime.sleep(2)
lcd.clear()

while True:
    direction = lire_joystick()
    
    if direction != "Neutre":
        deplacer_piece(direction)
    
    utime.sleep(0.2)  # Pause pour éviter la répétition rapide des actions
    
    position_y += 1  # Faire descendre la pièce progressivement
    afficher_grille()
    
    if position_y >= 1:  # Vérification simplifiée des lignes complètes
        verifier_lignes()
    
    if position_y > 5:  # Si la pièce touche le bas, nouvelle pièce
        position_y = 0
        piece_actuelle = nouvelle_piece()

100

101

102

103

104

105

106

107

108

109

from machine import I2C, Pin, ADC

from lcd_api import LcdApi

from i2c_lcd import I2cLcd

import utime

import random

# Initialisation de l'I2C pour l'écran LCD

i2c = I2C(0, scl=Pin(22), sda=Pin(21), freq=400000)

lcd = I2cLcd(i2c, 0x27, 2, 16) # LCD 16x2 à l'adresse 0x27

# Initialisation du joystick

joystick_x = ADC(Pin(34)) # Axe X

joystick_y = ADC(Pin(35)) # Axe Y

button = Pin(33, Pin.IN, Pin.PULL_UP) # Bouton pour la rotation

joystick_x.atten(ADC.ATTN_11DB)

joystick_y.atten(ADC.ATTN_11DB)

# Initialisation du buzzer

buzzer = Pin(23, Pin.OUT)

# Définition des pièces (simplifiées pour un affichage sur LCD 16x2)

pieces = [

[[1, 1, 1], [0, 1, 0]], # T

[[1, 1, 0], [0, 1, 1]], # Z

[[0, 1, 1], [1, 1, 0]], # S

[[1, 1], [1, 1]], # Carré

[[1, 1, 1, 1]], # Ligne

]

# Sélection aléatoire d'une pièce

def nouvelle_piece():

return random.choice(pieces)

def lire_joystick():

x = joystick_x.read()

y = joystick_y.read()

if x < 1500:

return "Gauche"

elif x > 2500:

return "Droite"

if y < 1500:

return "Bas"

if not button.value():

return "Rotation"

return "Neutre"

def bip_sonore():

buzzer.on()

utime.sleep(0.1)

buzzer.off()

position_x = 3

position_y = 0

piece_actuelle = nouvelle_piece()

def deplacer_piece(direction):

global position_x, position_y

if direction == "Gauche" and position_x > 0:

position_x -= 1

elif direction == "Droite" and position_x < 12:

position_x += 1

elif direction == "Bas":

position_y += 1

elif direction == "Rotation":

piece_actuelle[:] = list(zip(*piece_actuelle[::-1])) # Rotation

afficher_grille()

def afficher_grille():

lcd.clear()

for y, ligne in enumerate(piece_actuelle):

for x, val in enumerate(ligne):

if val == 1:

lcd.move_to(position_x + x, position_y + y)

lcd.putchar('█') # Utilisation d'un bloc pour représenter une pièce

def verifier_lignes():

global position_y

if position_y >= 1: # Simulation de suppression de ligne

bip_sonore() # Son lorsqu'une ligne est supprimée

lcd.clear()

lcd.putstr("Ligne supprimée!")

utime.sleep(1)

position_y = 0 # Réinitialisation de la position

lcd.clear()

lcd.putstr("TETRIS sur ESP32")

utime.sleep(2)

lcd.clear()

while True:

direction = lire_joystick()

if direction != "Neutre":

deplacer_piece(direction)

utime.sleep(0.2) # Pause pour éviter la répétition rapide des actions

position_y += 1 # Faire descendre la pièce progressivement

afficher_grille()

if position_y >= 1: # Vérification simplifiée des lignes complètes

verifier_lignes()

if position_y > 5: # Si la pièce touche le bas, nouvelle pièce

position_y = 0

piece_actuelle = nouvelle_piece()

Explication du fonctionnement du programme

1- Initialisation du matériel :

Écran LCD via I2C.

Joystick (X, Y, bouton-poussoir).

Buzzer pour effets sonores.

3- Affichage du jeu :

Le LCD affiche les pièces en utilisant des caractères personnalisés.

La pièce descend automatiquement ligne par ligne.

4- Contrôle avec le joystick :

Gauche/Droite : Déplace la pièce.

Bas : Accélère la descente.

Bouton-poussoir : Fait pivoter la pièce.

5- Vérification des lignes complètes :

Simulation d’une suppression de ligne avec un bip sonore et un message.

6- Nouvelles pièces :

Lorsque la pièce atteint le bas, une nouvelle pièce est généré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

Lecture des données du badge RFID en utilisant Arduino et RFID-RC522

Arduino UNO 08-03-25

Jeu TETRIS commandé par la carte Arduino

Arduino UNO 07-03-25

Jeu TETRIS contrôlé par la carte ESP32

ESP32 05-03-25

Jeu TETRIS contrôlé par la carte Micro:bit

Micro:bit 27-02-25

Commander le jeu Dinausore par la carte Arduino

Arduino UNO 18-02-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 4590vues

Allumer une LED par la carte ESP32

ESP32 4180vues

Présentation de la carte ESP32

ESP32 4076vues

La carte ESP32 et l’afficheur LCD I2C 1602

ESP32 3825vues

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

ESP32 Wifi 3556vues

Construction des robots

Tutoriels plus commentés

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

Création des jeux avec Micro:bit et MakeCode

Micro:bit 2 commentaires

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

Arduino UNO 2 commentaires

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

Arduino UNO 2 commentaires

Jeu TETRIS contrôlé par la carte ESP32

Plan du tutorial

1- Présenter le jeu Tetris

2- Fonctionnement du notre jeu

3- Matériel nécessaire

4- Câblage des composants du projet

5- Programme Micropython du jeu Tetris

Présenter le jeu Tetris

Fonctionnement du notre jeu

Matériel nécessaire

Schéma de câblage du projet

Programme Micropython 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