P2E-FAST-GAME

De MCHobby - Wiki
Sauter à la navigation Sauter à la recherche
Page-under-construction.pngPage(s) en cours de traduction/élaboration.

Page(s) under translation/construction

Fast Game

Ce jeu du plus rapide se joue à deux joueurs.

Le but de chaque joueur étant de presser le plus rapidement possible son bouton une fois que le signal sonore est émis.

La LED du vainqueur clignotera avec un petite mélodie de victoire.

P2E-fast-game-players.jpg

A noter que si un joueur presse son bouton avant le signal sonore alors ce dernier est automatiquement perdant (accompagné d'une petite mélodie funèbre).

Déroulement d'une partie

Le déroulement d'une partie est décrit par le diagramme ci-dessous:

P2E-fast-game-diagram-FR.jpg

Brancher

Réaliser les branchements suivants:

Pico Pico-2-Explorer
GP28 LED Rouge
GP27 Led Orange
GP26 LED Verte
GP21 Bouton 3
GP20 Bouton 2
GP19 Bouton 1
GP13 Buzzer

P2E-fast-game-wiring.jpg

Code

Le script fastgame.py est disponible dans le dépôt dédié au Pico-2-Explorer.

Ce dernier est repris-ci dessous avec quelques commentaire sur son fonctionnement. 

  1 from micropython import const
  2 from random import randint
  3 from machine import Pin
  4 from rtplay import *
  5 import time
  6 
  7 START_SONG = "Counter Strike - Time Bomb : d=4,o=5,b=100:16c#7,8p,16c#7,8p,16c#7,8p,16c#7"
  8 WIN_SONG = "Black Robb - Whoa : d=4,o=5,b=100:16g,16p,16g6,16a#6,16a6,16a#6,16g6,16p,16g,16p,16g6,16a#6,16a6,16a#6,16g6"
  9 LOOSE_SONG = "dark:d=4,o=5,b=140:8f#6,8e6,2f#6,16e6,16d#6,16d6,16b,a#,1b" 
 10 
 11 class Blinky:
 12 	""" Just handle LED with blink state """
 13 	FIXED = const( 0 )
 14 	BLINK_SLOW = const( 500 ) # 500 ms
 15 	BLINK_FAST = const( 200 ) # 200 ms
 16 
 17 	def __init__( self, pin ):
 18 		self.pin = pin
 19 		self.off()
 20 
 21 	def on( self ):
 22 		self.interval = self.FIXED
 23 		self.last_update = time.ticks_ms()
 24 		self.pin.value( True )
 25 
 26 	def off( self ):
 27 		self.interval = self.FIXED
 28 		self.last_update = time.ticks_ms()
 29 		self.pin.value( False )
 30 
 31 	def blink( self, fast=False ):
 32 		self.interval = self.BLINK_FAST if fast else self.BLINK_SLOW
 33 		self.last_update = time.ticks_ms() 
 34 		self.pin.value( True )
 35 		
 36 
 37 	def update( self ):
 38 		if self.interval == self.FIXED:
 39 			return
 40 		if time.ticks_diff( time.ticks_ms(), self.last_update ) < self.interval:
 41 			return
 42 		self.pin.toggle()
 43 		self.last_update = time.ticks_ms()
 44 
 45 
 46 # === Player 1 / Joueur 1 =================================
 47 led1 = Blinky( Pin( Pin.board.GP28, Pin.OUT ) )
 48 btn1 = Pin( Pin.board.GP19, Pin.IN, Pin.PULL_UP )
 49 first_btn1 = None # first time btn1 was pressed
 50 def btn1_pressed( obj ):
 51 	global first_btn1
 52 	if first_btn1==None:
 53 		first_btn1 = time.ticks_ms()
 54 btn1.irq( trigger=Pin.IRQ_FALLING, handler=btn1_pressed )
 55 
 56 # === Player 2 / Joueur 2 =================================
 57 led2 = Blinky( Pin( Pin.board.GP26, Pin.OUT ) ) 
 58 btn2 = Pin( Pin.board.GP21, Pin.IN, Pin.PULL_UP )
 59 first_btn2 = None
 60 def btn2_pressed( obj ):
 61 	global first_btn2
 62 	if first_btn2==None:
 63 		first_btn2 = time.ticks_ms()
 64 btn2.irq( trigger=Pin.IRQ_FALLING, handler=btn2_pressed )
 65 
 66 # === Other / Autre =======================================
 67 # Start / Demarrer
 68 btn_start = Pin( Pin.board.GP20, Pin.IN, Pin.PULL_UP )
 69 # LED status / LED de Status
 70 led_status = Blinky( Pin( Pin.board.GP27, Pin.OUT ) )
 71 # Buzzer
 72 buzzer = RingTonePlayer( Pin.board.GP13 )
 73 
 74 # === Game / Jeux =========================================
 75 
 76 # Start Button ? / Boutons Start ?
 77 led_status.blink()
 78 while btn_start.value()==1:
 79 	led_status.update()
 80 	time.sleep_ms(20)
 81 led_status.off()
 82 
 83 while True:
 84 	# All LEDs on / Toutes LEDs allumées 
 85 	led1.on()
 86 	led2.on()
 87 	led_status.on()
 88 
 89 	# Init round / initialisation round
 90 	wait_ms = randint( 3, 10 )*1000
 91 	first_btn1 = None
 92 	first_btn2 = None
 93 	buzzer.play_str( START_SONG )
 94 
 95 	# The round is starting / debut du round
 96 	led1.off()
 97 	led2.off()
 98 	led_status.off()
 99 
100 	# Wait loop
101 	start_ms = time.ticks_ms()
102 	_led = None
103 	while time.ticks_diff( time.ticks_ms(), start_ms ) < wait_ms:
104 		time.sleep_ms(100)
105 		if (first_btn1!=None) or (first_btn2!=None):
106 			_led = led1 if first_btn1!= None else led2
107 			_led.on()
108 			buzzer.play_str( LOOSE_SONG ) # End of game
109 			break
110 
111 	# Still running the game ? / Le jeux continue encore ?
112 	if (first_btn1==None) and (first_btn2==None):
113 		# Go Signal 
114 		buzzer.play_tone( 2500, 500 )
115 
116 		# Wait the first player to press a button
117 		# Attendre le premier joueur qui presse son bouton
118 		while (first_btn1==None) and (first_btn2==None):
119 			time.sleep_ms( 20 )
120 
121 		# We have a Winnner / Nous avons un gagnant
122 		if first_btn1==None:
123 			_led = led2
124 		elif first_btn2==None:
125 			_led = led1
126 		else:
127 			_led = led1 if first_btn1<first_btn2 else led2
128 		_led.on()
129 		buzzer.play_str( WIN_SONG )
130 
131 	_led.blink()
132 
133 	# Start Button ? / Boutons Start ?
134 	while btn_start.value()==1:
135 		_led.update()
136 		time.sleep_ms(20)
137 	_led.off()

Quelques mots d'explications:

  • Lignes 11 à 43 : déclaration de la classe `Blinky` prenant en charge une broche (en sortie) afin d'allumer, éteindre une LED mais aussi pour la faire clignoter. L'appel régulier à la méthode `update()` fera en sorte de mettre à jour l'état de la LED au moment adéquat.
  • Ligne 47 : déclaration de la LED pour je joueur 1. L'utilisation de la classe `Blinky` permet de doter celle-ci d'un effet de clignotement.
  • Ligne 48 : déclaration du bouton pour le joueur 1. L'entrée en maintenue au niveau HAUT par la résistance PULL_UP interne. L'entrée passe au niveau bas quand le bouton est pressé.
  • Ligne 49 : déclaration de la variable `first_btn1` pour le joueur 1. Cette variable est à None lorsque l'utilisateur n'a pas encore pressé le bouton. La première fois que l'utilisateur presse son bouton, cette variable contiendra le temps de la première pression sur le bouton.
  • Lignes 50 à 53 : définition de la fonction de rappel (callback en anglais) pour le bouton1. Celle-ci est appelée à chaque fois que le bouton 1 est pressé. La fonction vérifie si la variable `first_btn1` n'est pas initialisée, auquel cas le temps est stocké dans en lieu et place de None.
  • Ligne 54 : c'est sur cette ligne que le lien entre `btn1` et sa fonction de rappel est réalisé. Tel que configuré, la fonction de `btn1_pressed()` est appelée lorsque le signal passe du niveau haut au niveau bas (flan descendant, dit "FALLING" en anglais) sur btn1. Le signal sur btn1 (GP19) passe effectivement au niveau bas lorsque le bouton est pressé.
  • Lignes 57 à 64 : sont identiques aux lignes 47 à 54 exception fait que cela s'applique au joueur 2 (donc led2, btn2, btn2_pressed).
  • Lignes 67 à 72 : initialisation des derniers éléments, le bouton "start", la LED de statut et le `buzzer` comme élément sonore. La classe `RingTonePlayer` était abordé dans ce tutoriel.

Un problème?

xxx


Traduction augmentée réalisée par Meurisse. D pour shop.MCHobby.be - Licence CC-BY-SA.


MCHobby investit du temps et de l'argent dans la réalisation de traduction et/ou documentation. C'est un travail long et fastidieux réalisé dans l'esprit Open-Source... donc gratuit et librement accessible.
SI vous aimez nos traductions et documentations ALORS aidez nous à en produire plus en achetant vos produits chez MCHobby.
Récupérée de « https://wiki.mchobby.be/index.php?title=P2E-FAST-GAME&oldid=32956 »