|
|
@@ -0,0 +1,1534 @@
|
|
|
+#!/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)
|
DESKTOP-4GKCI80\Neuracle
