Jeu vaisseau spatial contrôlé par la carte ESP32
Plan du tutorial
1- Présenter le jeu vaisseau spatial
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 vaisseau spatial
Un jeu de vaisseau spatial est un type de jeu vidéo qui immerge les joueurs dans l'univers fascinant de l'exploration, du combat et de la stratégie intergalactique. Ces jeux sont souvent axés sur la science-fiction et peuvent se dérouler dans des galaxies fictives où le joueur pilote un vaisseau spatial.
Dans un jeu de vaisseau spatial, vous incarnez généralement un pilote ou un capitaine chargé de naviguer dans l'espace. Les objectifs peuvent varier, allant de l'exploration de nouveaux mondes à des batailles spatiales intenses ou encore la gestion d'une flotte interstellaire.
Principe du projet
Le joueur pilote un vaisseau spatial à l’aide d’un joystick et doit détruire des ennemis. L’action est affichée en temps réel sur un écran LCD I2C.
Fonctionnalités principales
1. Contrôle du vaisseau :
Le joystick permet de déplacer le vaisseau vers la gauche ou la droite.
La position du joystick est traduite en valeurs analogiques, puis convertie en mouvement du vaisseau.
2. Affichage des éléments de jeu :
Le vaisseau est représenté par un caractère ou un ensemble de pixels sur l'écran LCD.
Les ennemis ou projectiles sont également affichés
3. Mécaniques de jeu :
Évitement : Le joueur doit esquiver des obstacles générés aléatoirement.
Combat : Un bouton intégré au joystick peut être utilisé pour tirer des projectiles vers les ennemis.
Score et niveau : Le score augmente à mesure que le joueur détruit des ennemis ou évite des obstacles.
Vies/Énergie : Une barre de santé indique les dégâts subis.
4. Sons :
Un buzzer peut être ajouté pour générer des effets sonores, comme des tirs et le déplacement du vaisseau spatial.
Matériel nécessaire
Carte ESP32
Microcontrôleur pour gérer la logique du jeu, les entrées/sorties et la communication avec les périphériques.
Afficheur LCD 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 du mouvement du vaisseau dans différentes directions (X/Y) et, éventuellement, un bouton intégré pour des actions spéciales (tire).
Buzzer
Génération de sons pour le feedback du joueur, comme le mouvement du vaisseau, tire et destruction des ennemies.
Câble 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) :
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).
|
1 2 3 4 5 6 7 8 |
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 vaisseau spatial et position des ennemies).
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
ship='^' x=12 rocket='|' enemy1="o" x1=5 enemy2="o" x2=7 enemy3="o" x3=9 enemy4="o" x4=11 enemy5="o" x5=13 enemy6="o" x6=15 |
2- Affichage du jeu sur l’écran LCD :
Mise à jour fréquente de l'écran pour refléter la position du vaisseau spacial.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
# Afficher le vaisseau spacial lcd_ship.move_to(x,3) lcd_ship.putstr(ship) # Afficher les ennemies lcd_ship.move_to(x1,0) lcd_ship.putstr(enemy1) lcd_ship.move_to(x2,0) lcd_ship.putstr(enemy2) lcd_ship.move_to(x3,0) lcd_ship.putstr(enemy3) lcd_ship.move_to(x4,0) lcd_ship.putstr(enemy4) lcd_ship.move_to(x5,0) lcd_ship.putstr(enemy5) lcd_ship.move_to(x6,0) lcd_ship.putstr(enemy6) |
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 position du vaisseau spacial.
|
1 2 3 4 5 6 7 8 9 10 11 12 |
# lire les valeurs analogiques retournees par la manette xValue = xAxis.read() yValue = yAxis.read() # Si on bouge la manette à droite if yValue<1000 : # le vaisseau se deplace à droite x=x+1 # Si on bouge la manette à gauche if yValue==4095 : # le vaisseau se deplace à gauche x=x-1 |
4- Déplacement du vaisseau spatial :
Le vaisseau se déplace sur une ligne horizontale suivant le mouvement de la manette.
|
1 2 3 4 5 6 7 8 9 10 11 |
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- Destruction des ennemies :
- Si on appuie sur le bouton de la manette, le vaisseau tire le rocket.
- L'ennemie est détruit s'il est touché par la rocket.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
if button.value()==0 : # Si on appuie sur la manette # On lance la rockette lcd_rocket1.move_to(x,2) lcd_rocket1.putstr(rocket) lcd_rocket2.move_to(x,1) lcd_rocket2.putstr(rocket) sleep(0.5) # Si la rocket touche l'ennemi, on le detruit if x==x1 : enemy1='' if x==x2 : enemy2='' if x==x3 : enemy3='' if x==x4 : enemy4='' if x==x5 : enemy5='' if x==x6 : enemy6='' |
Voici le programme complet du programme :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 |
import machine from machine import Pin, SoftI2C,ADC from lcd_api import LcdApi from i2c_lcd import I2cLcd from time import sleep I2C_ADDR = 0x27 totalRows = 4 totalColumns = 20 #initializing the I2C method for ESP32 i2c = SoftI2C(scl=Pin(22), sda=Pin(21), freq=10000) lcd_ship = I2cLcd(i2c, I2C_ADDR, totalRows, totalColumns) lcd_enemy1 = I2cLcd(i2c, I2C_ADDR, totalRows, totalColumns) lcd_enemy2 = I2cLcd(i2c, I2C_ADDR, totalRows, totalColumns) lcd_enemy3 = I2cLcd(i2c, I2C_ADDR, totalRows, totalColumns) lcd_enemy4 = I2cLcd(i2c, I2C_ADDR, totalRows, totalColumns) lcd_enemy5 = I2cLcd(i2c, I2C_ADDR, totalRows, totalColumns) lcd_enemy6 = I2cLcd(i2c, I2C_ADDR, totalRows, totalColumns) lcd_rocket1 = I2cLcd(i2c, I2C_ADDR, totalRows, totalColumns) lcd_rocket2 = I2cLcd(i2c, I2C_ADDR, totalRows, totalColumns) # Connecter les broches de la manette a la carte ESP32 xAxis = ADC(Pin(34, Pin.IN)) xAxis.atten(xAxis.ATTN_11DB) yAxis = ADC(Pin(35, Pin.IN)) yAxis.atten(yAxis.ATTN_11DB) button = Pin(33, Pin.IN, Pin.PULL_UP) ship='^' x=12 rocket='|' enemy1="o" x1=5 enemy2="o" x2=7 enemy3="o" x3=9 enemy4="o" x4=11 enemy5="o" x5=13 enemy6="o" x6=15 while True: # lire les valeurs analogiques retournees par la manette xValue = xAxis.read() yValue = yAxis.read() # Si on bouge la manette à droite if yValue<1000 : # le vaisseau se deplace à droite x=x+1 # Si on bouge la manette à gauche if yValue==4095 : # le vaisseau se deplace à gauche x=x-1 if button.value()==0 : # Si on appuie sur la manette # On lance la rockette lcd_rocket1.move_to(x,2) lcd_rocket1.putstr(rocket) lcd_rocket2.move_to(x,1) lcd_rocket2.putstr(rocket) sleep(0.5) # Si la rocket touche l'ennemi, on le detruit if x==x1 : enemy1='' if x==x2 : enemy2='' if x==x3 : enemy3='' if x==x4 : enemy4='' if x==x5 : enemy5='' if x==x6 : enemy6='' # Afficher le vaisseau spacial lcd_ship.move_to(x,3) lcd_ship.putstr(ship) # Afficher les ennemies lcd_ship.move_to(x1,0) lcd_ship.putstr(enemy1) lcd_ship.move_to(x2,0) lcd_ship.putstr(enemy2) lcd_ship.move_to(x3,0) lcd_ship.putstr(enemy3) lcd_ship.move_to(x4,0) lcd_ship.putstr(enemy4) lcd_ship.move_to(x5,0) lcd_ship.putstr(enemy5) lcd_ship.move_to(x6,0) lcd_ship.putstr(enemy6) sleep(0.5) lcd_ship.clear() |
Explications du code
a. Lecture des entrées
Lire les valeurs du joystick (axes X et Y) à l’aide des ports analogiques de l’ESP32.
Lire l’état des boutons (appuyé/non appuyé).
b. Affichage
Envoyer les données de position et d'état des composants du jeu (vaisseau et ennemies) à l'écran LCD I2C via le protocole I2C.
Rafraîchir l'écran à intervalles réguliers pour donner une impression de mouvement fluide.
c. Mise à jour du jeu
Calculer la nouvelle position du vaisseau en fonction des entrées.
Vérifier les collisions (tir-ennemi).
d. Boucle principale
La logique du jeu est exécutée en boucle :
1- Lire les entrées (joystick, boutons).
2- Mettre à jour la position des objets et vérifier les collisions.
3- Afficher les données mises à jour sur l'écran.
4- Attendre un court délai pour synchroniser la fréquence d'exécution.
0 commentaire
laisser un commentaire
Passion de robotique
Tutoriels récents
Atelier robotique
Tutoriels populaires
Construction des robots
Tutoriels plus commentés
Bras robotique
Categories
Maison intelligente
