Thème : Informatique embarquée et objets connectés

Jeu Pierre Papier Ciseaux connecté avec microbit

Rappel de la règle du jeu Pierre Papier Ciseaux

L'objectif et le mécanisme de jeu est simple, il faut affronter un ou plusieurs adversaires en utilisant l'une des trois “armes”: la pierre, la feuille ou la paire de ciseaux.

  • La pierre gagne face aux ciseaux. Elle les broie.

  • Les ciseaux l'emportent face à la feuille qu'ils coupent.

  • La feuille bat la pierre en l'enveloppant.

    source

Le jeu "Pierre Papier Ciseaux" avec la micro:bit

Il faut au moins deux joueurs assis l'un près de l'autre. Chacun dispose d'une carte micro :bit. Les joueurs secouent (modérément) la carte micro:bit, et cette dernière (après réflexion) va afficher le symbole de la pierre , de la feuille de papier ou des ciseaux. Le gagnant est désigné lorsque son choix correspond à une des règles énoncées ci-avant.

L'affichage de la carte micro:bit est très limité, il correspond à une image de 5 pixels de coté. Voici les trois images correspondantes aux trois objets que l'on désire afficher (Pierre, Papier et Ciseaux).

Créer un nouveau programme nommé ppc1.py, l'enregistrer dans le même dossier que le précédent avec le code source ci-dessous.

Compléter le programme, (les images CISEAUX et PIERRE sont à faire après avoir étudié l'image PAPIER), la fonction qui permet de tester le "secouage" de la carte est : accelerometer.is_gesture('shake')

  • Transférer ce programme sur la carte.

  • Tester et vérifier le fonctionnement.

1
#     SI la microbit est secouée
2
#           elle tire au hasard un chiffre entre 1 et 3
3
#           SI le chiffre est 1 :
4
#                AFFICHE(symbole PIERRE)
5
#           SI le chiffre est 2 :
6
#                AFFICHE(symbole PAPIER)
7
#           SI le chiffre est 3 :
8
#                AFFICHE(symbole CISEAUX)
9
# #########################################################
10
from microbit import *
11
import random
12
PIERRE = Image ('*****:''*****:''*****:''*****:''*****')
13
PAPIER = Image ('99999:''90009:''90009:''90009:''99999')
14
CISEAUX = Image('*****:''*****:''*****:''*****:''*****')
15
16
while True:
17
    if accelerometer.is_gesture('shake'): # détection du secouage de la carte
18
        tirage = random.randint(1,3) # tirage est une variable qui vaudra 1, 2 ou 3
19
        if tirage==1:
20
            display.show(PIERRE)#Affichage de l'image PIERRE
21
        if ...........?:             
22
            ..............?
23
        if ...........?:             
24
            ..............?
ExempleUn jeu Pierre-Papier-Ciseaux connecté
Nous allons utiliser une fonction intéressante de la carte micro:bit, la liaison radio.
Deux cartes pouvant  communiquer entre elles par ondes radio, nous allons voir comment nous pouvons jouer à distance avec un adversaire. Pour cela, les cartes doivent émettre sur le même canal (un nombre compris entre 1 et 25). Chaque binôme devra tirer dans un chapeau un papier sur lequel sera inscrit un nombre . Si le groupe comporte 24 élèves, il y aura 12 papiers comportant un nombre compris entre 1 et 12., comme cela chacun aura un et un seul partenaire.
Le programme comportera 2 parties : dans la première partie, les deux joueurs doivent signaler qu'ils relèvent le défi de l'adversaire et qu'ils sont prêt à en découdre. Dans la deuxième partie, c'est l'affrontement sauvage proprement dit.
Au départ, un "X" clignote sur les micro:bits et les deux voyants sur le PC sont au rouge, Afin de signaler qu'ils sont prêts, les joueurs doivent appuyer sur le bouton A, ce qui fait passer le voyant local au vert, ainsi que le voyant vert visiteur de l'adversaire. A partir de ce moment,  le deuxième joueur a 10 secondes pour appuyer sur son bouton, faute de quoi les voyants repassent au rouge et tout est à refaire.
Lorsque les deux voyants sont au vert, les "X" disparaissent, les joueurs ont alors 10 s pour secouer la carte (encore une fois avec modération), le résultat du tirage s'affiche sur la micro:bit et sur les écrans, et est transmis à l'adversaire. Le score est alors rafraîchi. Si au bout de 10 s, les deux joueurs n'ont pas secoué la carte, les voyants repassent au rouge, on revient au départ, sans modification du score.
Les cartes micro:bit sont communicantes, elles peuvent envoyer des informations au PC sur lequel elles sont connectées grâce à la liaison USB. Elles peuvent envoyer une chaîne de caractères (type string), l'instruction python est alors : print("info à envoyer")
Elles peuvent aussi envoyer une chaîne de caractères à une autre carte micro:bit connectée sur le même canal, l'instruction est alors : radio.send("info à envoyer"). Pour recevoir un message radio, l'instruction est : data = radio.receive(). Si aucun message n'est reçu, data vaut None, sinon data prends pour valeur la chaîne de caractères qui a été envoyée.
MéthodeInstallation du logiciel
  • Entrer dans le répertoire SNT_info_Embarquée, et lancer le programme START3.bat (cela a pour effet de lancer la partie virtuelle à programmer), normalement vous n'aurez plus besoin de le relancer par la suite, car à chaque modification du programme, il suffira de cliquer sur le jeu et d'appuyer sur la touche "R" (comme redémarrage) pour réinitialiser le système.
MéthodeProgrammation de la carte Micro:bit
Lancer l'environnement de programmation « Mu » depuis le bureau et sélectionner le mode « BBC micro:bit ».
Nous programmerons la carte avec le langage Python et son module micro:bit.
Gestion du chronomètre : 
Pour déclencher le chrono, il faut initialiser la variable T0 : T0=running_time(), "running_time()" est le temps écoulé en ms depuis le démarrage du programme. Pour connaître le temps écoulé depuis le déclenchement du chrono, il suffit de soustraire T0 à "running_time()". Exemple : pour effectuer une action 5,2 s après le déclenchement du chrono : if running_time()-T0>5200 : Action
Gestion des pauses : 
à ne pas confondre avec le chronomètre, l'instruction sleep(2500) arrête le programme 2,5 s.
Gestion du tirage Pierre, Papier, Ciseaux : 
Pour tirer de manière aléatoire une chaîne de caractères, dans une liste de chaîne de caractère, on crée une liste, par exemple : liste=["Bonjour", "Hello", "Buongiorno", "Kaixo"], on importe la bibliothèque random : import random, et on lance le tirage : tirage = random.choice(liste) , à l'issue de cette instruction, tirage a pris pour valeur par exemple "Hello".
Copier le programme ci-dessous et compléter-le. 
Lorsque vous aurez terminé faire valider et demander la correction.
Sauvegarder votre programme sous le nom ppc2.py.
1
# Ecrit ton programme ici ;-)
2
3
from microbit import *
4
import radio
5
import random
6
radio.on()
7
radio.config(channel=1)  # Choix du canal de communication (entre 1 et 25)
8
radio.config(power=7)
9
uart.init(baudrate=9600)
10
PAPIER = Image("99999:""90009:""90009:""90009:""99999")
11
CISEAUX = Image('99009:''99090:''00900:''99090:''99009')
12
PIERRE = Image('00000:''09990:''09990:''09990:''00000')
13
display.scroll("SNT")
14
15
ready_joueur_local=False
16
ready_joueur_visiteur=False
17
18
X= Image('*****:''*****:''*****:''*****:''*****')# A compléter pour afficher un X
19
20
T0=0
21
mon_prenom="Juliette" #A moins que tu ne t'appelle Juliette, change le prénom
22
while True:
23
    while ready_joueur_local == False or ready_joueur_visiteur == False: #Tant que les 2 joueurs n'ont pas appuyé sur A
24
        data=radio.receive() # La carte ecoute la radio
25
        if data:  # Si un message est reçu      
26
            ready_joueur_visiteur = True  #C'est que le joueur visiteur est prêt
27
            print(data)   # La carte envoie l'info à son PC, qui va inscrire son prénom et passer le voyant au vert
28
            T0=running_time() # On déclenche le chrono 
29
  
30
        if button_a.is_pressed() and ready_joueur_local==False: #Si Le bouton A est appuyé
31
            ready_joueur_local=True             #C'est que le joueur local est prêt                  
32
            radio.send("visiteur="+mon_prenom)      # Il previent son adversaire par radio
33
            print("local="+mon_prenom)              # Et aussi son PC
34
            T0=running_time()                   # On déclenche le chrono
35
36
        ...........?     #On fait clignoter l'image "X" sur l'afficheur
37
        ...........?     #tempo 0,25s
38
        ...........?
39
        ...........?
40
41
        if running_time()-T0>10000:  # Si au bout de 10s les 2 joueurs ne sont pas prêts
42
            ready_joueur_local=False     #On réinitialise
43
            ready_joueur_visiteur=False
44
45
    # Arrivé ici, c'est que les deux joueurs sont prêts, ils ont 10s pour secouer la carte
46
47
    ...............?                   # On redéclenche le chrono
48
    while ready_joueur_local == True or ready_joueur_visiteur == True: #Tant que les 2 joueurs n'ont pas secoué la carte
49
        ...................?   # La carte ecoute la radio 
50
        if ......?:                #Si un message est reçu
51
            print(data)         # On envoie le tirage de l'adversaire au PC
52
            son_tirage=data[16:] # On stocke le tirage adverse dans la variable son_tirage
53
            ready_joueur_visiteur=False # Le joueur 2 a joué
54
55
        if accelerometer.is_gesture('shake') and ready_joueur_local==True: #Si la carte est secouée...
56
            liste=........................?    # On crée une liste de 3 chaînes, voir ci-dessous pour les trouver
57
            while accelerometer.is_gesture('shake'):  #tant qu'on secoue la carte...
58
                ...............?    # On tire au hasard dans la liste  et on affiche le tirage       
59
                if mon_tirage=="PIERRE":    display.show(PIERRE)
60
                if mon_tirage=="PAPIER":    display.show(PAPIER)
61
                if mon_tirage=="CISEAUX":   display.show(CISEAUX)
62
63
             # Le "secouage" s'est arrété...     
64
65
            ........?("tirage visiteur=" + mon_tirage) # La carte envoie mon tirage à l'adversaire
66
            ........?("tirage local=" + mon_tirage) # Elle l'envoie aussi à son PC
67
        
68
            ready_joueur_local=False   #Le joueur 1 a joué
69
70
    
71
        if  .......................: # Si au bout de 10s les 2 joueurs n'ont pas secoué la carte
72
            ready_joueur_local=False         # On réinitialise
73
            ready_joueur_visiteur=False
74
75
        if ready_joueur_local==False and ready_joueur_visiteur==False: # Lorsque les deux joeurs ont joué
76
            sleep(10000) # On fait une pause de 10s
77
ComplémentNouvelle fonctionnalité
Nous allons rajouter une nouvelle fonctionnalité : lorsque le joueur a perdu, on affichera un visage triste, et heureux dans le cas contraire.
Pour cela nous allons utiliser les mot clés and et or. 
Dans le programme précédent, nous allons supprimer les instructions suivantes :
1
        if ready_joueur_local==False and ready_joueur_visiteur==False: # Lorsque les deux joeurs ont joué
2
            sleep(10000) # On fait une pause de 10s
et les remplacer par les instructions ci-dessous à compléter : 
(les caractères "\" servent à aller à la ligne)
Compléter le programme, transférer-le dans la carte et tester.
1
        if ready_joueur_local==False and ready_joueur_visiteur==False: # Lorsque les deux joeurs ont joué
2
            .............? #pause de 5s
3
            if son_tirage=="PIERRE" and mon_tirage=="CISEAUX"\
4
                    or  ........................................... \
5
                        or ............................................:
6
                display.show(Image.SAD) # Affichage visage triste
7
            elif ........................................... \
8
                    or ........................................... \
9
                        or ........................................... :
10
                display.show(Image.HAPPY) # Affichage visage gai
11
            .............? #pause de 5s
PrécédentPrécédentFin
AccueilAccueilImprimerImprimerRéalisé avec Scenari (nouvelle fenêtre) modèle documentaire TechnOpale