Tutoriel débutant : orientation du regard

À propos d'OpenSesame

OpenSesame est un programme pour faciliter le développement d'expériences comportementales en psychologie, neurosciences et économie expérimentale. Pour les débutants, OpenSesame offre une interface graphique complète et point-and-click. Pour les utilisateurs avancés, OpenSesame prend en charge les scripts Python (non couverts dans ce tutoriel).

OpenSesame est disponible gratuitement sous la Licence publique générale v3.

À propos de ce tutoriel

Ce tutoriel montre comment créer une expérience psychologique simple mais complète en utilisant OpenSesame (Mathôt, Schreij et Theeuwes, 2012; Mathôt & March, 2022). Vous utiliserez principalement l'interface utilisateur graphique d'OpenSesame (c'est-à-dire sans codage Python), bien que vous apportiez de petites modifications au script OpenSesame. Ce tutoriel prend environ une heure.

Ressources

• Téléchargement -- Ce tutoriel suppose que vous exécutez la version 4.0.0 d'OpenSesame ou ultérieure. Pour vérifier la version que vous utilisez, consultez le coin inférieur droit de l'onglet "Commencer" (voir Figure 2). Vous pouvez télécharger la version la plus récente d'OpenSesame depuis:
  • https://osdoc.cogsci.nl/4.0/fr/download
• Documentation -- Un site de documentation dédié est disponible à l'adresse :
  • http://osdoc.cogsci.nl/
• Forum -- Un forum d'assistance est disponible à l'adresse :
  • http://forum.cogsci.nl/

L'expérience

Dans ce tutoriel, vous allez créer une expérience de guidage du regard comme indiqué par Friesen et Kingstone (1998). Dans cette expérience, un visage est présenté au centre de l'écran (Figure 1). Ce visage regarde soit à droite, soit à gauche. Une lettre cible (un 'F' ou un 'H') est présentée à gauche ou à droite du visage. Un stimulus distracteur (la lettre 'X') est présenté de l'autre côté du visage. La tâche consiste à indiquer le plus rapidement possible si la lettre cible est un 'F' ou un 'H'. Dans la condition congruente, le visage regarde la cible. Dans la condition incongruente, le visage regarde le distracteur. Comme vous l'avez peut-être deviné, la constatation typique est que les participants répondent plus rapidement dans la condition congruente que dans la condition incongruente, même si la direction du regard n'est pas prédictive de l'emplacement de la cible. Cela montre que notre attention est automatiquement guidée par le regard des autres, même dans des situations où cela ne sert à rien. (Et même quand le visage est juste un smiley!)

Figure 1. Le paradigme de guidage du regard (Friesen et Kingstone, 1998) que vous allez mettre en œuvre dans ce tutoriel. Cet exemple représente un essai dans la condition incongruente, car le smiley regarde le distracteur ('X') et non la cible ('F').

L'expérience se compose d'une phase d'entraînement et d'une phase expérimentale. Un retour visuel sera présenté après chaque bloc d'essais. Un son sera joué après chaque réponse incorrecte.

Conception expérimentale

Cette conception :

• est intrasujet, car tous les participants font toutes les conditions
• est entièrement croisée (ou factorielle complète), car toutes les combinaisons de conditions se produisent
• a trois facteurs (ou facteurs) :
  • côté du regard avec deux niveaux (gauche, droite)
  • côté cible avec deux niveaux (gauche, droite)
  • lettre cible avec deux niveaux (F, H)
• a N sujets

Voir également Video 1 pour une explication de la logique et de la conception de l'expérience:

Étape 1 : Créer la séquence principale

Lorsque vous démarrez OpenSesame, vous voyez l'onglet 'Commencer !' (Figure 2). Une liste de modèles est affichée sous "Démarrer une nouvelle expérience". Ces modèles constituent des points de départ pratiques pour les nouvelles expériences. Une fois que vous avez enregistré une expérience pour la première fois, les expériences récemment ouvertes sont affichées sous "Continuer avec une expérience récente". Au bas de la page, il y a des liens vers la documentation (qui comprend ce tutoriel), le forum de la communauté et une page avec des options de support professionnel (payant). Et bien sûr, un lien où vous pouvez nous acheter une tasse de café pour nous aider à rester éveillé pendant que nous travailons à fournir le meilleur logiciel gratuit !

Figure 2. La boîte de dialogue 'Commencer' lors du démarrage d'OpenSesame.

Cliquez sur 'Modèle par défaut' pour commencer avec un modèle expérimental minimal.

Par défaut, il y a une sequence principale, simplement appelée experiment. Cliquez sur experiment dans la zone d'aperçu (par défaut sur le côté gauche, voir Figure 3) pour ouvrir ses commandes dans la zone d'onglets. La sequence experiment est composée de deux éléments : un notepad appelé getting started et un sketchpad appelé welcome.

Nous n'avons pas besoin de ces deux éléments. Supprimez getting_started en faisant un clic droit dessus dans la zone d'aperçu et en sélectionnant "Supprimer" (raccourci : Del). Supprimez welcome de la même manière. La sequence experiment est maintenant vide.

Figure 3. La disposition par défaut de l'interface OpenSesame.

Ajoutez un élément form_text_display pour l'affichage des instructions

Comme son nom l'indique, un form_text_display est un formulaire qui affiche du texte. Nous allons utiliser un form_text_display pour donner des instructions au participant au début de l'expérience.

Cliquez sur experiment dans la zone d'aperçu pour ouvrir ses commandes dans la zone d'onglets. Vous verrez une sequence vide. Faites glisser un form_text_display depuis la barre d'outils des éléments (sous "Form", voir Figure 3) dans la sequence experiment de la zone d'onglets. Lorsque vous relâchez, un nouvel élément form_text_display sera inséré dans la sequence. (Nous y reviendrons à l'étape 12.)

Ajoutez un élément de boucle, contenant un nouvel élément de séquence, pour la phase de pratique

Nous devons ajouter un élément loop à la séquence experiment. Nous utiliserons cette boucle pour la phase de pratique de l'expérience. Cliquez sur la séquence experiment pour ouvrir ses contrôles dans la zone des onglets.

Faites glisser l'élément loop depuis la barre d'outils des éléments dans la séquence, comme vous l'avez fait pour le form_text_display. Les nouveaux éléments sont insérés sous l'élément sur lequel ils sont déposés. Par conséquent, si vous déposez la nouvelle boucle sur le form_text_display précédemment créé, elle apparaîtra là où vous le voulez : après le form_text_display. Mais ne vous inquiétez pas si vous déposez un nouvel élément au mauvais endroit, car vous pouvez toujours réorganiser les choses plus tard.

Un loop, en soi, ne fait rien. Un loop a toujours besoin d'un autre élément pour fonctionner. Par conséquent, vous devez remplir le nouvel élément loop avec un autre élément. (Si vous consultez l'élément loop, vous verrez également un avertissement : 'Aucun élément sélectionné'.) Faites glisser un élément sequence depuis la barre d'outils des éléments sur l'élément loop. Un menu contextuel apparaîtra, vous demandant si vous voulez insérer la sequence après ou dans l'élément loop. Sélectionnez "Insérer dans new_loop". (Nous reviendrons sur cette question à l'étape 2.)

Ajoutez un nouvel élément form_text_display pour le message de fin de la phase de pratique

Après la phase de pratique, nous voulons informer le participant que la véritable expérience commencera. Pour cela, nous avons besoin d'un autre form_text_display. Revenez à la séquence experiment et faites glisser unform_text_display depuis la barre d'outils des éléments sur l'élément loop. Le même menu contextuel apparaîtra qu'auparavant. Cette fois-ci, sélectionnez "Insérer après new_loop". (Nous reviendrons sur cette question à l'étape 12.)

Ajoutez un nouvel élément de boucle, contenant la séquence précédemment créée, pour la phase expérimentale

Nous avons besoin d'un élément loop pour la phase expérimentale, tout comme pour la phase de pratique. Par conséquent, faites glisser un loop depuis le menu de la barre d'outils des éléments sur * _ form_text_display *.

La nouvelle loop (appelée new_loop_1) est vide et doit être remplie avec une sequence, tout comme la BOUCLE que nous avons créée précédemment. Cependant, comme les essais de la phase de pratique et expérimentale sont identiques, ils peuvent utiliser la même SÉQUENCE. Par conséquent, au lieu de faire glisser une nouvelle sequence à partir de la barre d'outils, vous pouvez réutiliser celle existante (c'est-à-dire créer une copie liée).

Pour ce faire, faites un clic droit sur la new_sequence précédemment créée et sélectionnez "Copier (lié)". Maintenant, faites un clic droit sur new_loop_1 et sélectionnez "Coller". Dans le menu contextuel qui apparaît, sélectionnez "Insérer dans new_loop_1".

Ajoutez un nouvel élément form_text_display pour le message d'au revoir

Lorsque l'expérience est terminée, nous devons dire au revoir au participant. Pour cela, nous avons besoin d'un autre élément form_text_display. Revenez à la sequence expérimentale et faites glisser un form_text_display depuis la barre d'outils sur new_loop_1. Dans le menu contextuel qui apparaît, sélectionnez "Insérer après new_loop_1" (nous reviendrons à cela à l'étape 12).

Donnez aux nouveaux éléments des noms significatifs

Par défaut, les nouveaux éléments ont des noms tels que new_sequence et new_form_text_display_2. Il est recommandé de donner des noms significatifs aux éléments. Cela facilite grandement la compréhension de la structure de l'expérience. Si vous le souhaitez, vous pouvez également ajouter une description à chaque élément. Les noms des éléments doivent être composés de caractères alphanumériques et/ou de tirets bas.

• Sélectionnez new_form_text_display dans la zone d'aperçu, double-cliquez sur son étiquette en haut de la zone des onglets et renommez l'élément instructions. (Raccourci zone d'aperçu : F2)
• Renommez new_loop en practice_loop.
• Renommez new_sequence en block_sequence. Comme vous avez réutilisé cet élément dans new_loop_1, le nom change automatiquement là aussi. (Cela illustre pourquoi il est efficace de créer des copies liées chaque fois que cela est possible.)
• Renommez new_form_text_display_1 en end_of_practice.
• Renommez new_loop_1 en experimental_loop.
• Renommez new_form_text_display_2 en end_of_experiment.

Donnez à toute l'expérience un nom significatif

L'expérience dans son ensemble a également un titre et une description. Cliquez sur "Nouvelle expérience" dans la zone d'aperçu. Vous pouvez renommer l'expérience de la même manière que vous avez renommé ses éléments. Le titre actuel est "Nouvelle expérience". Renommez l'expérience en "Tutoriel : Gaze cuing". Contrairement aux noms des éléments, le titre de l'expérience peut contenir des espaces, etc.

La zone d'aperçu de votre expérience ressemble maintenant à Figure 5. Ce serait un bon moment pour sauvegarder votre expérience (raccourci : Ctrl+S).

Figure 5. La zone d'aperçu à la fin de l'étape 1.

Étape 2 : Créer la séquence de bloc

Cliquez sur block_sequence dans l'aperçu. Pour l'instant, cette sequence est vide. Nous voulons que block_sequence se compose d'un bloc d'essais, suivi d'un affichage feedback. Pour cela, nous devons faire ce qui suit :

Ajoutez un élément reset_feedback pour réinitialiser les variables de retour

Nous ne voulons pas que notre retour soit biaisé par les touches que les participants ont appuyées pendant la phase d'instruction ou les blocs d'essais précédents. Par conséquent, nous commençons chaque bloc d'essais en réinitialisant les variables de retour. Pour ce faire, il nous faut un élément reset_feedback. Prenez reset_feedback dans la barre d'outils (sous "Collecte de réponses") et faites-le glisser sur block_sequence.

Ajoutez une nouvelle boucle, contenant une nouvelle séquence, pour un bloc d'essais

Pour une seule essai, nous avons besoin d'une sequence. Pour un bloc d'essais, nous devons répéter cette SÉQUENCE plusieurs fois. Par conséquent, pour un bloc d'essais, nous devons entourer une loop autour d'une SÉQUENCE. Faites glisser une BOUCLE depuis la barre d'outils des éléments sur new_reset_feedback. Ensuite, faites glisser une SÉQUENCE depuis la barre d'outils des éléments sur la BOUCLE nouvellement créée, et sélectionnez 'Insérer dans new_loop' dans le menu contextuel qui apparaît. (Nous reviendrons sur ce point à l'étape 3.)

Ajoutez un élément de feedback

Après chaque bloc d'essais, nous voulons donner un retour d'information au participant, afin qu'il sache comment il/elle se débrouille. Pour cela, nous avons besoin d'un élément feedback. Faites glisser un feedback depuis la barre d'outils des éléments sur new_loop, et sélectionnez 'Insérer après la boucle' dans le menu contextuel qui apparaît. (Nous reviendrons sur ce point à l'étape 10.)

Donnez des noms logiques aux nouveaux éléments

Renommez : (Voir l'étape 1 si vous ne vous souvenez pas comment faire.)

• new_loop en block_loop
• new_sequence en trial_sequence
• new_reset_feedback en reset_feedback
• new_feedback en feedback

L'aperçu de votre expérience ressemble maintenant à Figure 6. N'oubliez pas d'enregistrer régulièrement votre expérience.

Figure 6. La zone d'aperçu à la fin de l'étape 2.

Étape 3 : Remplir la boucle de blocs avec des variables indépendantes

Comme son nom l'indique, block_loop correspond à un seul bloc d'essais. Dans l'étape précédente, nous avons créé le block_loop, mais nous devons encore définir les variables indépendantes qui seront modifiées à l'intérieur du bloc. Notre expérience a trois variables indépendantes :

• gaze_cue peut être 'gauche' ou 'droite'.
• target_pos (la position de la cible) peut être '-300' ou '300'. Ces valeurs reflètent l'abscisse X de la cible en pixels (0 = centre). Utiliser les coordonnées directement, plutôt que 'gauche' et 'droite', sera pratique lorsque nous créerons les affichages cibles (voir étape 5).
• target_letter (la lettre cible) peut être 'F' ou 'H'.

Par conséquent, notre expérience a 2 x 2 x 2 = 8 niveaux. Bien que 8 niveaux ne soit pas si élevé (la plupart des expériences en auront plus), nous n'avons pas besoin de saisir toutes les combinaisons possibles manuellement. Cliquez sur block_loop dans l'aperçu pour ouvrir son onglet. Cliquez maintenant sur le bouton 'Plan factoriel complet'. Dans l'assistant des variables, vous définissez simplement toutes les variables en tapant le nom dans la première rangée et les niveaux dans les rangées sous le nom (voir Figure 7). Si vous sélectionnez 'Ok', vous verrez que block_loop a été rempli avec les 8 combinaisons possibles.

Figure 7. L'assistant des variables de boucle à l'étape 3.

Dans le tableau des boucles résultant, chaque ligne correspond à une exécution de trial_sequence. Comme, dans notre cas, une exécution de trial_sequence correspond à un essai, chaque ligne de notre tableau de boucle correspond à un essai. Chaque colonne correspond à une variable, qui peut avoir une valeur différente à chaque essai.

Mais nous n'avons pas encore terminé. Nous devons ajouter trois autres variables : l'emplacement du distractor, la réponse correcte et la congruence.

• dist_pos -- Sur la première ligne de la première colonne vide, saisissez 'dist_pos'. Cela ajoute automatiquement une nouvelle variable expérimentale nommée 'dist_pos'. Dans les lignes ci-dessous, saisissez '300' lorsque 'target_pos' est -300, et '-300' lorsque 'target_pos' est 300. En d'autres termes, la cible et le distracteur doivent être positionnés à l'opposé l'un de l'autre.
• correct_response -- Créez une autre variable, dans une autre colonne vide, avec le nom 'correct_response'. Définissez 'correct_response' sur 'z' lorsque 'target_letter' est 'F', et sur 'm' lorsque 'target_letter' est 'H'. Cela signifie que le participant doit appuyer sur la touche 'z' s'il voit un 'F' et sur la touche 'm' s'il voit un 'H'. (N'hésitez pas à choisir d'autres touches si 'z' et 'm' sont gênantes sur la disposition de votre clavier; par exemple, 'w' et 'n' sont meilleures sur les claviers AZERTY.)
• congruency -- Créez une autre variable avec le nom 'congruency'. Définissez 'congruency' sur 'congruent' lorsque 'target_pos' est '-300' et 'gaze_cue' est 'left', et lorsque 'target_pos' est '300' et 'gaze_cue' est 'right'. En d'autres termes, un essai est congruent si le visage regarde la cible. Définissez 'congruency' sur 'incronguent' pour les essais où le visage regarde le distracteur. La variable 'congruency' n'est pas nécessaire pour exécuter l'expérience; cependant, elle est utile pour analyser les données ultérieurement.

Nous devons faire encore une dernière chose. 'Repeat' est actuellement défini sur '1.00'. Cela signifie que chaque cycle sera exécuté une fois. Le bloc est donc composé de 8 essais, ce qui est un peu court. Une longueur raisonnable pour un bloc d'essais est de 24, donc définissez 'Repeat' sur 3.00 (3 répétitions x 8 cycles = 24 essais). Vous n'avez pas besoin de changer 'Order', car 'random' est exactement ce que nous voulons.

Le block_loop ressemble maintenant à Figure 8. N'oubliez pas d'enregistrer régulièrement votre expérience.

Figure 8. Le block_loop à la fin de l'étape 3.

Étape 4 : Ajoutez des images et des fichiers sonores à la pool de fichiers

Pour nos stimuli, nous utiliserons des images provenant de fichiers. De plus, nous jouerons un son si le participant commet une erreur. Pour cela, nous avons besoin d'un fichier sonore.

Vous pouvez télécharger les fichiers requis ici (dans la plupart des navigateurs, vous pouvez cliquer avec le bouton droit sur les liens et choisir 'Enregistrer le lien sous' ou une option similaire) :

• gaze_neutral.png
• gaze_left.png
• gaze_right.png
• incorrect.ogg

Une fois que vous avez téléchargé ces fichiers (sur votre bureau, par exemple), vous pouvez les ajouter à la pool de fichiers. Si la pool de fichiers n'est pas déjà visible (par défaut à droite de la fenêtre), cliquez sur le bouton 'Afficher la pool de fichiers' dans la barre d'outils principale (raccourci : Ctrl+P). La manière la plus simple d'ajouter les quatre fichiers à la pool de fichiers est de les faire glisser du bureau (ou de l'endroit où vous les avez téléchargés) dans la pool de fichiers. Vous pouvez également cliquer sur le bouton '+' dans la pool de fichiers et ajouter des fichiers en utilisant la boîte de dialogue de sélection de fichiers qui apparaît. La pool de fichiers sera enregistrée automatiquement avec votre expérience.

Votre pool de fichiers ressemble maintenant à Figure 9. N'oubliez pas d'enregistrer régulièrement votre expérience.

Figure 9. La pool de fichiers à la fin de l'étape 4.

Étape 5 : Remplissez la séquence d'essai avec des éléments

Un essai dans notre expérience se présente comme suit :

1. Point de fixation -- 750 ms, élément sketchpad
2. Regard neutre -- 750 ms, élément sketchpad
3. Indice de regard -- 500 ms, élément sketchpad
4. Cible -- 0 ms, élément sketchpad
5. Collecte de réponse -- élément keyboard_response
6. Jouer un son si la réponse est incorrecte -- élément sampler
7. Enregistrer la réponse dans un fichier -- élément logger

Cliquez sur trial_sequence dans l'aperçu pour ouvrir l'onglet trial_sequence. Prenez un sketchpad dans la barre d'outils des éléments et faites-le glisser dans le trial_sequence. Répétez cette opération trois fois de plus, de sorte que trial_sequence contienne quatre sketchpads. Ensuite, sélectionnez et ajoutez un élément keyboard_response, un élément sampler et un élément logger.

De nouveau, nous allons renommer les nouveaux éléments, pour nous assurer que le trial_sequence est facile à comprendre. Renommez :

• new_sketchpad en fixation_dot
• new_sketchpad_1 en neutral_gaze
• new_sketchpad_2 en gaze_cue
• new_sketchpad_3 en target
• new_keyboard_response en keyboard_response
• new_sampler en incorrect_sound
• new_logger en logger

Par défaut, les éléments sont toujours exécutés, ce qui est indiqué par l'expression run-if True. Cependant, nous voulons changer cela pour l'élément incorrect_sound, qui ne doit être exécuté que si une erreur a été commise. Pour ce faire, il faut modifier l'expression "Run if" en correct == 0 dans l'onglet trial_sequence. Ceci fonctionne, car l'élément keyboard_response crée automatiquement une variable correct, qui est définie à 1 (correct), 0 (incorrect) ou undefined (cela repose sur la variable correct_response définie à l'étape 3). Le double signe égal est la syntaxe Python et indique que vous voulez comparer si les deux choses sont égales entre elles, dans ce cas si la variable correct est égale à 0. Pour modifier une expression run-if, double-cliquez dessus (raccourci : F3).

Le trial_sequence ressemble maintenant à Figure 10.

Figure 10. Le trial_sequence à la fin de l'étape 5.

Étape 6 : Dessiner les éléments sketchpad

Les éléments sketchpad que nous avons créés à l'étape 5 sont toujours vides. Il est temps de faire quelques dessins !

Définir la couleur d'arrière-plan en blanc

Cliquez sur fixation_dot dans la zone d'aperçu pour ouvrir son onglet. Le sketchpad est toujours gris foncé, alors que les images que nous avons téléchargées ont un fond blanc. Oups, nous avons oublié de définir la couleur d'arrière-plan de l'expérience en blanc (elle est gris foncé par défaut) ! Cliquez sur 'Tutoriel : Gaze cuing' dans la zone d'aperçu pour ouvrir l'onglet 'Propriétés générales'. Changez 'Avant-plan' en 'noir' et 'Arrière-plan' en 'blanc'.

Dessinez le point de fixation

Revenez au fixation_dot en cliquant sur fixation_dot dans l'aperçu. Sélectionnez maintenant l'élément du point de fixation en cliquant sur le bouton avec la croix. Si vous déplacez votre curseur sur le sketchpad, vous pouvez voir les coordonnées de l'écran en haut à droite. Définissez la couleur (de premier plan) sur 'noir'. Cliquez au centre de l'écran (0, 0) pour dessiner un point de fixation central.

Enfin, changez le champ 'Durée' de 'keypress' à '745', car nous voulons que le point de fixation soit présenté pendant 750 ms. Attendez... pourquoi n'avons-nous pas simplement spécifié une durée de 750 ms? La raison en est que la durée réelle de présentation de l'affichage est toujours arrondie à une valeur compatible avec le taux de rafraîchissement de votre écran. Cela peut paraître compliqué, mais pour la plupart des utilisations, les règles de base suivantes sont suffisantes:

1. Choisissez une durée qui est possible étant donné le taux de rafraîchissement de votre écran. Par exemple, si le taux de rafraîchissement de votre écran est de 60 Hz, cela signifie que chaque image dure 16,7 ms (= 1000 ms / 60 Hz). Par conséquent, sur un écran de 60 Hz, vous devez toujours choisir une durée qui est un multiple de 16,7 ms, comme 16,7, 33,3, 50, 100, etc.
2. Dans le champ de durée du sketchpad, indiquez une durée de quelques millisecondes de moins que ce que vous visez. Ainsi, si vous souhaitez présenter un sketchpad pendant 50 ms, choisissez une durée de 45. Si vous voulez présenter un sketchpad pendant 1000 ms, choisissez une durée de 995. Etc.

Dessinez le regard neutre

Ouvrez le sketchpad neutral_gaze. Sélectionnez maintenant l'outil image en cliquant sur le bouton avec l'icône de paysage montagneux. Cliquez au centre de l'écran (0, 0). La boîte de dialogue 'Sélectionner un fichier dans la base' apparaîtra. Sélectionnez le fichier gaze_neutral.png et cliquez sur le bouton 'Sélectionner'. L'image du regard neutre vous fixera maintenant depuis le centre de l'écran ! Enfin, comme précédemment, changez le champ 'Durée' de 'keypress' à '745'. (Et notez à nouveau que cela signifie une durée de 750 ms sur la plupart des écrans!)

Dessinez le repère du regard

Ouvrez le sketchpad gaze_cue et sélectionnez à nouveau l'outil image. Cliquez au centre de l'écran (0, 0) et sélectionnez le fichier gaze_left.png.

Mais nous n'avons pas encore terminé! Parce que le repère du regard ne doit pas toujours être 'à gauche', mais doit dépendre de la variable gaze_cue, que nous avons définie à l'étape 3. Cependant, en dessinant l'image gaze_left.png sur le sketchpad, nous avons généré un script qui nécessite seulement une petite modification pour s'assurer que l'image appropriée est affichée. Cliquez sur le bouton 'Sélectionner la vue' en haut à droite de l'onglet gaze_cue et sélectionnez 'Voir le script'. Vous verrez maintenant le script qui correspond au sketchpad que nous venons de créer:

set duration keypress
set description "Affiche les stimuli"
draw image center=1 file="gaze_left.png" scale=1 show_if=True x=0 y=0 z_index=0

La seule chose que nous devons faire est de remplacer gaze_left.png par gaze_{gaze_cue}.png. Cela signifie qu'OpenSesame utilise la variable gaze_cue (qui a les valeurs left et right) pour déterminer quelle image doit être affichée.

Tant qu'à faire, nous pourrions aussi changer la durée à '495' (arrondi à 500 !). Le script ressemble maintenant à ceci :

set duration 495
set description "Affiche les stimuli"
draw image center=1 file="gaze_{gaze_cue}.png" scale=1 show_if=True x=0 y=0 z_index=0

Cliquez sur le bouton 'Appliquer' en haut à droite pour appliquer vos modifications au script et revenir aux contrôles d'éléments normaux. OpenSesame vous avertira que l'image ne peut être affichée, car elle est définie à l'aide de variables, et une image substitut sera affichée à la place. Ne vous inquiétez pas, l'image correcte sera affichée pendant l'expérience !

Dessiner la cible

Nous voulons que trois objets fassent partie de l'affichage de la cible : la lettre cible, la lettre distractrice et l'indice de regard (voir Figure 1). Comme auparavant, nous commencerons par créer un affichage statique à l'aide de l'éditeur sketchpad. Ensuite, nous n'aurons besoin d'apporter que de légères modifications au script pour que l'affichage exact dépende des variables.

Cliquez sur target dans l'aperçu pour ouvrir l'onglet cible et, comme avant, dessinez l'image gaze_left.png au centre de l'écran. Sélectionnez maintenant l'outil de dessin de texte en cliquant sur le bouton avec l'icône 'A'. Changez la couleur de premier plan en 'noir' (si ce n'est pas déjà le cas). La taille de la police par défaut est de 18 px, ce qui est un peu petit pour notre objectif, alors changez la taille de la police à 32 px. Maintenant, cliquez sur (-320, 0) dans le sketchpad (la coordonnée X n'a pas besoin d'être exactement 320, puisque nous la changerons de toute façon en variable). Entrez "{target_letter}" dans la boîte de dialogue qui apparaît, pour dessiner la lettre cible (lorsque vous dessinez du texte, vous pouvez utiliser directement les variables). De même, cliquez sur (320, 0) et dessinez un 'X' (le distracteur est toujours un 'X').

Ouvrez maintenant l'éditeur de script en cliquant sur le bouton "Sélectionner la vue" en haut à droite de l'onglet et en sélectionnant "Voir le script". Le script ressemble à ceci :

set duration keypress
set duration keypress
set description "Affiche les stimuli"
draw image center=1 file="gaze_left.png" scale=1 show_if=True x=0 y=0 z_index=0
draw textline center=1 color=black font_bold=no font_family=mono font_italic=no font_size=32 html=yes show_if=True text="{target_letter}" x=-320 y=0 z_index=0
draw textline center=1 color=black font_bold=no font_family=mono font_italic=no font_size=32 html=yes show_if=True text=X x=320 y=0 z_index=0

Comme précédemment, changez gaze_left.png en gaze_{gaze_cue}.png. Nous devons également faire en sorte que la position de la cible et du distracteur dépende des variables target_pos et dist_pos respectivement. Pour ce faire, changez simplement -320 en {target_pos} et 320 en {dist_pos}. Assurez-vous de laisser le 0, qui est la coordonnée Y. Le script ressemble maintenant à ceci :

set duration keypress
set description "Affiche les stimuli"
draw image center=1 file="gaze_{gaze_cue}.png" scale=1 show_if=True x=0 y=0 z_index=0
draw textline center=1 color=black font_bold=no font_family=mono font_italic=no font_size=32 html=yes show_if=True text="{target_letter}" x={target_pos} y=0 z_index=0
draw textline center=1 color=black font_bold=no font_family=mono font_italic=no font_size=32 html=yes show_if=True text=X x={dist_pos} y=0 z_index=0

Cliquez sur le bouton "Appliquer" pour appliquer le script et revenir aux contrôles d'éléments normaux.

Enfin, réglez le champ 'Duration' sur '0'. Cela ne signifie pas que la cible est présentée pour seulement 0 ms, mais que l'expérience passera à l'élément suivant (le keyboard_response) immédiatement. Comme le keyboard_response attend une réponse, mais ne change pas ce qui est affiché à l'écran, la cible restera visible jusqu'à ce qu'une réponse soit donnée.

N'oubliez pas d'enregistrer régulièrement votre expérience.

Étape 7: Configurer l'élément de réponse au clavier

Cliquez sur keyboard_response dans l'aperçu pour ouvrir son onglet. Vous voyez trois options: Correct response, Allowed responses, Timeout et Event type.

Nous avons déjà défini la variable correct_response à l'étape 3. Sauf si nous spécifions explicitement une réponse correcte, OpenSesame utilise automatiquement la variable correct_response si elle est disponible. Par conséquent, nous n'avons pas besoin de modifier le champ 'Correct response' ici.

Nous devons définir les réponses autorisées. Entrez 'z;m' dans le champ allowed-responses (ou d'autres touches si vous avez choisi des touches de réponse différentes). Le point-virgule est utilisé pour séparer les réponses. Le keyboard_response n'accepte désormais que les touches 'z' et 'm'. Toutes les autres pressions de touches sont ignorées, à l'exception de 'échap', qui met l'expérience en pause.

Nous voulons également définir un délai d'attente, qui est l'intervalle maximum que le keyboard_response attend avant de décider que la réponse est incorrecte et de régler la variable 'response' sur 'Aucune'. '2000' (ms) est une bonne valeur.

Nous n'avons pas besoin de modifier le type d'événement, car nous voulons que le participant réponde en appuyant sur une touche (keypress, par défaut) et non en relâchant une touche (keyrelease).

Le keyboard_response ressemble maintenant à Figure 12.

Figure 12. Le keyboard_response à la fin de l'étape 7.

Étape 8: Configurer l'élément incorrect (sampler)

L'élément incorrect_sound ne nécessite pas beaucoup de travail: nous devons seulement sélectionner le son qui doit être joué. Cliquez sur incorrect_sound dans l'aperçu pour ouvrir son onglet. Cliquez sur le bouton 'Parcourir' et sélectionnez incorrect.ogg dans le fichier pool.

Le sampler ressemble maintenant à Figure 13.

Figure 13. L'élément incorrect_sound à la fin de l'étape 8.

Étape 9 : Configurer le variable logger

En réalité, nous n'avons pas besoin de configurer le logger variable, mais jetons-y un coup d'œil quand même. Cliquez sur logger dans l'aperçu pour ouvrir son onglet. Vous voyez que l'option "Enregistrer automatiquement toutes les variables" est sélectionnée. Cela signifie qu'OpenSesame enregistre tout, ce qui est très bien.

Étape 10 : Dessiner l'élément de feedback

Après chaque bloc d'essais, nous voulons présenter un feedback au participant pour le/la informer de sa performance. C'est pourquoi, à l'étape 2, nous avons ajouté un élément feedback, simplement nommé feedback à la fin de block_sequence.

Cliquez sur feedback dans l'aperçu pour ouvrir son onglet, sélectionnez l'outil de dessin de texte, changez la couleur d'avant-plan en 'noir' (si ce n'est pas déjà fait), et cliquez à (0, 0). Entrez maintenant le texte suivant :

Fin du bloc

Votre temps de réponse moyen était de {avg_rt} ms
Votre précision était de {acc} %

Appuyez sur n'importe quelle touche pour continuer

Puisque nous voulons que l'élément de feedback reste visible aussi longtemps que le participant le souhaite (c'est-à-dire jusqu'à ce qu'il/elle appuie sur une touche), nous laissons le champ "Durée" défini sur "touche enfoncée".

L'élément de feedback ressemble maintenant à Figure 14.

Figure 14. L'élément de feedback à la fin de l'étape 10.

Étape 11 : Définir la durée de la phase de pratique et de la phase expérimentale

Nous avons précédemment créé les éléments practice_loop et experiment_loop, qui appellent tous deux block_sequence (c'est-à-dire un bloc d'essais). Cependant, pour l'instant, ils n'appellent block_sequence qu'une seule fois, ce qui signifie que la phase de pratique et la phase expérimentale ne comportent qu'un seul bloc d'essais chacune.

Cliquez sur practice_loop pour ouvrir son onglet et définissez "Répéter" sur "2.00". Cela signifie que la phase de pratique se compose de deux blocs.

Cliquez sur experimental_loop pour ouvrir son onglet et définissez "Répéter" sur "8.00". Cela signifie que la phase expérimentale se compose de huit blocs.

Étape 12 : Rédiger les formulaires d'instruction, de fin de pratique et de fin d'expérience

Je pense que vous pouvez gérer cette étape vous-même ! Ouvrez simplement les éléments appropriés et ajoutez du texte pour présenter les instructions, un message de fin de pratique et un message de fin d'expérience.

Étape 13 : Exécuter l'expérience !

C'est terminé ! Cliquez sur les boutons 'Exécuter dans une fenêtre' (raccourci : Ctrl+W) ou 'Exécuter en plein écran' (raccourci : Ctrl+R) dans la barre d'outils pour lancer votre expérience.

Comprendre les erreurs

Être capable de comprendre les messages d'erreur est une compétence essentielle lorsqu'on travaille avec OpenSeame. Après tout, une expérience nouvellement construite fonctionne rarement immédiatement sans erreur !

Supposons que nous ayons fait une erreur lors de l'une des étapes ci-dessus. Lorsque nous essayons d'exécuter l'expérience, nous obtenons le message d'erreur suivant (Figure 15) :

Figure 15. Un message d'erreur dans OpenSesame.

Le message d'erreur commence par un nom, dans ce cas FStringError, qui indique le type général d'erreur. Il est suivi d'un court texte explicatif, dans ce cas "Échec de l'évaluation de l'expression f-string dans le texte suivant : gaze_{gaze_ceu}.png". Même sans comprendre ce qu'est une f-string (c'est une chaîne de caractères qui contient du code Python entre accolades), il est clair qu'il y a un problème avec le texte '{gaze_ceu}.png'.

Le message d'erreur indique également que l'erreur provient de la phase de préparation de l'élément gaze_cue.

Enfin, le message d'erreur indique ce qui s'est mal passé lors de l'évaluation du texte 'gaze_{gaze_ceu}.png' : le nom 'gaze_ceu' n'est pas défini.

En lisant attentivement le message d'erreur, la cause et la solution vous sont probablement déjà venues à l'esprit : nous avons fait une simple faute de frappe dans l'élément gaze_cue, en écrivant '{gaze_ceu}' au lieu de '{gaze_cue}' ! Et cela a entraîné une erreur car il n'y a pas de variable avec le nom gaze_ceu. Il suffit d'ouvrir le script de l'élément gaze_cue et de corriger la faute de frappe.

Enfin : Quelques considérations générales concernant le timing et la sélection du backend

Dans l'onglet 'Propriétés générales' de l'expérience (l'onglet que vous ouvrez en cliquant sur le nom de l'expérience), vous pouvez sélectionner un backend. Le backend est la couche logicielle qui contrôle l'affichage, les périphériques d'entrée, le son, etc. La plupart des expériences fonctionnent avec tous les backends, mais il y a des raisons de préférer un backend à un autre, principalement liées au timing. Actuellement, il existe quatre backends (selon votre système, les trois ne sont peut-être pas disponibles) :

• psycho -- un backend accéléré matériellement basé sur PsychoPy (Peirce, 2007). C'est le choix par défaut.
• xpyriment -- un backend accéléré matériellement basé sur Expyriment (Krause & Lindeman, 2013)
• legacy -- un backend 'sûr', basé sur PyGame. Il offre des performances fiables sur la plupart des plates-formes, mais, en raison de l'absence d'accélération matérielle, ses propriétés de temporisation ne sont pas aussi bonnes que celles des autres backends.
• osweb -- exécute des expériences dans un navigateur (Mathôt & March, 2022).

Voir aussi :

• https://osdoc.cogsci.nl/4.0/fr/manual/backends
• https://osdoc.cogsci.nl/4.0/fr/manual/timing

Références