Création du jeu Snake avec la carte ESP8266

ESP8266 18-12-24

31 0

Plan du tutorial

1- Présenter le jeu Snake

2- L'objectif de notre projet

3- Matériel nécessaire

4- Schéma de câblage du projet

5- Programmation de la carte ESP8266 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.

L'objectif de notre projet

L'objectif principal de ce projet est de concevoir et de programmer le jeu classique Snake en utilisant une carte ESP8266, un afficheur LCD I2C, un buzzer pour les effets sonores, et quatre boutons poussoirs pour le contrôle de la direction du Snake.

Objectifs spécifiques :

1- Création du Snake sur l'afficheur LCD :

Dessiner le Snake et les objets (nourriture) sur l'écran LCD en utilisant des caractères ou des blocs.

Mettre à jour en temps réel l'affichage en fonction des mouvements du Snake.

2- Contrôle avec les boutons poussoirs :

Configurer les boutons poussoirs pour permettre les déplacements du Snake (haut, bas, gauche, droite).

Gérer les interruptions ou les états des boutons pour des commandes fluides.

3- Gestion de la logique du jeu :

Faire bouger le Snake sur une grille simulée.

Gérer la collision avec la nourriture qui sera généré aléatoirement.

4- Effets sonores avec le buzzer :

Ajouter des effets sonores pour des actions spécifiques (manger et collision).

Matériel nécessaire

Carte ESP8266 NodeMCU

Cœur du système, la carte ESP8266 sert de microcontrôleur pour gérer l'affichage, les entrées des boutons, la logique du jeu et le contrôle du buzzer.

1- La carte ESP8266 Lit les entrées des boutons poussoirs pour déterminer la direction du Snake.

2- Elle gère l'affichage du Snake et des objets sur l'écran LCD en mettant à jour les caractères affichés.

3- Elle contrôle le buzzer pour jouer des sons en réponse aux événements.

Afficheur LCD I2C

Pinouts of 1602 LCD display with I2C

Il Affiche les éléments visuels du jeu Snake, y compris le serpent, la nourriture, et éventuellement le score.

Buzzer passif

Il fournit des effets sonores pour les événements du jeu, comme manger de la nourriture, collision, ou démarrage du jeu.

Boutons poussoirs (x4)

bouton-poussoir

Il permettent de contrôler les mouvements du Snake (haut, bas, gauche, droite).

Chacun des quatre boutons est affecté à une direction spécifique.

Fils de connexion :

Fils de connexion

Ils sont Utilisés pour relier tous les composants entre eux.

Breadboard

plaque d'essai

Une breadboard facilite le prototypage sans soudure.

Schéma de câblage du projet

1- Connexion de l'afficheur LCD I2C :

VCC : Connecté à la broche VIN de la carte ESP8266.

GND : Connecté à la broche GND de la carte ESP8266.

SDA : Connecté à la broche D2 (GPIO 4) de la carte ESP8266 pour les données I2C.

SCL : Connecté à la broche D1 (GPIO 5 ) de la carte ESP8266 pour l'horloge I2C.

2- Connexion du Buzzer :

La borne (+) connectée à la broche D3 (GPIO 0) de la carte ESP8266 configuré en sortie.

La borne (-) connectée à la masse (GND) de la carte ESP8266.

Pour le premier bouton (pour la direction gauche):

1- Connectez une patte du premier bouton-poussoir à la broche D8 (GPIO 15) de la carte ESP8266.

2- Mettre une résistance entre cette patte et la broche GND de la carte ESP8266.

3- Connectez une autre patte du premier bouton-poussoir à la broche 3V de la carte ESP8266.

Pour le deuxième bouton (pour la direction droite):

1- Connectez une patte du premier bouton-poussoir à la broche D7 (GPIO 13) de la carte ESP8266.

2- Mettre une résistance entre cette patte et la broche GND de la carte ESP8266.

3- Connectez une autre patte du premier bouton-poussoir à la broche 3V de la carte ESP8266.

Pour le troisième bouton (pour la direction haut) :

1- Connectez une patte du premier bouton-poussoir à la broche D6 (GPIO 12) de la carte ESP8266.

2- Mettre une résistance entre cette patte et la broche GND de la carte ESP8266.

3- Connectez une autre patte du premier bouton-poussoir à la broche 3V de la carte ESP8266.

Pour le quatrième bouton (pour la direction bas) :

1- Connectez une patte du premier bouton-poussoir à la broche D5 (GPIO 14) de la carte ESP8266.

2- Mettre une résistance entre cette patte et la broche GND de la carte ESP8266.

3- Connectez une autre patte du premier bouton-poussoir à la broche 3V de la carte ESP8266.

Programmation de la carte ESP8266 avec Micropython

Le code suivant utilise le langage Micropython pour programmer l'ESP8266. Assurez-vous d'avoir les bibliothèques suivantes installées :

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

def randint(min, max):
    span = max - min + 1
    div = 0x3fffffff // span
    offset = urandom.getrandbits(30) // div
    val = min + offset
    return val

I2C_ADDR = 0x27
totalRows = 4
totalColumns = 20

i2c = SoftI2C(sda=Pin(4), scl=Pin(5), freq=400000)   #D2(SDA) D1(SCL) #initializing the I2C method for ESP32
lcd_snake = I2cLcd(i2c, I2C_ADDR, totalRows, totalColumns)
lcd_food = I2cLcd(i2c, I2C_ADDR, totalRows, totalColumns)

button_left = Pin(15, Pin.IN) #D8
button_right = Pin(13, Pin.IN) #D7
button_up = Pin(12, Pin.IN) #D6
button_down = Pin(14, Pin.IN) #D5
buzzer = machine.PWM(machine.Pin(0))#D3

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

# Food coordonnee
x1=10
y1=0

# Définir une fonction tone qui prend en entrée un objet Pin représentant le buzzer, une fréquence en Hz et une durée en millisecondes
def tone(pin, frequency, duration):
    pin.freq(frequency) # Définir la fréquence
    pin.duty(50) # Définir le cycle de service
    time.sleep_ms(duration) # Pause pour la durée en millisecondes
    pin.duty(0) # Définir le cycle de service à 0 pour arrêter le son
B4 = 494
sens='droite'
while True:
   
    if button_up.value()==1 :
       sens='haut'
       snake='^'
      
    
    if button_right.value()==1 :
       sens='droite'
       snake='>'
      
    
    if button_left.value()==1 :
       sens='gauche'
       snake='<'
       
    
    if button_down.value()==1 :
       sens='bas'
       snake='v'
      
    
    if sens == 'haut' and y>0: 
        y=y-1 # deplacer vers le haut 
       
    if sens=='droite' and x<19:
        x=x+1 # deplacer vers la droite
       
    if sens=='gauche' and x>0:
        x=x-1 # deplacer vers le gauche
       
    if sens=='bas' and y<3:
        y=y+1 # deplacer vers le bas 
    
    if x==x1 and y==y1 : # en cas de collision avec la nourriture
        tone(buzzer, B4, 500)
        x1=randint(0, 15) # modifier la position de la nourriture
        y1=randint(0, 1)
        
    lcd_food.move_to(x1,y1) 
    lcd_food.putstr('o') # Afficher la nourrityure sur l'écran LCD
    lcd_snake.move_to(x,y)
    lcd_snake.putstr(snake) # Afficher le snake sur l'écran LCD
    tone(buzzer, B4, 50) # activer le Buzzer à chaque mouvement du Snake
    sleep(0.5)
    lcd_snake.clear()
    lcd_food.clear()

import machine

from machine import Pin, SoftI2C,ADC

from lcd_api import LcdApi

from i2c_lcd import I2cLcd

from time import sleep

import urandom

import time

def randint(min, max):

span = max - min + 1

div = 0x3fffffff // span

offset = urandom.getrandbits(30) // div

val = min + offset

return val

I2C_ADDR = 0x27

totalRows = 4

totalColumns = 20

i2c = SoftI2C(sda=Pin(4), scl=Pin(5), freq=400000) #D2(SDA) D1(SCL) #initializing the I2C method for ESP32

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

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

button_left = Pin(15, Pin.IN) #D8

button_right = Pin(13, Pin.IN) #D7

button_up = Pin(12, Pin.IN) #D6

button_down = Pin(14, Pin.IN) #D5

buzzer = machine.PWM(machine.Pin(0))#D3

# Snake coordonee

x=0

y=0

snake='>'

# Food coordonnee

x1=10

y1=0

# Définir une fonction tone qui prend en entrée un objet Pin représentant le buzzer, une fréquence en Hz et une durée en millisecondes

def tone(pin, frequency, duration):

pin.freq(frequency) # Définir la fréquence

pin.duty(50) # Définir le cycle de service

time.sleep_ms(duration) # Pause pour la durée en millisecondes

pin.duty(0) # Définir le cycle de service à 0 pour arrêter le son

B4 = 494

sens='droite'

while True:

if button_up.value()==1 :

sens='haut'

snake='^'

if button_right.value()==1 :

sens='droite'

snake='>'

if button_left.value()==1 :

sens='gauche'

snake='<'

if button_down.value()==1 :

sens='bas'

snake='v'

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

y=y-1 # deplacer vers le haut

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

x=x+1 # deplacer vers la droite

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

x=x-1 # deplacer vers le gauche

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

y=y+1 # deplacer vers le bas

if x==x1 and y==y1 : # en cas de collision avec la nourriture

tone(buzzer, B4, 500)

x1=randint(0, 15) # modifier la position de la nourriture

y1=randint(0, 1)

lcd_food.move_to(x1,y1)

lcd_food.putstr('o') # Afficher la nourrityure sur l'écran LCD

lcd_snake.move_to(x,y)

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

tone(buzzer, B4, 50) # activer le Buzzer à chaque mouvement du Snake

sleep(0.5)

lcd_snake.clear()

lcd_food.clear()

Explication du programme:

1- Initialisation :

a) Configurer les broches à utiliser pour l'afficheur LCD et les boutons poussoirs.

I2C_ADDR = 0x27
totalRows = 4
totalColumns = 20

i2c = SoftI2C(sda=Pin(4), scl=Pin(5), freq=400000)   #D2(SDA) D1(SCL) #initializing the I2C method for ESP32
lcd_snake = I2cLcd(i2c, I2C_ADDR, totalRows, totalColumns)
lcd_food = I2cLcd(i2c, I2C_ADDR, totalRows, totalColumns)

button_left = Pin(15, Pin.IN) #D8
button_right = Pin(13, Pin.IN) #D7
button_up = Pin(12, Pin.IN) #D6
button_down = Pin(14, Pin.IN) #D5
buzzer = machine.PWM(machine.Pin(0))#D3

I2C_ADDR = 0x27

totalRows = 4

totalColumns = 20

i2c = SoftI2C(sda=Pin(4), scl=Pin(5), freq=400000) #D2(SDA) D1(SCL) #initializing the I2C method for ESP32

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

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

button_left = Pin(15, Pin.IN) #D8

button_right = Pin(13, Pin.IN) #D7

button_up = Pin(12, Pin.IN) #D6

button_down = Pin(14, Pin.IN) #D5

buzzer = machine.PWM(machine.Pin(0))#D3

b) Initialiser l'écran et les positions de la nourriture et le Snake.

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

# Food coordonnee
x1=10
y1=0

# Snake coordonee

x=0

y=0

snake='>'

# Food coordonnee

x1=10

y1=0

2- Contrôle :

Les boutons permettent de changer la direction.

    if button_up.value()==1 :
       sens='haut'
       snake='^'
          
    if button_right.value()==1 :
       sens='droite'
       snake='>'
          
    if button_left.value()==1 :
       sens='gauche'
       snake='<'
           
    if button_down.value()==1 :
       sens='bas'
       snake='v'

if button_up.value()==1 :

sens='haut'

snake='^'

if button_right.value()==1 :

sens='droite'

snake='>'

if button_left.value()==1 :

sens='gauche'

snake='<'

if button_down.value()==1 :

sens='bas'

snake='v'

3- Collision :

Vérifie si le Snake touche la nourriture.

 if x==x1 and y==y1 : # en cas de collision avec la nourriture
        tone(buzzer, B4, 500)
        x1=randint(0, 15) # modifier la position de la nourriture
        y1=randint(0, 1)

if x==x1 and y==y1 : # en cas de collision avec la nourriture

tone(buzzer, B4, 500)

x1=randint(0, 15) # modifier la position de la nourriture

y1=randint(0, 1)

4- Affichage :

Le Snake et la nourriture sont dessinés sur l'écran.

    lcd_food.move_to(x1,y1) 
    lcd_food.putstr('o') # Afficher la nourrityure sur l'écran LCD
    lcd_snake.move_to(x,y)
    lcd_snake.putstr(snake) # Afficher le snake sur l'écran LCD

lcd_food.move_to(x1,y1)

lcd_food.putstr('o') # Afficher la nourrityure sur l'écran LCD

lcd_snake.move_to(x,y)

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

5- Buzzer : Émet des sons pour signaler les actions (déplacement et collision avec la nourriture).

 tone(buzzer, B4, 50) # activer le Buzzer à chaque mouvement du Snake

1	tone(buzzer, B4, 50) # activer le Buzzer à chaque mouvement du Snake

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

ESP32 Robot voiture à deux roues commandé via Bluetooth

ESP32 19-12-24

Création du jeu Snake avec la carte ESP8266

ESP8266 18-12-24

Piloter des moteurs par l’Arduino UNO et le module L293D

Arduino UNO 18-12-24

Agriculture intelligente connectée à IoT en utilisant l’Arduino

Arduino UNO 16-12-24

Création du jeu Snake avec la carte Arduino UNO

Arduino UNO 14-12-24

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 3179vues

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

ESP32 Wifi 2961vues

Allumer une LED par la carte ESP32

ESP32 2928vues

Présentation de la carte ESP32

ESP32 2770vues

La carte ESP32 et l’afficheur LCD I2C 1602

ESP32 2710vues

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 SSD1306

Arduino UNO 2 commentaires

Système de détection d’obstacles basé sur HC-SR04, afficheur SSD1306 et Arduino UNO

Arduino UNO 2 commentaires

Création du jeu Snake avec la carte ESP8266

Plan du tutorial

1- Présenter le jeu Snake

2- L'objectif de notre projet

3- Matériel nécessaire

4- Schéma de câblage du projet

5- Programmation de la carte ESP8266 avec Micropython

Présenter le jeu Snake

Principe de base

Mécanisme de fonctionnement

L'objectif de notre projet

Objectifs spécifiques :

Matériel nécessaire

Schéma de câblage du projet

Programmation de la carte ESP8266 avec Micropython

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