Discussion :

[josmiley]

j'avais corrigé entre temps pour le print.
sinon wait() c'est bien; plus ou moins rapide, ça je sais pas.
il faut limiter les instructions entre le flip(), l'initialisation de ticks0 et la boucle pour 'plus' de précision.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
pygame.init()
etc ...
draw_stimulus(grey,grey_side)
KEY = pygame.key.get_pressed()
pygame.display.flip()
ticks0 = pygame.time.get_ticks()
while not KEY[pygame.K_SPACE]|KEY[pygame.K_ESCAPE]:
    pygame.event.wait()
    KEY = pygame.key.get_pressed()
response_time = pygame.time.get_ticks() - ticks0
if KEY[pygame.K_ESCAPE]:raise Exception()

[dividee]

Il y a déjà beaucoup de versions, j'en rajoute une couche:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
pygame.init()
etc ...
draw_stimulus(grey,grey_side)
KEY = pygame.key.get_pressed()
pygame.display.flip()
ticks0 = pygame.time.get_ticks()
while not KEY[pygame.K_SPACE]:
    pygame.event.wait()
    response_time = pygame.time.get_ticks() - ticks0
    KEY = pygame.key.get_pressed()
    if KEY[pygame.K_ESCAPE]:raise Exception()

1) Pour plus de précision, calculer response_time après chaque event, avant même de vérifier si la barre d'espace est pressée. Si ce n'est pas le cas, on n'en tiendra pas compte de toute façon.

2) Autant laisser le raise dans la boucle; l'exception fera de toute façon sortir de la boucle. Cela simplifie un peu la condition du while.

[josmiley]

bien vu dividee !!

de toutes façons je ne comprends pas l'intérêt de quitter la boucle via 'echappe' à ce moment du programme puisque ce n'est pas bloquant; il suffit d'appuyer sur 'espace' pour quitter la boucle, libre ensuite de quitter le programme.
si c'etait moi je ferai comme ça:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
pygame.init()
etc ...
draw_stimulus(grey,grey_side)
pygame.display.flip()
ticks0 = pygame.time.get_ticks()
while not pygame.key.get_pressed()[pygame.K_SPACE]:pygame.event.wait()
response_time = pygame.time.get_ticks() - ticks0

[eyquem]

Je ne comprends pas ce que vous trouvez comme intérêt à
pygame.key.get_pressed() dans le cas présent:

- c’est une fonction qui nécessite d’être appelée pour renvoyer quelque chose:
.....between two calls to pygame.key.get_pressed.....
Donc ça oblige à un while.

- ce qu’elle renvoie est superfétatoire par rapport au besoin:
Returns a sequence of boolean values .....
Getting the list of pushed buttons with this function .....

http://www.pygame.org/docs/ref/key.html





Tandis que pygame.event.wait() convient très bien:

- elle renvoie bien quelque chose, limité à une unité à la fois
Returns a single event from the queue.
Il faut bien vérifier que c’est le cas, tout de même.

- tant que la queue est vide, elle reste peinarde:
If the queue is empty this function will wait until one is created. ...... While the program is waiting it will sleep in an idle state.
Cela tranche avec l’agitation de pygame.key.get_pressed() qui nécessite d’ètre appelée régulièrement même quand il ne se passe rien et qui renvoie par dessus le marché une moisson de valeurs booléennes à chaque fois.

http://www.pygame.org/docs/ref/key.html





Mon précédent code ne mettait pas le renvoi de pygame.event.wait() sous référence (= dans une variable, en s’exprimant avec les notions des autres langages, qui ne s’appliquent pas à Python). Ce qui ne m’a pas permis de faire plusieurs tests sur la valeur renvoyée.

Dans le code suivant, je le fais et le code gagne en clarté. Avec aussi la possibilité de mettre le calcul de response_time juste après le renvoi de pygame.event.wait() (astuce dividee +1)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
import pygame
from time import clock,sleep
 
KSP = pygame.K_SPACE
pygevwait = pygame.event.wait
 
pygame.event.set_allowed(pygame.KEYDOWN)
 
while 1:
    response_time = None
    draw_stimulus(grey,grey_side)
    pygame.event.clear()
    pygame.display.flip()
    ticks0 = clock()
    x = pygevwait()
    response_time = ticks1 - ticks0        
    if x==KSP:
        # utilisation de response_time, par exemple:
        print 'response_time =',response_time
        # temporisation de la relance du test:
        sleep(2)
    elif x==pygame.K_ESCAPE:
        print '-- Fin du programme --'
        break
    else:
        print 'Taper ESPACE pour reagir, ou ESCAPE pour arreter'

Je trouve le programme obtenu plus lisible que celui du message #22, dans lequel il y a
KEY = pygame.key.get_pressed()
qui suit pygame.event.wait()
et qui est donc destinée à ne renvoyer l’état des touches (toutes les touches, beaucoup trop de touches...) que lorsque pygame.event.wait() a été réveillée par un événement, sans savoir lequel alors que cette fonction renvoit la nature de l’événement.
C’est mal fichu, et c’est bien pourquoi josmiley estime préférable un code dans lequel il n’y a plus pygame.event.wait()

Je pense exactement le contraire: il faut garder pygame.event.wait() et éliminer pygame.key.get_pressed()
Qu’est ce qu’elle de mal, ma proposition avec pygame.event.wait() ?

[josmiley]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

pygame.event.set_allowed(pygame.KEYDOWN)

ne sert à rien si les autres evenements n'ont pas été bloqués

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

pygame.event.clear()

ne sert à rien car wait() vide la file d'attente

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
draw_stimulus(grey,grey_side)
pygame.display.flip()

devraient, à mon avis, se trouver hors de la boucle

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

sleep(2)

???

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

x = pygevwait().key

plutôt

sinon, ne rien faire tant qu'on a pas appuyer sur 'espace' ...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
import pygame
pygame.init()
etc ...
pygame.event.set_allowed(None)
pygame.event.set_allowed(pygame.KEYDOWN)
draw_stimulus(grey,grey_side)
pygame.display.flip()
ticks0 = pygame.time.get_ticks()
while pygame.event.wait().key != pygame.K_SPACE:pass
response_time = pygame.time.get_ticks() - ticks0
pygame.event.set_allowed(range(32))

[eyquem]

pygame.event.set_allowed(pygame.KEYDOWN)

ne sert à rien si les autres evenements n'ont pas été bloqués

Ah. Je pensais que spécifier l’autorisation de certains entrainait l’exclusion des autres. En fait c’est dynamique, on peut autoriser-interdire chaque événement à l’unité, sans changer les autres, si je comprends bien.

pygame.event.clear()

ne sert à rien car wait() vide la file d'attente

Ah bon ? Tu voudrais dire que quand pygame.event.wait() entre en action, il expurge d’abord la queue d’événements avant d’attendre le prochain événement ?
Tu as peut être raison mais je ne l’ai pas lu.
J’ai donc mis cette instruction pour que lorsque x = pygevwait() est exécutée la première fois, il n’y ait rien dans la file d’événements.

draw_stimulus(grey,grey_side)
pygame.display.flip()

devraient, à mon avis, se trouver hors de la boucle

Mais non ! La boucle while 1 permet de réitérer la présentation du stimulus.

sleep(2)

???

mes présentations de stimuli ont au moins 1 seconde d'intervalle entre chaque

fuyo2004 message #18

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
while 1:

    # je balance une image sur l’écran
    response_time = None
    draw_stimulus(grey,grey_side)
    pygame.event.clear()
    pygame.display.flip()
    ticks0 = clock()
    x = pygevwait()

    # le gars vient de réagir
    response_time = ticks1 - ticks0        
    if x==KSP:
        # utilisation de response_time, par exemple:
        print 'response_time =',response_time
        # temporisation de la relance du test:
        # le gars a réagi correctement en tapant sur la barre d’espace
        # je le laisse souffler en attendant 2 secondes 
        # avant de rebalancer une autre image
        sleep(2)
    elif x==pygame.K_ESCAPE:
        print '-- Fin du programme --'
        break
    else:
        print 'Taper ESPACE pour reagir, ou ESCAPE pour arreter'

M’enfin !!

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

x = pygevwait().key

En effet, il le faut.

sinon, ne rien faire tant qu'on a pas appuyer sur 'espace' ...

while pygame.event.wait().key != pygame.K_SPACE:pass
response_time = pygame.time.get_ticks() - ticks0

Pas bon à mon avis: le fait d’extraire l’identité de la touche en faisant .key sur le renvoi de pygame.event.wait() introduit un petit délai avant le calcul de response_time -> on perd l’avantage introduit par l’astuce de dividee (rien entre la réaction et le calcul de response_time)

Je pense préférable de corriger simplement mon code qui était incomplet

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
import pygame
from time import clock,sleep
 
KSP = pygame.K_SPACE
pygticks = pygame.time.get_ticks
pygevwait = pygame.event.wait
 
pygame.event.set_allowed(pygame.KEYDOWN)
 
while 1:
    response_time = None
    draw_stimulus(grey,grey_side)
    pygame.event.clear()
    pygame.display.flip()
    ticks0 = clock()
    x = pygevwait()
    response_time = pygticks() - ticks0        
    if x.key==KSP:
        # utilisation de response_time, par exemple:
        print 'response_time =',response_time
        # temporisation de la relance du test:
        sleep(2)
    elif x.key==pygame.K_ESCAPE:
        print '-- Fin du programme --'
        break
    else:
        print 'Taper ESPACE pour reagir, ou ESCAPE pour arreter'

[eyquem]

Je suis en train de penser:
après que la personne ait réagi correctement à un stimulus en tapant sur la barre d’espace,
et avant de rebalancer un nouveau stimulus, il faut effacer l’image affichée par le stimulus précédent
Quelque chose du genre:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
import pygame
from time import clock,sleep
 
KSP = pygame.K_SPACE
pygticks = pygame.time.get_ticks
pygevwait = pygame.event.wait
 
pygame.event.set_allowed(pygame.KEYDOWN)
 
while 1:
    response_time = None
    draw_stimulus(grey,grey_side)
    pygame.event.clear()
    pygame.display.flip()
    ticks0 = clock()
    x = pygevwait()
    response_time = pygticks() - ticks0        
    if x.key==KSP:
        # utilisation de response_time, par exemple:
        print 'response_time =',response_time
        # purge de l’ecran:
        draw_stimulus(rien,nothing)
        pygame.display.flip()
        # temporisation de la relance du test:
        sleep(2)
    elif x.key==pygame.K_ESCAPE:
        print '-- Fin du programme --'
        break
    else:
        print 'Taper ESPACE pour reagir, ou ESCAPE pour arreter'

[fuyo2004]

J'ai besoin de conserver la possibilité d'appuyer sur échap car la présentation du stimulus est répétée des dizaines de fois : appuyer sur espace fait passer au stimulus suivant mais ne fait pas sortir du programme.

@eyquem : le traitement de response_time se fait plus tard dans mon programme, entre la présentation de deux stimuli : enregistrement de response_time et quelques autres paramètres dans un fichier .dat. Je préfèrerais donc garder une structure en boucle while comme dans les exemples de josmiley et dividee, même si je suis d'accord avec toi qu'il semble peu optimal de scanner toutes les touches si je n'ai besoin que de la barre espace et la touche échap.

La désactivation des événements autres que keydown avait bien été faite ailleurs dans le programme. Le temps d'attente entre deux stimuli, la suppression du stimulus après sa présentation, etc... tout ça était effectué un peu avant.

Là je ne me concentrais encore une fois que sur le bout de code qui me permettrait d'avoir la meilleure résolution dans les temps de réponse.

[josmiley]

j'vais me faire taper sur les doigts à cause du in ^^
pour gérer ESC :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
import pygame
pygame.init()
etc ...
pygame.event.set_allowed(None)
pygame.event.set_allowed(pygame.KEYDOWN)
draw_stimulus(grey,grey_side)
pygame.display.flip()
ticks0 = pygame.time.get_ticks()
while pygame.event.wait().key not in (pygame.K_SPACE,pygame.K_ESCAPE):pass
response_time = pygame.time.get_ticks() - ticks0
pygame.event.set_allowed(range(32))
if pygame.key.get_pressed()[pygame.ESCAPE]:quitter le programme

[fuyo2004]

Ne t'inquiète pas, je ne suis pas expert en python et encore moins puriste, alors pour moi ta solution me va parfaitement !

Qu'est-ce qui ne va pas avec le in ?

En passant, que fait l'instruction

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
pygame.event.set_allowed(range(32))

?


Edit : je ne comprends pas comment marche l'instruction pygame.event.poll(). La doc dit que cette fonction renvoit un seul élément de la file, mais lequel ? Un au hasard ?

Et pourquoi le code suivant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
while pygame.event.poll().key != pygame.K_SPACE:pass

me donne l'erreur AttributeError: event member not defined

Ce qui m'embête avec l'utilisation de pygame.event.wait(), c'est que je n'ai aucun moyen de tester la vitesse de réaction de cette instruction, et qu'elle introduit peut-être un délai non négligeable dans mon temps de réponse.

[josmiley]

Qu'est-ce qui ne va pas avec le in ?

rien, je me disais due eyquem allait réagir ... mais non.

En passant, que fait l'instruction

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
pygame.event.set_allowed(range(32))

?

ça débloque tous les évênements

Edit : je ne comprends pas comment marche l'instruction pygame.event.poll(). La doc dit que cette fonction renvoit un seul élément de la file, mais lequel ? Un au hasard ?

poll() renvoie le 1er evenement de la file puis efface la file. Si la file est vide, poll() renvoie l'evenement NOEVENT.

Et pourquoi le code suivant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
while pygame.event.poll().key != pygame.K_SPACE:pass

me donne l'erreur AttributeError: event member not defined

parce que l'evenement retourné par poll() ne possede pas l'attribut key. c'est le cas de NOEVENT qui n'est pas bloquable (sinon poll() n'aurait pas de sens ^^)

Ce qui m'embête avec l'utilisation de pygame.event.wait(), c'est que je n'ai aucun moyen de tester la vitesse de réaction de cette instruction, et qu'elle introduit peut-être un délai non négligeable dans mon temps de réponse.

si c'est pour des tests, tu peux toi même injecter un évênement ...
et mesurer le temps entre l'injection et la réaction.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

pygame.event.post(pygame.event.Event(pygame.KEYDOWN,{'key':pygame.K_SPACE}))

Perso je pense que wait() est plus rapide que poll() car poll() utilise plus de ressource.

[fuyo2004]

si c'est pour des tests, tu peux toi même injecter un évênement ...

Je ne vois pas comment je pourrais tester pygame.event.wait() de cette manière... Comment la ligne contenant l'injection peut-elle être lue si le programme reste bloqué à la ligne précédente pygame.event.wait() en attente d'un événement ?

[dividee]

Il est vrai que poll() utilisera plus de ressource CPU que wait() (attente active vs. attente passive), mais poll() devrait avoir une latence plus faible. wait() "endort" le processus, c'est ce qui fait qu'il utilise moins de ressources, mais quand un événement se produit le processus doit être réveillé par l'OS, ce qui prend un peu de temps. poll() sera donc plus efficace ici, à mon avis.

poll() renvoie le 1er evenement de la file puis efface la file. Si la file est vide, poll() renvoie l'evenement NOEVENT.

poll() renvoie le 1er evenement de la file et l'efface de la file. Il ne vide pas toute la file.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

pygame.event.clear()

ne sert à rien car wait() vide la file d'attente

Ah bon ? Tu voudrais dire que quand pygame.event.wait() entre en action, il expurge d’abord la queue d’événements avant d’attendre le prochain événement ?

Non. Mais si la file n'est pas vide, wait() terminera tout de suite et la file sera vidée rapidement en quelques tours de boucle. Cela peut quand-même poser un problème si l'utilisateur appuie sur espace AVANT de voir le stimulus; dans ce cas un temps de réponse proche de 0 sera enregistré. Le clear() est donc conseillé...

La méthode la plus efficace, à mon avis, sera donc

1. clear() avant la boucle
2. poll() dans la boucle
3. calcul immédiat de response_time
4. test de l'event retourné par poll() (effectivement, c'est plus joli que get_pressed, même si je ne pense pas que get_pressed soit aussi lourd qu'il y parait).

L'utilisation CPU montera à 100% (d'un seul CPU) pendant l'attente, mais ce n'est pas grave vu qu'à ce moment-là, ce processus est certainement le plus important du système.

Remarque pour eyquem: le sleep(2) n'était pas une bonne idée; si le temps d'attente est constant entre 2 stimuli l'utilisateur va vite 'attraper le rythme' et anticiper les stimuli, ce qui va fausser les résultats...

[fuyo2004]

J'ai toujours du mal avec pygame.event.poll()... Le problème c'est qu'il retire l'événement de la file, du coup un tour de boucle après poll() renvoie l'attribut NOEVENT et je ne peux plus le tester avec l'attribut .key.

Par exemple, d'après les indications du message précédent de dividee, j'ai essayé le code suivant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
    pygame.event.set_allowed(None)
    pygame.event.set_allowed(KEYDOWN)
    pygame.event.clear()
 
# pour éviter que poll ne renvoie la valeur NOEVENT et ne puisse pas supporter l'attribut .key :
 
    pygame.event.post(pygame.event.Event(pygame.KEYDOWN,{'key':pygame.K_t}))  
 
    draw_stimulus_inhibition(grey,grey_side)
    pygame.display.flip()
    ticks0 = pygame.time.get_ticks()
    while pygame.event.poll().key != pygame.K_SPACE:
        print(pygame.time.get_ticks() - ticks0) #test de la vitesse de ma boucle, ne sera pas dans le programme final
        if pygame.event.poll().key == pygame.K_ESCAPE:raise Exception()
    response_time = pygame.time.get_ticks() - ticks0

mais ce code me donne toujours l'erreur : AttributeError: event member not defined, ici au niveau du test de la touche échap puisque la première utilisation de poll a renvoyé l'événement K_t puis l'a supprimé, me laissant avec une file vide.

[josmiley]

poll() renvoie le 1er evenement de la file et l'efface de la file. Il ne vide pas toute la file.
...
Non. Mais si la file n'est pas vide, wait() terminera tout de suite et la file sera vidée rapidement en quelques tours de boucle. Cela peut quand-même poser un problème si l'utilisateur appuie sur espace AVANT de voir le stimulus; dans ce cas un temps de réponse proche de 0 sera enregistré. Le clear() est donc conseillé

Bien vu!
j'ai fait des tests, effectivement la file n'est pas vidée, j'étais pourtant persuadé du contraire car les boucles wait() semblaient 'rater' des events, je pensais qu'ils avaient été effacés (cette logique à fonctionnée jusque là ^^ dans mes progs).
Mais ton explication m'a fait comprendre que les 'ratés' venaient de ma mauvaise gestion de la file.
Bravo.

[josmiley]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
    pygame.event.set_allowed(None)
    pygame.event.set_allowed(KEYDOWN)
    pygame.event.clear()
 
# pour éviter que poll ne renvoie la valeur NOEVENT et ne puisse pas supporter l'attribut .key :
 
    pygame.event.post(pygame.event.Event(pygame.KEYDOWN,{'key':pygame.K_t}))  
 
    draw_stimulus_inhibition(grey,grey_side)
    pygame.display.flip()
    ticks0 = pygame.time.get_ticks()
    while pygame.event.poll().key != pygame.K_SPACE:
        print(pygame.time.get_ticks() - ticks0) #test de la vitesse de ma boucle, ne sera pas dans le programme final
        if pygame.event.poll().key == pygame.K_ESCAPE:raise Exception()
        pygame.event.post(pygame.event.Event(pygame.KEYDOWN,{'key':pygame.K_t}))  
    response_time = pygame.time.get_ticks() - ticks0

en postant l'event dans la boucle while, le file ne sera jamais vide.

[fuyo2004]

en postant l'event dans la boucle while, le file ne sera jamais vide.

Oui mais si l'événement utilisateur intervient juste avant l'événement posté (et après le test du while), la réponse de l'utilisateur ne sera pas prise en compte...

Par ailleurs, le code que tu donnes renverra la même erreur à la ligne du test de la touche échap.

[dividee]

Il ne faut pas essayer d'éviter les NOEVENT, il faut les traiter. Je voyais un code comme ceci (non testé):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
pygame.event.set_allowed(None)
pygame.event.set_allowed(KEYDOWN)
pygame.event.clear()
ticks0 = pygame.time.get_ticks()
while True:
    evt = pygame.event.poll()
    response_time = pygame.time.get_ticks() - ticks0
    if evt.type == KEYDOWN:
        if evt.key == K_SPACE: break
        elif evt.key == K_ESCAPE: raise Exception("QUIT")

En voyant ça, je me dis que get_ticks() sera appelée très souvent. Si elle est un peu lente (je n'en sais rien), il pourrait être plus efficace de la placer dans le premier "if" tout de même et pas avant. Oui c'est sûrement mieux:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
    ...
    evt = pygame.event.poll()
    if evt.type == KEYDOWN:
        response_time = pygame.time.get_ticks() - ticks0
        ...