Programmer la carte ESP32 pour créer le jeu Snake

ESP32 12-12-24

46 0

Plan du tutorial

1- Présenter le jeu Snake

2- Principe du projet

3- Matériel nécessaire

4- Schéma de câblage du projet

5- Programmation de la carte ESP32 avec Micropython

Présenter le jeu Snake

Le jeu Snake est un jeu vidéo classique, simple mais addictif, qui consiste à contrôler un serpent qui grandit au fur et à mesure qu'il mange de la nourriture, tout en évitant les obstacles et sa propre queue. Voici une description du principe et du fonctionnement de ce jeu :

Principe de base

1- Contrôle du serpent :

Le joueur contrôle un serpent (ou une ligne) qui se déplace sur une grille ou un écran.

Les mouvements du serpent sont généralement limités à quatre directions : haut, bas, gauche, et droite.

2- Objectif :

Manger des éléments de nourriture qui apparaissent aléatoirement sur la grille.

À chaque fois que le serpent mange un élément de nourriture, il grandit en longueur.

3- Conditions de fin de jeu :

Le jeu se termine si :

a) Le serpent entre en collision avec les bords de l'écran (dans les versions sans murs infinis).

b) Le serpent entre en collision avec sa propre queue.

Mécanisme de fonctionnement

Déplacement continu :

Le serpent avance automatiquement dans la direction choisie par le joueur.

Le joueur peut uniquement changer la direction du mouvement (90 degrés à la fois).

Croissance :

Lorsqu'un élément de nourriture est mangé, une nouvelle section s'ajoute à la queue du serpent, ce qui le rend plus long.

Cela augmente également le score du joueur.

Principe du projet

Le jeu Snake est un classique des jeux vidéo, et sa réalisation sur une plateforme embarquée comme l'ESP32 offre une expérience captivante en exploitant plusieurs périphériques tels qu’un afficheur LCD I2C 20x4, un joystick, et un buzzer.

Fonctionnalités du jeu :

1- Affichage du jeu : L'écran LCD 20x4 affiche :

La grille de jeu en caractères.

Le serpent représenté par des symboles spécifiques

La pomme comme un autre caractère .

2- Contrôle via le joystick :

Le joystick permet de déplacer le serpent dans quatre directions (haut, bas, gauche, droite).

Le bouton du joystick peut être utilisé pour mettre en pause ou redémarrer le jeu.

3- Son avec le buzzer :

Collision ou Game Over : Un son d'alerte.

Manger une pomme : Une tonalité joyeuse pour signaler un point gagné.

4- Logique du jeu :

Le serpent grandit en consommant les pommes, augmentant la difficulté.

Une collision avec le corps du serpent entraîne la fin du jeu.

Les pommes apparaissent aléatoirement sur la grille.

5- Score et progression :

Le score est incrémenté à chaque pomme mangée.

Matériel nécessaire

Carte ESP32

Processeur principal pour exécuter la logique du jeu et contrôler les périphériques.

Afficheur LCD I2C

Pinouts of 1602 LCD display with I2C

Affichage du jeu (position du serpent, pommes et score).

Connexion facilitée grâce à l'interface I2C, utilisant seulement 4 fils (VCC, GND, SDA, SCL).

Joystick analogique

Contrôle les déplacements du serpent. Le joystick a deux potentiomètres pour les axes X et Y, et un bouton-poussoir.

Buzzer

Génération de sons pour le feedback du joueur, comme lors de la consommation d’une pomme ou une collision.

Câble de connexion

Fils de connexion

Vous aurez besoin d'un câble pour connecter l'afficheur LCD et la manette (Joystick) à 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

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.

Programmation de la carte ESP32 avec Micropython

Pour programmer la carte ESP32 en MicroPython pour créer le jeu Snake, vous pouvez suivre les étapes suivantes :

1- vous devez disposer d'un environnement MicroPython installé sur votre ESP32.

2- Flashez votre ESP32 avec MicroPython en utilisant Firmware esp32-20210902-v1.17.bin.

3- Importer les bibliothèques "i2c_lcd" et "lcd_api" dédiées à l'écran LCD I2C

Description du programme :

1- Initialisation :

Configuration des périphériques (I2C pour l'écran, ADC pour le joystick).

i2c = SoftI2C(scl=Pin(22), sda=Pin(21), freq=10000)     #initializing the I2C method for ESP32
lcd_snake = I2cLcd(i2c, I2C_ADDR, totalRows, totalColumns)
lcd_food = I2cLcd(i2c, I2C_ADDR, totalRows, totalColumns)

xAxis = ADC(Pin(34, Pin.IN)) # créer un objet ADC agissant sur une broche
xAxis.atten(xAxis.ATTN_11DB)
yAxis = ADC(Pin(35, Pin.IN)) # créer un objet ADC agissant sur une broche
yAxis.atten(yAxis.ATTN_11DB)

i2c = SoftI2C(scl=Pin(22), sda=Pin(21), freq=10000) #initializing the I2C method for ESP32

lcd_snake = I2cLcd(i2c, I2C_ADDR, totalRows, totalColumns)

lcd_food = I2cLcd(i2c, I2C_ADDR, totalRows, totalColumns)

xAxis = ADC(Pin(34, Pin.IN)) # créer un objet ADC agissant sur une broche

xAxis.atten(xAxis.ATTN_11DB)

yAxis = ADC(Pin(35, Pin.IN)) # créer un objet ADC agissant sur une broche

yAxis.atten(yAxis.ATTN_11DB)

Initialisation des variables de jeu (position initiale du serpent, position de la pomme, score).

# Snake coordonee
x=0
y=0
snake='>'

# Food coordonne
x1=10
y1=0

# Snake coordonee

x=0

y=0

snake='>'

# Food coordonne

x1=10

y1=0

2- Affichage du jeu sur l’écran LCD :

Mise à jour fréquente de l'écran pour refléter la position du serpent et des pommes.

lcd_food.move_to(x1,y1)
    lcd_food.putstr('o')
    lcd_snake.move_to(x,y)
    lcd_snake.putstr(snake) # Afficher du texte sur l'écran LCD
    sleep(0.5)
    lcd_snake.clear()
    lcd_food.clear()

lcd_food.move_to(x1,y1)

lcd_food.putstr('o')

lcd_snake.move_to(x,y)

lcd_snake.putstr(snake) # Afficher du texte sur l'écran LCD

sleep(0.5)

lcd_snake.clear()

lcd_food.clear()

3- Lecture des entrées du joystick :

Conversion des valeurs analogiques des axes X et Y en directions.

Interprétation des mouvements pour changer la direction du serpent.

    xValue = xAxis.read()  # lire une valeur analogique 
    yValue = yAxis.read()  # lire une valeur analogique 
    
    if xValue<1000 and sens != 'bas':
       sens='haut'
       snake='^'
      
    
    if yValue<1000 and sens != 'gauche':
       sens='droite'
       snake='>'
      
    
    if yValue==4095 and sens != 'droite' :
       sens='gauche'
       snake='<'
       
    
    if xValue==4095 and sens != 'haut':
       sens='bas'
       snake='v'

xValue = xAxis.read() # lire une valeur analogique

yValue = yAxis.read() # lire une valeur analogique

if xValue<1000 and sens != 'bas':

sens='haut'

snake='^'

if yValue<1000 and sens != 'gauche':

sens='droite'

snake='>'

if yValue==4095 and sens != 'droite' :

sens='gauche'

snake='<'

if xValue==4095 and sens != 'haut':

sens='bas'

snake='v'

4- Déplacement du serpent :

Ajout d’un segment à la position de la tête dans la direction choisie.

if sens == 'haut' and y>0: 
        y=y-1 # deplacer le serpent vers le haut
       
    if sens=='droite' and x<15:
        x=x+1 # deplacer le serpent vers la droite
       
    if sens=='gauche' and x>0:
        x=x-1 # deplacer le serpent vers le gauche
       
    if sens=='bas' and y<1:
        y=y+1 # deplacer le serpent vers le bas

if sens == 'haut' and y>0:

y=y-1 # deplacer le serpent vers le haut

if sens=='droite' and x<15:

x=x+1 # deplacer le serpent vers la droite

if sens=='gauche' and x>0:

x=x-1 # deplacer le serpent vers le gauche

if sens=='bas' and y<1:

y=y+1 # deplacer le serpent vers le bas

5- Détection des collisions :

Vérification si la tête du serpent entre en collision avec un bord ou avec son propre corps.

if x==x1 and y==y1 :

1	if x==x1 and y==y1 :

6- Mise à jour de la pomme :

Génération d'une nouvelle position aléatoire après consommation par le serpent.

x1=random.randrange(0, 15)
y1=random.randrange(0, 1)

1 2	x1=random.randrange(0, 15) y1=random.randrange(0, 1)

Voici le programme complet du programme :

from machine import Pin, SoftI2C,ADC
from lcd_api import LcdApi
from i2c_lcd import I2cLcd
from time import sleep
import random


I2C_ADDR = 0x27
totalRows = 4
totalColumns = 20

i2c = SoftI2C(scl=Pin(22), sda=Pin(21), freq=10000)     #initializing the I2C method for ESP32
lcd_snake = I2cLcd(i2c, I2C_ADDR, totalRows, totalColumns)
lcd_food = I2cLcd(i2c, I2C_ADDR, totalRows, totalColumns)

xAxis = ADC(Pin(34, Pin.IN)) # créer un objet ADC agissant sur une broche
xAxis.atten(xAxis.ATTN_11DB)
yAxis = ADC(Pin(35, Pin.IN)) # créer un objet ADC agissant sur une broche
yAxis.atten(yAxis.ATTN_11DB)
button = Pin(33, Pin.IN, Pin.PULL_UP)

# Snake coordonee
x=0
y=0
snake='>'

# Food coordonne
x1=10
y1=0


sens='droite'
while True:
    xValue = xAxis.read()  # lire une valeur analogique 
    yValue = yAxis.read()  # lire une valeur analogique 
    
    if xValue<1000 and sens != 'bas':
       sens='haut'
       snake='^'
      
    
    if yValue<1000 and sens != 'gauche':
       sens='droite'
       snake='>'
      
    
    if yValue==4095 and sens != 'droite' :
       sens='gauche'
       snake='<'
       
    
    if xValue==4095 and sens != 'haut':
       sens='bas'
       snake='v'
      
    
    if sens == 'haut' and y>0: 
        y=y-1
       
    if sens=='droite' and x<15:
        x=x+1
       
    if sens=='gauche' and x>0:
        x=x-1
       
    if sens=='bas' and y<1:
        y=y+1 
    
    if x==x1 and y==y1 :
        x1=random.randrange(0, 15)
        y1=random.randrange(0, 1)
        
    lcd_food.move_to(x1,y1)
    lcd_food.putstr('o')
    lcd_snake.move_to(x,y)
    lcd_snake.putstr(snake) # Afficher du texte sur l'écran LCD
    sleep(0.5)
    lcd_snake.clear()
    lcd_food.clear()