def testWithNoKwargs():
"""
testWithNoKwargs illustrates using the launchHubServer function with no
parameters at all. Considerations:
* A Keyboard, Mouse, Monitor, and Experiment device are created by default.
* All devices use their default parameter settings. Therefore, not very useful in real studies.
* ioHub DataStore is not enabled.
"""
io=launchHubServer()
# Get the default keyboard device created.
keyboard=io.devices.keyboard
print()
print("** PRESS A KEY TO CONTINUE.....")
# Check for new events every 1/4 second.
# By using the io.wait() fucntion, the ioHub Process is checked for
# events every 50 msec or so, and they are cached in the PsychoPy process
# until the next getEvents() call is made. On Windows, messagePump() is also
# called periodically so that any Window you have created does not lock up.
#
while not keyboard.getEvents():
io.wait(0.25)
print("A Keyboard Event was Detected; exiting Test.")
io.quit()
def start_iohub(sess_code=None):
import time, os
# Create initial default session code
if sess_code is None:
sess_code='S_{0}'.format(long(time.mktime(time.localtime())))
# Ask for session name / hdf5 file name
save_to = fileSaveDlg(initFilePath=os.path.dirname(__file__),initFileName=sess_code,
prompt="Set Session Output File",
allowed="ioHub Datastore Files (*.hdf5)|*.hdf5")
if save_to:
# session code should equal results file name
fdir, sess_code = os.path.split(save_to)
sess_code=sess_code[0:min(len(sess_code),24)]
if sess_code.endswith('.hdf5'):
sess_code = sess_code[:-5]
if save_to.endswith('.hdf5'):
save_to = save_to[:-5]
else:
save_to = sess_code
exp_code='wintab_evts_test'
kwargs={'experiment_code':exp_code,
'session_code':sess_code,
'datastore_name':save_to,
'wintab.WintabTablet':{'name':'tablet',
'mouse_simulation': {'enable':False,
'leave_region_timeout':2.0
}
}
}
return launchHubServer(**kwargs)
def testEnabledDataStore():
"""
testEnabledDataStore is the same as testUsingPsychoPyMonitorConfig above,
but by adding an experiment_code parameter the ioHub DataStore will
be enabled, using a auto generated session_code each time it is run.
Experiment and session metadata is printed at the end of the demo.
Considerations:
* A Keyboard, Mouse, Monitor, and Experiment device are created by default.
* If the psychopy_monitor_name is valid, the ioHub Display is updated to
use the display size and viewing distance specified in the psychopy monitor config.
* ioHub DataStore is enabled because experiment_code is provided.
session_code will be auto generated using the current time.
"""
psychopy_mon_name='testMonitor'
exp_code='gap_endo_que'
io=launchHubServer(psychopy_monitor_name=psychopy_mon_name, experiment_code=exp_code)
display=io.devices.display
print('Display Psychopy Monitor Name: ', display.getPsychopyMonitorName())
print('Display Default Eye Distance: ', display.getDefaultEyeDistance())
print('Display Physical Dimensions: ', display.getPhysicalDimensions())
from pprint import pprint
print('Experiment Metadata: ')
pprint(io.getExperimentMetaData())
print('\nSession Metadata: ')
pprint(io.getSessionMetaData())
io.quit()
def testUsingPsychoPyMonitorConfig():
"""
testUsingPsychoPyMonitorConfig illustrates using the launchHubServer function
and providing a PsychoPy monitor configuration file name.
Considerations:
* A Keyboard, Mouse, Monitor, and Experiment device are created by default.
* If the psychopy_monitor_name is valid, the ioHub Display is updated to
use the display size and viewing distance specified in the psychopy monitor config.
* ioHub DataStore is not enabled.
"""
io=launchHubServer(psychopy_monitor_name='testMonitor')
# Get the default display device created.
#
display=io.devices.display
# print(the display's physical characteristics, showing they have
# been updated based on the settings in the PsychoPy monitor config.
#
print('Display Psychopy Monitor Name: ', display.getPsychopyMonitorName())
print('Display Default Eye Distance: ', display.getDefaultEyeDistance())
print('Display Physical Dimensions: ', display.getPhysicalDimensions())
# That's it, shut doqn the ioHub Proicess and exit. ;)
#
io.quit()
def testUsingPsychoPyMonitorConfig():
"""
testUsingPsychoPyMonitorConfig illustrates using the launchHubServer function
and providing a PsychoPy monitor configuration file name.
Considerations:
* A Keyboard, Mouse, Monitor, and Experiment device are created by default.
* If the psychopy_monitor_name is valid, the ioHub Display is updated to
use the display size and viewing distance specified in the psychopy monitor config.
* ioHub DataStore is not enabled.
"""
io = launchHubServer(psychopy_monitor_name='testMonitor')
# Get the default display device created.
#
display = io.devices.display
# print(the display's physical characteristics, showing they have
# been updated based on the settings in the PsychoPy monitor config.
#
print('Display Psychopy Monitor Name: ', display.getPsychopyMonitorName())
print('Display Default Eye Distance: ', display.getDefaultEyeDistance())
print('Display Physical Dimensions: ', display.getPhysicalDimensions())
# That's it, shut doqn the ioHub Proicess and exit. ;)
#
io.quit()
def testEnabledDataStore():
"""
testEnabledDataStore is the same as testUsingPsychoPyMonitorConfig above,
but by adding an experiment_code parameter the ioHub DataStore will
be enabled, using a auto generated session_code each time it is run.
Experiment and session metadata is printed at the end of the demo.
Considerations:
* A Keyboard, Mouse, Monitor, and Experiment device are created by default.
* If the psychopy_monitor_name is valid, the ioHub Display is updated to
use the display size and viewing distance specified in the psychopy monitor config.
* ioHub DataStore is enabled because experiment_code is provided.
session_code will be auto generated using the current time.
"""
psychopy_mon_name = 'testMonitor'
exp_code = 'gap_endo_que'
io = launchHubServer(psychopy_monitor_name=psychopy_mon_name,
experiment_code=exp_code)
display = io.devices.display
print('Display Psychopy Monitor Name: ', display.getPsychopyMonitorName())
print('Display Default Eye Distance: ', display.getDefaultEyeDistance())
print('Display Physical Dimensions: ', display.getPhysicalDimensions())
from pprint import pprint
print('Experiment Metadata: ')
pprint(io.getExperimentMetaData())
print('\nSession Metadata: ')
pprint(io.getSessionMetaData())
io.quit()
def testWithNoKwargs():
"""
testWithNoKwargs illustrates using the launchHubServer function with no
parameters at all. Considerations:
* A Keyboard, Mouse, Monitor, and Experiment device are created by default.
* All devices use their default parameter settings. Therefore, not very useful in real studies.
* ioHub DataStore is not enabled.
"""
io = launchHubServer()
# Get the default keyboard device created.
keyboard = io.devices.keyboard
print()
print("** PRESS A KEY TO CONTINUE.....")
# Check for new events every 1/4 second.
# By using the io.wait() fucntion, the ioHub Process is checked for
# events every 50 msec or so, and they are cached in the PsychoPy process
# until the next getEvents() call is made. On Windows, messagePump() is also
# called periodically so that any Window you have created does not lock up.
#
while not keyboard.getEvents():
io.wait(0.25)
print("A Keyboard Event was Detected; exiting Test.")
io.quit()
def startHubProcess():
io = launchHubServer()
assert io != None
io_proc = Computer.getIoHubProcess()
io_proc_pid = io_proc.pid
assert io_proc != None and io_proc_pid > 0
return io
def __connect_eyetracker(self, sample_rate: int=300) -> Any:
iohub_config: dict = {'eyetracker.hw.tobii.EyeTracker':
{'name': 'tracker',
'runtime_settings': {'sampling_rate': sample_rate}}
}
io: Any = launchHubServer(**iohub_config)
return io
def startHubProcess():
io = launchHubServer()
assert io != None
io_proc = Computer.getIoHubProcess()
io_proc_pid = io_proc.pid
assert io_proc != None and io_proc_pid > 0
return io
def connect_eyetracker(sample_rate = 300):
print("CONNECTING EYETRACKER...")
iohub_config = {'eyetracker.hw.tobii.EyeTracker':
{'name': 'tracker',
'runtime_settings': {'sampling_rate': sample_rate}}}
io = launchHubServer(**iohub_config)
print("SUCCESS!")
return io
def run():
global numEventRequests
io = launchHubServer(experiment_code='delay_test')
lastFlipTime = 0.0
# create fullscreen pyglet window at current resolution, as well as required resources / drawings
psychoWindow, psychoStim = createPsychoGraphicsWindow(io)
# create stats numpy arrays, set experiment process to high priority.
# Init Results numpy array
results= zeros((totalEventRequestsForTest,3),dtype='f4')
numEventRequests=0
# clear the ioHub event Buffer before starting the test.
# This is VERY IMPORTANT, given an existing bug in ioHub.
# You would want to do this before each trial started until the bug is fixed.
io.clearEvents('all')
# draw and flip to the updated graphics state.
flipTime = drawAndFlipPsychoWindow(psychoStim, psychoWindow, io, None)
ifi = flipTime - lastFlipTime
lastFlipTime = flipTime
# START TEST LOOP >>>>>>>>>>>>>>>>>>>>>>>>>>
while numEventRequests < totalEventRequestsForTest:
# send an Experiment Event to the ioHub server process
io.sendMessageEvent("This is a test message %.3f" % flipTime)
# check for any new events from any of the devices, and return the events list and the time it took to
# request the events and receive the reply
events, callDuration = checkForEvents(io)
if events:
# events were available
results[numEventRequests][0] = callDuration # ctime it took to get events from ioHub
results[numEventRequests][1] = len(events) # number of events returned
results[numEventRequests][2] = ifi * 1000.0 # calculating inter flip interval.
numEventRequests += 1 # incrementing tally counterfgh
# draw and flip to the updated graphics state.
flipTime = drawAndFlipPsychoWindow(psychoStim, psychoWindow, io, events)
ifi = flipTime - lastFlipTime
lastFlipTime = flipTime
# END TEST LOOP <<<<<<<<<<<<<<<<<<<<<<<<<<
psychoWindow.close()
# plot collected delay and retrace detection results.
plotResults(results)
printResults(results)
def start_iohub(sess_info):
'''
Starts the iohub server process, using data from the dict returned by
showSessionInfoDialog() to create the hdf5 file name. If the file
already exists, the existing file is renamed so that it is not
overwritten by the current sessions data.
iohub device configuration information is read from an
'iohub_config.yaml' file which must be in the same folder as this file.
The created ioHubConnection object is returned after the iohub
server has started and is ready for interaction with the experiment
runtime.
:param sess_info: dict returned from showSessionInfoDialog()
:return: ioHubConnection object
'''
import os, shutil
save_to = os.path.join(os.path.dirname(__file__),u'results',
sess_info['Session Code'])
save_to = os.path.normpath(save_to)
if not save_to.endswith('.hdf5'):
save_to = save_to+u'.hdf5'
fdir, sess_code = os.path.split(save_to)
if not os.path.exists(fdir):
os.mkdir(fdir)
#TODO: Ask if file should be overwritten, or new session code entered.
si = 1
save_dest = save_to
while os.path.exists(save_dest):
sname, sext = sess_code.rsplit(u'.',1)
save_dest = os.path.join(fdir, u"{}_{}.{}".format(sname,si,sext))
si+=1
if save_dest is not save_to:
shutil.move(save_to,save_dest)
sess_code=sess_code[0:min(len(sess_code),24)]
if sess_code.endswith(u'.hdf5'):
sess_code = sess_code[:-5]
if save_to.endswith(u'.hdf5'):
save_to = save_to[:-5]
kwargs={'experiment_code':EXP_NAME,
'session_code':sess_code,
'datastore_name':save_to,
'iohub_config_name': 'iohub_config.yaml'
}
return launchHubServer(**kwargs)
def __init__(self):
# Set up iohub and internal clock. Use existing ioHubServer if it exists.
from psychopy import iohub, core, sys
self._sys = sys
self._core = core
self._timeAtLastReset = core.getTime()
self._EventConstants = iohub.EventConstants
existing_iohub = iohub.ioHubConnection.ACTIVE_CONNECTION
self._io = existing_iohub if existing_iohub else iohub.launchHubServer()
import numpy
self._np = numpy
def __init__(self):
# Set up iohub and internal clock. Use existing ioHubServer if it exists.
from psychopy import iohub, core, sys
self._sys = sys
self._core = core
self._timeAtLastReset = core.getTime()
self._EventConstants = iohub.EventConstants
existing_iohub = iohub.ioHubConnection.ACTIVE_CONNECTION
self._io = existing_iohub or iohub.launchHubServer()
import numpy
self._np = numpy
def init_devices(self):
# Initialize test screen
if self.test_screen is not None:
self.close_test_screen = False
else:
self.test_screen = visual.Window(fullscr=True,
units='pix',
winType='pyglet')
self.test_screen.winHandle.activate()
self.test_screen.mouseVisible = False
# Initialize keyboard input
self.io = iohub.launchHubServer()
self.keyboard = self.io.devices.keyboard
def init_eyetracker(self):
if not self.eyetracker_on:
raise ValueError("Cannot initialize eyetracker if eyetracker_on=False!")
EYETRACKER_NAME = 'eyetracker.hw.sr_research.eyelink.EyeTracker'
# default_native_data_file_name: et_data
self.iohub = launchHubServer(
psychopy_monitor_name=self.monitor.name,
datastore_name='test_et',
**{EYETRACKER_NAME: {
'enable_interface_without_connection': True
}}
)
self.tracker = self.iohub.getDevice('eyetracker.hw.sr_research.eyelink.EyeTracker')
def EyeTrackerInitialization():
iohub_config = {
'eyetracker.hw.sr_research.eyelink.EyeTracker': {
'name': 'tracker',
'model_name': 'EYELINK 1000 DESKTOP',
'runtime_settings': {
'sampling_rate': 500,
'track_eyes': 'RIGHT'
}
}
}
io = launchHubServer(**iohub_config)
# Get the eye tracker device.
tracker = io.devices.tracker
return tracker
def __init__(self, rows, cols, buttons, maxTime, myWin, thisExp):
self.maxTime = maxTime
self.buttonGrid = ButtonGrid(myWin, buttons, rows=0, cols=6)
self.buttonGrid.autoDraw = False
self.io = iohub.launchHubServer()
self.trialN = 0
self.myWin = myWin
self.thisExp = thisExp
self.instr = visual.TextStim(win=self.myWin, name='instr',
text=u'+',
font='Comic Sans',
pos=(0, 0), height=180, wrapWidth=None, ori=0,
color='white', colorSpace='rgb', opacity=1,
depth=0.0);
self.freq = SigTo(value=440, time=0.001, init=440)
self.sine = SineLoop(freq=[self.freq, self.freq], feedback=0.08, mul=.3)
self.freqTarget = {'C': 261.626 ,'Cis': 277.183,'D' : 293.665,'Dis' : 311.127,'E' : 329.628,'F' : 349.228,'Fis' : 369.994,'G' : 391.995,'Gis' : 415.305,'A' : 440,'B' : 466.164,'H': 493.883}
def t5():
# Open the window and hide the cursor
w = visual.Window(screen=1, fullscr=True, units='pix')
m = event.Mouse(visible=False, win=w)
m.setExclusive(True)
# Turn on IOHub
io = iohub.launchHubServer()
kb = io.devices.keyboard
# Delay a while
t_end = core.getTime() + 10
while core.getTime() < t_end:
core.wait(0.010)
# Turn off iohub, release the cursor and close the window
io.quit()
m.setExclusive(False)
w.close()
def startIOHub():
"""
Starts the ioHub process, saving events to events.hdf5, recording data from
all standard devices as well as the ioSync MCU device.
"""
global io
import time
psychopy_mon_name = 'testMonitor'
exp_code = 'events'
sess_code = 'S_{0}'.format(int(time.mktime(time.localtime())))
iohub_config = {
"psychopy_monitor_name": psychopy_mon_name,
"mcu.iosync.MCU": dict(serial_port='auto',
monitor_event_types=['AnalogInputEvent',
'DigitalInputEvent']),
"experiment_code": exp_code,
"session_code": sess_code
}
return launchHubServer(**iohub_config)
def init_eyetracker(self):
""" Initializes eyetracker.
After initialization, tracker object ("device" in iohub lingo)
can be accessed from self.tracker
"""
if not self.eyetracker_on:
raise ValueError(
"Cannot initialize eyetracker if eyetracker_on=False!")
EYETRACKER_NAME = 'eyetracker.hw.sr_research.eyelink.EyeTracker'
self.iohub = launchHubServer(
psychopy_monitor_name=self.monitor.name,
**{
EYETRACKER_NAME: {
'enable_interface_without_connection': False,
}
})
self.tracker = self.iohub.devices.eyetracker
def testEnabledDataStoreAutoSessionCode():
"""
testEnabledDataStoreAutoSessionCode is the same as testEnabledDataStore
above, but session_code is provided by the script instead of being
auto-generated. The ioHub DataStore will be enabled, using the
experiment and session_code provided each time it is run. Experiment
and session metadata is printed at the end of the demo.
Considerations:
* A Keyboard, Mouse, Monitor, and Experiment device are created by
default.
* If the psychopy_monitor_name is valid, the ioHub Display is
updated to use the display size and viewing distance specified
in the psychopy monitor config.
* ioHub DataStore is enabled because experiment_code and
session_code are provided.
"""
import time
from pprint import pprint
psychopy_mon_name = 'testMonitor'
exp_code = 'gap_endo_que'
sess_code = 'S_{0}'.format(int(time.mktime(time.localtime())))
print('Current Session Code will be: ', sess_code)
io = launchHubServer(psychopy_monitor_name=psychopy_mon_name,
experiment_code=exp_code,
session_code=sess_code)
display = io.devices.display
print('Display Psychopy Monitor Name: ', display.getPsychopyMonitorName())
print('Display Default Eye Distance: ', display.getDefaultEyeDistance())
print('Display Physical Dimensions: ', display.getPhysicalDimensions())
print('Experiment Metadata: ')
pprint(io.getExperimentMetaData())
print('\nSession Metadata: ')
pprint(io.getSessionMetaData())
io.quit()
def testEnabledDataStoreAutoSessionCode():
"""
testEnabledDataStoreAutoSessionCode is the same as testEnabledDataStore
above, but session_code is provided by the script instead of being
auto-generated. The ioHub DataStore will be enabled, using the
experiment and session_code provided each time it is run. Experiment
and session metadata is printed at the end of the demo.
Considerations:
* A Keyboard, Mouse, Monitor, and Experiment device are created by
default.
* If the psychopy_monitor_name is valid, the ioHub Display is
updated to use the display size and viewing distance specified
in the psychopy monitor config.
* ioHub DataStore is enabled because experiment_code and
session_code are provided.
"""
import time
from pprint import pprint
psychopy_mon_name = 'testMonitor'
exp_code = 'gap_endo_que'
sess_code = 'S_{0}'.format(int(time.mktime(time.localtime())))
print('Current Session Code will be: ', sess_code)
io = launchHubServer(psychopy_monitor_name=psychopy_mon_name,
experiment_code=exp_code,
session_code=sess_code)
display = io.devices.display
print('Display Psychopy Monitor Name: ', display.getPsychopyMonitorName())
print('Display Default Eye Distance: ', display.getDefaultEyeDistance())
print('Display Physical Dimensions: ', display.getPhysicalDimensions())
print('Experiment Metadata: ')
pprint(io.getExperimentMetaData())
print('\nSession Metadata: ')
pprint(io.getSessionMetaData())
io.quit()
def start_iohub(sess_code=None):
import time, os
# Create initial default session code
if sess_code is None:
sess_code = 'S_{0}'.format(long(time.mktime(time.localtime())))
# Ask for session name / hdf5 file name
save_to = fileSaveDlg(initFilePath=os.path.dirname(__file__),
initFileName=sess_code,
prompt="Set Session Output File",
allowed="ioHub Datastore Files (*.hdf5)|*.hdf5")
if save_to:
# session code should equal results file name
fdir, sess_code = os.path.split(save_to)
sess_code = sess_code[0:min(len(sess_code), 24)]
if sess_code.endswith('.hdf5'):
sess_code = sess_code[:-5]
if save_to.endswith('.hdf5'):
save_to = save_to[:-5]
else:
save_to = sess_code
exp_code = 'wintab_evts_test'
kwargs = {
'experiment_code': exp_code,
'session_code': sess_code,
'datastore_name': save_to,
'wintab.WintabTablet': {
'name': 'tablet',
'mouse_simulation': {
'enable': False,
'leave_region_timeout': 2.0
}
}
}
return launchHubServer(**kwargs)
def startIOHub():
"""
Starts the ioHub process, saving events to events.hdf5, recording data from
all standard devices as well as the ioSync MCU device.
"""
global io
import time
psychopy_mon_name = 'testMonitor'
exp_code = 'events'
sess_code = 'S_{0}'.format(long(time.mktime(time.localtime())))
iohub_config = {
"psychopy_monitor_name":
psychopy_mon_name,
"mcu.iosync.MCU":
dict(serial_port='auto',
monitor_event_types=['AnalogInputEvent', 'DigitalInputEvent']),
"experiment_code":
exp_code,
"session_code":
sess_code
}
return launchHubServer(**iohub_config)
def __init__(self, root, filter=None, sample_rate=300, calibrate=True):
super(EyeTracker, self).__init__(filter)
self.daemon = True #??? TODO any issue with this closing down psychopy?
#https://stackoverflow.com/questions/40391812/running-code-when-closing-a-python-daemon
try:
from psychopy.iohub import launchHubServer
except Exception as e:
raise EyeTrackingError("IMPORT FAILED.", cause=e)
#self.io = connect_eyetracker(sample_rate = sample_rate)
iohub_config = {
'eyetracker.hw.tobii.EyeTracker': {
'name': 'tracker',
'runtime_settings': {
'sampling_rate': sample_rate
}
}
}
self.io = launchHubServer(**iohub_config)
self.tracker = self.io.devices.tracker
self.sample_rate = sample_rate
self.tk_root = root
#self.tk_root.bind("<Configure>", self.tk_update) #TODO some thought here, cannot bind multiple <Configure>..?
# transform eye tracking coordinates to tk window coordinates
self.tk_position = (self.tk_root.winfo_x(), self.tk_root.winfo_y())
self.tk_screen_size2 = (
root.winfo_screenwidth() / 2, root.winfo_screenheight() / 2
) #psychopy coordinate system is 0,0 screen center
if calibrate:
if not self.tracker.runSetupProcedure():
print("WARNING: EYETRACKER CALIBRATION FAILED")
self.closed = threading.Event()
name = "{0}:{1}".format(EyeTracker.__name__, str(0))
self.register(name)
fetching and processing events from hardware; mice, keyboards, eyetrackers). Inital Version: May 6th, 2013, Sol Simpson Abbrieviated: May 2013, Jon Peirce Updated July, 2013, Sol, Added timeouts """ from __future__ import division import sys from psychopy import visual, core from psychopy.iohub import launchHubServer # create the process that will run in the background polling devices io = launchHubServer() # some default devices have been created that can now be used display = io.devices.display keyboard = io.devices.keyboard mouse = io.devices.mouse # Hide the 'system mouse cursor'. mouse.setSystemCursorVisibility(False) # We can use display to find info for the Window creation, like the resolution # (which means PsychoPy won't warn you that the fullscreen does not match your requested size) display_resolution = display.getPixelResolution() # ioHub currently supports the use of a single full-screen PsychoPy Window win = visual.Window(display_resolution, units="pix", fullscr=True, allowGUI=False, screen=0)
def setup(cls):
if cls.io is not None:
cls.io.quit()
cls.io = iohub.launchHubServer()
cls.keyboard = cls.io.devices.keyboard
Demonstrate iohub module versus event module with a flip-loop.
iohub registers responses during win.flip(), thus always scores
responses as faster than event.getKeys() which timestamps according
to the time that the function is called.
Jonas Kristoffer Lindeløv, 2015.
"""
import psychopy
psychopy.useVersion("1.81.02")
from psychopy import iohub, visual, event
win = visual.Window()
textStim = visual.TextStim(win, text="press now", height=0.1, wrapWidth=100)
io = iohub.launchHubServer()
keyboard = io.devices.keyboard
# Comparing iohub.
while True:
# Animate and show results
textStim.ori += 0.1
textStim.draw()
win.flip()
# Get responses
event_getkeys = event.getKeys(timeStamped=True)
io_getpresses = keyboard.getPresses()
# Update text if a matching response was found
if len(event_getkeys) and len(io_getpresses):
from psychopy.iohub import launchHubServer, getCurrentDateTimeString
#Particicpant Info and Other Settings
info = {}
info['participant'] = '0'
info['dateStr'] = data.getDateStr() #will create str of current date/time
dlg = gui.DlgFromDict(info) #dialog box
if not dlg.OK: #did they push ok?
core.quit()
###############----ioHub Start and Hardware----#############
io = launchHubServer(iohub_config_name = 'iohub_config.yaml', experiment_code = info['participant'])
#Declare our Hardware
try:
tracker=io.devices.tracker
except Exception:
# No eye tracker config found in iohub_config.yaml
from psychopy.iohub.util import MessageDialog
md = MessageDialog(title="No Eye Tracker Configuration Found",
msg="Update the iohub_config.yaml file by "
"uncommenting\nthe appropriate eye tracker "
"config lines.\n\nPress OK to exit demo.",
showButtons=MessageDialog.OK_BUTTON,
dialogType=MessageDialog.ERROR_DIALOG,
allowCancel=False,
display_index=0)
import time
from psychopy import core
from psychopy.iohub import launchHubServer
getTime=core.getTime
try:
psychopy_mon_name='testMonitor'
exp_code='events'
sess_code='S_{0}'.format(long(time.mktime(time.localtime())))
iohub_config={
"psychopy_monitor_name":psychopy_mon_name,
"mcu.iosync.MCU":dict(serial_port='auto',monitor_event_types=['DigitalInputEvent',]),
"experiment_code":exp_code,
"session_code":sess_code
}
io=launchHubServer(**iohub_config)
mcu=io.devices.mcu
kb=io.devices.keyboard
core.wait(0.5)
mcu.enableEventReporting(True)
io.clearEvents("all")
while not kb.getEvents():
mcu_events= mcu.getEvents()
for mcu_evt in mcu_events:
print'{0}\t{1}'.format(mcu_evt.time,mcu_evt.state)
core.wait(0.002,0)
io.clearEvents('all')
except Exception:
import traceback
traceback.print_exc()
Demo of using the iohub mouse.
"""
import sys
from psychopy import visual, core
from psychopy.iohub import launchHubServer
win = visual.Window((1920, 1080),
units='height',
fullscr=True,
allowGUI=False,
screen=0)
# create the process that will run in the background polling devices
io = launchHubServer(window=win)
# some default devices have been created that can now be used
keyboard = io.devices.keyboard
mouse = io.devices.mouse
mouse.setPosition((0.0, .250))
#win.setMouseVisible(False)
# Create some psychopy visual stim
fixSpot = visual.GratingStim(win,
tex="none",
mask="gauss",
pos=(0, 0),
size=(.03, .03),
color='black',
autoLog=False)
logFile = logging.LogFile(filename+'.log', level=logging.DEBUG)
logging.console.setLevel(logging.WARNING) # this outputs to the screen, not a file
# 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)
#-------------------------------------------------------------------------------
# iohub stuff
#-------------------------------------------------------------------------------
# create the process that will run in the background polling devices
io=launchHubServer(experiment_code='target-sequences', psychopy_monitor_name='default')
# some default devices have been created that can now be used
display = io.devices.display
keyboard = io.devices.keyboard
mouse=io.devices.mouse
# Hide the 'system mouse cursor'.
mouse.setSystemCursorVisibility(False)
mouse.enableEventReporting(True)
# We can use display to find info for the Window creation, like the resolution
# (which means PsychoPy won't warn you that the fullscreen does not match your requested size)
display_resolution=display.getPixelResolution()
#-------------------------------------------------------------------------------
# Create a circle to use for the Gaze Cursor. Current units assume pix.
#
gaze_dot = visual.GratingStim(window, tex=None, mask="gauss", pos=(0, 0),
size=(0.1, 0.1), color='green')
# Create a Text Stim for use on /instruction/ type screens.
# Current units assume pix.
instructions_text_stim = visual.TextStim(window, text='', pos=[0, 0], units='pix', height=24, color=[-1, -1, -1],
wrapWidth=window.size[0]*.9)
exp_conditions = importConditions('trial_conditions.xlsx')
trials = TrialHandler(exp_conditions, 1)
io_hub = launchHubServer(window=window, experiment_code='gc_cursor', **devices_config)
# Inform the ioDataStore that the experiment is using a TrialHandler. The ioDataStore will create a table
# which can be used to record the actual trial variable values (DV or IV) in the order run / collected.
#
io_hub.createTrialHandlerRecordTable(trials)
# Let's make some short-cuts to the devices we will be using in this demo.
tracker = None
try:
tracker = io_hub.devices.tracker
except Exception:
print(" No eye tracker config found in iohub_config.yaml")
io_hub.quit()
core.quit()
display = io_hub.devices.display
from __future__ import print_function
from psychopy import iohub
from psychopy.visual.window import Window
from psychopy.visual.circle import Circle
io = iohub.launchHubServer()
mouse = io.devices.mouse
win = Window(units='pix', fullscr=True)
circle = Circle(win, size=300)
circle.draw()
win.flip()
mouse.clearEvents()
while True:
e = mouse.getEvents(event_type=(iohub.EventConstants.MOUSE_BUTTON_PRESS))
if e:
x, y = e[0].x_position, e[0].y_position
if circle.contains((x, y), units='pix'):
print('Received button press!')
break
win.close()
io.quit()
Displays event information from ioHub Keyboard Events.
Inital Version: May 6th, 2013, Sol Simpson
Updated June 22nd: Added demo timeout. SS
"""
from psychopy import core, visual
from psychopy.iohub import launchHubServer, EventConstants
# launchHubServer is a fucntion that can be used to create an instance of the
# ioHub Process within a procedural PsychoPy Script and without the need for
# external configuration files. It is useful when devices like the Keyboard,
# Mouse, Display, and Experiment are all that is needed. By default the
# Display device will use pixel units and display index 0 of a multimonitor setup.
# The returned 'io' variable gives access to the ioHub Process.
#
io = launchHubServer(experiment_code='key_evts',
psychopy_monitor_name='default')
# Devices that have been created on the ioHub Process and will be monitored
# for events during the experiment can be accessed via the io.devices.* attribute.
#
# save some 'dots' during the trial loop
#
display = io.devices.display
keyboard = io.devices.keyboard
mouse = io.devices.mouse
# Hide the 'system mouse cursor'.
mouse.setSystemCursorVisibility(False)
# Get settings needed to create the PsychoPy full screen window.
# - display_resolution: the current resolution of diplsay specified by the screen_index.
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
Test for using iohub mouse with multiple windows on multiple monitors.
To enable multi window support for the iohub Mouse device:
launchHubServer(window=win, Mouse=dict(enable_multi_window=True))
In this mode, if the mouse is over a psychopy window, mouse position is returned
as the pix position within the window, with origin (0,0) at window center. mouse event
window_id will equal a psychopy window handle (pyglet only).
Note: If testing using 'cm' or 'deg' units, use your actual monitor configurations
or update the `monitors.Monitor` created below to match your setup.
If the mouse is not over a psychopy window, desktop mouse position is returned with
window_id = 0.
"""
import sys
from psychopy import visual, core, monitors
from psychopy.iohub import launchHubServer
from psychopy.iohub.constants import EventConstants
# True = print mouse events to stdout, False = do not
PRINT_MOUSE_EVENTS = False
# Test creating a monitor before starting iohub
mon0 = monitors.Monitor('monitor0')
mon0.setDistance(60.0)
"""
Created on Thu Oct 17 22:46:06 2013
@author: Sol
"""
from __future__ import print_function
from builtins import str
from psychopy import visual,core
from psychopy.data import TrialHandler,importConditions
from psychopy.iohub import launchHubServer,Computer,EventConstants
getTime=Computer.getTime
psychopy_mon_name='testMonitor'
exp_code='io_stroop'
io=launchHubServer(psychopy_monitor_name=psychopy_mon_name, experiment_code=exp_code)
io.sendMessageEvent(category='EXP',text='Experiment Started')
kb=io.devices.keyboard
mouse = io.devices.mouse
win = visual.Window(allowGUI=False,fullscr=True)
gabor = visual.GratingStim(win,tex="sin",mask="gauss",texRes=256,
size=[200.0,200.0], sf=[4,0], ori = 0, name='gabor1')
letter = visual.TextStim(win,pos=(0.0,0.0),text='X')
retrace_count=0
def loggedFlip(letter_char,letter_color):
global retrace_count
gabor.draw()
iohubkwargs = {
'psychopy_monitor_name':
psychopy_mon_name,
'experiment_code':
exp_code,
'session_code':
sess_code,
'serial.Serial':
dict(name='serial',
port=SERIAL_PORT,
baud=BAUDRATE,
event_parser=dict(byte_diff=True))
}
# start the iohub server and set up display and PST box devices
io = launchHubServer(**iohubkwargs)
display = io.devices.display
pstbox = io.devices.serial
# Prepare the PST box.
#
# Bit 7 = 128 -> Enable/Disable streaming.
# Bit 6 = 64 -> Lower bits control lamp state.
# Bit 5 = 32 -> Enable/Disable button queries.
# Bit 0-4 = 1-16 -> Enable/Disable Lamp 0-4.
#
# Source: https://psychtoolbox-3.googlecode.com/svn/beta/Psychtoolbox/PsychHardware/CMUBox.m
print('Switching response box to streaming mode and switching on lamp #3...')
pstbox.write(chr(np.uint8(128 + 32 + 64 + 4)))
core.wait(0.25)
print('...done.')
from psychopy import visual, core
from psychopy.iohub import launchHubServer, EventConstants
def normalizedValue2Coord(normed_position,normed_magnitude,display_coord_area):
x,y=normed_position[0]*normed_magnitude,normed_position[1]*normed_magnitude
w,h=display_coord_area
return x*(w/2.0),y*(h/2.0)
if __name__ == '__main__':
# Start the ioHub Event Server, requesting an XInput Gamepad Device to be
# created along with the default devices. Since the configuration dict
# for the Gamepad is empty, all default values will be used.
#
kwargs={'psychopy_monitor_name':'default','xinput.Gamepad':{}}
io=launchHubServer(**kwargs)
display = io.devices.display
mouse = io.devices.mouse
display = io.devices.display
keyboard = io.devices.keyboard
gamepad = io.devices.gamepad
display_resolution=display.getPixelResolution()
psychopy_monitor=display.getPsychopyMonitorName()
unit_type=display.getCoordinateType()
screen_index=display.getIndex()
dl,dt,dr,db=display.getCoordBounds()
coord_size=dr-dl,dt-db
myWin=visual.Window(display_resolution, monitor=psychopy_monitor,
Displays event information from ioHub Keyboard Events. Inital Version: May 6th, 2013, Sol Simpson """ from psychopy import visual from psychopy.iohub import launchHubServer,EventConstants # launchHubServer is a fucntion that can be used to create an instance of the # ioHub Process within a procedural PsychoPy Script and without the need for # external configuration files. It is useful when devices like the Keyboard, # Mouse, Display, and Experiment are all that is needed. By default the # Display device will use pixel units and display index 0 of a multimonitor setup. # The returned 'io' variable gives access to the ioHub Process. # io=launchHubServer(experiment_code='key_evts',psychopy_monitor_name='default') # Devices that have been created on the ioHub Process and will be monitored # for events during the experiment can be accessed via the io.devices.* attribute. # # save some 'dots' during the trial loop # display = io.devices.display keyboard = io.devices.keyboard mouse=io.devices.mouse # Hide the 'system mouse cursor'. mouse.setSystemCursorVisibility(False) # Get settings needed to create the PsychoPy full screen window. # - display_resolution: the current resolution of diplsay specified by the screen_index.
Inital Version: May 6th, 2013, Sol Simpson Abbrieviated: May 2013, Jon Peirce Updated July, 2013, Sol, Added timeouts """ from __future__ import division from __future__ import print_function import sys from psychopy import visual, core from psychopy.iohub import launchHubServer # create the process that will run in the background polling devices io = launchHubServer() # some default devices have been created that can now be used display = io.devices.display keyboard = io.devices.keyboard mouse = io.devices.mouse # Hide the 'system mouse cursor'. mouse.setSystemCursorVisibility(False) # We can use display to find info for the Window creation, like the resolution # (which means PsychoPy won't warn you that the fullscreen does not match your requested size) display_resolution = display.getPixelResolution() # ioHub currently supports the use of a single full-screen PsychoPy Window win = visual.Window(display_resolution,
# standard from __future__ import print_function, division from psychopy.iohub import launchHubServer _IO_HUB = launchHubServer()
# -*- coding: utf-8 -*-
"""
keyboard_rt.run.py
Keyboard Reaction Time Calculation shown within a line length matching task.
Initial Version: May 6th, 2013, Sol Simpson
"""
from __future__ import absolute_import, division, print_function
from psychopy import core, visual
from psychopy.iohub import launchHubServer
from math import fabs
io = launchHubServer(psychopy_monitor_name='default')
display = io.devices.display
win = visual.Window(display.getPixelResolution(), monitor='default',
units='pix', fullscr=True, allowGUI=False)
# save some 'dots' during the trial loop
keyboard = io.devices.keyboard
# constants for use in example
line_size_match_delay = 5 + int(core.getTime() * 1000) % 5
full_length = win.size[0] / 2
latest_length = 0
static_bar = visual.ShapeStim(win=win, lineColor='Firebrick',
fillColor='Firebrick',
vertices=[[0, 0], [full_length, 0], [full_length, 5], [0, 5]],
psychopy_mon_name = 'testMonitor'
exp_code = 'events'
sess_code = 'S_{0}'.format(long(time.mktime(time.localtime())))
iohub_config = {
"psychopy_monitor_name":
psychopy_mon_name,
"mcu.iosync.MCU":
dict(serial_port='auto', monitor_event_types=[
'DigitalInputEvent',
]),
"experiment_code":
exp_code,
"session_code":
sess_code
}
io = launchHubServer(**iohub_config)
mcu = io.devices.mcu
kb = io.devices.keyboard
core.wait(0.5)
mcu.enableEventReporting(True)
io.clearEvents("all")
while not kb.getEvents():
mcu_events = mcu.getEvents()
for mcu_evt in mcu_events:
print '{0}\t{1}'.format(mcu_evt.time, mcu_evt.state)
core.wait(0.002, 0)
io.clearEvents('all')
except:
import traceback
traceback.print_exc()
SERIAL_PORT = 'COM5'
BAUDRATE = 19200
# ioHub configuration.
psychopy_mon_name = 'Monitor_01'
exp_code = 'pstbox'
sess_code = 'S_{0}'.format(int(time.mktime(time.localtime())))
iohubkwargs = {
'psychopy_monitor_name': psychopy_mon_name,
'experiment_code': exp_code,
'session_code': sess_code,
'serial.Pstbox': dict(name='pstbox', port=SERIAL_PORT, baud=BAUDRATE)
}
# Start the iohub server and set up devices.
io = launchHubServer(**iohubkwargs)
computer = Computer
display = io.devices.display
pstbox = io.devices.pstbox
print('Switching on lamp #3...')
pstbox.setLampState([0, 0, 1, 0, 0])
print('...done.')
# Create a window.
win = visual.Window(
display.getPixelResolution(),
units='pix', fullscr=True, allowGUI=False,
screen=0
)
def main(fCue, fStim, fInterval, fTest, fPause, recLength, recWidth,
cubeLength, cubeWidth, tPerBlock, stimType, arraySize, targPresent,
numTrials):
fStim = fStim
fTest = fTest
fPause = fPause
recLength = recLength
recWidth = recWidth
cubeLength = cubeLength
cubeWidth = cubeWidth
tPerBlock = tPerBlock
stimType = stimType
arraySize = arraySize
targPresent = targPresent
numTrials = numTrials
# Ensure that relative paths start from the same directory as this script
_thisDir = os.path.dirname(os.path.abspath(__file__))
os.chdir(_thisDir + u'\%s%s%s' % (targPresent[0], stimType, arraySize[0]))
# Store info about the experiment session
expName = 'VST.py'
expInfo = {'session': '001', 'participant': ''}
dlg = gui.DlgFromDict(dictionary=expInfo, title=expName)
if dlg.OK == False:
core.quit() # user pressed cancel
expInfo['date'] = data.getDateStr() # add a simple timestamp
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'])
# 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
# 300 x 2 x 10 x 1 matrix
# 300 entries, xy for each shape, 10 shape locations
f = open('genCoorVST.pckl', 'rb')
genCoor = pickle.load(f)
f.close()
win = visual.Window([1600, 900], units='height', fullscr=True)
clock = core.Clock()
# KEYBOARD STUFF
# Start iohub process. The iohub process can be accessed using `io`.
io = launchHubServer()
# A `keyboard` variable is used to access the iohub Keyboard device.
keyboard = io.devices.keyboard
events = keyboard.getKeys()
# INITIALIZE
# trialN : number of trial
# trialResp : their response on each trial
# correctResp : if their response was correct
# responseTime : the amount of time it took for them to respond on each trial
m = 0
trialN = [-1 for x in range(numTrials)]
trialResp = [9 for x in range(numTrials)]
correctResp = [9 for x in range(numTrials)]
responseTime = [0 for x in range(numTrials)]
respChar = [['r', 'i'], ['f', 'j']]
numSet = 100
rectangles = not stimType
shapeN = [[], []]
# COLORS
recColors = ['#0000ff', '#ff0000']
cubeColors = [['#0000ff', '#9999ff', '#000066'],
['#ff0000', '#ff9999', '#660000']]
# STIMULI
center = [0, 0]
posTheta = [0, math.pi / 4, math.pi / 2, 3 * math.pi / 4]
posCubes = [0, 1]
pauseText = visual.TextStim(win,
text="Press the Spacebar to Continue",
font=u'Arial',
pos=(0, 0),
height=0.1,
wrapWidth=None,
ori=0,
color=u'white',
colorSpace='rgb',
opacity=1,
depth=0.0)
# rotates [x,y] by theta
def rotate(xy, center, theta):
#pts = {} Rotates points(nx2) about center by angle theta in radians
return numpy.dot(
xy - center,
numpy.array([[math.cos(theta), math.sin(theta)],
[-math.sin(theta), math.cos(theta)]])) + center
def rotateRec(center, theta):
center = center
theta = theta
p1 = [center[0] - recWidth, center[1] - recLength]
p2 = [center[0] - recWidth, center[1] + recLength]
p3 = [center[0] + recWidth, center[1] + recLength]
p4 = [center[0] + recWidth, center[1] - recLength]
rVert = rotate(numpy.array([p1, p2, p3, p4]), center, theta)
return rVert
# creates a three-sided cube
def cubeCreator(centerV, cubeType):
center = centerV
cubeType = cubeType
if cubeType == 0:
p1 = [center[0], center[1]]
p2 = [center[0], center[1] - cubeLength]
p3 = [center[0] - cubeWidth, center[1] - cubeLength / 2]
p4 = [center[0] - cubeWidth, center[1] + cubeLength / 2]
sideOne = [p1, p2, p3, p4]
q1 = [center[0], center[1]]
q2 = [center[0], center[1] - cubeLength]
q3 = [center[0] + cubeWidth, center[1] - cubeLength / 2]
q4 = [center[0] + cubeWidth, center[1] + cubeLength / 2]
sideTwo = [q1, q2, q3, q4]
r1 = [center[0], center[1]]
r2 = [center[0] - cubeWidth, center[1] + cubeLength / 2]
r3 = [center[0], center[1] + cubeLength]
r4 = [center[0] + cubeWidth, center[1] + cubeLength / 2]
sideThree = [r1, r2, r3, r4]
else:
m1 = [center[0], center[1]]
m2 = [center[0], center[1] + cubeLength]
m3 = [center[0] + cubeWidth, center[1] + cubeLength / 2]
m4 = [center[0] + cubeWidth, center[1] - cubeLength / 2]
sideOne = [m1, m2, m3, m4]
n1 = [center[0], center[1]]
n2 = [center[0], center[1] + cubeLength]
n3 = [center[0] - cubeWidth, center[1] + cubeLength / 2]
n4 = [center[0] - cubeWidth, center[1] - cubeLength / 2]
sideTwo = [n1, n2, n3, n4]
s1 = [center[0], center[1]]
s2 = [center[0] - cubeWidth, center[1] - cubeLength / 2]
s3 = [center[0], center[1] - cubeLength]
s4 = [center[0] + cubeWidth, center[1] - cubeLength / 2]
sideThree = [s1, s2, s3, s4]
# k cubes x 3 sides x 4 vertices x 2 coordinates
cVert = [sideOne, sideTwo, sideThree]
return cVert
def randShuf(inputList):
shufList = inputList[:]
while True:
random.shuffle(shufList)
for a, b in zip(inputList, shufList):
if a == b:
break
else:
return shufList
def recDraw(frames, nStim, stimulus, changeT, order):
frames = frames
for k in range(nStim):
stimulus[k].draw()
print('stimType%d_arraySize%d_trial%d_targPresent%d_order%d.png' %
(stimType, arraySize[t], t, targPresent[t], order))
time.sleep(0.03)
win.getMovieFrame(buffer='back')
win.flip()
win.saveMovieFrames(
'stimType%d_arraySize%d_trial%d_targPresent%d_order%d.png' %
(stimType, arraySize[t], t, targPresent[t], order))
def cubeDraw(frames, nStim, stimulus, changeT, order):
frames = frames
for j in range(nStim):
for k in range(3):
stimulus[j][k].draw()
stimulus[j][k].draw()
print('stimType%d_arraySize%d_trial%d_targPresent%d_order%d.png' %
(stimType, arraySize[t], t, targPresent[t], order))
time.sleep(0.03)
win.getMovieFrame(buffer='back')
win.flip()
win.saveMovieFrames(
'stimType%d_arraySize%d_trial%d_targPresent%d_order%d.png' %
(stimType, arraySize[t], t, targPresent[t], order))
for t in range(numTrials):
if (t % tPerBlock == 0) & (t > 1):
waiting = []
while not ' ' in waiting:
pauseText.draw()
win.flip()
waiting = keyboard.getKeys()
random.shuffle(recColors[0][0])
trialN[t] = t + 1
nStim = arraySize[t]
shapes = [[] for i in range(nStim)]
recStim = [[] for i in range(nStim)]
recVert = [[] for i in range(nStim)]
cubeV = [[] for i in range(nStim)]
# 3 because 3 sides
targCube = [[] for i in range(3)]
cubeStim = [[[], [], []] for i in range(nStim)]
stimIndex = nStim - 1
# START WORKING HERE
# Choose random trial and get center coordinates of objects
# ASSUMING ARRAYSIZE[T] IS A VECTOR OF ARRAY SIZES
# genCoor (300 x 2 x 10 x 1)
# 300 sets, (X pos, Y pos), 10 points
# x any y pos of arraySize[t] locations
randInt = random.randint(0, numSet - 1)
for j in range(0, nStim):
xCoor = genCoor[randInt, 0, j]
yCoor = genCoor[randInt, 1, j]
shapes[j] = [xCoor[0], yCoor[0]]
if rectangles:
# create a unique rectangle that will only been seen once or not at all
random.shuffle(posTheta)
coinFlip = (random.random() > .5)
targTheta = posTheta[0]
targColor = coinFlip
targRectVert = rotateRec([0, 0], targTheta)
# creates unique rectangle for cue
targRect = ShapeStim(win,
vertices=targRectVert,
fillColor=recColors[targColor],
size=.5)
# creates numRect rectangles with random orientations and random colors
for k in range(nStim):
coinFlip = (random.random() > .5)
random.shuffle(posTheta)
while posTheta[0] == targTheta and coinFlip == targColor:
coinFlip = (random.random() > .5)
random.shuffle(posTheta)
recVert[k] = rotateRec(shapes[k], posTheta[0])
recStim[k] = ShapeStim(win,
vertices=recVert[k],
fillColor=recColors[coinFlip],
size=.5)
coinFlip = (random.random() > .5)
random.shuffle(posTheta)
else:
# create a unique cube that will only been seen once or not at all
random.shuffle(posCubes)
coinFlip = (random.random() > .5)
targOrientation = posCubes[coinFlip]
random.shuffle(cubeColors[coinFlip])
targCubeColors = cubeColors[coinFlip][:]
targCubeVert = cubeCreator([0, 0], targOrientation)
# creates unique cube for cue
for b in range(3):
targCube[b] = ShapeStim(win,
vertices=targCubeVert[b],
fillColor=targCubeColors[b],
size=.5)
for j in range(nStim):
coinFlip = (random.random() > .5)
random.shuffle(posCubes)
random.shuffle(cubeColors[0])
random.shuffle(cubeColors[1])
while posCubes[0] == targOrientation and cubeColors[
coinFlip] == targCubeColors:
coinFlip = (random.random() > .5)
random.shuffle(posCubes)
random.shuffle(cubeColors[0])
random.shuffle(cubeColors[1])
cubeVert = cubeCreator(shapes[j], posCubes[0])
cubeV[j] = cubeCreator(shapes[j], posCubes[0])
# creates each side
for i in range(3):
cubeStim[j][i] = ShapeStim(
win,
vertices=cubeVert[i],
fillColor=cubeColors[coinFlip][i],
size=.5)
# STIM PRESENTATION
#
# presents target
if rectangles:
recDraw(fStim, 1, [targRect], targPresent[t], 0)
else:
cubeDraw(fStim, 1, [targCube], targPresent[t], 0)
## presents interval
#for frameN in range(fPause + 1):
# win.flip()
# presents stim
if targPresent[t]:
if rectangles:
# inserts target rectangle into line-up
targRect = rotateRec(shapes[0], targTheta)
recStim[0] = ShapeStim(win,
vertices=targRect,
fillColor=recColors[targColor],
size=.5)
recDraw(fStim, nStim, recStim, targPresent[t], 1)
else:
# inserts target cube into line-up
for b in range(3):
cubeStim[0][b] = ShapeStim(win,
vertices=cubeV[0][b],
fillColor=targCubeColors[b],
size=.5)
cubeDraw(fStim, nStim, cubeStim, targPresent[t], 1)
else:
if rectangles:
recDraw(fStim, nStim, recStim, targPresent[t], 1)
else:
cubeDraw(fStim, nStim, cubeStim, targPresent[t], 1)
if trialResp[t] == targPresent[t]:
correctResp[t] = 1
else:
correctResp[t] = 0
# OUTPUT
print()
print('Correct response trials')
print(correctResp)
print('Percent correct')
print(sum(correctResp) / numTrials)
print('Response Time')
print(responseTime)
print('Average response time')
print(sum(responseTime) / numTrials)
thisExp.addData('correct responses', correctResp)
thisExp.nextEntry()
thisExp.addData('response times', responseTime)
thisExp.nextEntry()
# these shouldn't be strictly necessary (should auto-save)
thisExp.saveAsWideText(filename + '.csv')
thisExp.saveAsPickle(filename)
logging.flush()
# make sure everything is closed down
thisExp.abort() # or data files will save again on exit
origLUT = numpy.round(win.backend._origGammaRamp *
65535.0).astype("uint16")
origLUT = origLUT.byteswap() / 255.0
win.backend._origGammaRamp = origLUT
win.close()
core.quit()
def generate_variables(game):
# game logic
game.show_feedback = False
game.show_cue = False
game.header_written = False
game.feedback_score_history = [0]
game.feedback_requesting_bool = False
game.trial_stage = 'splash' # splash, zscore, cue, wait, feedback, iti
game.feedback_status = 'idle' # idle, calculated
# input/output
io = launchHubServer()
game.keyboard = io.devices.keyboard
game.monitor = monitors.Monitor('projector',
width=game.SCREEN_WIDTH,
distance=game.SCREEN_DISTANCE)
game.monitor.setSizePix(game.SCREEN_DIMS)
game.screen = visual.Window(game.SCREEN_DIMS,
monitor=game.monitor,
fullscr=game.FULLSCREEN,
units='deg',
color=game.BG_COLOR,
colorSpace='rgb')
# visual stims
game.max_score_circ = visual.Circle(game.screen,
edges=64,
lineWidth=1,
lineColor=game.BG_COLOR,
lineColorSpace='rgb',
fillColor=game.SCORE_COLOR,
fillColorSpace='rgb255',
radius=0.5 *
game.SCORE_DIAMETER_MAX_INDICATOR,
interpolate=True)
game.max_score_circ_mask = visual.Circle(game.screen,
edges=64,
lineWidth=1,
lineColor=game.BG_COLOR,
lineColorSpace='rgb',
fillColor=game.BG_COLOR,
fillColorSpace='rgb',
radius=0.5 *
game.SCORE_DIAMETER_MAX,
interpolate=True)
game.score_circ = visual.Circle(game.screen,
edges=64,
lineWidth=1,
lineColor=game.SCORE_COLOR,
lineColorSpace='rgb255',
fillColor=game.SCORE_COLOR,
fillColorSpace='rgb255',
radius=0.5 * game.SCORE_DIAMETER_MIN,
interpolate=True)
game.score_circ_mask = visual.Circle(game.screen,
edges=64,
lineWidth=1,
lineColor=game.BG_COLOR,
lineColorSpace='rgb',
fillColor=game.BG_COLOR,
fillColorSpace='rgb',
radius=0.5 *
game.SCORE_DIAMETER_MIN_INDICATOR,
interpolate=True)
game.fixation = visual.Circle(game.screen,
lineWidth=1,
lineColor=game.FIXATION_COLOR,
lineColorSpace='rgb',
fillColor=game.FIXATION_COLOR,
fillColorSpace='rgb',
radius=0.5 * game.FIXATION_DIAMETER,
interpolate=True)
game.cue = visual.Circle(game.screen,
lineWidth=1,
lineColor=game.SCORE_COLOR,
lineColorSpace='rgb255',
fillColor=game.SCORE_COLOR,
fillColorSpace='rgb255',
radius=0.5 * game.FIXATION_DIAMETER,
interpolate=True)
game.splash_msg = visual.TextStim(
game.screen,
text=game.SPLASH_MSG_BASE.format(current=str(1), total=str(game.RUNS)))
game.reward_msg = visual.TextStim(game.screen, text='', pos=(0, 2.5))
game.debug_msg = visual.TextStim(game.screen, text='', pos=(-0.25, -0.25))
game.debug_msg_base = ('last volume: {last_vol}\n' +
'last classifier: {last_clf}\n')
# timers
game.trial_clock = core.Clock()
game.feedback_update_clock = core.Clock()
game.self_pace_start_clock = core.Clock()
game.trial_count = 0
game.run_count = -1
# reward
game.run_reward_history = []
game.total_reward = 0