#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
This experiment was created using PsychoPy3 Experiment Builder (v2023.2.3),
on 十二月 18, 2023, at 10:55
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.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)