|
|
@@ -1,1534 +0,0 @@
|
|
|
-#!/usr/bin/env python
|
|
|
-# -*- coding: utf-8 -*-
|
|
|
-"""
|
|
|
-This experiment was created using PsychoPy3 Experiment Builder (v2023.2.3),
|
|
|
- on 十二月 18, 2023, at 10:54
|
|
|
-If you publish work using this script the most relevant publication is:
|
|
|
-
|
|
|
- Peirce J, Gray JR, Simpson S, MacAskill M, Höchenberger R, Sogo H, Kastman E, Lindeløv JK. (2019)
|
|
|
- PsychoPy2: Experiments in behavior made easy Behav Res 51: 195.
|
|
|
- https://doi.org/10.3758/s13428-018-01193-y
|
|
|
-
|
|
|
-"""
|
|
|
-
|
|
|
-# --- Import packages ---
|
|
|
-from psychopy import locale_setup
|
|
|
-from psychopy import prefs
|
|
|
-from psychopy import plugins
|
|
|
-plugins.activatePlugins()
|
|
|
-prefs.hardware['audioLib'] = 'ptb'
|
|
|
-prefs.hardware['audioLatencyMode'] = '3'
|
|
|
-from psychopy import sound, gui, visual, core, data, event, logging, clock, colors, layout
|
|
|
-from psychopy.tools import environmenttools
|
|
|
-from psychopy.constants import (NOT_STARTED, STARTED, PLAYING, PAUSED,
|
|
|
- STOPPED, FINISHED, PRESSED, RELEASED, FOREVER, priority)
|
|
|
-
|
|
|
-import numpy as np # whole numpy lib is available, prepend 'np.'
|
|
|
-from numpy import (sin, cos, tan, log, log10, pi, average,
|
|
|
- sqrt, std, deg2rad, rad2deg, linspace, asarray)
|
|
|
-from numpy.random import random, randint, normal, shuffle, choice as randchoice
|
|
|
-import os # handy system and path functions
|
|
|
-import sys # to get file system encoding
|
|
|
-
|
|
|
-import psychopy.iohub as io
|
|
|
-from psychopy.hardware import keyboard
|
|
|
-
|
|
|
-# Run 'Before Experiment' code from config
|
|
|
-import argparse
|
|
|
-import time
|
|
|
-from device.fubo_pneumatic_finger import FuboPneumaticFingerClient
|
|
|
-from device.trigger_box import TriggerNeuracle
|
|
|
-from settings.config import settings
|
|
|
-
|
|
|
-
|
|
|
-# get train params
|
|
|
-
|
|
|
-def parse_args():
|
|
|
-
|
|
|
- parser = argparse.ArgumentParser(
|
|
|
-
|
|
|
- description='Grasp training'
|
|
|
-
|
|
|
- )
|
|
|
-
|
|
|
- parser.add_argument(
|
|
|
-
|
|
|
- '--n-trials',
|
|
|
-
|
|
|
- dest='n_trials',
|
|
|
-
|
|
|
- help='Trial number',
|
|
|
-
|
|
|
- type=int,
|
|
|
-
|
|
|
- )
|
|
|
-
|
|
|
- parser.add_argument(
|
|
|
-
|
|
|
- '--com',
|
|
|
-
|
|
|
- dest='com',
|
|
|
-
|
|
|
- help='Peripheral serial port',
|
|
|
-
|
|
|
- type=str
|
|
|
-
|
|
|
- )
|
|
|
-
|
|
|
- parser.add_argument(
|
|
|
-
|
|
|
- '--finger-model',
|
|
|
-
|
|
|
- '-fm',
|
|
|
-
|
|
|
- dest='finger_model',
|
|
|
-
|
|
|
- help='Gesture to train',
|
|
|
-
|
|
|
- type=str
|
|
|
-
|
|
|
- )
|
|
|
-
|
|
|
- return parser.parse_args()
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-args = parse_args()
|
|
|
-
|
|
|
-hand_device = FuboPneumaticFingerClient({'port': args.com})
|
|
|
-
|
|
|
-# connect to trigger box
|
|
|
-trigger = TriggerNeuracle()
|
|
|
-
|
|
|
-# Run 'Before Experiment' code from code
|
|
|
-
|
|
|
-
|
|
|
-# --- Setup global variables (available in all functions) ---
|
|
|
-# Ensure that relative paths start from the same directory as this script
|
|
|
-_thisDir = os.path.dirname(os.path.abspath(__file__))
|
|
|
-# Store info about the experiment session
|
|
|
-psychopyVersion = '2023.2.3'
|
|
|
-expName = 'grasp_data_collection' # from the Builder filename that created this script
|
|
|
-expInfo = {
|
|
|
- 'participant': f"{randint(0, 999999):06.0f}",
|
|
|
- 'session': '001',
|
|
|
- 'date': data.getDateStr(), # add a simple timestamp
|
|
|
- 'expName': expName,
|
|
|
- 'psychopyVersion': psychopyVersion,
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-def showExpInfoDlg(expInfo):
|
|
|
- """
|
|
|
- Show participant info dialog.
|
|
|
- Parameters
|
|
|
- ==========
|
|
|
- expInfo : dict
|
|
|
- Information about this experiment, created by the `setupExpInfo` function.
|
|
|
-
|
|
|
- Returns
|
|
|
- ==========
|
|
|
- dict
|
|
|
- Information about this experiment.
|
|
|
- """
|
|
|
- # temporarily remove keys which the dialog doesn't need to show
|
|
|
- poppedKeys = {
|
|
|
- 'date': expInfo.pop('date', data.getDateStr()),
|
|
|
- 'expName': expInfo.pop('expName', expName),
|
|
|
- 'psychopyVersion': expInfo.pop('psychopyVersion', psychopyVersion),
|
|
|
- }
|
|
|
- # show participant info dialog
|
|
|
- dlg = gui.DlgFromDict(dictionary=expInfo, sortKeys=False, title=expName)
|
|
|
- if dlg.OK == False:
|
|
|
- core.quit() # user pressed cancel
|
|
|
- # restore hidden keys
|
|
|
- expInfo.update(poppedKeys)
|
|
|
- # return expInfo
|
|
|
- return expInfo
|
|
|
-
|
|
|
-
|
|
|
-def setupData(expInfo, dataDir=None):
|
|
|
- """
|
|
|
- Make an ExperimentHandler to handle trials and saving.
|
|
|
-
|
|
|
- Parameters
|
|
|
- ==========
|
|
|
- expInfo : dict
|
|
|
- Information about this experiment, created by the `setupExpInfo` function.
|
|
|
- dataDir : Path, str or None
|
|
|
- Folder to save the data to, leave as None to create a folder in the current directory.
|
|
|
- Returns
|
|
|
- ==========
|
|
|
- psychopy.data.ExperimentHandler
|
|
|
- Handler object for this experiment, contains the data to save and information about
|
|
|
- where to save it to.
|
|
|
- """
|
|
|
-
|
|
|
- # data file name stem = absolute path + name; later add .psyexp, .csv, .log, etc
|
|
|
- if dataDir is None:
|
|
|
- dataDir = _thisDir
|
|
|
- filename = u'data/%s_%s_%s' % (expInfo['participant'], expName, expInfo['date'])
|
|
|
- # make sure filename is relative to dataDir
|
|
|
- if os.path.isabs(filename):
|
|
|
- dataDir = os.path.commonprefix([dataDir, filename])
|
|
|
- filename = os.path.relpath(filename, dataDir)
|
|
|
-
|
|
|
- # an ExperimentHandler isn't essential but helps with data saving
|
|
|
- thisExp = data.ExperimentHandler(
|
|
|
- name=expName, version='',
|
|
|
- extraInfo=expInfo, runtimeInfo=None,
|
|
|
- originPath='D:\\Graduate\\kraken\\backend\\grasp_data_collection_threestages.py',
|
|
|
- savePickle=True, saveWideText=True,
|
|
|
- dataFileName=dataDir + os.sep + filename, sortColumns='time'
|
|
|
- )
|
|
|
- thisExp.setPriority('thisRow.t', priority.CRITICAL)
|
|
|
- thisExp.setPriority('expName', priority.LOW)
|
|
|
- # return experiment handler
|
|
|
- return thisExp
|
|
|
-
|
|
|
-
|
|
|
-def setupLogging(filename):
|
|
|
- """
|
|
|
- Setup a log file and tell it what level to log at.
|
|
|
-
|
|
|
- Parameters
|
|
|
- ==========
|
|
|
- filename : str or pathlib.Path
|
|
|
- Filename to save log file and data files as, doesn't need an extension.
|
|
|
-
|
|
|
- Returns
|
|
|
- ==========
|
|
|
- psychopy.logging.LogFile
|
|
|
- Text stream to receive inputs from the logging system.
|
|
|
- """
|
|
|
- # this outputs to the screen, not a file
|
|
|
- logging.console.setLevel(logging.EXP)
|
|
|
- # save a log file for detail verbose info
|
|
|
- logFile = logging.LogFile(filename+'.log', level=logging.EXP)
|
|
|
-
|
|
|
- return logFile
|
|
|
-
|
|
|
-
|
|
|
-def setupWindow(expInfo=None, win=None):
|
|
|
- """
|
|
|
- Setup the Window
|
|
|
-
|
|
|
- Parameters
|
|
|
- ==========
|
|
|
- expInfo : dict
|
|
|
- Information about this experiment, created by the `setupExpInfo` function.
|
|
|
- win : psychopy.visual.Window
|
|
|
- Window to setup - leave as None to create a new window.
|
|
|
-
|
|
|
- Returns
|
|
|
- ==========
|
|
|
- psychopy.visual.Window
|
|
|
- Window in which to run this experiment.
|
|
|
- """
|
|
|
- if win is None:
|
|
|
- # if not given a window to setup, make one
|
|
|
- win = visual.Window(
|
|
|
- size=[1707, 1067], fullscr=True, screen=0,
|
|
|
- winType='pyglet', allowStencil=False,
|
|
|
- monitor='testMonitor', color=[1,1,1], colorSpace='rgb',
|
|
|
- backgroundImage='', backgroundFit='none',
|
|
|
- blendMode='avg', useFBO=True,
|
|
|
- units='height'
|
|
|
- )
|
|
|
- if expInfo is not None:
|
|
|
- # store frame rate of monitor if we can measure it
|
|
|
- expInfo['frameRate'] = win.getActualFrameRate()
|
|
|
- else:
|
|
|
- # if we have a window, just set the attributes which are safe to set
|
|
|
- win.color = [1,1,1]
|
|
|
- win.colorSpace = 'rgb'
|
|
|
- win.backgroundImage = ''
|
|
|
- win.backgroundFit = 'none'
|
|
|
- win.units = 'height'
|
|
|
- win.mouseVisible = False
|
|
|
- win.hideMessage()
|
|
|
- return win
|
|
|
-
|
|
|
-
|
|
|
-def setupInputs(expInfo, thisExp, win):
|
|
|
- """
|
|
|
- Setup whatever inputs are available (mouse, keyboard, eyetracker, etc.)
|
|
|
-
|
|
|
- Parameters
|
|
|
- ==========
|
|
|
- expInfo : dict
|
|
|
- Information about this experiment, created by the `setupExpInfo` function.
|
|
|
- thisExp : psychopy.data.ExperimentHandler
|
|
|
- Handler object for this experiment, contains the data to save and information about
|
|
|
- where to save it to.
|
|
|
- win : psychopy.visual.Window
|
|
|
- Window in which to run this experiment.
|
|
|
- Returns
|
|
|
- ==========
|
|
|
- dict
|
|
|
- Dictionary of input devices by name.
|
|
|
- """
|
|
|
- # --- Setup input devices ---
|
|
|
- inputs = {}
|
|
|
- ioConfig = {}
|
|
|
-
|
|
|
- # Setup iohub keyboard
|
|
|
- ioConfig['Keyboard'] = dict(use_keymap='psychopy')
|
|
|
-
|
|
|
- ioSession = '1'
|
|
|
- if 'session' in expInfo:
|
|
|
- ioSession = str(expInfo['session'])
|
|
|
- ioServer = io.launchHubServer(window=win, **ioConfig)
|
|
|
- eyetracker = None
|
|
|
-
|
|
|
- # create a default keyboard (e.g. to check for escape)
|
|
|
- defaultKeyboard = keyboard.Keyboard(backend='iohub')
|
|
|
- # return inputs dict
|
|
|
- return {
|
|
|
- 'ioServer': ioServer,
|
|
|
- 'defaultKeyboard': defaultKeyboard,
|
|
|
- 'eyetracker': eyetracker,
|
|
|
- }
|
|
|
-
|
|
|
-def pauseExperiment(thisExp, inputs=None, win=None, timers=[], playbackComponents=[]):
|
|
|
- """
|
|
|
- Pause this experiment, preventing the flow from advancing to the next routine until resumed.
|
|
|
-
|
|
|
- Parameters
|
|
|
- ==========
|
|
|
- thisExp : psychopy.data.ExperimentHandler
|
|
|
- Handler object for this experiment, contains the data to save and information about
|
|
|
- where to save it to.
|
|
|
- inputs : dict
|
|
|
- Dictionary of input devices by name.
|
|
|
- win : psychopy.visual.Window
|
|
|
- Window for this experiment.
|
|
|
- timers : list, tuple
|
|
|
- List of timers to reset once pausing is finished.
|
|
|
- playbackComponents : list, tuple
|
|
|
- List of any components with a `pause` method which need to be paused.
|
|
|
- """
|
|
|
- # if we are not paused, do nothing
|
|
|
- if thisExp.status != PAUSED:
|
|
|
- return
|
|
|
-
|
|
|
- # pause any playback components
|
|
|
- for comp in playbackComponents:
|
|
|
- comp.pause()
|
|
|
- # prevent components from auto-drawing
|
|
|
- win.stashAutoDraw()
|
|
|
- # run a while loop while we wait to unpause
|
|
|
- while thisExp.status == PAUSED:
|
|
|
- # make sure we have a keyboard
|
|
|
- if inputs is None:
|
|
|
- inputs = {
|
|
|
- 'defaultKeyboard': keyboard.Keyboard(backend='ioHub')
|
|
|
- }
|
|
|
- # check for quit (typically the Esc key)
|
|
|
- if inputs['defaultKeyboard'].getKeys(keyList=['escape']):
|
|
|
- endExperiment(thisExp, win=win, inputs=inputs)
|
|
|
- # flip the screen
|
|
|
- win.flip()
|
|
|
- # if stop was requested while paused, quit
|
|
|
- if thisExp.status == FINISHED:
|
|
|
- endExperiment(thisExp, inputs=inputs, win=win)
|
|
|
- # resume any playback components
|
|
|
- for comp in playbackComponents:
|
|
|
- comp.play()
|
|
|
- # restore auto-drawn components
|
|
|
- win.retrieveAutoDraw()
|
|
|
- # reset any timers
|
|
|
- for timer in timers:
|
|
|
- timer.reset()
|
|
|
-
|
|
|
-
|
|
|
-def run(expInfo, thisExp, win, inputs, globalClock=None, thisSession=None):
|
|
|
- """
|
|
|
- Run the experiment flow.
|
|
|
-
|
|
|
- Parameters
|
|
|
- ==========
|
|
|
- expInfo : dict
|
|
|
- Information about this experiment, created by the `setupExpInfo` function.
|
|
|
- thisExp : psychopy.data.ExperimentHandler
|
|
|
- Handler object for this experiment, contains the data to save and information about
|
|
|
- where to save it to.
|
|
|
- psychopy.visual.Window
|
|
|
- Window in which to run this experiment.
|
|
|
- inputs : dict
|
|
|
- Dictionary of input devices by name.
|
|
|
- globalClock : psychopy.core.clock.Clock or None
|
|
|
- Clock to get global time from - supply None to make a new one.
|
|
|
- thisSession : psychopy.session.Session or None
|
|
|
- Handle of the Session object this experiment is being run from, if any.
|
|
|
- """
|
|
|
- # mark experiment as started
|
|
|
- thisExp.status = STARTED
|
|
|
- # make sure variables created by exec are available globally
|
|
|
- exec = environmenttools.setExecEnvironment(globals())
|
|
|
- # get device handles from dict of input devices
|
|
|
- ioServer = inputs['ioServer']
|
|
|
- defaultKeyboard = inputs['defaultKeyboard']
|
|
|
- eyetracker = inputs['eyetracker']
|
|
|
- # make sure we're running in the directory for this experiment
|
|
|
- os.chdir(_thisDir)
|
|
|
- # get filename from ExperimentHandler for convenience
|
|
|
- filename = thisExp.dataFileName
|
|
|
- frameTolerance = 0.001 # how close to onset before 'same' frame
|
|
|
- endExpNow = False # flag for 'escape' or other condition => quit the exp
|
|
|
- # get frame duration from frame rate in expInfo
|
|
|
- if 'frameRate' in expInfo and expInfo['frameRate'] is not None:
|
|
|
- frameDur = 1.0 / round(expInfo['frameRate'])
|
|
|
- else:
|
|
|
- frameDur = 1.0 / 60.0 # could not measure, so guess
|
|
|
-
|
|
|
- # Start Code - component code to be run after the window creation
|
|
|
-
|
|
|
- # --- Initialize components for Routine "prepare" ---
|
|
|
- text = visual.TextStim(win=win, name='text',
|
|
|
- text='抓握训练即将开始\n如果准备好了，请按空格键',
|
|
|
- font='Open Sans',
|
|
|
- pos=(0, 0), height=0.05, wrapWidth=None, ori=0.0,
|
|
|
- color='black', colorSpace='rgb', opacity=1.0,
|
|
|
- languageStyle='LTR',
|
|
|
- depth=0.0);
|
|
|
- key_resp = keyboard.Keyboard()
|
|
|
-
|
|
|
- # --- Initialize components for Routine "ready" ---
|
|
|
- ready_text = visual.TextStim(win=win, name='ready_text',
|
|
|
- text='请准备',
|
|
|
- font='Open Sans',
|
|
|
- pos=(0, 0), height=0.05, wrapWidth=None, ori=0.0,
|
|
|
- color='black', colorSpace='rgb', opacity=None,
|
|
|
- languageStyle='LTR',
|
|
|
- depth=0.0);
|
|
|
-
|
|
|
- # --- Initialize components for Routine "extend" ---
|
|
|
- extend_img = visual.ImageStim(
|
|
|
- win=win,
|
|
|
- name='extend_img',
|
|
|
- image='static/images/extend.png', mask=None, anchor='center',
|
|
|
- ori=0.0, pos=(0, 0), size=(0.5, 0.5),
|
|
|
- color=[1,1,1], colorSpace='rgb', opacity=None,
|
|
|
- flipHoriz=False, flipVert=False,
|
|
|
- texRes=128.0, interpolate=True, depth=0.0)
|
|
|
- attention = sound.Sound('static/audios/ding.wav', secs=1.0, stereo=True, hamming=True,
|
|
|
- name='attention')
|
|
|
- attention.setVolume(1.0)
|
|
|
- extend_wav = sound.Sound('static/audios/extend.wav', secs=2, stereo=True, hamming=True,
|
|
|
- name='extend_wav')
|
|
|
- extend_wav.setVolume(1.0)
|
|
|
-
|
|
|
- # --- Initialize components for Routine "flex" ---
|
|
|
- flex_img = visual.ImageStim(
|
|
|
- win=win,
|
|
|
- name='flex_img',
|
|
|
- image='static/images/flex.png', mask=None, anchor='center',
|
|
|
- ori=0.0, pos=(0, 0), size=(0.5, 0.5),
|
|
|
- color=[1,1,1], colorSpace='rgb', opacity=None,
|
|
|
- flipHoriz=False, flipVert=False,
|
|
|
- texRes=128.0, interpolate=True, depth=0.0)
|
|
|
- flex_wav = sound.Sound('static/audios/flex.wav', secs=2, stereo=True, hamming=True,
|
|
|
- name='flex_wav')
|
|
|
- flex_wav.setVolume(1.0)
|
|
|
-
|
|
|
- # --- Initialize components for Routine "hold" ---
|
|
|
- hold_img = visual.ImageStim(
|
|
|
- win=win,
|
|
|
- name='hold_img',
|
|
|
- image='static/images/hold.png', mask=None, anchor='center',
|
|
|
- ori=0.0, pos=(0, 0), size=(0.5, 0.5),
|
|
|
- color=[1,1,1], colorSpace='rgb', opacity=None,
|
|
|
- flipHoriz=False, flipVert=False,
|
|
|
- texRes=128.0, interpolate=True, depth=0.0)
|
|
|
- hold_wav = sound.Sound('static/audios/hold.wav', secs=2, stereo=True, hamming=True,
|
|
|
- name='hold_wav')
|
|
|
- hold_wav.setVolume(1.0)
|
|
|
-
|
|
|
- # --- Initialize components for Routine "rest" ---
|
|
|
- rest_img = visual.ImageStim(
|
|
|
- win=win,
|
|
|
- name='rest_img',
|
|
|
- image='static/images/rest.png', mask=None, anchor='center',
|
|
|
- ori=0.0, pos=(0, 0), size=(0.5, 0.5),
|
|
|
- color=[1,1,1], colorSpace='rgb', opacity=None,
|
|
|
- flipHoriz=False, flipVert=False,
|
|
|
- texRes=128.0, interpolate=True, depth=0.0)
|
|
|
- rest_wav1 = sound.Sound('static/audios/ding.wav', secs=1.0, stereo=True, hamming=True,
|
|
|
- name='rest_wav1')
|
|
|
- rest_wav1.setVolume(1.0)
|
|
|
- rest_wav2 = sound.Sound('static/audios/rest.wav', secs=2, stereo=True, hamming=True,
|
|
|
- name='rest_wav2')
|
|
|
- rest_wav2.setVolume(1.0)
|
|
|
-
|
|
|
- # --- Initialize components for Routine "end" ---
|
|
|
- end_text = visual.TextStim(win=win, name='end_text',
|
|
|
- text='恭喜您！\n完成训练！',
|
|
|
- font='Open Sans',
|
|
|
- pos=(0, 0), height=0.05, wrapWidth=None, ori=0.0,
|
|
|
- color='black', colorSpace='rgb', opacity=1.0,
|
|
|
- languageStyle='LTR',
|
|
|
- depth=0.0);
|
|
|
-
|
|
|
- # create some handy timers
|
|
|
- if globalClock is None:
|
|
|
- globalClock = core.Clock() # to track the time since experiment started
|
|
|
- if ioServer is not None:
|
|
|
- ioServer.syncClock(globalClock)
|
|
|
- logging.setDefaultClock(globalClock)
|
|
|
- routineTimer = core.Clock() # to track time remaining of each (possibly non-slip) routine
|
|
|
- win.flip() # flip window to reset last flip timer
|
|
|
- # store the exact time the global clock started
|
|
|
- expInfo['expStart'] = data.getDateStr(format='%Y-%m-%d %Hh%M.%S.%f %z', fractionalSecondDigits=6)
|
|
|
-
|
|
|
- # --- Prepare to start Routine "prepare" ---
|
|
|
- continueRoutine = True
|
|
|
- # update component parameters for each repeat
|
|
|
- thisExp.addData('prepare.started', globalClock.getTime())
|
|
|
- key_resp.keys = []
|
|
|
- key_resp.rt = []
|
|
|
- _key_resp_allKeys = []
|
|
|
- # Run 'Begin Routine' code from config
|
|
|
-
|
|
|
-
|
|
|
- # keep track of which components have finished
|
|
|
- prepareComponents = [text, key_resp]
|
|
|
- for thisComponent in prepareComponents:
|
|
|
- thisComponent.tStart = None
|
|
|
- thisComponent.tStop = None
|
|
|
- thisComponent.tStartRefresh = None
|
|
|
- thisComponent.tStopRefresh = None
|
|
|
- if hasattr(thisComponent, 'status'):
|
|
|
- thisComponent.status = NOT_STARTED
|
|
|
- # reset timers
|
|
|
- t = 0
|
|
|
- _timeToFirstFrame = win.getFutureFlipTime(clock="now")
|
|
|
- frameN = -1
|
|
|
-
|
|
|
- # --- Run Routine "prepare" ---
|
|
|
- routineForceEnded = not continueRoutine
|
|
|
- while continueRoutine:
|
|
|
- # get current time
|
|
|
- t = routineTimer.getTime()
|
|
|
- tThisFlip = win.getFutureFlipTime(clock=routineTimer)
|
|
|
- tThisFlipGlobal = win.getFutureFlipTime(clock=None)
|
|
|
- frameN = frameN + 1 # number of completed frames (so 0 is the first frame)
|
|
|
- # update/draw components on each frame
|
|
|
-
|
|
|
- # *text* updates
|
|
|
-
|
|
|
- # if text is starting this frame...
|
|
|
- if text.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance:
|
|
|
- # keep track of start time/frame for later
|
|
|
- text.frameNStart = frameN # exact frame index
|
|
|
- text.tStart = t # local t and not account for scr refresh
|
|
|
- text.tStartRefresh = tThisFlipGlobal # on global time
|
|
|
- win.timeOnFlip(text, 'tStartRefresh') # time at next scr refresh
|
|
|
- # add timestamp to datafile
|
|
|
- thisExp.timestampOnFlip(win, 'text.started')
|
|
|
- # update status
|
|
|
- text.status = STARTED
|
|
|
- text.setAutoDraw(True)
|
|
|
-
|
|
|
- # if text is active this frame...
|
|
|
- if text.status == STARTED:
|
|
|
- # update params
|
|
|
- pass
|
|
|
-
|
|
|
- # *key_resp* updates
|
|
|
- waitOnFlip = False
|
|
|
-
|
|
|
- # if key_resp is starting this frame...
|
|
|
- if key_resp.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance:
|
|
|
- # keep track of start time/frame for later
|
|
|
- key_resp.frameNStart = frameN # exact frame index
|
|
|
- key_resp.tStart = t # local t and not account for scr refresh
|
|
|
- key_resp.tStartRefresh = tThisFlipGlobal # on global time
|
|
|
- win.timeOnFlip(key_resp, 'tStartRefresh') # time at next scr refresh
|
|
|
- # add timestamp to datafile
|
|
|
- thisExp.timestampOnFlip(win, 'key_resp.started')
|
|
|
- # update status
|
|
|
- key_resp.status = STARTED
|
|
|
- # keyboard checking is just starting
|
|
|
- waitOnFlip = True
|
|
|
- win.callOnFlip(key_resp.clock.reset) # t=0 on next screen flip
|
|
|
- win.callOnFlip(key_resp.clearEvents, eventType='keyboard') # clear events on next screen flip
|
|
|
- if key_resp.status == STARTED and not waitOnFlip:
|
|
|
- theseKeys = key_resp.getKeys(keyList=['space'], ignoreKeys=["escape"], waitRelease=False)
|
|
|
- _key_resp_allKeys.extend(theseKeys)
|
|
|
- if len(_key_resp_allKeys):
|
|
|
- key_resp.keys = _key_resp_allKeys[-1].name # just the last key pressed
|
|
|
- key_resp.rt = _key_resp_allKeys[-1].rt
|
|
|
- key_resp.duration = _key_resp_allKeys[-1].duration
|
|
|
- # a response ends the routine
|
|
|
- continueRoutine = False
|
|
|
-
|
|
|
- # check for quit (typically the Esc key)
|
|
|
- if defaultKeyboard.getKeys(keyList=["escape"]):
|
|
|
- thisExp.status = FINISHED
|
|
|
- if thisExp.status == FINISHED or endExpNow:
|
|
|
- endExperiment(thisExp, inputs=inputs, win=win)
|
|
|
- return
|
|
|
-
|
|
|
- # check if all components have finished
|
|
|
- if not continueRoutine: # a component has requested a forced-end of Routine
|
|
|
- routineForceEnded = True
|
|
|
- break
|
|
|
- continueRoutine = False # will revert to True if at least one component still running
|
|
|
- for thisComponent in prepareComponents:
|
|
|
- if hasattr(thisComponent, "status") and thisComponent.status != FINISHED:
|
|
|
- continueRoutine = True
|
|
|
- break # at least one component has not yet finished
|
|
|
-
|
|
|
- # refresh the screen
|
|
|
- if continueRoutine: # don't flip if this routine is over or we'll get a blank screen
|
|
|
- win.flip()
|
|
|
-
|
|
|
- # --- Ending Routine "prepare" ---
|
|
|
- for thisComponent in prepareComponents:
|
|
|
- if hasattr(thisComponent, "setAutoDraw"):
|
|
|
- thisComponent.setAutoDraw(False)
|
|
|
- thisExp.addData('prepare.stopped', globalClock.getTime())
|
|
|
- # check responses
|
|
|
- if key_resp.keys in ['', [], None]: # No response was made
|
|
|
- key_resp.keys = None
|
|
|
- thisExp.addData('key_resp.keys',key_resp.keys)
|
|
|
- if key_resp.keys != None: # we had a response
|
|
|
- thisExp.addData('key_resp.rt', key_resp.rt)
|
|
|
- thisExp.addData('key_resp.duration', key_resp.duration)
|
|
|
- thisExp.nextEntry()
|
|
|
- # the Routine "prepare" was not non-slip safe, so reset the non-slip timer
|
|
|
- routineTimer.reset()
|
|
|
-
|
|
|
- # set up handler to look after randomisation of conditions etc
|
|
|
- trials = data.TrialHandler(nReps=args.n_trials, method='random',
|
|
|
- extraInfo=expInfo, originPath=-1,
|
|
|
- trialList=[None],
|
|
|
- seed=None, name='trials')
|
|
|
- thisExp.addLoop(trials) # add the loop to the experiment
|
|
|
- thisTrial = trials.trialList[0] # so we can initialise stimuli with some values
|
|
|
- # abbreviate parameter names if possible (e.g. rgb = thisTrial.rgb)
|
|
|
- if thisTrial != None:
|
|
|
- for paramName in thisTrial:
|
|
|
- globals()[paramName] = thisTrial[paramName]
|
|
|
-
|
|
|
- for thisTrial in trials:
|
|
|
- currentLoop = trials
|
|
|
- thisExp.timestampOnFlip(win, 'thisRow.t')
|
|
|
- # pause experiment here if requested
|
|
|
- if thisExp.status == PAUSED:
|
|
|
- pauseExperiment(
|
|
|
- thisExp=thisExp,
|
|
|
- inputs=inputs,
|
|
|
- win=win,
|
|
|
- timers=[routineTimer],
|
|
|
- playbackComponents=[]
|
|
|
- )
|
|
|
- # abbreviate parameter names if possible (e.g. rgb = thisTrial.rgb)
|
|
|
- if thisTrial != None:
|
|
|
- for paramName in thisTrial:
|
|
|
- globals()[paramName] = thisTrial[paramName]
|
|
|
-
|
|
|
- # --- Prepare to start Routine "ready" ---
|
|
|
- continueRoutine = True
|
|
|
- # update component parameters for each repeat
|
|
|
- thisExp.addData('ready.started', globalClock.getTime())
|
|
|
- # keep track of which components have finished
|
|
|
- readyComponents = [ready_text]
|
|
|
- for thisComponent in readyComponents:
|
|
|
- thisComponent.tStart = None
|
|
|
- thisComponent.tStop = None
|
|
|
- thisComponent.tStartRefresh = None
|
|
|
- thisComponent.tStopRefresh = None
|
|
|
- if hasattr(thisComponent, 'status'):
|
|
|
- thisComponent.status = NOT_STARTED
|
|
|
- # reset timers
|
|
|
- t = 0
|
|
|
- _timeToFirstFrame = win.getFutureFlipTime(clock="now")
|
|
|
- frameN = -1
|
|
|
-
|
|
|
- # --- Run Routine "ready" ---
|
|
|
- routineForceEnded = not continueRoutine
|
|
|
- while continueRoutine and routineTimer.getTime() < 1.5:
|
|
|
- # get current time
|
|
|
- t = routineTimer.getTime()
|
|
|
- tThisFlip = win.getFutureFlipTime(clock=routineTimer)
|
|
|
- tThisFlipGlobal = win.getFutureFlipTime(clock=None)
|
|
|
- frameN = frameN + 1 # number of completed frames (so 0 is the first frame)
|
|
|
- # update/draw components on each frame
|
|
|
-
|
|
|
- # *ready_text* updates
|
|
|
-
|
|
|
- # if ready_text is starting this frame...
|
|
|
- if ready_text.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance:
|
|
|
- # keep track of start time/frame for later
|
|
|
- ready_text.frameNStart = frameN # exact frame index
|
|
|
- ready_text.tStart = t # local t and not account for scr refresh
|
|
|
- ready_text.tStartRefresh = tThisFlipGlobal # on global time
|
|
|
- win.timeOnFlip(ready_text, 'tStartRefresh') # time at next scr refresh
|
|
|
- # add timestamp to datafile
|
|
|
- thisExp.timestampOnFlip(win, 'ready_text.started')
|
|
|
- # update status
|
|
|
- ready_text.status = STARTED
|
|
|
- ready_text.setAutoDraw(True)
|
|
|
-
|
|
|
- # if ready_text is active this frame...
|
|
|
- if ready_text.status == STARTED:
|
|
|
- # update params
|
|
|
- pass
|
|
|
-
|
|
|
- # if ready_text is stopping this frame...
|
|
|
- if ready_text.status == STARTED:
|
|
|
- # is it time to stop? (based on global clock, using actual start)
|
|
|
- if tThisFlipGlobal > ready_text.tStartRefresh + 1.5-frameTolerance:
|
|
|
- # keep track of stop time/frame for later
|
|
|
- ready_text.tStop = t # not accounting for scr refresh
|
|
|
- ready_text.frameNStop = frameN # exact frame index
|
|
|
- # add timestamp to datafile
|
|
|
- thisExp.timestampOnFlip(win, 'ready_text.stopped')
|
|
|
- # update status
|
|
|
- ready_text.status = FINISHED
|
|
|
- ready_text.setAutoDraw(False)
|
|
|
-
|
|
|
- # check for quit (typically the Esc key)
|
|
|
- if defaultKeyboard.getKeys(keyList=["escape"]):
|
|
|
- thisExp.status = FINISHED
|
|
|
- if thisExp.status == FINISHED or endExpNow:
|
|
|
- endExperiment(thisExp, inputs=inputs, win=win)
|
|
|
- return
|
|
|
-
|
|
|
- # check if all components have finished
|
|
|
- if not continueRoutine: # a component has requested a forced-end of Routine
|
|
|
- routineForceEnded = True
|
|
|
- break
|
|
|
- continueRoutine = False # will revert to True if at least one component still running
|
|
|
- for thisComponent in readyComponents:
|
|
|
- if hasattr(thisComponent, "status") and thisComponent.status != FINISHED:
|
|
|
- continueRoutine = True
|
|
|
- break # at least one component has not yet finished
|
|
|
-
|
|
|
- # refresh the screen
|
|
|
- if continueRoutine: # don't flip if this routine is over or we'll get a blank screen
|
|
|
- win.flip()
|
|
|
-
|
|
|
- # --- Ending Routine "ready" ---
|
|
|
- for thisComponent in readyComponents:
|
|
|
- if hasattr(thisComponent, "setAutoDraw"):
|
|
|
- thisComponent.setAutoDraw(False)
|
|
|
- thisExp.addData('ready.stopped', globalClock.getTime())
|
|
|
- # using non-slip timing so subtract the expected duration of this Routine (unless ended on request)
|
|
|
- if routineForceEnded:
|
|
|
- routineTimer.reset()
|
|
|
- else:
|
|
|
- routineTimer.addTime(-1.500000)
|
|
|
-
|
|
|
- # --- Prepare to start Routine "extend" ---
|
|
|
- continueRoutine = True
|
|
|
- # update component parameters for each repeat
|
|
|
- thisExp.addData('extend.started', globalClock.getTime())
|
|
|
- attention.setSound('static/audios/ding.wav', secs=1.0, hamming=True)
|
|
|
- attention.setVolume(1.0, log=False)
|
|
|
- attention.seek(0)
|
|
|
- # Run 'Begin Routine' code from code
|
|
|
- i = 0
|
|
|
-
|
|
|
- extend_wav.setSound('static/audios/extend.wav', secs=2, hamming=True)
|
|
|
- extend_wav.setVolume(1.0, log=False)
|
|
|
- extend_wav.seek(0)
|
|
|
- # keep track of which components have finished
|
|
|
- extendComponents = [extend_img, attention, extend_wav]
|
|
|
- for thisComponent in extendComponents:
|
|
|
- thisComponent.tStart = None
|
|
|
- thisComponent.tStop = None
|
|
|
- thisComponent.tStartRefresh = None
|
|
|
- thisComponent.tStopRefresh = None
|
|
|
- if hasattr(thisComponent, 'status'):
|
|
|
- thisComponent.status = NOT_STARTED
|
|
|
- # reset timers
|
|
|
- t = 0
|
|
|
- _timeToFirstFrame = win.getFutureFlipTime(clock="now")
|
|
|
- frameN = -1
|
|
|
-
|
|
|
- # --- Run Routine "extend" ---
|
|
|
- routineForceEnded = not continueRoutine
|
|
|
- while continueRoutine and routineTimer.getTime() < 7.0:
|
|
|
- # get current time
|
|
|
- t = routineTimer.getTime()
|
|
|
- tThisFlip = win.getFutureFlipTime(clock=routineTimer)
|
|
|
- tThisFlipGlobal = win.getFutureFlipTime(clock=None)
|
|
|
- frameN = frameN + 1 # number of completed frames (so 0 is the first frame)
|
|
|
- # update/draw components on each frame
|
|
|
-
|
|
|
- # *extend_img* updates
|
|
|
-
|
|
|
- # if extend_img is starting this frame...
|
|
|
- if extend_img.status == NOT_STARTED and tThisFlip >= 1-frameTolerance:
|
|
|
- # keep track of start time/frame for later
|
|
|
- extend_img.frameNStart = frameN # exact frame index
|
|
|
- extend_img.tStart = t # local t and not account for scr refresh
|
|
|
- extend_img.tStartRefresh = tThisFlipGlobal # on global time
|
|
|
- win.timeOnFlip(extend_img, 'tStartRefresh') # time at next scr refresh
|
|
|
- # add timestamp to datafile
|
|
|
- thisExp.timestampOnFlip(win, 'extend_img.started')
|
|
|
- # update status
|
|
|
- extend_img.status = STARTED
|
|
|
- extend_img.setAutoDraw(True)
|
|
|
-
|
|
|
- # if extend_img is active this frame...
|
|
|
- if extend_img.status == STARTED:
|
|
|
- # update params
|
|
|
- pass
|
|
|
-
|
|
|
- # if extend_img is stopping this frame...
|
|
|
- if extend_img.status == STARTED:
|
|
|
- # is it time to stop? (based on global clock, using actual start)
|
|
|
- if tThisFlipGlobal > extend_img.tStartRefresh + 6-frameTolerance:
|
|
|
- # keep track of stop time/frame for later
|
|
|
- extend_img.tStop = t # not accounting for scr refresh
|
|
|
- extend_img.frameNStop = frameN # exact frame index
|
|
|
- # add timestamp to datafile
|
|
|
- thisExp.timestampOnFlip(win, 'extend_img.stopped')
|
|
|
- # update status
|
|
|
- extend_img.status = FINISHED
|
|
|
- extend_img.setAutoDraw(False)
|
|
|
-
|
|
|
- # if attention is starting this frame...
|
|
|
- if attention.status == NOT_STARTED and tThisFlip >= 1-frameTolerance:
|
|
|
- # keep track of start time/frame for later
|
|
|
- attention.frameNStart = frameN # exact frame index
|
|
|
- attention.tStart = t # local t and not account for scr refresh
|
|
|
- attention.tStartRefresh = tThisFlipGlobal # on global time
|
|
|
- # add timestamp to datafile
|
|
|
- thisExp.addData('attention.started', tThisFlipGlobal)
|
|
|
- # update status
|
|
|
- attention.status = STARTED
|
|
|
- attention.play(when=win) # sync with win flip
|
|
|
-
|
|
|
- # if attention is stopping this frame...
|
|
|
- if attention.status == STARTED:
|
|
|
- # is it time to stop? (based on global clock, using actual start)
|
|
|
- if tThisFlipGlobal > attention.tStartRefresh + 1.0-frameTolerance:
|
|
|
- # keep track of stop time/frame for later
|
|
|
- attention.tStop = t # not accounting for scr refresh
|
|
|
- attention.frameNStop = frameN # exact frame index
|
|
|
- # add timestamp to datafile
|
|
|
- thisExp.timestampOnFlip(win, 'attention.stopped')
|
|
|
- # update status
|
|
|
- attention.status = FINISHED
|
|
|
- attention.stop()
|
|
|
- # update attention status according to whether it's playing
|
|
|
- if attention.isPlaying:
|
|
|
- attention.status = STARTED
|
|
|
- elif attention.isFinished:
|
|
|
- attention.status = FINISHED
|
|
|
- # Run 'Each Frame' code from code
|
|
|
-
|
|
|
- if i== 119:
|
|
|
- hand_device.start('extend')
|
|
|
- # send trigger
|
|
|
- current_true_label = settings.FINGERMODEL_IDS['extend']
|
|
|
- win.callOnFlip(trigger.send_trigger, current_true_label)
|
|
|
-
|
|
|
- i += 1
|
|
|
- # 每轮开始前空白等待1s + 反应时1s + 新版extend时间4.5s + 0.5s裕量 = 7s
|
|
|
-
|
|
|
- # if extend_wav is starting this frame...
|
|
|
- if extend_wav.status == NOT_STARTED and tThisFlip >= 1.8-frameTolerance:
|
|
|
- # keep track of start time/frame for later
|
|
|
- extend_wav.frameNStart = frameN # exact frame index
|
|
|
- extend_wav.tStart = t # local t and not account for scr refresh
|
|
|
- extend_wav.tStartRefresh = tThisFlipGlobal # on global time
|
|
|
- # add timestamp to datafile
|
|
|
- thisExp.addData('extend_wav.started', tThisFlipGlobal)
|
|
|
- # update status
|
|
|
- extend_wav.status = STARTED
|
|
|
- extend_wav.play(when=win) # sync with win flip
|
|
|
-
|
|
|
- # if extend_wav is stopping this frame...
|
|
|
- if extend_wav.status == STARTED:
|
|
|
- # is it time to stop? (based on global clock, using actual start)
|
|
|
- if tThisFlipGlobal > extend_wav.tStartRefresh + 2-frameTolerance:
|
|
|
- # keep track of stop time/frame for later
|
|
|
- extend_wav.tStop = t # not accounting for scr refresh
|
|
|
- extend_wav.frameNStop = frameN # exact frame index
|
|
|
- # add timestamp to datafile
|
|
|
- thisExp.timestampOnFlip(win, 'extend_wav.stopped')
|
|
|
- # update status
|
|
|
- extend_wav.status = FINISHED
|
|
|
- extend_wav.stop()
|
|
|
- # update extend_wav status according to whether it's playing
|
|
|
- if extend_wav.isPlaying:
|
|
|
- extend_wav.status = STARTED
|
|
|
- elif extend_wav.isFinished:
|
|
|
- extend_wav.status = FINISHED
|
|
|
-
|
|
|
- # check for quit (typically the Esc key)
|
|
|
- if defaultKeyboard.getKeys(keyList=["escape"]):
|
|
|
- thisExp.status = FINISHED
|
|
|
- if thisExp.status == FINISHED or endExpNow:
|
|
|
- endExperiment(thisExp, inputs=inputs, win=win)
|
|
|
- return
|
|
|
-
|
|
|
- # check if all components have finished
|
|
|
- if not continueRoutine: # a component has requested a forced-end of Routine
|
|
|
- routineForceEnded = True
|
|
|
- break
|
|
|
- continueRoutine = False # will revert to True if at least one component still running
|
|
|
- for thisComponent in extendComponents:
|
|
|
- if hasattr(thisComponent, "status") and thisComponent.status != FINISHED:
|
|
|
- continueRoutine = True
|
|
|
- break # at least one component has not yet finished
|
|
|
-
|
|
|
- # refresh the screen
|
|
|
- if continueRoutine: # don't flip if this routine is over or we'll get a blank screen
|
|
|
- win.flip()
|
|
|
-
|
|
|
- # --- Ending Routine "extend" ---
|
|
|
- for thisComponent in extendComponents:
|
|
|
- if hasattr(thisComponent, "setAutoDraw"):
|
|
|
- thisComponent.setAutoDraw(False)
|
|
|
- thisExp.addData('extend.stopped', globalClock.getTime())
|
|
|
- attention.pause() # ensure sound has stopped at end of Routine
|
|
|
- extend_wav.pause() # ensure sound has stopped at end of Routine
|
|
|
- # using non-slip timing so subtract the expected duration of this Routine (unless ended on request)
|
|
|
- if routineForceEnded:
|
|
|
- routineTimer.reset()
|
|
|
- else:
|
|
|
- routineTimer.addTime(-7.000000)
|
|
|
-
|
|
|
- # --- Prepare to start Routine "flex" ---
|
|
|
- continueRoutine = True
|
|
|
- # update component parameters for each repeat
|
|
|
- thisExp.addData('flex.started', globalClock.getTime())
|
|
|
- # Run 'Begin Routine' code from code_2
|
|
|
- i = 0
|
|
|
-
|
|
|
- flex_wav.setSound('static/audios/flex.wav', secs=2, hamming=True)
|
|
|
- flex_wav.setVolume(1.0, log=False)
|
|
|
- flex_wav.seek(0)
|
|
|
- # keep track of which components have finished
|
|
|
- flexComponents = [flex_img, flex_wav]
|
|
|
- for thisComponent in flexComponents:
|
|
|
- thisComponent.tStart = None
|
|
|
- thisComponent.tStop = None
|
|
|
- thisComponent.tStartRefresh = None
|
|
|
- thisComponent.tStopRefresh = None
|
|
|
- if hasattr(thisComponent, 'status'):
|
|
|
- thisComponent.status = NOT_STARTED
|
|
|
- # reset timers
|
|
|
- t = 0
|
|
|
- _timeToFirstFrame = win.getFutureFlipTime(clock="now")
|
|
|
- frameN = -1
|
|
|
-
|
|
|
- # --- Run Routine "flex" ---
|
|
|
- routineForceEnded = not continueRoutine
|
|
|
- while continueRoutine and routineTimer.getTime() < 6.0:
|
|
|
- # get current time
|
|
|
- t = routineTimer.getTime()
|
|
|
- tThisFlip = win.getFutureFlipTime(clock=routineTimer)
|
|
|
- tThisFlipGlobal = win.getFutureFlipTime(clock=None)
|
|
|
- frameN = frameN + 1 # number of completed frames (so 0 is the first frame)
|
|
|
- # update/draw components on each frame
|
|
|
-
|
|
|
- # *flex_img* updates
|
|
|
-
|
|
|
- # if flex_img is starting this frame...
|
|
|
- if flex_img.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance:
|
|
|
- # keep track of start time/frame for later
|
|
|
- flex_img.frameNStart = frameN # exact frame index
|
|
|
- flex_img.tStart = t # local t and not account for scr refresh
|
|
|
- flex_img.tStartRefresh = tThisFlipGlobal # on global time
|
|
|
- win.timeOnFlip(flex_img, 'tStartRefresh') # time at next scr refresh
|
|
|
- # add timestamp to datafile
|
|
|
- thisExp.timestampOnFlip(win, 'flex_img.started')
|
|
|
- # update status
|
|
|
- flex_img.status = STARTED
|
|
|
- flex_img.setAutoDraw(True)
|
|
|
-
|
|
|
- # if flex_img is active this frame...
|
|
|
- if flex_img.status == STARTED:
|
|
|
- # update params
|
|
|
- pass
|
|
|
-
|
|
|
- # if flex_img is stopping this frame...
|
|
|
- if flex_img.status == STARTED:
|
|
|
- # is it time to stop? (based on global clock, using actual start)
|
|
|
- if tThisFlipGlobal > flex_img.tStartRefresh + 6-frameTolerance:
|
|
|
- # keep track of stop time/frame for later
|
|
|
- flex_img.tStop = t # not accounting for scr refresh
|
|
|
- flex_img.frameNStop = frameN # exact frame index
|
|
|
- # add timestamp to datafile
|
|
|
- thisExp.timestampOnFlip(win, 'flex_img.stopped')
|
|
|
- # update status
|
|
|
- flex_img.status = FINISHED
|
|
|
- flex_img.setAutoDraw(False)
|
|
|
- # Run 'Each Frame' code from code_2
|
|
|
- if i == 59:
|
|
|
- hand_device.start(args.finger_model)
|
|
|
- # trigger
|
|
|
- current_true_label = settings.FINGERMODEL_IDS[args.finger_model]
|
|
|
- # win.callOnFlip(trigger.send_trigger, current_true_label)
|
|
|
-
|
|
|
- i += 1
|
|
|
-
|
|
|
- # 反应时1s+新版气动手flex时间4.5s + 0.5s裕量 = 6s
|
|
|
-
|
|
|
- # if flex_wav is starting this frame...
|
|
|
- if flex_wav.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance:
|
|
|
- # keep track of start time/frame for later
|
|
|
- flex_wav.frameNStart = frameN # exact frame index
|
|
|
- flex_wav.tStart = t # local t and not account for scr refresh
|
|
|
- flex_wav.tStartRefresh = tThisFlipGlobal # on global time
|
|
|
- # add timestamp to datafile
|
|
|
- thisExp.addData('flex_wav.started', tThisFlipGlobal)
|
|
|
- # update status
|
|
|
- flex_wav.status = STARTED
|
|
|
- flex_wav.play(when=win) # sync with win flip
|
|
|
-
|
|
|
- # if flex_wav is stopping this frame...
|
|
|
- if flex_wav.status == STARTED:
|
|
|
- # is it time to stop? (based on global clock, using actual start)
|
|
|
- if tThisFlipGlobal > flex_wav.tStartRefresh + 2-frameTolerance:
|
|
|
- # keep track of stop time/frame for later
|
|
|
- flex_wav.tStop = t # not accounting for scr refresh
|
|
|
- flex_wav.frameNStop = frameN # exact frame index
|
|
|
- # add timestamp to datafile
|
|
|
- thisExp.timestampOnFlip(win, 'flex_wav.stopped')
|
|
|
- # update status
|
|
|
- flex_wav.status = FINISHED
|
|
|
- flex_wav.stop()
|
|
|
- # update flex_wav status according to whether it's playing
|
|
|
- if flex_wav.isPlaying:
|
|
|
- flex_wav.status = STARTED
|
|
|
- elif flex_wav.isFinished:
|
|
|
- flex_wav.status = FINISHED
|
|
|
-
|
|
|
- # check for quit (typically the Esc key)
|
|
|
- if defaultKeyboard.getKeys(keyList=["escape"]):
|
|
|
- thisExp.status = FINISHED
|
|
|
- if thisExp.status == FINISHED or endExpNow:
|
|
|
- endExperiment(thisExp, inputs=inputs, win=win)
|
|
|
- return
|
|
|
-
|
|
|
- # check if all components have finished
|
|
|
- if not continueRoutine: # a component has requested a forced-end of Routine
|
|
|
- routineForceEnded = True
|
|
|
- break
|
|
|
- continueRoutine = False # will revert to True if at least one component still running
|
|
|
- for thisComponent in flexComponents:
|
|
|
- if hasattr(thisComponent, "status") and thisComponent.status != FINISHED:
|
|
|
- continueRoutine = True
|
|
|
- break # at least one component has not yet finished
|
|
|
-
|
|
|
- # refresh the screen
|
|
|
- if continueRoutine: # don't flip if this routine is over or we'll get a blank screen
|
|
|
- win.flip()
|
|
|
-
|
|
|
- # --- Ending Routine "flex" ---
|
|
|
- for thisComponent in flexComponents:
|
|
|
- if hasattr(thisComponent, "setAutoDraw"):
|
|
|
- thisComponent.setAutoDraw(False)
|
|
|
- thisExp.addData('flex.stopped', globalClock.getTime())
|
|
|
- flex_wav.pause() # ensure sound has stopped at end of Routine
|
|
|
- # using non-slip timing so subtract the expected duration of this Routine (unless ended on request)
|
|
|
- if routineForceEnded:
|
|
|
- routineTimer.reset()
|
|
|
- else:
|
|
|
- routineTimer.addTime(-6.000000)
|
|
|
-
|
|
|
- # --- Prepare to start Routine "hold" ---
|
|
|
- continueRoutine = True
|
|
|
- # update component parameters for each repeat
|
|
|
- thisExp.addData('hold.started', globalClock.getTime())
|
|
|
- # Run 'Begin Routine' code from code_3
|
|
|
- win.callOnFlip(trigger.send_trigger, settings.FINGERMODEL_IDS['hold'])
|
|
|
- hold_wav.setSound('static/audios/hold.wav', secs=2, hamming=True)
|
|
|
- hold_wav.setVolume(1.0, log=False)
|
|
|
- hold_wav.seek(0)
|
|
|
- # keep track of which components have finished
|
|
|
- holdComponents = [hold_img, hold_wav]
|
|
|
- for thisComponent in holdComponents:
|
|
|
- thisComponent.tStart = None
|
|
|
- thisComponent.tStop = None
|
|
|
- thisComponent.tStartRefresh = None
|
|
|
- thisComponent.tStopRefresh = None
|
|
|
- if hasattr(thisComponent, 'status'):
|
|
|
- thisComponent.status = NOT_STARTED
|
|
|
- # reset timers
|
|
|
- t = 0
|
|
|
- _timeToFirstFrame = win.getFutureFlipTime(clock="now")
|
|
|
- frameN = -1
|
|
|
-
|
|
|
- # --- Run Routine "hold" ---
|
|
|
- routineForceEnded = not continueRoutine
|
|
|
- while continueRoutine and routineTimer.getTime() < 5.0:
|
|
|
- # get current time
|
|
|
- t = routineTimer.getTime()
|
|
|
- tThisFlip = win.getFutureFlipTime(clock=routineTimer)
|
|
|
- tThisFlipGlobal = win.getFutureFlipTime(clock=None)
|
|
|
- frameN = frameN + 1 # number of completed frames (so 0 is the first frame)
|
|
|
- # update/draw components on each frame
|
|
|
-
|
|
|
- # *hold_img* updates
|
|
|
-
|
|
|
- # if hold_img is starting this frame...
|
|
|
- if hold_img.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance:
|
|
|
- # keep track of start time/frame for later
|
|
|
- hold_img.frameNStart = frameN # exact frame index
|
|
|
- hold_img.tStart = t # local t and not account for scr refresh
|
|
|
- hold_img.tStartRefresh = tThisFlipGlobal # on global time
|
|
|
- win.timeOnFlip(hold_img, 'tStartRefresh') # time at next scr refresh
|
|
|
- # add timestamp to datafile
|
|
|
- thisExp.timestampOnFlip(win, 'hold_img.started')
|
|
|
- # update status
|
|
|
- hold_img.status = STARTED
|
|
|
- hold_img.setAutoDraw(True)
|
|
|
-
|
|
|
- # if hold_img is active this frame...
|
|
|
- if hold_img.status == STARTED:
|
|
|
- # update params
|
|
|
- pass
|
|
|
-
|
|
|
- # if hold_img is stopping this frame...
|
|
|
- if hold_img.status == STARTED:
|
|
|
- # is it time to stop? (based on global clock, using actual start)
|
|
|
- if tThisFlipGlobal > hold_img.tStartRefresh + 5-frameTolerance:
|
|
|
- # keep track of stop time/frame for later
|
|
|
- hold_img.tStop = t # not accounting for scr refresh
|
|
|
- hold_img.frameNStop = frameN # exact frame index
|
|
|
- # add timestamp to datafile
|
|
|
- thisExp.timestampOnFlip(win, 'hold_img.stopped')
|
|
|
- # update status
|
|
|
- hold_img.status = FINISHED
|
|
|
- hold_img.setAutoDraw(False)
|
|
|
-
|
|
|
- # if hold_wav is starting this frame...
|
|
|
- if hold_wav.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance:
|
|
|
- # keep track of start time/frame for later
|
|
|
- hold_wav.frameNStart = frameN # exact frame index
|
|
|
- hold_wav.tStart = t # local t and not account for scr refresh
|
|
|
- hold_wav.tStartRefresh = tThisFlipGlobal # on global time
|
|
|
- # add timestamp to datafile
|
|
|
- thisExp.addData('hold_wav.started', tThisFlipGlobal)
|
|
|
- # update status
|
|
|
- hold_wav.status = STARTED
|
|
|
- hold_wav.play(when=win) # sync with win flip
|
|
|
-
|
|
|
- # if hold_wav is stopping this frame...
|
|
|
- if hold_wav.status == STARTED:
|
|
|
- # is it time to stop? (based on global clock, using actual start)
|
|
|
- if tThisFlipGlobal > hold_wav.tStartRefresh + 2-frameTolerance:
|
|
|
- # keep track of stop time/frame for later
|
|
|
- hold_wav.tStop = t # not accounting for scr refresh
|
|
|
- hold_wav.frameNStop = frameN # exact frame index
|
|
|
- # add timestamp to datafile
|
|
|
- thisExp.timestampOnFlip(win, 'hold_wav.stopped')
|
|
|
- # update status
|
|
|
- hold_wav.status = FINISHED
|
|
|
- hold_wav.stop()
|
|
|
- # update hold_wav status according to whether it's playing
|
|
|
- if hold_wav.isPlaying:
|
|
|
- hold_wav.status = STARTED
|
|
|
- elif hold_wav.isFinished:
|
|
|
- hold_wav.status = FINISHED
|
|
|
-
|
|
|
- # check for quit (typically the Esc key)
|
|
|
- if defaultKeyboard.getKeys(keyList=["escape"]):
|
|
|
- thisExp.status = FINISHED
|
|
|
- if thisExp.status == FINISHED or endExpNow:
|
|
|
- endExperiment(thisExp, inputs=inputs, win=win)
|
|
|
- return
|
|
|
-
|
|
|
- # check if all components have finished
|
|
|
- if not continueRoutine: # a component has requested a forced-end of Routine
|
|
|
- routineForceEnded = True
|
|
|
- break
|
|
|
- continueRoutine = False # will revert to True if at least one component still running
|
|
|
- for thisComponent in holdComponents:
|
|
|
- if hasattr(thisComponent, "status") and thisComponent.status != FINISHED:
|
|
|
- continueRoutine = True
|
|
|
- break # at least one component has not yet finished
|
|
|
-
|
|
|
- # refresh the screen
|
|
|
- if continueRoutine: # don't flip if this routine is over or we'll get a blank screen
|
|
|
- win.flip()
|
|
|
-
|
|
|
- # --- Ending Routine "hold" ---
|
|
|
- for thisComponent in holdComponents:
|
|
|
- if hasattr(thisComponent, "setAutoDraw"):
|
|
|
- thisComponent.setAutoDraw(False)
|
|
|
- thisExp.addData('hold.stopped', globalClock.getTime())
|
|
|
- hold_wav.pause() # ensure sound has stopped at end of Routine
|
|
|
- # using non-slip timing so subtract the expected duration of this Routine (unless ended on request)
|
|
|
- if routineForceEnded:
|
|
|
- routineTimer.reset()
|
|
|
- else:
|
|
|
- routineTimer.addTime(-5.000000)
|
|
|
-
|
|
|
- # --- Prepare to start Routine "rest" ---
|
|
|
- continueRoutine = True
|
|
|
- # update component parameters for each repeat
|
|
|
- thisExp.addData('rest.started', globalClock.getTime())
|
|
|
- # Run 'Begin Routine' code from code_4
|
|
|
- i = 0
|
|
|
- rest_wav1.setSound('static/audios/ding.wav', secs=1.0, hamming=True)
|
|
|
- rest_wav1.setVolume(1.0, log=False)
|
|
|
- rest_wav1.seek(0)
|
|
|
- rest_wav2.setSound('static/audios/rest.wav', secs=2, hamming=True)
|
|
|
- rest_wav2.setVolume(1.0, log=False)
|
|
|
- rest_wav2.seek(0)
|
|
|
- # keep track of which components have finished
|
|
|
- restComponents = [rest_img, rest_wav1, rest_wav2]
|
|
|
- for thisComponent in restComponents:
|
|
|
- thisComponent.tStart = None
|
|
|
- thisComponent.tStop = None
|
|
|
- thisComponent.tStartRefresh = None
|
|
|
- thisComponent.tStopRefresh = None
|
|
|
- if hasattr(thisComponent, 'status'):
|
|
|
- thisComponent.status = NOT_STARTED
|
|
|
- # reset timers
|
|
|
- t = 0
|
|
|
- _timeToFirstFrame = win.getFutureFlipTime(clock="now")
|
|
|
- frameN = -1
|
|
|
-
|
|
|
- # --- Run Routine "rest" ---
|
|
|
- routineForceEnded = not continueRoutine
|
|
|
- while continueRoutine and routineTimer.getTime() < 6.0:
|
|
|
- # get current time
|
|
|
- t = routineTimer.getTime()
|
|
|
- tThisFlip = win.getFutureFlipTime(clock=routineTimer)
|
|
|
- tThisFlipGlobal = win.getFutureFlipTime(clock=None)
|
|
|
- frameN = frameN + 1 # number of completed frames (so 0 is the first frame)
|
|
|
- # update/draw components on each frame
|
|
|
-
|
|
|
- # *rest_img* updates
|
|
|
-
|
|
|
- # if rest_img is starting this frame...
|
|
|
- if rest_img.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance:
|
|
|
- # keep track of start time/frame for later
|
|
|
- rest_img.frameNStart = frameN # exact frame index
|
|
|
- rest_img.tStart = t # local t and not account for scr refresh
|
|
|
- rest_img.tStartRefresh = tThisFlipGlobal # on global time
|
|
|
- win.timeOnFlip(rest_img, 'tStartRefresh') # time at next scr refresh
|
|
|
- # add timestamp to datafile
|
|
|
- thisExp.timestampOnFlip(win, 'rest_img.started')
|
|
|
- # update status
|
|
|
- rest_img.status = STARTED
|
|
|
- rest_img.setAutoDraw(True)
|
|
|
-
|
|
|
- # if rest_img is active this frame...
|
|
|
- if rest_img.status == STARTED:
|
|
|
- # update params
|
|
|
- pass
|
|
|
-
|
|
|
- # if rest_img is stopping this frame...
|
|
|
- if rest_img.status == STARTED:
|
|
|
- # is it time to stop? (based on global clock, using actual start)
|
|
|
- if tThisFlipGlobal > rest_img.tStartRefresh + 6-frameTolerance:
|
|
|
- # keep track of stop time/frame for later
|
|
|
- rest_img.tStop = t # not accounting for scr refresh
|
|
|
- rest_img.frameNStop = frameN # exact frame index
|
|
|
- # add timestamp to datafile
|
|
|
- thisExp.timestampOnFlip(win, 'rest_img.stopped')
|
|
|
- # update status
|
|
|
- rest_img.status = FINISHED
|
|
|
- rest_img.setAutoDraw(False)
|
|
|
- # Run 'Each Frame' code from code_4
|
|
|
- if i== 59:
|
|
|
- hand_device.start('rest')
|
|
|
- # trigger
|
|
|
- win.callOnFlip(trigger.send_trigger, settings.FINGERMODEL_IDS['rest'])
|
|
|
-
|
|
|
- i += 1
|
|
|
-
|
|
|
- # if rest_wav1 is starting this frame...
|
|
|
- if rest_wav1.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance:
|
|
|
- # keep track of start time/frame for later
|
|
|
- rest_wav1.frameNStart = frameN # exact frame index
|
|
|
- rest_wav1.tStart = t # local t and not account for scr refresh
|
|
|
- rest_wav1.tStartRefresh = tThisFlipGlobal # on global time
|
|
|
- # add timestamp to datafile
|
|
|
- thisExp.addData('rest_wav1.started', tThisFlipGlobal)
|
|
|
- # update status
|
|
|
- rest_wav1.status = STARTED
|
|
|
- rest_wav1.play(when=win) # sync with win flip
|
|
|
-
|
|
|
- # if rest_wav1 is stopping this frame...
|
|
|
- if rest_wav1.status == STARTED:
|
|
|
- # is it time to stop? (based on global clock, using actual start)
|
|
|
- if tThisFlipGlobal > rest_wav1.tStartRefresh + 1.0-frameTolerance:
|
|
|
- # keep track of stop time/frame for later
|
|
|
- rest_wav1.tStop = t # not accounting for scr refresh
|
|
|
- rest_wav1.frameNStop = frameN # exact frame index
|
|
|
- # add timestamp to datafile
|
|
|
- thisExp.timestampOnFlip(win, 'rest_wav1.stopped')
|
|
|
- # update status
|
|
|
- rest_wav1.status = FINISHED
|
|
|
- rest_wav1.stop()
|
|
|
- # update rest_wav1 status according to whether it's playing
|
|
|
- if rest_wav1.isPlaying:
|
|
|
- rest_wav1.status = STARTED
|
|
|
- elif rest_wav1.isFinished:
|
|
|
- rest_wav1.status = FINISHED
|
|
|
-
|
|
|
- # if rest_wav2 is starting this frame...
|
|
|
- if rest_wav2.status == NOT_STARTED and tThisFlip >= 0.8-frameTolerance:
|
|
|
- # keep track of start time/frame for later
|
|
|
- rest_wav2.frameNStart = frameN # exact frame index
|
|
|
- rest_wav2.tStart = t # local t and not account for scr refresh
|
|
|
- rest_wav2.tStartRefresh = tThisFlipGlobal # on global time
|
|
|
- # add timestamp to datafile
|
|
|
- thisExp.addData('rest_wav2.started', tThisFlipGlobal)
|
|
|
- # update status
|
|
|
- rest_wav2.status = STARTED
|
|
|
- rest_wav2.play(when=win) # sync with win flip
|
|
|
-
|
|
|
- # if rest_wav2 is stopping this frame...
|
|
|
- if rest_wav2.status == STARTED:
|
|
|
- # is it time to stop? (based on global clock, using actual start)
|
|
|
- if tThisFlipGlobal > rest_wav2.tStartRefresh + 2-frameTolerance:
|
|
|
- # keep track of stop time/frame for later
|
|
|
- rest_wav2.tStop = t # not accounting for scr refresh
|
|
|
- rest_wav2.frameNStop = frameN # exact frame index
|
|
|
- # add timestamp to datafile
|
|
|
- thisExp.timestampOnFlip(win, 'rest_wav2.stopped')
|
|
|
- # update status
|
|
|
- rest_wav2.status = FINISHED
|
|
|
- rest_wav2.stop()
|
|
|
- # update rest_wav2 status according to whether it's playing
|
|
|
- if rest_wav2.isPlaying:
|
|
|
- rest_wav2.status = STARTED
|
|
|
- elif rest_wav2.isFinished:
|
|
|
- rest_wav2.status = FINISHED
|
|
|
-
|
|
|
- # check for quit (typically the Esc key)
|
|
|
- if defaultKeyboard.getKeys(keyList=["escape"]):
|
|
|
- thisExp.status = FINISHED
|
|
|
- if thisExp.status == FINISHED or endExpNow:
|
|
|
- endExperiment(thisExp, inputs=inputs, win=win)
|
|
|
- return
|
|
|
-
|
|
|
- # check if all components have finished
|
|
|
- if not continueRoutine: # a component has requested a forced-end of Routine
|
|
|
- routineForceEnded = True
|
|
|
- break
|
|
|
- continueRoutine = False # will revert to True if at least one component still running
|
|
|
- for thisComponent in restComponents:
|
|
|
- if hasattr(thisComponent, "status") and thisComponent.status != FINISHED:
|
|
|
- continueRoutine = True
|
|
|
- break # at least one component has not yet finished
|
|
|
-
|
|
|
- # refresh the screen
|
|
|
- if continueRoutine: # don't flip if this routine is over or we'll get a blank screen
|
|
|
- win.flip()
|
|
|
-
|
|
|
- # --- Ending Routine "rest" ---
|
|
|
- for thisComponent in restComponents:
|
|
|
- if hasattr(thisComponent, "setAutoDraw"):
|
|
|
- thisComponent.setAutoDraw(False)
|
|
|
- thisExp.addData('rest.stopped', globalClock.getTime())
|
|
|
- rest_wav1.pause() # ensure sound has stopped at end of Routine
|
|
|
- rest_wav2.pause() # ensure sound has stopped at end of Routine
|
|
|
- # using non-slip timing so subtract the expected duration of this Routine (unless ended on request)
|
|
|
- if routineForceEnded:
|
|
|
- routineTimer.reset()
|
|
|
- else:
|
|
|
- routineTimer.addTime(-6.000000)
|
|
|
- thisExp.nextEntry()
|
|
|
-
|
|
|
- if thisSession is not None:
|
|
|
- # if running in a Session with a Liaison client, send data up to now
|
|
|
- thisSession.sendExperimentData()
|
|
|
- # completed args.n_trials repeats of 'trials'
|
|
|
-
|
|
|
-
|
|
|
- # --- Prepare to start Routine "end" ---
|
|
|
- continueRoutine = True
|
|
|
- # update component parameters for each repeat
|
|
|
- thisExp.addData('end.started', globalClock.getTime())
|
|
|
- # keep track of which components have finished
|
|
|
- endComponents = [end_text]
|
|
|
- for thisComponent in endComponents:
|
|
|
- thisComponent.tStart = None
|
|
|
- thisComponent.tStop = None
|
|
|
- thisComponent.tStartRefresh = None
|
|
|
- thisComponent.tStopRefresh = None
|
|
|
- if hasattr(thisComponent, 'status'):
|
|
|
- thisComponent.status = NOT_STARTED
|
|
|
- # reset timers
|
|
|
- t = 0
|
|
|
- _timeToFirstFrame = win.getFutureFlipTime(clock="now")
|
|
|
- frameN = -1
|
|
|
-
|
|
|
- # --- Run Routine "end" ---
|
|
|
- routineForceEnded = not continueRoutine
|
|
|
- while continueRoutine and routineTimer.getTime() < 3.0:
|
|
|
- # get current time
|
|
|
- t = routineTimer.getTime()
|
|
|
- tThisFlip = win.getFutureFlipTime(clock=routineTimer)
|
|
|
- tThisFlipGlobal = win.getFutureFlipTime(clock=None)
|
|
|
- frameN = frameN + 1 # number of completed frames (so 0 is the first frame)
|
|
|
- # update/draw components on each frame
|
|
|
-
|
|
|
- # *end_text* updates
|
|
|
-
|
|
|
- # if end_text is starting this frame...
|
|
|
- if end_text.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance:
|
|
|
- # keep track of start time/frame for later
|
|
|
- end_text.frameNStart = frameN # exact frame index
|
|
|
- end_text.tStart = t # local t and not account for scr refresh
|
|
|
- end_text.tStartRefresh = tThisFlipGlobal # on global time
|
|
|
- win.timeOnFlip(end_text, 'tStartRefresh') # time at next scr refresh
|
|
|
- # add timestamp to datafile
|
|
|
- thisExp.timestampOnFlip(win, 'end_text.started')
|
|
|
- # update status
|
|
|
- end_text.status = STARTED
|
|
|
- end_text.setAutoDraw(True)
|
|
|
-
|
|
|
- # if end_text is active this frame...
|
|
|
- if end_text.status == STARTED:
|
|
|
- # update params
|
|
|
- pass
|
|
|
-
|
|
|
- # if end_text is stopping this frame...
|
|
|
- if end_text.status == STARTED:
|
|
|
- # is it time to stop? (based on global clock, using actual start)
|
|
|
- if tThisFlipGlobal > end_text.tStartRefresh + 3-frameTolerance:
|
|
|
- # keep track of stop time/frame for later
|
|
|
- end_text.tStop = t # not accounting for scr refresh
|
|
|
- end_text.frameNStop = frameN # exact frame index
|
|
|
- # add timestamp to datafile
|
|
|
- thisExp.timestampOnFlip(win, 'end_text.stopped')
|
|
|
- # update status
|
|
|
- end_text.status = FINISHED
|
|
|
- end_text.setAutoDraw(False)
|
|
|
-
|
|
|
- # check for quit (typically the Esc key)
|
|
|
- if defaultKeyboard.getKeys(keyList=["escape"]):
|
|
|
- thisExp.status = FINISHED
|
|
|
- if thisExp.status == FINISHED or endExpNow:
|
|
|
- endExperiment(thisExp, inputs=inputs, win=win)
|
|
|
- return
|
|
|
-
|
|
|
- # check if all components have finished
|
|
|
- if not continueRoutine: # a component has requested a forced-end of Routine
|
|
|
- routineForceEnded = True
|
|
|
- break
|
|
|
- continueRoutine = False # will revert to True if at least one component still running
|
|
|
- for thisComponent in endComponents:
|
|
|
- if hasattr(thisComponent, "status") and thisComponent.status != FINISHED:
|
|
|
- continueRoutine = True
|
|
|
- break # at least one component has not yet finished
|
|
|
-
|
|
|
- # refresh the screen
|
|
|
- if continueRoutine: # don't flip if this routine is over or we'll get a blank screen
|
|
|
- win.flip()
|
|
|
-
|
|
|
- # --- Ending Routine "end" ---
|
|
|
- for thisComponent in endComponents:
|
|
|
- if hasattr(thisComponent, "setAutoDraw"):
|
|
|
- thisComponent.setAutoDraw(False)
|
|
|
- thisExp.addData('end.stopped', globalClock.getTime())
|
|
|
- # using non-slip timing so subtract the expected duration of this Routine (unless ended on request)
|
|
|
- if routineForceEnded:
|
|
|
- routineTimer.reset()
|
|
|
- else:
|
|
|
- routineTimer.addTime(-3.000000)
|
|
|
-
|
|
|
- # mark experiment as finished
|
|
|
- endExperiment(thisExp, win=win, inputs=inputs)
|
|
|
-
|
|
|
-
|
|
|
-def saveData(thisExp):
|
|
|
- """
|
|
|
- Save data from this experiment
|
|
|
-
|
|
|
- Parameters
|
|
|
- ==========
|
|
|
- thisExp : psychopy.data.ExperimentHandler
|
|
|
- Handler object for this experiment, contains the data to save and information about
|
|
|
- where to save it to.
|
|
|
- """
|
|
|
- filename = thisExp.dataFileName
|
|
|
- # these shouldn't be strictly necessary (should auto-save)
|
|
|
- thisExp.saveAsWideText(filename + '.csv', delim='auto')
|
|
|
- thisExp.saveAsPickle(filename)
|
|
|
-
|
|
|
-
|
|
|
-def endExperiment(thisExp, inputs=None, win=None):
|
|
|
- """
|
|
|
- End this experiment, performing final shut down operations.
|
|
|
-
|
|
|
- This function does NOT close the window or end the Python process - use `quit` for this.
|
|
|
-
|
|
|
- Parameters
|
|
|
- ==========
|
|
|
- thisExp : psychopy.data.ExperimentHandler
|
|
|
- Handler object for this experiment, contains the data to save and information about
|
|
|
- where to save it to.
|
|
|
- inputs : dict
|
|
|
- Dictionary of input devices by name.
|
|
|
- win : psychopy.visual.Window
|
|
|
- Window for this experiment.
|
|
|
- """
|
|
|
- if win is not None:
|
|
|
- # remove autodraw from all current components
|
|
|
- win.clearAutoDraw()
|
|
|
- # Flip one final time so any remaining win.callOnFlip()
|
|
|
- # and win.timeOnFlip() tasks get executed
|
|
|
- win.flip()
|
|
|
- # mark experiment handler as finished
|
|
|
- thisExp.status = FINISHED
|
|
|
- # shut down eyetracker, if there is one
|
|
|
- if inputs is not None:
|
|
|
- if 'eyetracker' in inputs and inputs['eyetracker'] is not None:
|
|
|
- inputs['eyetracker'].setConnectionState(False)
|
|
|
- logging.flush()
|
|
|
-
|
|
|
-
|
|
|
-def quit(thisExp, win=None, inputs=None, thisSession=None):
|
|
|
- """
|
|
|
- Fully quit, closing the window and ending the Python process.
|
|
|
-
|
|
|
- Parameters
|
|
|
- ==========
|
|
|
- win : psychopy.visual.Window
|
|
|
- Window to close.
|
|
|
- inputs : dict
|
|
|
- Dictionary of input devices by name.
|
|
|
- thisSession : psychopy.session.Session or None
|
|
|
- Handle of the Session object this experiment is being run from, if any.
|
|
|
- """
|
|
|
- thisExp.abort() # or data files will save again on exit
|
|
|
- # make sure everything is closed down
|
|
|
- if win is not None:
|
|
|
- # Flip one final time so any remaining win.callOnFlip()
|
|
|
- # and win.timeOnFlip() tasks get executed before quitting
|
|
|
- win.flip()
|
|
|
- win.close()
|
|
|
- if inputs is not None:
|
|
|
- if 'eyetracker' in inputs and inputs['eyetracker'] is not None:
|
|
|
- inputs['eyetracker'].setConnectionState(False)
|
|
|
- logging.flush()
|
|
|
- if thisSession is not None:
|
|
|
- thisSession.stop()
|
|
|
- # terminate Python process
|
|
|
- core.quit()
|
|
|
-
|
|
|
-
|
|
|
-# if running this experiment as a script...
|
|
|
-if __name__ == '__main__':
|
|
|
- # call all functions in order
|
|
|
- expInfo = showExpInfoDlg(expInfo=expInfo)
|
|
|
- thisExp = setupData(expInfo=expInfo)
|
|
|
- logFile = setupLogging(filename=thisExp.dataFileName)
|
|
|
- win = setupWindow(expInfo=expInfo)
|
|
|
- inputs = setupInputs(expInfo=expInfo, thisExp=thisExp, win=win)
|
|
|
- run(
|
|
|
- expInfo=expInfo,
|
|
|
- thisExp=thisExp,
|
|
|
- win=win,
|
|
|
- inputs=inputs
|
|
|
- )
|
|
|
- saveData(thisExp=thisExp)
|
|
|
- quit(thisExp=thisExp, win=win, inputs=inputs)
|
