opacity=1,
languageStyle='LTR',
depth=-2.0)
# Create some handy timers
globalClock = core.Clock() # to track the time since experiment started
routineTimer = core.CountdownTimer(
) # to track time remaining of each (non-slip) routine
# ------Prepare to start Routine "wait_for_trig"-------
t = 0
wait_for_trigClock.reset() # clock
frameN = -1
continueRoutine = True
# update component parameters for each repeat
initial_trigger = event.BuilderKeyResponse()
# keep track of which components have finished
wait_for_trigComponents = [intial_fix, initial_trigger]
for thisComponent in wait_for_trigComponents:
if hasattr(thisComponent, 'status'):
thisComponent.status = NOT_STARTED
# -------Start Routine "wait_for_trig"-------
while continueRoutine:
# get current time
t = wait_for_trigClock.getTime()
frameN = frameN + 1 # number of completed frames (so 0 is the first frame)
# update/draw components on each frame
# *intial_fix* updates
if t >= 0.0 and intial_fix.status == NOT_STARTED:
depth=0.0)
blockList = ['1', '2', '3', '4', '5', '6']
random.shuffle(blockList)
# Create some handy timers
globalClock = core.Clock() # to track the time since experiment started
routineTimer = core.CountdownTimer(
) # to track time remaining of each (non-slip) routine
#------Prepare to start Routine "start"-------
t = 0
startClock.reset() # clock
frameN = -1
# update component parameters for each repeat
start_key_resp = event.BuilderKeyResponse(
) # create an object of type KeyResponse
start_key_resp.status = NOT_STARTED
# keep track of which components have finished
startComponents = []
startComponents.append(start_text)
startComponents.append(start_key_resp)
for thisComponent in startComponents:
if hasattr(thisComponent, 'status'):
thisComponent.status = NOT_STARTED
#-------Start Routine "start"-------
continueRoutine = True
while continueRoutine:
# get current time
t = startClock.getTime()
frameN = frameN + 1 # number of completed frames (so 0 is the first frame)
opacity=1,
languageStyle='LTR',
depth=0.0)
# Create some handy timers
globalClock = core.Clock() # to track the time since experiment started
routineTimer = core.CountdownTimer(
) # to track time remaining of each (non-slip) routine
# ------Prepare to start Routine "instructions"-------
t = 0
instructionsClock.reset() # clock
frameN = -1
continueRoutine = True
# update component parameters for each repeat
ready = event.BuilderKeyResponse()
# keep track of which components have finished
instructionsComponents = [text, ready]
for thisComponent in instructionsComponents:
if hasattr(thisComponent, 'status'):
thisComponent.status = NOT_STARTED
# -------Start Routine "instructions"-------
while continueRoutine:
# get current time
t = instructionsClock.getTime()
frameN = frameN + 1 # number of completed frames (so 0 is the first frame)
# update/draw components on each frame
# *text* updates
if t >= 0.0 and text.status == NOT_STARTED:
for paramName in thisBlock_loop.keys():
exec(paramName + '= thisBlock_loop.' + paramName)
for thisBlock_loop in block_loop:
currentLoop = block_loop
# abbreviate parameter names if possible (e.g. rgb = thisBlock_loop.rgb)
if thisBlock_loop != None:
for paramName in thisBlock_loop.keys():
exec(paramName + '= thisBlock_loop.' + paramName)
#------Prepare to start Routine "Block_Instructions"-------
t = 0
Block_InstructionsClock.reset() # clock
frameN = -1
# update component parameters for each repeat
block_key = event.BuilderKeyResponse(
) # create an object of type KeyResponse
block_key.status = NOT_STARTED
Block_image.setImage("Instructions/" + block_display + ".png")
# keep track of which components have finished
Block_InstructionsComponents = []
Block_InstructionsComponents.append(block_key)
Block_InstructionsComponents.append(Block_image)
for thisComponent in Block_InstructionsComponents:
if hasattr(thisComponent, 'status'):
thisComponent.status = NOT_STARTED
#-------Start Routine "Block_Instructions"-------
continueRoutine = True
while continueRoutine:
# get current time
t = Block_InstructionsClock.getTime()
core.quit()
elif thisKey[0] == 'backspace' and counter > 0:
counter -= 1
else:
counter += 1
# ===== PRACTICE TRIALS ====== #
trial_num = 0
for thisPracTrial in prac_list:
trial_num += 1
# Abbeviate parameter names... e.g. thisPracTrial['beat_type'] becomes beat_type
if thisPracTrial != None:
for paramName in thisPracTrial:
exec('{} = thisPracTrial[paramName]'.format(paramName))
probe_resp = event.BuilderKeyResponse()
####====SETUP TRIAL COMPONENTS LIST====####
# initialize trial components list
trialComponents = []
audio_stim = sound.Sound(
str(
os.path.join('Stimuli', 'Audio', 'Practise',
('sent' + str(sent_number + 1) + '.wav'))))
trialComponents.extend([
audio_stim,
]) # add audio stim to trialComponents list
# set probe text for the trial
probe_text.setText(probe)
if hasattr(thisComponent, "setAutoDraw"):
thisComponent.setAutoDraw(False)
# the Routine "simon_setup" was not non-slip safe, so reset the non-slip timer
routineTimer.reset()
# ------Prepare to start Routine "simon_trial"-------
t = 0
simon_trialClock.reset() # clock
frameN = -1
continueRoutine = True
routineTimer.add(2.000000)
# update component parameters for each repeat
left_stim.setText(left_stim_text)
right_stim.setText(right_stim_text)
resp = event.BuilderKeyResponse()
# keep track of which components have finished
simon_trialComponents = [fixation_cross, left_stim, right_stim, ITI, resp]
for thisComponent in simon_trialComponents:
if hasattr(thisComponent, 'status'):
thisComponent.status = NOT_STARTED
# -------Start Routine "simon_trial"-------
while continueRoutine and routineTimer.getTime() > 0:
# get current time
t = simon_trialClock.getTime()
frameN = frameN + 1 # number of completed frames (so 0 is the first frame)
# update/draw components on each frame
# *fixation_cross* updates
if t >= 0.0 and fixation_cross.status == NOT_STARTED:
texRes=128,
interpolate=True,
depth=-1.0)
# Create some handy timers
globalClock = core.Clock() # to track the time since experiment started
routineTimer = core.CountdownTimer(
) # to track time remaining of each (non-slip) routine
# ------Prepare to start Routine "instructions"-------
t = 0
instructionsClock.reset() # clock
frameN = -1
continueRoutine = True
# update component parameters for each repeat
Weiter = event.BuilderKeyResponse()
# keep track of which components have finished
instructionsComponents = [text, Weiter]
for thisComponent in instructionsComponents:
if hasattr(thisComponent, 'status'):
thisComponent.status = NOT_STARTED
# -------Start Routine "instructions"-------
while continueRoutine:
# get current time
t = instructionsClock.getTime()
frameN = frameN + 1 # number of completed frames (so 0 is the first frame)
# update/draw components on each frame
# *text* updates
if t >= 0.0 and text.status == NOT_STARTED:
pos=[0.9, -0.9],
height=0.1,
wrapWidth=None,
color=u'red',
colorSpace='rgb',
opacity=1,
depth=-4.0)
#------Prepare to start Routine "trial"-------
t = 0
kk = np.random.randint(3, 20, size=1)
trialClock.reset() # clock
trialClock_all.reset() # clock
#routineTimer.add(40.000000)
# update component parameters for each repeat
keybrd_input = event.BuilderKeyResponse(
) # create an object of type KeyResponse
keybrd_input.status = NOT_STARTED
# keep track of which components have finished
trialComponents = []
trialComponents.append(instruction)
trialComponents.append(keybrd_input)
trialComponents.append(fixation)
trialComponents.append(End_instruction)
trialComponents.append(clock_disp)
for thisComponent in trialComponents:
if hasattr(thisComponent, 'status'):
thisComponent.status = NOT_STARTED
#-------Start Routine "trial"-------
continueRoutine = True
frameN = -1
# update component parameters for each repeat
if podle == 'vy':
if verze == '2D':
textNapoveda = u'shora, od Vás'
else:
textNapoveda = u'z boku, od Vás'
else:
if verze == '2D':
textNapoveda = u'shora, od Značky'
else:
textNapoveda = u'z boku, od Značky'
text.setText(textNapoveda)
text3.setText(opakovani)
respNapoveda = event.BuilderKeyResponse(
) # create an object of type KeyResponse
respNapoveda.status = NOT_STARTED
# keep track of which components have finished
napovedaComponents = []
napovedaComponents.append(text)
napovedaComponents.append(text2)
napovedaComponents.append(text3)
napovedaComponents.append(respNapoveda)
for thisComponent in napovedaComponents:
if hasattr(thisComponent, 'status'):
thisComponent.status = NOT_STARTED
#-------Start Routine "napoveda"-------
continueRoutine = True
while continueRoutine:
# get current time
def run3_func(expInfo):
# main function
# Ensure that relative paths start from the same directory as this script
_thisDir = os.path.dirname(os.path.abspath(__file__)).decode(sys.getfilesystemencoding())
os.chdir(_thisDir)
# Store info about the experiment session
expName = u'tnac_exp' # from the Builder filename that created this script
expInfo['expName'] = expName
# Data file name stem = absolute path + name; later add .psyexp, .csv, .log, etc
filename = _thisDir + os.sep + u'data/%s_%s_%s' %(expInfo['participant'], expName, expInfo['date'])
trg_dict = {"music": 1,
"voice": 2,
"song": 3,
"sound_off": 100,
"pause_block": 200,
"stop_run": 300,
"start_run": 400,
"start_block": 500,
}
#define path to csvs
run_var= _thisDir+'/run3.csv'
# An ExperimentHandler isn't essential but helps with data saving
thisExp = data.ExperimentHandler(name=expName, version='',
extraInfo=expInfo, runtimeInfo=None,
originPath=None,
savePickle=True, saveWideText=True,
dataFileName=filename)
# save a log file for detail verbose info
logFile = logging.LogFile(filename+'.log', level=logging.EXP)
logging.console.setLevel(logging.WARNING) # this outputs to the screen, not a file
endExpNow = False # flag for 'escape' or other condition => quit the exp
# Start Code - component code to be run before the window creation
# Setup the Window
## TODO: set window to fullscreen
win = visual.Window(
size=[1366, 768], fullscr=True, screen=0,
allowGUI=True, allowStencil=False,
monitor='testMonitor', color=[0,0,0], colorSpace='rgb',
blendMode='avg', useFBO=True)
# store frame rate of monitor if we can measure it
expInfo['frameRate'] = win.getActualFrameRate()
if expInfo['frameRate'] != None:
frameDur = 1.0 / round(expInfo['frameRate'])
else:
frameDur = 1.0 / 60.0 # could not measure, so guess
# Initialize components for Routine "trial"
trialClock = core.Clock()
stim_1 = sound.Sound('A', secs=-1)
stim_1.setVolume(1)
fix_1 = visual.TextStim(win=win, name='fix_1',
text='+',
font='Arial',
pos=(0, 0), height=0.1, wrapWidth=None, ori=0,
color='white', colorSpace='rgb', opacity=1,
depth=-1.0);
# Initialize components for Routine "run_start"
run_startClock = core.Clock()
run_start_msg_screen = visual.TextStim(win=win, name='run_start_msg_screen',
text=u'Kurze Pause.',
font='Arial',
units='norm', pos=[0,0], height=0.12, wrapWidth=2, ori=0,
color='white', colorSpace='rgb', opacity=1,
depth=0.0);
# Initialize components for Routine "run_trigger_sync"
StartClock = core.Clock()
run_trigger_syncClock = core.Clock()
run_start_msg = visual.TextStim(win=win, name='run_start_msg',
text='Durchgang beginnt!',
font='Arial',
units='norm', pos=[0, 0], height=0.15, wrapWidth=2, ori=0,
color='white', colorSpace='rgb', opacity=1,
depth=-1.0);
movie = visual.MovieStim3(
win=win, name='movie',units='pix',
noAudio = True,
# rename path
filename='C:\Paradigmen\AG_Brain\Peer\TNAC\movies\mov3.mkv',
ori=0, pos=(0, 0), opacity=1,
depth=0.0,)
# Create some handy timers
globalClock = core.Clock() # to track the time since experiment started
routineTimer = core.CountdownTimer() # to track time remaining of each (non-slip) routine
block_delay = [4,5,6]*12
random.shuffle(block_delay)
#print(block_delay)
# ------Prepare to start Routine "run_start"-------
t = 0
run_startClock.reset() # clock
frameN = -1
continueRoutine = True
# update component parameters for each repeat
run_start_trigger_key = event.BuilderKeyResponse()
# keep track of which components have finished
run_startComponents = [run_start_msg_screen, run_start_trigger_key]
for thisComponent in run_startComponents:
if hasattr(thisComponent, 'status'):
thisComponent.status = NOT_STARTED
# -------Start Routine "run_start"-------
while continueRoutine:
# get current time
t = run_startClock.getTime()
thisExp.addData('start_run',globalClock.getTime())
frameN = frameN + 1 # number of completed frames (so 0 is the first frame)
# update/draw components on each frame
# *run_start_msg_screen* updates
if t >= 0.0 and run_start_msg_screen.status == NOT_STARTED:
# keep track of start time/frame for later
run_start_msg_screen.tStart = t
run_start_msg_screen.frameNStart = frameN # exact frame index
run_start_msg_screen.setAutoDraw(True)
# *run_start_trigger_key* updates
if t >= 0.0 and run_start_trigger_key.status == NOT_STARTED:
# keep track of start time/frame for later
run_start_trigger_key.tStart = t
run_start_trigger_key.frameNStart = frameN # exact frame index
run_start_trigger_key.status = STARTED
# keyboard checking is just starting
event.clearEvents(eventType='keyboard')
if run_start_trigger_key.status == STARTED:
theseKeys = event.getKeys(keyList=['s'])
# check for quit:
if "escape" in theseKeys:
endExpNow = True
if len(theseKeys) > 0: # at least one key was pressed
# a response ends the routine
continueRoutine = False
# check if all components have finished
if not continueRoutine: # a component has requested a forced-end of Routine
break
continueRoutine = False # will revert to True if at least one component still running
for thisComponent in run_startComponents:
if hasattr(thisComponent, "status") and thisComponent.status != FINISHED:
continueRoutine = True
break # at least one component has not yet finished
# check for quit (the Esc key)
if endExpNow or event.getKeys(keyList=["escape"]):
core.quit()
# refresh the screen
if continueRoutine: # don't flip if this routine is over or we'll get a blank screen
win.flip()
# -------Ending Routine "run_start"-------
for thisComponent in run_startComponents:
if hasattr(thisComponent, "setAutoDraw"):
thisComponent.setAutoDraw(False)
# the Routine "run_start" was not non-slip safe, so reset the non-slip timer
routineTimer.reset()
# ------Prepare to start Routine "run_trigger_sync"-------
t = 0
run_trigger_syncClock.reset() # clock
frameN = -1
continueRoutine = True
# update component parameters for each repeat
run_trigger_sync_ = event.BuilderKeyResponse()
# keep track of which components have finished
run_trigger_syncComponents = [run_trigger_sync_, run_start_msg]
for thisComponent in run_trigger_syncComponents:
if hasattr(thisComponent, 'status'):
thisComponent.status = NOT_STARTED
# -------Start Routine "run_trigger_sync"-------
while continueRoutine:
# get current time
print('waiting for scanner trigger....')
t = run_trigger_syncClock.getTime()
frameN = frameN + 1 # number of completed frames (so 0 is the first frame)
# update/draw components on each frame
# *run_trigger_sync_* updates
if t >= 0.0 and run_trigger_sync_.status == NOT_STARTED:
# keep track of start time/frame for later
run_trigger_sync_.tStart = t
run_trigger_sync_.frameNStart = frameN # exact frame index
run_trigger_sync_.status = STARTED
# keyboard checking is just starting
win.callOnFlip(run_trigger_sync_.clock.reset) # t=0 on next screen flip
event.clearEvents(eventType='keyboard')
if run_trigger_sync_.status == STARTED:
theseKeys = event.getKeys(keyList=['t'])
# check for quit:
if "escape" in theseKeys:
endExpNow = True
if len(theseKeys) > 0: # at least one key was pressed
run_trigger_sync_.keys = theseKeys[-1] # just the last key pressed
run_trigger_sync_.rt = run_trigger_sync_.clock.getTime()
# a response ends the routine
continueRoutine = False
# *run_start_msg* updates
if t >= 0.0 and run_start_msg.status == NOT_STARTED:
# keep track of start time/frame for later
run_start_msg.tStart = t
run_start_msg.frameNStart = frameN # exact frame index
run_start_msg.setAutoDraw(True)
frameRemains = 0.0 + 5- win.monitorFramePeriod * 0.75 # most of one frame period left
if run_start_msg.status == STARTED and t >= frameRemains:
run_start_msg.setAutoDraw(False)
# check if all components have finished
if not continueRoutine: # a component has requested a forced-end of Routine
break
continueRoutine = False # will revert to True if at least one component still running
for thisComponent in run_trigger_syncComponents:
if hasattr(thisComponent, "status") and thisComponent.status != FINISHED:
continueRoutine = True
break # at least one component has not yet finished
# check for quit (the Esc key)
if endExpNow or event.getKeys(keyList=["escape"]):
core.quit()
# refresh the screen
if continueRoutine: # don't flip if this routine is over or we'll get a blank screen
win.flip()
# -------Ending Routine "run_trigger_sync"-------
for thisComponent in run_trigger_syncComponents:
if hasattr(thisComponent, "setAutoDraw"):
thisComponent.setAutoDraw(False)
# check responses
if run_trigger_sync_.keys in ['', [], None]: # No response was made
run_trigger_sync_.keys=None
thisExp.addData('run_trigger_sync_.keys',run_trigger_sync_.keys)
if run_trigger_sync_.keys != None: # we had a response
thisExp.addData('run_trigger_sync_.rt', run_trigger_sync_.rt)
run_start_timestamp = StartClock.getTime()
send_trigger(400)
# the Routine "run_trigger_sync" was not non-slip safe, so reset the non-slip timer
routineTimer.reset()
start_delay=False
delay_counter= 0
#print(block_delay)
#print(delay_counter)
# start movie for whole run (loop over trials)
mov='movies/mov3.mkv'
#print(mov)
movie.setMovie(mov)
if t >= 0.0 and movie.status == NOT_STARTED:
# keep track of start time/frame for later
movie.tStart = t
movie.frameNStart = frameN # exact frame index
movie.setAutoDraw(True)
frameRemains = 0.0 + 2- win.monitorFramePeriod * 0.75 # most of one frame period left
# set up handler to look after randomisation of conditions etc
trials = data.TrialHandler(nReps=1, method='sequential',
extraInfo=expInfo, originPath=-1,
trialList=data.importConditions(run_var),
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.keys():
exec(paramName + '= thisTrial.' + paramName)
stimuli_played=0
for thisTrial in trials:
currentLoop = trials
# abbreviate parameter names if possible (e.g. rgb = thisTrial.rgb)
if thisTrial != None:
for paramName in thisTrial.keys():
exec(paramName + '= thisTrial.' + paramName)
# ------Prepare to start Routine "trial"-------
t = 0
trialClock.reset() # clock
frameN = -1
continueRoutine = True
routineTimer.add(2.000000)
# update component parameters for each repeat
stim_1.setSound(stimuli, secs=2)
#read stimuli into dict and set port value
abc= stimuli.split('/')[0]
trg = trg_dict.get(abc, 100)
# keep track of which components have finished
trialComponents = [stim_1, fix_1]
for thisComponent in trialComponents:
if hasattr(thisComponent, 'status'):
thisComponent.status = NOT_STARTED
# -------Start Routine "trial"-------
while continueRoutine and routineTimer.getTime() > 0:
# get current time
t = trialClock.getTime()
frameN = frameN + 1 # number of completed frames (so 0 is the first frame)
# update/draw components on each frame
# start/stop stim_1
if t >= 0.0 and stim_1.status == NOT_STARTED:
# keep track of start time/frame for later
stim_1.tStart = t
stim_1.frameNStart = frameN # exact frame index
## TODO reinstate: send_trigger(abc)
#print(abc)
stim_1.play() # start the sound (it finishes automatically)
send_trigger(trg) # send block specific trigger
# get time for stimuls start
thisExp.addData('stimulus_start_global',globalClock.getTime())
thisExp.addData('stimulus_start_routineTimer',routineTimer.getTime())
thisExp.addData('stimulus_start_',frameN)
#print(stim_1)
stimuli_played+=1
if stimuli_played%5 == 0:
start_delay=True
print('stimuli_nr:'+str(stimuli_played))
frameRemains = 0.0 + 1.5 - win.monitorFramePeriod * 0.75 # most of one frame period left
#frameRemainsdelay = 0.0 + 1.5- win.monitorFramePeriod * 0.75 # most of one frame period left
if stim_1.status == STARTED and t >= frameRemains:
stim_1.stop() # stop the sound (if longer than duration)
send_trigger(100) # send sound off trigger
# get info on stim end
thisExp.addData('stimulus_end_global',globalClock.getTime())
thisExp.addData('stimulus_end_routineTimer',routineTimer.getTime())
# add delay intervall after 5 stimuli
if stimuli_played %5 == 0 and start_delay and delay_counter != 35:
send_trigger(200)
delay=block_delay[delay_counter]
routineTimer.add(block_delay[delay_counter])
#frameRemainsdelay = 0.0 + 1.5 + delay - win.monitorFramePeriod * 0.75 # most of one frame period left
#print('delay='+str(delay_counter))
delay_counter +=1
thisExp.addData('delay_counter',block_delay[delay_counter])
thisExp.addData('block_end_global',globalClock.getTime())
start_delay=False
if stim_1.status == STARTED and t >= frameRemains:
stim_1.stop() # stop the sound (if longer than duration)
send_trigger(100) # send sound off trigger
# get info on stim end
thisExp.addData('stimulus_end_global',globalClock.getTime())
thisExp.addData('stimulus_end_routineTimer',routineTimer.getTime())
# check if all components have finished
if not continueRoutine: # a component has requested a forced-end of Routine
break
continueRoutine = False # will revert to True if at least one component still running
for thisComponent in trialComponents:
if hasattr(thisComponent, "status") and thisComponent.status != FINISHED:
continueRoutine = True
break # at least one component has not yet finished
# check for quit (the Esc key)
if endExpNow or event.getKeys(keyList=["escape"]):
core.quit()
# refresh the screen
if continueRoutine: # don't flip if this routine is over or we'll get a blank screen
win.flip()
stim_1.stop() # ensure sound has stopped at end of routine
thisExp.nextEntry()
# completed 1 repeats of 'trials'
thisExp.nextEntry()
# completed 1 repeats of 'block'
if stimuli_played == 180:
movie.setAutoDraw(False)
send_trigger(300) # END RUN
thisExp.saveAsWideText(filename+'run3'+'.csv')
thisExp.saveAsPickle(filename+'run3')
logging.flush()
# make sure everything is closed down
thisExp.abort() # or data files will save again on exit
win.close()
font='Arial',
pos=(0, 0), height=30, wrapWidth=None, ori=0,
color='white', colorSpace='rgb', opacity=1,
depth=0.0);
# Create some handy timers
globalClock = core.Clock() # to track the time since experiment started
routineTimer = core.CountdownTimer() # to track time remaining of each (non-slip) routine
# ------Prepare to start Routine "consg"-------
t = 0
consgClock.reset() # clock
frameN = -1
continueRoutine = True
# update component parameters for each repeat
resp = event.BuilderKeyResponse()
# keep track of which components have finished
consgComponents = [appuyer, resp]
for thisComponent in consgComponents:
if hasattr(thisComponent, 'status'):
thisComponent.status = NOT_STARTED
# -------Start Routine "consg"-------
while continueRoutine:
# get current time
t = consgClock.getTime()
frameN = frameN + 1 # number of completed frames (so 0 is the first frame)
# update/draw components on each frame
# *appuyer* updates
font='arial',
pos=[0, 0], height=0.2, wrapWidth=None, ori=0,
color=[1, 1, 1], colorSpace='rgb', opacity=1,
depth=0.0);
# Create some handy timers
globalClock = core.Clock() # to track the time since experiment started
routineTimer = core.CountdownTimer() # to track time remaining of each (non-slip) routine
# ------Prepare to start Routine "instructPractice"-------
t = 0
instructPracticeClock.reset() # clock
frameN = -1
continueRoutine = True
# update component parameters for each repeat
ready1 = event.BuilderKeyResponse()
# keep track of which components have finished
instructPracticeComponents = [instr1, ready1]
for thisComponent in instructPracticeComponents:
if hasattr(thisComponent, 'status'):
thisComponent.status = NOT_STARTED
# -------Start Routine "instructPractice"-------
while continueRoutine:
# get current time
t = instructPracticeClock.getTime()
frameN = frameN + 1 # number of completed frames (so 0 is the first frame)
# update/draw components on each frame
# *instr1* updates
if t >= 0.0 and instr1.status == NOT_STARTED:
colorSpace='rgb',
opacity=1,
depth=0.0)
# Create some handy timers
globalClock = core.Clock() # to track the time since experiment started
routineTimer = core.CountdownTimer(
) # to track time remaining of each (non-slip) routine
# ------Prepare to start Routine "intro"-------
t = 0
introClock.reset() # clock
frameN = -1
continueRoutine = True
# update component parameters for each repeat
key_resp_2 = event.BuilderKeyResponse()
# keep track of which components have finished
introComponents = [key_resp_2, intro_txt]
for thisComponent in introComponents:
if hasattr(thisComponent, 'status'):
thisComponent.status = NOT_STARTED
# -------Start Routine "intro"-------
while continueRoutine:
# get current time
t = introClock.getTime()
frameN = frameN + 1 # number of completed frames (so 0 is the first frame)
# update/draw components on each frame
# *key_resp_2* updates
if t >= 0.0 and key_resp_2.status == NOT_STARTED:
def choice(leftVarText, leftVarMoney, rightVarText, rightVarMoney):
t = 0
ChoiceClock.reset()
frameN = -1
continueRoutine = True
routineTimer.add(3.0000)
leftText.setText(leftVarText)
rightText.setText(rightVarText)
rightMoney.setText(rightVarMoney)
leftMoney.setText(leftVarMoney)
responses = event.BuilderKeyResponse()
blank.setText('')
ChoiceComponents = [
leftText, rightText, rightMoney, leftMoney, responses, blank
]
for thisComponent in ChoiceComponents:
if hasattr(thisComponent, 'status'):
thisComponent.status = NOT_STARTED
while continueRoutine:
t = ChoiceClock.getTime()
frameN = frameN + 1
if t >= 0.0 and leftText.status == NOT_STARTED:
leftText.tStart = t
leftText.frameNStart = frameN
leftText.setAutoDraw(True)
if t >= 0.0 and rightText.status == NOT_STARTED:
rightText.tStart = t
rightText.frameNStart = frameN
rightText.setAutoDraw(True)
if t >= 0.0 and rightMoney.status == NOT_STARTED:
rightMoney.tStart = t
rightMoney.frameNStart = frameN
rightMoney.setAutoDraw(True)
if t >= 0.0 and leftMoney.status == NOT_STARTED:
leftMoney.tStart = t
leftMoney.frameNStart = frameN
leftMoney.setAutoDraw(True)
if t >= 0.0 and responses.status == NOT_STARTED:
responses.tStart = t
responses.frameNStart = frameN
responses.status = STARTED
win.callOnFlip(responses.clock.reset)
event.clearEvents(eventType='keyboard')
if responses.status == STARTED and bool(blank.status == STARTED):
responses.status = FINISHED
if responses.status == STARTED:
theseKeys = event.getKeys(keyList=['q', 'p'])
if "escape" in theseKeys:
endExpNow = True
if len(theseKeys) > 0:
responses.keys = theseKeys[-1]
responses.rt = responses.clock.getTime()
if responses.keys == 'p':
rightMoney.setColor("green")
rightText.setColor('green')
if responses.keys == 'q':
leftMoney.setColor("green")
leftText.setColor('green')
if leftText.status == STARTED and t >= 3.000:
leftText.setAutoDraw(False)
rightText.setAutoDraw(False)
leftMoney.setAutoDraw(False)
rightMoney.setAutoDraw(False)
blank.setAutoDraw(False)
continueRoutine = False
if (blank.status == STARTED and t >= (blank.tStart + 1.0)):
blank.setAutoDraw(False)
if responses.keys == 'p' or responses.keys == 'q':
responses.status = FINISHED
if (blank.status == FINISHED):
rightText.setAutoDraw(False)
rightMoney.setAutoDraw(False)
leftMoney.setAutoDraw(False)
leftText.setAutoDraw(False)
continueRoutine = False
if (responses.keys == 'p'
or responses.keys == 'q') and blank.status == NOT_STARTED:
blank.tStart = t
blank.frameNStart = frameN
blank.setAutoDraw(True)
if not continueRoutine:
break
continueRoutine = False
for thisComponent in ChoiceComponents:
if hasattr(thisComponent,
"status") and thisComponent.status != FINISHED:
continueRoutine = True
break
if continueRoutine:
win.flip()
for thisComponent in ChoiceComponents:
if hasattr(thisComponent, "setAutoDraw"):
thisComponent.setAutoDraw(False)
if responses.keys in ['', [], None]:
responses.keys = None
Loop.addData('responses.keys', responses.keys)
if responses.keys != None:
Loop.addData('responses.rt', responses.rt)
if blank.status == FINISHED:
leftMoney.setAutoDraw(False)
rightMoney.setAutoDraw(False)
leftText.setAutoDraw(False)
rightText.setAutoDraw(False)
leftMoney.setColor('white')
rightMoney.setColor('white')
leftText.setColor('white')
rightText.setColor('white')
routineTimer.reset()
dfStims['block_'+str(type+1)+'_img'] = img_ids
dfStims['block_'+str(type+1)+'_ans'] = seq_ans
dfStims.to_csv('practice_stims.csv', index= False)
# Create some handy timers
globalClock = core.Clock() # to track the time since experiment started
routineTimer = core.CountdownTimer() # to track time remaining of each (non-slip) routine
#------Prepare to start Routine "Instructions"-------
t = 0
InstructionsClock.reset() # clock
frameN = -1
# update component parameters for each repeat
instructions_response = event.BuilderKeyResponse() # create an object of type KeyResponse
instructions_response.status = NOT_STARTED
# keep track of which components have finished
InstructionsComponents = []
InstructionsComponents.append(instrText)
InstructionsComponents.append(instructions_response)
for thisComponent in InstructionsComponents:
if hasattr(thisComponent, 'status'):
thisComponent.status = NOT_STARTED
#-------Start Routine "Instructions"-------
continueRoutine = True
while continueRoutine:
# get current time
t = InstructionsClock.getTime()
frameN = frameN + 1 # number of completed frames (so 0 is the first frame)
colorSpace='rgb',
opacity=1,
depth=-1.0)
# Create some handy timers
globalClock = core.Clock() # to track the time since experiment started
routineTimer = core.CountdownTimer(
) # to track time remaining of each (non-slip) routine
#------Prepare to start Routine "Inst"-------
t = 0
InstClock.reset() # clock
frameN = -1
# update component parameters for each repeat
MoveOn = event.BuilderKeyResponse() # create an object of type KeyResponse
MoveOn.status = NOT_STARTED
# keep track of which components have finished
InstComponents = []
InstComponents.append(Instructions)
InstComponents.append(MoveOn)
for thisComponent in InstComponents:
if hasattr(thisComponent, 'status'):
thisComponent.status = NOT_STARTED
#-------Start Routine "Inst"-------
continueRoutine = True
while continueRoutine:
# get current time
t = InstClock.getTime()
frameN = frameN + 1 # number of completed frames (so 0 is the first frame)
pos=[0, 0], height=0.1, wrapWidth=None,
color='white', colorSpace='rgb', opacity=1,
depth=0.0)
# Create some handy timers
globalClock = core.Clock() # to track the time since experiment started
routineTimer = core.CountdownTimer() # to track time remaining of each (non-slip) routine
#------Prepare to start Routine "instr"-------
switchasdf4 = False
switchasdf6 = False
t = 0
instrClock.reset() # clock
frameN = -1
# update component parameters for each repeat
key_resp_3 = event.BuilderKeyResponse() # create an object of type KeyResponse
key_resp_3.status = NOT_STARTED
# keep track of which components have finished
instrComponents = []
instrComponents.append(text)
instrComponents.append(key_resp_3)
for thisComponent in instrComponents:
if hasattr(thisComponent, 'status'):
thisComponent.status = NOT_STARTED
#-------Start Routine "instr"-------
continueRoutine = True
while continueRoutine:
# get current time
t = instrClock.getTime()
frameN = frameN + 1 # number of completed frames (so 0 is the first frame)
WordListObjects.append(textTemp)
count += 1
# ########
# Create some handy timers
globalClock = core.Clock() # to track the time since experiment started
routineTimer = core.CountdownTimer(
) # to track time remaining of each (non-slip) routine
# ------Prepare to start Routine "Instructions"-------
t = 0
InstructionsClock.reset() # clock
frameN = -1
continueRoutine = True
# update component parameters for each repeat
key_resp_4 = event.BuilderKeyResponse()
# keep track of which components have finished
InstructionsComponents = [instr, key_resp_4]
for thisComponent in InstructionsComponents:
if hasattr(thisComponent, 'status'):
thisComponent.status = NOT_STARTED
# -------Start Routine "Instructions"-------
while continueRoutine:
# get current time
t = InstructionsClock.getTime()
frameN = frameN + 1 # number of completed frames (so 0 is the first frame)
# update/draw components on each frame
# *instr* updates
if t >= 0.0 and instr.status == NOT_STARTED:
color='white',
colorSpace='rgb',
opacity=1,
depth=-3.0)
# Create some handy timers
globalClock = core.Clock() # to track the time since experiment started
routineTimer = core.CountdownTimer(
) # to track time remaining of each (non-slip) routine
#------Prepare to start Routine "wait_for_trig"-------
t = 0
wait_for_trigClock.reset() # clock
frameN = -1
# update component parameters for each repeat
start_trigger = event.BuilderKeyResponse(
) # create an object of type KeyResponse
start_trigger.status = NOT_STARTED
# keep track of which components have finished
wait_for_trigComponents = []
wait_for_trigComponents.append(wait_crosshair)
wait_for_trigComponents.append(start_trigger)
for thisComponent in wait_for_trigComponents:
if hasattr(thisComponent, 'status'):
thisComponent.status = NOT_STARTED
#-------Start Routine "wait_for_trig"-------
continueRoutine = True
while continueRoutine:
# get current time
t = wait_for_trigClock.getTime()
frameN = frameN + 1 # number of completed frames (so 0 is the first frame)
pos=[0, 0], height=0.2, wrapWidth=None, ori=0,
color=[1, 1, 1], colorSpace='rgb', opacity=1,
languageStyle='LTR',
depth=0.0);
# Create some handy timers
globalClock = core.Clock() # to track the time since experiment started
routineTimer = core.CountdownTimer() # to track time remaining of each (non-slip) routine
# ------Prepare to start Routine "instruct"-------
t = 0
instructClock.reset() # clock
frameN = -1
continueRoutine = True
# update component parameters for each repeat
ready = event.BuilderKeyResponse()
# keep track of which components have finished
instructComponents = [instrText, ready]
for thisComponent in instructComponents:
if hasattr(thisComponent, 'status'):
thisComponent.status = NOT_STARTED
# -------Start Routine "instruct"-------
while continueRoutine:
# get current time
t = instructClock.getTime()
frameN = frameN + 1 # number of completed frames (so 0 is the first frame)
# update/draw components on each frame
# *instrText* updates
if t >= 0 and instrText.status == NOT_STARTED:
while prac_redo:
for thisPrac_inst_trial in prac_inst_trials:
currentLoop = prac_inst_trials
# abbreviate parameter names if possible (e.g. rgb = thisPrac_inst_trial.rgb)
if thisPrac_inst_trial != None:
for paramName in thisPrac_inst_trial:
exec('{} = thisPrac_inst_trial[paramName]'.format(paramName))
# ------Prepare to start Routine "trial"-------
t = 0
trialClock.reset() # clock
frameN = -1
continueRoutine = True
# update component parameters for each repeat
inst_image.setImage(inst_cat_path + inst_image_path)
key_resp_2 = event.BuilderKeyResponse()
# keep track of which components have finished
trialComponents = [inst_image, key_resp_2]
for thisComponent in trialComponents:
if hasattr(thisComponent, 'status'):
thisComponent.status = NOT_STARTED
# -------Start Routine "trial"-------
while continueRoutine:
# get current time
t = trialClock.getTime()
frameN = frameN + 1 # number of completed frames (so 0 is the first frame)
# update/draw components on each frame
# *inst_image* updates
# Pre-load first distractor so psychopy will be ready to draw it.
# Keep track of stim number here, to be updated each loop (after distractor "off")
stim_num = 0
CRA_distractor = CRA_dist_list[stim][stim_num]
# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
# Pre-load first position so psychopy will be ready to draw it.
# Keep track of position number here, to be updated each loop (after distractor "off")
pos_num = 0
CRA_distractor.pos = CRA_pos_list[position][pos_num]
# !!!!!!!!!!!!!!!!!!!!!!!!!!!
# How long between distractors
offTime = distTime + 1.0
solution_cra = event.BuilderKeyResponse(
) # create an object of type KeyResponse
solution_cra.status = NOT_STARTED
# keep track of which components have finished
CRAComponents = []
CRAComponents.append(CRA_problems)
CRAComponents.append(CRA_distractor)
CRAComponents.append(solution_cra)
for thisComponent in CRAComponents:
if hasattr(thisComponent, 'status'):
thisComponent.status = NOT_STARTED
# -------Start Routine "CRA"-------
continueRoutine = True
while continueRoutine and routineTimer.getTime() > 0:
# get current time
# update component parameters for each repeat
stimuli.setSound('Stimuli' + os.path.sep + 'normalized-180' + os.path.sep +
'%s_%s' % (thisTrial.sound, thisTrial.speaker) +
os.path.sep + '%s%s.wav' %
(thisTrial.sound, thisTrial.file))
triggercounter = 0
trialClock = core.Clock()
t = 0
trialClock.reset() # clock
frameN = -1
routineTimer.add(0.500000)
# keep track of which components have finished
pausePress = []
resumePress = []
pauseKey = event.BuilderKeyResponse(
) #create an object of type KeyResponse
pauseKey.status = NOT_STARTED
resumeKey = event.BuilderKeyResponse(
) #create an object of type KeyResponse
resumeKey.status = NOT_STARTED
respKey1 = event.BuilderKeyResponse(
) #create an object of type KeyResponse
respKey1.status = NOT_STARTED
trialComponents = []
trialComponents.append(stimuli)
trialComponents.append(pauseScr)
for thisComponent in trialComponents:
if hasattr(thisComponent, 'status'):
thisComponent.status = NOT_STARTED
#-------Start Routine "trial"-------
# refresh the screen
if continueRoutine: # don't flip if this routine is over or we'll get a blank screen
win.flip()
# -------Ending Routine "welcome"-------
for thisComponent in welcomeComponents:
if hasattr(thisComponent, "setAutoDraw"):
thisComponent.setAutoDraw(False)
# ------Prepare to start Routine "scantrigger"-------
t = 0
scantriggerClock.reset() # clock
frameN = -1
continueRoutine = True
# update component parameters for each repeat
scan_trigger = event.BuilderKeyResponse()
# keep track of which components have finished
scantriggerComponents = [scan_trigger, scan_trigger_text]
for thisComponent in scantriggerComponents:
if hasattr(thisComponent, 'status'):
thisComponent.status = NOT_STARTED
# -------Start Routine "scantrigger"-------
while continueRoutine:
# get current time
t = scantriggerClock.getTime()
frameN = frameN + 1 # number of completed frames (so 0 is the first frame)
# update/draw components on each frame
# *scan_trigger* updates
if t >= 0.0 and scan_trigger.status == NOT_STARTED:
treminder_sound.setVolume(1)
blockList = ['1', '2', '3', '4', '5', '6']
random.shuffle(blockList)
# Create some handy timers
globalClock = core.Clock() # to track the time since experiment started
routineTimer = core.CountdownTimer(
) # to track time remaining of each (non-slip) routine
#------Prepare to start Routine "instr3_5"-------
t = 0
instr3_5Clock.reset() # clock
frameN = -1
# update component parameters for each repeat
key_resp_13 = event.BuilderKeyResponse(
) # create an object of type KeyResponse
key_resp_13.status = NOT_STARTED
# keep track of which components have finished
instr3_5Components = []
instr3_5Components.append(text_11)
instr3_5Components.append(key_resp_13)
instr3_5Components.append(image_15)
for thisComponent in instr3_5Components:
if hasattr(thisComponent, 'status'):
thisComponent.status = NOT_STARTED
#-------Start Routine "instr3_5"-------
continueRoutine = True
while continueRoutine:
# get current time
t = instr3_5Clock.getTime()
InstructionLoopNum = 1
#-----If 'left' button is pressed to go back in instructions------
#--------call up appropriate instruction to be displayed.---------
instructionImgDisplayed = instruct_Dir + os.sep+'memInstruct_' + str(InstructionLoopNum) + '.JPG'
#-----------Get Time of Onset for each Instruction----------
Onset = TaskClock.getTime()
#-----------------Add Data---------------------
thisExp.addData('Stimulus','instructions')
thisExp.addData('Onset',Onset)
Instruction.setImage(instructionImgDisplayed)
nextInstruction = event.BuilderKeyResponse()
# keep track of which components have finished
InstructComponents = [Instruction, nextInstruction]
for thisComponent in InstructComponents:
if hasattr(thisComponent, 'status'):
thisComponent.status = NOT_STARTED
# -------Start Routine "Instruct"-------
while continueRoutine:
# get current time
t = InstructClock.getTime()
frameN = frameN + 1 # number of completed frames (so 0 is the first frame)
# update/draw components on each frame
# *Instruction* updates
# Create some handy timers
globalClock = core.Clock() # to track the time since experiment started
routineTimer = core.CountdownTimer(
) # to track time remaining of each (non-slip) routine
#------Prepare to start Routine "trial_2"-------
t = 0
trial_2Clock.reset() # clock
frameN = -1
routineTimer.add(11.000000)
# update component parameters for each repeat
UpperText.setText(' L K R G M X ')
UpperBrackets.setText(' { }')
LowerText.setText(' b t y g q j ')
resp = event.BuilderKeyResponse() # create an object of type KeyResponse
resp.status = NOT_STARTED
# keep track of which components have finished
trial_2Components = []
trial_2Components.append(ISI)
trial_2Components.append(TopUpperLine)
trial_2Components.append(UpperText)
trial_2Components.append(UpperBrackets)
trial_2Components.append(BotUpperLine)
trial_2Components.append(TopLowerLine)
trial_2Components.append(LowerText)
trial_2Components.append(LowerBrackets)
trial_2Components.append(BotLowerLine)
trial_2Components.append(TrialCrossHair)
trial_2Components.append(RestCrossHair)
trial_2Components.append(resp)
font='Arial',
units='pix', pos=[0, 0], height=60.0, wrapWidth=None, ori=0,
color='black', colorSpace='rgb', opacity=1,
depth=-1.0);
# Create some handy timers
globalClock = core.Clock() # to track the time since experiment started
routineTimer = core.CountdownTimer() # to track time remaining of each (non-slip) routine
# ------Prepare to start Routine "instruction"-------
t = 0
instructionClock.reset() # clock
frameN = -1
continueRoutine = True
# update component parameters for each repeat
toStart = event.BuilderKeyResponse()
# keep track of which components have finished
instructionComponents = [Instr, toStart]
for thisComponent in instructionComponents:
if hasattr(thisComponent, 'status'):
thisComponent.status = NOT_STARTED
# -------Start Routine "instruction"-------
while continueRoutine:
# get current time
t = instructionClock.getTime()
frameN = frameN + 1 # number of completed frames (so 0 is the first frame)
# update/draw components on each frame
# *Instr* updates
if t >= 0.0 and Instr.status == NOT_STARTED:
font='Arial',
pos=[0, 0], height=0.1, wrapWidth=None, ori=0,
color='white', colorSpace='rgb', opacity=1,
depth=0.0);
# Create some handy timers
globalClock = core.Clock() # to track the time since experiment started
routineTimer = core.CountdownTimer() # to track time remaining of each (non-slip) routine
# ------Prepare to start Routine "intro"-------
t = 0
introClock.reset() # clock
frameN = -1
continueRoutine = True
# update component parameters for each repeat
key_resp_2 = event.BuilderKeyResponse()
# keep track of which components have finished
introComponents = [intro_text, key_resp_2]
for thisComponent in introComponents:
if hasattr(thisComponent, 'status'):
thisComponent.status = NOT_STARTED
# -------Start Routine "intro"-------
while continueRoutine:
# get current time
t = introClock.getTime()
frameN = frameN + 1 # number of completed frames (so 0 is the first frame)
# update/draw components on each frame
# *intro_text* updates
if t >= 0.0 and intro_text.status == NOT_STARTED:
def InstructionsPractice(thisPrac, endExpNow):
# Setup the Window
dispWidth = 1024
dispHeight = 768
wini = visual.Window(size=(dispWidth, dispHeight),
fullscr=True,
screen=0,
allowGUI=False,
allowStencil=False,
monitor='testMonitor',
color=[0.5, 0.5, 0.5],
colorSpace='rgb',
blendMode='avg',
useFBO=False,
units='pix')
# Initialize components for Routine "instrMain"
instrMainClock = core.Clock()
inst = ''
instrPic = visual.ImageStim(win=wini,
name='instrPic',
image='sin',
mask=None,
ori=0,
pos=(0, 0),
color=[1, 1, 1],
colorSpace='rgb',
opacity=1,
flipHoriz=False,
flipVert=False,
texRes=128,
interpolate=False,
depth=-1.0)
# Show instructions on screen
inst_n = 0
inst_list = [
'instr_prac1.png', 'instr_prac2.png', 'instr_prac3.png',
'instr_prac4.png', 'instr_prac5.png', 'instr_prac6.png',
'instr_prac7.png', 'instr_prac8.png', 'instr_prac9.png',
'instr_prac10.png', 'instr_prac11.png', 'instr_prac12.png',
'instr_prac13.png'
]
inst_pres = 1
while inst_pres == 1:
# ------Prepare to start Routine "instrMain"-------
t = 0
instrMainClock.reset() # clock
continueRoutine = True
# update component parameters for each repeat
inst = 'instructions/' + inst_list[inst_n]
instrPic.setImage(inst)
ok1 = event.BuilderKeyResponse()
# keep track of which components have finished
instrMainComponents = [instrPic, ok1]
for thisComponent in instrMainComponents:
if hasattr(thisComponent, 'status'):
thisComponent.status = NOT_STARTED
# -------Start Routine "instrMain"-------
while continueRoutine:
# get current time
t = instrMainClock.getTime()
# *instrPic* updates
if t >= 0.0 and instrPic.status == NOT_STARTED:
# keep track of start time/frame for later
instrPic.tStart = t
instrPic.setAutoDraw(True)
# *ok1* updates
if t >= 0.0 and ok1.status == NOT_STARTED:
# keep track of start time/frame for later
ok1.tStart = t
ok1.status = STARTED
# keyboard checking is just starting
wini.callOnFlip(ok1.clock.reset) # t=0 on next screen flip
event.clearEvents(eventType='keyboard')
if ok1.status == STARTED:
theseKeys = event.getKeys(keyList=['left', 'down', 'right'])
# check for quit:
if "escape" in theseKeys:
endExpNow = True
if len(theseKeys) > 0: # at least one key was pressed
ok1.keys = theseKeys[-1] # just the last key pressed
ok1.rt = ok1.clock.getTime()
# a response ends the routine
continueRoutine = False
# check if all components have finished
if not continueRoutine: # a component has requested a forced-end of Routine
break
continueRoutine = False # will revert to True if at least one component still running
for thisComponent in instrMainComponents:
if hasattr(thisComponent,
"status") and thisComponent.status != FINISHED:
continueRoutine = True
break # at least one component has not yet finished
# check for quit (the Esc key)
if endExpNow or event.getKeys(keyList=["escape"]):
wini.close()
core.quit()
# refresh the screen
if continueRoutine: # don't flip if this routine is over or we'll get a blank screen
wini.flip()
# -------Ending Routine "instrMain"-------
for thisComponent in instrMainComponents:
if hasattr(thisComponent, "setAutoDraw"):
thisComponent.setAutoDraw(False)
# check responses
thisPrac.addData('ok1.keys', ok1.keys)
thisPrac.addData('ok1.rt', ok1.rt)
thisPrac.nextEntry()
# determine which image to show next
if inst_n not in [5, 6, 8, 9]:
if ok1.keys == 'right': # right click = move forward
if inst_n == 12:
inst_pres = 0
break
else:
inst_n = inst_n + 1
elif ok1.keys == 'left': #left click = move back
if inst_n >= 1:
inst_n = inst_n - 1
elif inst_n in [5, 9]: #test questions where correct response is down
if ok1.keys == 'down':
inst_n = inst_n + 1
elif inst_n in [6, 8]: #test questions where correct response is right
if ok1.keys == 'right':
inst_n = inst_n + 1
return (thisPrac)
