Piloter le jeu Dinausore par la carte ESP32

ESP32 06-02-25

71 0

Plan du tutorial

1- Présentation du jeu Dinausore du Google Chrome

2- Principe de notre jeu

3- Matériel nécessaire

4- Schéma de câblage du projet

5- Programmation Micropython de la carte ESP32

Présentation du jeu Dinausore du Google Chrome

Le jeu du dinosaure de Google Chrome, aussi appelé "Dino Game" ou "Chrome Dino", est un petit jeu caché dans Google Chrome qui s'active automatiquement lorsque vous perdez votre connexion Internet. Il met en scène un dinosaure T-Rex qui doit éviter des obstacles comme des cactus et des ptérodactyles en sautant ou en s'accroupissant.

🎮 Comment y jouer ?

1. Sans connexion Internet :

a- Ouvre Google Chrome.

b- Si tu n’es pas connecté à Internet, un message s’affichera : "Aucune connexion Internet", avec un petit dinosaure au-dessus.

c- Appuie sur la barre d’espace pour commencer à jouer.

d- Utilise la barre d’espace pour sauter et la flèche bas pour t’accroupir.

2. Avec connexion Internet :

a- Ouvre un nouvel onglet dans Chrome.

b- Tape l’URL suivante : chrome://dino

c- Appuie sur Entrée, puis sur la barre d’espace pour démarrer le jeu.

Principe de notre jeu

Pour réaliser une version du jeu du dinosaure de Google Chrome avec une carte ESP32, un afficheur LCD I2C, et un bouton poussoir pour contrôler le saut, voici le principe de base du projet :

Le dinosaure court en continu sur l'écran LCD. Le joueur doit appuyer sur le bouton poussoir pour le faire sauter et éviter des obstacles (représentés par des pixels ou des blocs).

- Le dinosaure est représenté par un caractère ou un bloc sur l'écran LCD.

- Les obstacles apparaissent à droite de l'écran et se déplacent vers la gauche.

- Lorsque le bouton est pressé, le dinosaure "saute" (change de ligne ou de position verticale).

- Si le dinosaure touche un obstacle, la partie est terminée.

Matériel nécessaire

Carte ESP32

L'ESP32 est un microcontrôleur puissant avec un processeur double cœur, des capacités Wi-Fi/Bluetooth, et de nombreux GPIO (broches d’entrée/sortie). Il est parfait pour les projets embarqués grâce à sa vitesse de traitement élevée et sa faible consommation d'énergie.

Rôle dans le jeu :

- Gérer la logique du jeu (détection des obstacles, gestion du saut, collisions, etc.)

- Contrôler l'affichage des éléments sur l’écran LCD

- Générer des sons via le buzzer (effet sonore pour les sauts ou le Game Over)

- Lire l'état du bouton poussoir pour détecter les sauts du dinosaure

Afficheur LCD I2C (16x2 ou 20x4)

Pinouts of 1602 LCD display with I2C

Un écran LCD (Liquid Crystal Display) permet d’afficher du texte ou des caractères personnalisés. Le module I2C simplifie les connexions en utilisant seulement deux fils pour la communication.

Rôle dans le jeu :

- Afficher le dinosaure, les obstacles et le score

- Mettre à jour l’affichage à chaque cycle pour simuler le mouvement

- Afficher des messages comme "Game Over" ou "Score"

Bouton Poussoir

bouton-poussoir

Un simple interrupteur momentané qui établit une connexion lorsqu'il est pressé. Il est souvent utilisé pour les interactions basiques dans les projets électroniques.

Rôle dans le jeu :

- Détecter l’action du joueur pour déclencher le saut du dinosaure

Buzzer

Le buzzer est un composant électronique capable de produire des sons ou des bips sonores. Il existe deux types :

Rôle dans le jeu :

- Produire un son lors des sauts du dinosaure

- Générer un son distinct en cas de collision (Game Over)

- Ajouter des effets sonores pour rendre le jeu plus immersif

Câble de connexion

Fils de connexion

Vous aurez besoin d'un câble pour connecter l'afficheur LCD et le bouton poussoir à la carte ESP32.

Plaque d'essai (Breadboard) :

plaque d'essai

On utilise la plaque d'essai pour faciliter le câblage des différents composants.

Schéma de câblage du projet

ESP32 → LCD I2C

SDA → GPIO 21

SCL → GPIO 22

VCC → 5V

GND → GND

ESP32 → Bouton Poussoir

Une patte → GPIO 19

Autre patte → GND

ESP32 → Buzzer

+ du buzzer → GPIO 23 (PWM)

- du buzzer → GND

Programmation Micropython de la carte ESP32

Voici un exemple de programme MicroPython pour réaliser une version simplifiée du jeu Chrome Dinosaur :

Assurez-vous que les fichiers "i2c_lcd" et "lcd_api" sont bien présents dans votre système MicroPython.

from machine import I2C, Pin, PWM
import time
from lcd_api import LcdApi
from i2c_lcd import I2cLcd

# ===============================
# Configuration du LCD I2C 16x2
# ===============================
# Configuration de l'I2C (vérifiez les pins SCL/SDA de votre montage)
i2c = I2C(scl=Pin(22), sda=Pin(21), freq=400000)
I2C_ADDR = 0x27  # adresse I2C typique du module LCD (à adapter si nécessaire)
lcd = I2cLcd(i2c, I2C_ADDR, 2, 16)  # 2 lignes, 16 colonnes

# ===============================
# Configuration du bouton et du buzzer
# ===============================
# Bouton branché sur la pin 19 en entrée avec résistance pull-up
bouton = Pin(19, Pin.IN, Pin.PULL_UP)
# Buzzer branché sur la pin 23
buzzer_pin = Pin(23, Pin.OUT)

# ===============================
# Paramètres et variables du jeu
# ===============================
DINO_COL    = 2      # Colonne fixe du dinosaure sur l'écran
GROUND_ROW  = 1      # Ligne de sol (la deuxième ligne du LCD, numérotée 1)
AIR_ROW     = 0      # Ligne en l'air (première ligne, numérotée 0)
JUMP_FRAMES = 3      # Nombre de cycles pendant lesquels le dinosaure reste en l'air

# Variables de jeu
dino_row    = GROUND_ROW  # Position initiale du dinosaure (sur le sol)
jumping     = False       # Etat du saut
jump_counter= 0           # Compteur pour la durée du saut

obstacle_col = 15         # Position initiale de l'obstacle (à l'extrémité droite de l'écran)
score        = 0          # Score initial

# ===============================
# Fonction de son pour le buzzer
# ===============================
def beep(freq=1000, duration=0.1):
    """
    Active le buzzer à la fréquence 'freq' pendant 'duration' secondes.
    """
    buzzer = PWM(buzzer_pin)
    buzzer.freq(freq)
    buzzer.duty(512)  # rapport cyclique à 50%
    time.sleep(duration)
    buzzer.deinit()

# ===============================
# Boucle principale du jeu
# ===============================
while True:
    # --- Gestion du saut ---
    # Si le bouton est pressé, que le dinosaure est sur le sol et qu'il n'est pas déjà en saut
    if not bouton.value() and (not jumping) and (dino_row == GROUND_ROW):
        jumping = True
        jump_counter = JUMP_FRAMES
        beep(1500, 0.05)  # court bip lors du lancement du saut

    if jumping:
        dino_row = AIR_ROW  # le dinosaure se trouve en l'air
        jump_counter -= 1
        if jump_counter <= 0:
            jumping = False
            dino_row = GROUND_ROW  # retour au sol
    else:
        dino_row = GROUND_ROW

    # --- Déplacement de l'obstacle ---
    obstacle_col -= 1
    if obstacle_col < 0:
        obstacle_col = 15  # réinitialisation de l'obstacle à droite
        score += 1       # le score augmente à chaque passage complet de l'obstacle

    # --- Mise à jour de l'affichage sur le LCD ---
    lcd.clear()
    
    # Affichage du score (positionné en haut à droite sur la première ligne)
    lcd.move_to(10, 0)
    lcd.putstr("S:" + str(score))
    
    # Affichage du dinosaure (représenté par le caractère "D")
    lcd.move_to(DINO_COL, dino_row)
    lcd.putstr("D")
    
    # Affichage de l'obstacle (représenté par le caractère "O") sur le sol
    if 0 <= obstacle_col < 16:
        lcd.move_to(obstacle_col, GROUND_ROW)
        lcd.putstr("O")
    
    # --- Détection de collision ---
    # Si le dinosaure est sur le sol et que l'obstacle se trouve dans la même colonne
    if dino_row == GROUND_ROW and obstacle_col == DINO_COL:
        beep(500, 0.2)  # bip de collision à basse fréquence
        lcd.clear()
        lcd.putstr("GAME OVER")
        lcd.move_to(0, 1)
        lcd.putstr("Score:" + str(score))
        time.sleep(2)
        # Réinitialisation des variables de jeu
        dino_row    = GROUND_ROW
        jumping     = False
        obstacle_col= 15
        score       = 0
        continue  # recommence la boucle principale

    time.sleep(0.2)  # temporisation entre chaque cycle de jeu

100

101

102

103

104

105

106

107

108

109

from machine import I2C, Pin, PWM

import time

from lcd_api import LcdApi

from i2c_lcd import I2cLcd

# ===============================

# Configuration du LCD I2C 16x2

# ===============================

# Configuration de l'I2C (vérifiez les pins SCL/SDA de votre montage)

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

I2C_ADDR = 0x27 # adresse I2C typique du module LCD (à adapter si nécessaire)

lcd = I2cLcd(i2c, I2C_ADDR, 2, 16) # 2 lignes, 16 colonnes

# ===============================

# Configuration du bouton et du buzzer

# ===============================

# Bouton branché sur la pin 19 en entrée avec résistance pull-up

bouton = Pin(19, Pin.IN, Pin.PULL_UP)

# Buzzer branché sur la pin 23

buzzer_pin = Pin(23, Pin.OUT)

# ===============================

# Paramètres et variables du jeu

# ===============================

DINO_COL = 2 # Colonne fixe du dinosaure sur l'écran

GROUND_ROW = 1 # Ligne de sol (la deuxième ligne du LCD, numérotée 1)

AIR_ROW = 0 # Ligne en l'air (première ligne, numérotée 0)

JUMP_FRAMES = 3 # Nombre de cycles pendant lesquels le dinosaure reste en l'air

# Variables de jeu

dino_row = GROUND_ROW # Position initiale du dinosaure (sur le sol)

jumping = False # Etat du saut

jump_counter= 0 # Compteur pour la durée du saut

obstacle_col = 15 # Position initiale de l'obstacle (à l'extrémité droite de l'écran)

score = 0 # Score initial

# ===============================

# Fonction de son pour le buzzer

# ===============================

def beep(freq=1000, duration=0.1):

"""

Active le buzzer à la fréquence 'freq' pendant 'duration' secondes.

"""

buzzer = PWM(buzzer_pin)

buzzer.freq(freq)

buzzer.duty(512) # rapport cyclique à 50%

time.sleep(duration)

buzzer.deinit()

# ===============================

# Boucle principale du jeu

# ===============================

while True:

# --- Gestion du saut ---

# Si le bouton est pressé, que le dinosaure est sur le sol et qu'il n'est pas déjà en saut

if not bouton.value() and (not jumping) and (dino_row == GROUND_ROW):

jumping = True

jump_counter = JUMP_FRAMES

beep(1500, 0.05) # court bip lors du lancement du saut

if jumping:

dino_row = AIR_ROW # le dinosaure se trouve en l'air

jump_counter -= 1

if jump_counter <= 0:

jumping = False

dino_row = GROUND_ROW # retour au sol

else:

dino_row = GROUND_ROW

# --- Déplacement de l'obstacle ---

obstacle_col -= 1

if obstacle_col < 0:

obstacle_col = 15 # réinitialisation de l'obstacle à droite

score += 1 # le score augmente à chaque passage complet de l'obstacle

# --- Mise à jour de l'affichage sur le LCD ---

lcd.clear()

# Affichage du score (positionné en haut à droite sur la première ligne)

lcd.move_to(10, 0)

lcd.putstr("S:" + str(score))

# Affichage du dinosaure (représenté par le caractère "D")

lcd.move_to(DINO_COL, dino_row)

lcd.putstr("D")

# Affichage de l'obstacle (représenté par le caractère "O") sur le sol

if 0 <= obstacle_col < 16:

lcd.move_to(obstacle_col, GROUND_ROW)

lcd.putstr("O")

# --- Détection de collision ---

# Si le dinosaure est sur le sol et que l'obstacle se trouve dans la même colonne

if dino_row == GROUND_ROW and obstacle_col == DINO_COL:

beep(500, 0.2) # bip de collision à basse fréquence

lcd.clear()

lcd.putstr("GAME OVER")

lcd.move_to(0, 1)

lcd.putstr("Score:" + str(score))

time.sleep(2)

# Réinitialisation des variables de jeu

dino_row = GROUND_ROW

jumping = False

obstacle_col= 15

score = 0

continue # recommence la boucle principale

time.sleep(0.2) # temporisation entre chaque cycle de jeu

Explications du code

1- Initialisation du LCD I2C

On configure l'I2C sur les pins définies (ici, SCL sur la pin 22 et SDA sur la pin 21) avec une fréquence de 400 kHz.

L'objet lcd est créé à partir de la classe I2cLcd (du module i2c_lcd.py), qui utilise également la classe de base LcdApi (fournie par lcd_api.py).

2- Bouton et Buzzer

Le bouton est configuré en entrée avec une résistance pull-up intégrée (le bouton renvoie 0 lorsqu'il est pressé).

Le buzzer est piloté via PWM sur la pin 15. La fonction beep() permet de générer un son en spécifiant la fréquence et la durée.

3- Mécanique du Jeu

Le dinosaure est représenté par le caractère D et se situe à une colonne fixe (DINO_COL) sur le LCD.

Il est sur le sol (GROUND_ROW) par défaut et passe à la ligne d'en haut (AIR_ROW) lors d'un saut, dont la durée est contrôlée par JUMP_FRAMES.

L'obstacle (représenté par O) se déplace de droite à gauche sur la ligne du sol. Lorsqu'il sort de l'écran (colonne < 0), il est réinitialisé à droite et le score augmente. 4- Affichage et Collision

À chaque cycle, l'écran est effacé et on affiche le score, le dinosaure et l'obstacle aux positions appropriées.

Une collision est détectée lorsque le dinosaure est sur le sol et que l'obstacle se trouve exactement dans la même colonne. En cas de collision, un bip est émis, un message « GAME OVER » est affiché avec le score, puis le jeu est réinitialisé.