def __init__(self):
self._connection = connect_client(type=peers.LOGIC)
self._long_mgr = UgmConfigManager()
self._long_mgr.update_from_file(LONG_FILE, True)
self._word_mgr = UgmConfigManager()
self._word_mgr.update_from_file(WORD_FILE, True)
self.fixation = '+'
self.mask = 'XXXXXXXXXXXXXX'
self.available_keys = ['1', '2', '3', '4', '5']
self.word_config = {'id': 5555, 'message': ''}
self.img_config = {'id': 6666, 'image_path': ''}
self.data_manager = DataManager()
self.run_tag = {}
def __init__(self):
self._connection = connect_client(type = peers.LOGIC)
self._long_mgr = UgmConfigManager()
self._long_mgr.update_from_file(LONG_FILE, True)
self._word_mgr = UgmConfigManager()
self._word_mgr.update_from_file(WORD_FILE, True)
self.fixation = '+'
self.mask = 'XXXXXXXXXXXXXX'
self.available_keys = ['1','2','3','4','5']
self.word_config = {'id':5555, 'message':''}
self.img_config = {'id':6666, 'image_path':''}
self.data_manager = DataManager()
self.run_tag = {}
def __init__(self, p_config_name=None):
super(Experiment_manager, self).__init__()
self.config_file = self.read_experiment_config(p_config_name)
print self.config_file
self.screens = self.config_file['screens']
self.sc_configs = []
self.repeats = self.config_file['repeats']
self.readable_names = self.config_file['readable_names']
self.programme = self.config_file['file_to_run']
# set up screens configuration - pair screens with diode freqs
if not self.config_file.get('USE_DEFAULT_FREQS'):
self.freq_sets = self.config_file['freqs']
print "UWAGA"
print ""
print ""
print self.screens
print len(self.screens)
print self.freq_sets
print len(self.freq_sets)
assert(len(self.screens) == len(self.freq_sets))
self.sc_configs = [zip(scr, fre) for scr, fre in zip(self.screens,
self.freq_sets)]
else:
def_freqs = self.config_file['DEFAULT_FREQS']
assert(def_freqs != None)
self.sc_configs = [zip(scr, def_freqs) for scr in self.screens]
LOGGER.info("screens and freqs: \n" + \
str(self.sc_configs))
self._prepare_screens(self.sc_configs)
LOGGER.debug("SHUFFLED screens and freqs: \n" + \
str(self.sc_configs))
self._delay = self.config_file['delay']
self._last_delay = None
try:
self._delay + 0
# No error, delay is not random, just a number
self._rand_delay = False
except TypeError:
self._rand_delay = True
self.config_manager = UgmConfigManager()
self._connection = None
self._screen_sounds = self.config_file.get('sounds', None)
self._screen_look_num = 0
if self._screen_sounds:
import pygame
import settings
pygame.init()
for i, s in enumerate(self._screen_sounds):
self._screen_sounds[i] = os.path.join(
settings.module_abs_path(),
self._screen_sounds[i])
class Experiment_manager(object):
"""This class is responsible for managing UGM experiments. It loads and holds configs
of those experiments and makes it possible to run them"""
def __init__(self, p_config_name=None):
super(Experiment_manager, self).__init__()
self.config_file = self.read_experiment_config(p_config_name)
print self.config_file
self.screens = self.config_file['screens']
self.sc_configs = []
self.repeats = self.config_file['repeats']
self.readable_names = self.config_file['readable_names']
self.programme = self.config_file['file_to_run']
# set up screens configuration - pair screens with diode freqs
if not self.config_file.get('USE_DEFAULT_FREQS'):
self.freq_sets = self.config_file['freqs']
print "UWAGA"
print ""
print ""
print self.screens
print len(self.screens)
print self.freq_sets
print len(self.freq_sets)
assert(len(self.screens) == len(self.freq_sets))
self.sc_configs = [zip(scr, fre) for scr, fre in zip(self.screens,
self.freq_sets)]
else:
def_freqs = self.config_file['DEFAULT_FREQS']
assert(def_freqs != None)
self.sc_configs = [zip(scr, def_freqs) for scr in self.screens]
LOGGER.info("screens and freqs: \n" + \
str(self.sc_configs))
self._prepare_screens(self.sc_configs)
LOGGER.debug("SHUFFLED screens and freqs: \n" + \
str(self.sc_configs))
self._delay = self.config_file['delay']
self._last_delay = None
try:
self._delay + 0
# No error, delay is not random, just a number
self._rand_delay = False
except TypeError:
self._rand_delay = True
self.config_manager = UgmConfigManager()
self._connection = None
self._screen_sounds = self.config_file.get('sounds', None)
self._field_look_nums = self.config_file.get('field_look_nums',None)
if self._field_look_nums != None:
self._sc_look_index = 0
else:
self._screen_look_num = 0
if self._screen_sounds:
import pygame
import settings
pygame.init()
for i, s in enumerate(self._screen_sounds):
self._screen_sounds[i] = os.path.join(
settings.module_abs_path(),
self._screen_sounds[i])
def _prepare_screens(self, p_sc_set):
""" Shuffle screens in each pack """
for i_nr in range(len(p_sc_set)):
l_original_screens = p_sc_set[i_nr]
if not self.config_file.get('shuffle', True):
l_current_screens = l_original_screens*self.repeats
elif len(l_original_screens) > 2:
l_current_screens = []
l_last_screen = None
for i_iterations in range(self.repeats):
random.shuffle(l_original_screens)
if l_original_screens[0] == l_last_screen:
l_tmp = l_original_screens[0]
l_original_screens[0] = l_original_screens[1]
l_original_screens[1] = l_tmp
l_last_screen = l_original_screens[-1]
l_current_screens += l_original_screens
else:
l_current_screens = p_sc_set[i_nr] * self.repeats
random.shuffle(l_current_screens)
p_sc_set[i_nr] = l_current_screens
if self.config_file.get('shuffle', True):
# shuffle screen packs
random.shuffle(p_sc_set)
def run(self):
self.send_hi_screen()
if USE_MULTIPLEXER:
l_saver_control = signal_saver_control.SignalSaverControl()
l_saver_control.start_saving()
l_time = time.time()
TAGGER.send_tag(l_time, l_time, "experiment_start",
{
"exp_config" : self.config_file
})
for i_screens_pack in self.sc_configs:
# a pack is a list of tuples (screen + [diode freqs])
self._pre_screen_package(i_screens_pack)
LOGGER.debug("PACK: \n" + str(i_screens_pack))
for i_screen_conf in i_screens_pack:
l_delay = self._get_delay()
self._pre_screen(i_screen_conf)
# perform some action, like executing other stimuli than visual
if self.programme != '':
os.system("python " + self.programme)
# let ugm read config for new screen...
self.config_manager.update_from_file(i_screen_conf[0], True)
# ...then update itself
self.send_to_ugm()
# change diode frequencies
self.update_diode_freqs(i_screen_conf[1])
time.sleep(l_delay)
self._post_screen(i_screen_conf)
self._post_screen_package(i_screens_pack)
self.send_bye_screen()
l_time = time.time()
TAGGER.send_tag(l_time, l_time, "experiment_end", {})
if USE_MULTIPLEXER:
l_saver_control.finish_saving()
def send_hi_screen(self):
l_sc = self.config_file['hi_screen']
l_sc_del = self.config_file['hi_screen_delay']
if l_sc:
self._send_simple_screen(l_sc, 'experiment_hi', l_sc_del)
time.sleep(l_sc_del)
def send_bye_screen(self):
l_sc = self.config_file['bye_screen']
l_sc_del = self.config_file.get('bye_screen_delay',0)
if l_sc:
self._send_simple_screen(l_sc, 'experiment_bye', l_sc_del)
time.sleep(l_sc_del)
def _send_simple_screen(self, p_screen, p_tag_name, p_delay):
self.config_manager.update_from_file(p_screen, True)
self.send_to_ugm()
l_time = time.time()
TAGGER.send_tag(l_time, l_time, p_tag_name,
{
"delay" : p_delay
})
def send_to_ugm(self):
if USE_MULTIPLEXER:
l_type = 0
l_msg = variables_pb2.UgmUpdate()
l_msg.type = int(l_type)
l_msg.value = self.config_manager.config_to_message()
# Everything done :) All that is left is to establish connection if needed...
if not self._connection:
self._connection = connect_client(type = peers.LOGIC)
# ...and send message to UGM
self._connection.send_message(
message = l_msg.SerializeToString(),
type=types.UGM_UPDATE_MESSAGE, flush=True)
else:
self.config_manager.update_to_file('ugm_config', True)
def update_diode_freqs(self, p_freqs):
l_freq_str = p_freqs
if not isinstance(p_freqs, basestring):
l_freq_str = " ".join(['%s' % i for i in p_freqs])
if USE_MULTIPLEXER:
l_msg = variables_pb2.Variable()
l_msg.key = "Freqs"
l_msg.value = l_freq_str
# Everything done :) All that is left is to establish connection if needed...
if not self._connection:
self._connection = connect_client(type = peers.LOGIC)
# ...and send message to diode control
self._connection.send_message(
message = l_msg.SerializeToString(),
type=types.DIODE_UPDATE_MESSAGE, flush=True)
def _get_delay(self):
ret = None
if self._rand_delay:
ret = self._delay[0] + random.random()*(self._delay[1]-self._delay[0])
else:
ret = self._delay
self._last_delay = ret
LOGGER.debug("Computed stimulus delay: "+str(ret))
return ret
def _pre_screen_package(self, p_screen_package):
print('New screen package: ' + str(p_screen_package))
if self._field_look_nums != None:
self._sc_look_index = 0
else:
self._screen_look_num = 0
def _post_screen_package(self, p_screen_package):
if self.config_file['make_package_breaks']:
self.update_diode_freqs(self.config_file['break_package_freqs'])
l_delay = self.config_file['break_package_len']
self._send_simple_screen(self.config_file['break_package_screen'],
'experiment_package_break', l_delay)
time.sleep(l_delay)
def _pre_screen(self, p_screen_config):
print('New screen: ' + str(p_screen_config[0]))
# TODO: wybieranie pola do koncentracji, dzwiek oznajmiajacy o tym, zapis do tagu
self._play_sound()
if self._screen_sounds != None:
self._screen_look_num = (self._screen_look_num + 1) % \
len(self._screen_sounds)
elif self._field_look_nums != None:
self._screen_look_num = self._field_look_nums[self._sc_look_index]
l_screen_config_name = p_screen_config[0]
if l_screen_config_name in self.readable_names:
l_screen_name = self.readable_names[l_screen_config_name]
else:
l_screen_name = l_screen_config_name
l_time = time.time()
TAGGER.send_tag(l_time, l_time, "experiment_update",
{
"concentrating_on_field" : self._screen_look_num,
"screen" : l_screen_name,
"Freqs" : p_screen_config[1],
"delay" : self._last_delay
})
LOGGER.info('screen ' + str(p_screen_config[0]) + ' freqs: ' +\
str(p_screen_config[1]) + ' delay: '+ str(self._last_delay))
def _post_screen(self, p_screen_config):
# Make after-screen beak if defined in config
if self.config_file['make_screen_breaks']:
self.update_diode_freqs(self.config_file['break_screen_freqs'])
l_delay = self.config_file['break_screen_len']
self._send_simple_screen(self.config_file['break_screen_screen'],
'experiment__screen_break', l_delay)
time.sleep(l_delay)
if self._field_look_nums != None:
self._sc_look_index = (self._sc_look_index + 1) % \
len(self._field_look_nums)
LOGGER.info("look: " + str(self._sc_look_index))
def _play_sound(self):
if not self._screen_sounds:
return
import pygame
p_wave_file = self._screen_sounds[self._screen_look_num]
pygame.mixer.Sound(p_wave_file).play()
def read_experiment_config(self, p_config_name):
CONFIG = {}
Config = ConfigParser.ConfigParser()
if p_config_name == None:
import inspect
path = inspect.getsourcefile(self.__class__)
p_config_name = os.path.dirname(path) + "/config/config_file.ini"
print "------CONFIG NAME: ", p_config_name
Config.readfp(open(p_config_name))
for section in Config.sections():
print section
for option in Config.options(section):
print Config.get(section, option)
CONFIG[option] = eval(Config.get(section, option))
#CONFIG['screens'] = eval(CONFIG['screens'])
#CONFIG['freqs'] = eval(CONFIG['freq_sets'])
return CONFIG
def __init__(self, p_config_name=None):
super(Experiment_manager, self).__init__()
self.config_file = self.read_experiment_config(p_config_name)
print self.config_file
self.screens = self.config_file['screens']
self.sc_configs = []
self.repeats = self.config_file['repeats']
self.readable_names = self.config_file['readable_names']
self.programme = self.config_file['file_to_run']
# set up screens configuration - pair screens with diode freqs
if not self.config_file.get('USE_DEFAULT_FREQS'):
self.freq_sets = self.config_file['freqs']
print "UWAGA"
print ""
print ""
print self.screens
print len(self.screens)
print self.freq_sets
print len(self.freq_sets)
assert (len(self.screens) == len(self.freq_sets))
self.sc_configs = [
zip(scr, fre) for scr, fre in zip(self.screens, self.freq_sets)
]
else:
def_freqs = self.config_file['DEFAULT_FREQS']
assert (def_freqs != None)
self.sc_configs = [zip(scr, def_freqs) for scr in self.screens]
LOGGER.info("screens and freqs: \n" + \
str(self.sc_configs))
self._prepare_screens(self.sc_configs)
LOGGER.debug("SHUFFLED screens and freqs: \n" + \
str(self.sc_configs))
self._delay = self.config_file['delay']
self._last_delay = None
try:
self._delay + 0
# No error, delay is not random, just a number
self._rand_delay = False
except TypeError:
self._rand_delay = True
self.config_manager = UgmConfigManager()
self._connection = None
self._screen_sounds = self.config_file.get('sounds', None)
self._field_look_nums = self.config_file.get('field_look_nums', None)
if self._field_look_nums != None:
self._sc_look_index = 0
else:
self._screen_look_num = 0
if self._screen_sounds:
import pygame
import settings
pygame.init()
for i, s in enumerate(self._screen_sounds):
self._screen_sounds[i] = os.path.join(
settings.module_abs_path(), self._screen_sounds[i])
class Experiment_manager(object):
"""This class is responsible for managing UGM experiments. It loads and holds configs
of those experiments and makes it possible to run them"""
def __init__(self, p_config_name=None):
super(Experiment_manager, self).__init__()
self.config_file = self.read_experiment_config(p_config_name)
print self.config_file
self.screens = self.config_file['screens']
self.sc_configs = []
self.repeats = self.config_file['repeats']
self.readable_names = self.config_file['readable_names']
self.programme = self.config_file['file_to_run']
# set up screens configuration - pair screens with diode freqs
if not self.config_file.get('USE_DEFAULT_FREQS'):
self.freq_sets = self.config_file['freqs']
print "UWAGA"
print ""
print ""
print self.screens
print len(self.screens)
print self.freq_sets
print len(self.freq_sets)
assert (len(self.screens) == len(self.freq_sets))
self.sc_configs = [
zip(scr, fre) for scr, fre in zip(self.screens, self.freq_sets)
]
else:
def_freqs = self.config_file['DEFAULT_FREQS']
assert (def_freqs != None)
self.sc_configs = [zip(scr, def_freqs) for scr in self.screens]
LOGGER.info("screens and freqs: \n" + \
str(self.sc_configs))
self._prepare_screens(self.sc_configs)
LOGGER.debug("SHUFFLED screens and freqs: \n" + \
str(self.sc_configs))
self._delay = self.config_file['delay']
self._last_delay = None
try:
self._delay + 0
# No error, delay is not random, just a number
self._rand_delay = False
except TypeError:
self._rand_delay = True
self.config_manager = UgmConfigManager()
self._connection = None
self._screen_sounds = self.config_file.get('sounds', None)
self._field_look_nums = self.config_file.get('field_look_nums', None)
if self._field_look_nums != None:
self._sc_look_index = 0
else:
self._screen_look_num = 0
if self._screen_sounds:
import pygame
import settings
pygame.init()
for i, s in enumerate(self._screen_sounds):
self._screen_sounds[i] = os.path.join(
settings.module_abs_path(), self._screen_sounds[i])
def _prepare_screens(self, p_sc_set):
""" Shuffle screens in each pack """
for i_nr in range(len(p_sc_set)):
l_original_screens = p_sc_set[i_nr]
if not self.config_file.get('shuffle', True):
l_current_screens = l_original_screens * self.repeats
elif len(l_original_screens) > 2:
l_current_screens = []
l_last_screen = None
for i_iterations in range(self.repeats):
random.shuffle(l_original_screens)
if l_original_screens[0] == l_last_screen:
l_tmp = l_original_screens[0]
l_original_screens[0] = l_original_screens[1]
l_original_screens[1] = l_tmp
l_last_screen = l_original_screens[-1]
l_current_screens += l_original_screens
else:
l_current_screens = p_sc_set[i_nr] * self.repeats
random.shuffle(l_current_screens)
p_sc_set[i_nr] = l_current_screens
if self.config_file.get('shuffle', True):
# shuffle screen packs
random.shuffle(p_sc_set)
def run(self):
self.send_hi_screen()
if USE_MULTIPLEXER:
l_saver_control = signal_saver_control.SignalSaverControl()
l_saver_control.start_saving()
l_time = time.time()
TAGGER.send_tag(l_time, l_time, "experiment_start",
{"exp_config": self.config_file})
for i_screens_pack in self.sc_configs:
# a pack is a list of tuples (screen + [diode freqs])
self._pre_screen_package(i_screens_pack)
LOGGER.debug("PACK: \n" + str(i_screens_pack))
for i_screen_conf in i_screens_pack:
l_delay = self._get_delay()
self._pre_screen(i_screen_conf)
# perform some action, like executing other stimuli than visual
if self.programme != '':
os.system("python " + self.programme)
# let ugm read config for new screen...
self.config_manager.update_from_file(i_screen_conf[0], True)
# ...then update itself
self.send_to_ugm()
# change diode frequencies
self.update_diode_freqs(i_screen_conf[1])
time.sleep(l_delay)
self._post_screen(i_screen_conf)
self._post_screen_package(i_screens_pack)
self.send_bye_screen()
l_time = time.time()
TAGGER.send_tag(l_time, l_time, "experiment_end", {})
if USE_MULTIPLEXER:
l_saver_control.finish_saving()
def send_hi_screen(self):
l_sc = self.config_file['hi_screen']
l_sc_del = self.config_file['hi_screen_delay']
if l_sc:
self._send_simple_screen(l_sc, 'experiment_hi', l_sc_del)
time.sleep(l_sc_del)
def send_bye_screen(self):
l_sc = self.config_file['bye_screen']
l_sc_del = self.config_file.get('bye_screen_delay', 0)
if l_sc:
self._send_simple_screen(l_sc, 'experiment_bye', l_sc_del)
time.sleep(l_sc_del)
def _send_simple_screen(self, p_screen, p_tag_name, p_delay):
self.config_manager.update_from_file(p_screen, True)
self.send_to_ugm()
l_time = time.time()
TAGGER.send_tag(l_time, l_time, p_tag_name, {"delay": p_delay})
def send_to_ugm(self):
if USE_MULTIPLEXER:
l_type = 0
l_msg = variables_pb2.UgmUpdate()
l_msg.type = int(l_type)
l_msg.value = self.config_manager.config_to_message()
# Everything done :) All that is left is to establish connection if needed...
if not self._connection:
self._connection = connect_client(type=peers.LOGIC)
# ...and send message to UGM
self._connection.send_message(message=l_msg.SerializeToString(),
type=types.UGM_UPDATE_MESSAGE,
flush=True)
else:
self.config_manager.update_to_file('ugm_config', True)
def update_diode_freqs(self, p_freqs):
l_freq_str = p_freqs
if not isinstance(p_freqs, basestring):
l_freq_str = " ".join(['%s' % i for i in p_freqs])
if USE_MULTIPLEXER:
l_msg = variables_pb2.Variable()
l_msg.key = "Freqs"
l_msg.value = l_freq_str
# Everything done :) All that is left is to establish connection if needed...
if not self._connection:
self._connection = connect_client(type=peers.LOGIC)
# ...and send message to diode control
self._connection.send_message(message=l_msg.SerializeToString(),
type=types.DIODE_UPDATE_MESSAGE,
flush=True)
def _get_delay(self):
ret = None
if self._rand_delay:
ret = self._delay[0] + random.random() * (self._delay[1] -
self._delay[0])
else:
ret = self._delay
self._last_delay = ret
LOGGER.debug("Computed stimulus delay: " + str(ret))
return ret
def _pre_screen_package(self, p_screen_package):
print('New screen package: ' + str(p_screen_package))
if self._field_look_nums != None:
self._sc_look_index = 0
else:
self._screen_look_num = 0
def _post_screen_package(self, p_screen_package):
if self.config_file['make_package_breaks']:
self.update_diode_freqs(self.config_file['break_package_freqs'])
l_delay = self.config_file['break_package_len']
self._send_simple_screen(self.config_file['break_package_screen'],
'experiment_package_break', l_delay)
time.sleep(l_delay)
def _pre_screen(self, p_screen_config):
print('New screen: ' + str(p_screen_config[0]))
# TODO: wybieranie pola do koncentracji, dzwiek oznajmiajacy o tym, zapis do tagu
self._play_sound()
if self._screen_sounds != None:
self._screen_look_num = (self._screen_look_num + 1) % \
len(self._screen_sounds)
elif self._field_look_nums != None:
self._screen_look_num = self._field_look_nums[self._sc_look_index]
l_screen_config_name = p_screen_config[0]
if l_screen_config_name in self.readable_names:
l_screen_name = self.readable_names[l_screen_config_name]
else:
l_screen_name = l_screen_config_name
l_time = time.time()
TAGGER.send_tag(
l_time, l_time, "experiment_update", {
"concentrating_on_field": self._screen_look_num,
"screen": l_screen_name,
"Freqs": p_screen_config[1],
"delay": self._last_delay
})
LOGGER.info('screen ' + str(p_screen_config[0]) + ' freqs: ' +\
str(p_screen_config[1]) + ' delay: '+ str(self._last_delay))
def _post_screen(self, p_screen_config):
# Make after-screen beak if defined in config
if self.config_file['make_screen_breaks']:
self.update_diode_freqs(self.config_file['break_screen_freqs'])
l_delay = self.config_file['break_screen_len']
self._send_simple_screen(self.config_file['break_screen_screen'],
'experiment__screen_break', l_delay)
time.sleep(l_delay)
if self._field_look_nums != None:
self._sc_look_index = (self._sc_look_index + 1) % \
len(self._field_look_nums)
LOGGER.info("look: " + str(self._sc_look_index))
def _play_sound(self):
if not self._screen_sounds:
return
import pygame
p_wave_file = self._screen_sounds[self._screen_look_num]
pygame.mixer.Sound(p_wave_file).play()
def read_experiment_config(self, p_config_name):
CONFIG = {}
Config = ConfigParser.ConfigParser()
if p_config_name == None:
import inspect
path = inspect.getsourcefile(self.__class__)
p_config_name = os.path.dirname(path) + "/config/config_file.ini"
print "------CONFIG NAME: ", p_config_name
Config.readfp(open(p_config_name))
for section in Config.sections():
print section
for option in Config.options(section):
print Config.get(section, option)
CONFIG[option] = eval(Config.get(section, option))
#CONFIG['screens'] = eval(CONFIG['screens'])
#CONFIG['freqs'] = eval(CONFIG['freq_sets'])
return CONFIG
class Experiment(object):
def __init__(self):
self._connection = connect_client(type=peers.LOGIC)
self._long_mgr = UgmConfigManager()
self._long_mgr.update_from_file(LONG_FILE, True)
self._word_mgr = UgmConfigManager()
self._word_mgr.update_from_file(WORD_FILE, True)
self.fixation = '+'
self.mask = 'XXXXXXXXXXXXXX'
self.available_keys = ['1', '2', '3', '4', '5']
self.word_config = {'id': 5555, 'message': ''}
self.img_config = {'id': 6666, 'image_path': ''}
self.data_manager = DataManager()
self.run_tag = {}
def run(self):
#time.sleep(INIT_SLEEP)
l_saver_control = signal_saver_control.SignalSaverControl()
l_saver_control.start_saving()
self.send_text(u"Gotowy? Aby rozpocząć wciśnij '1'.")
keystroke.wait(['1'])
for i in range(self.data_manager.words_count()):
self.send_fixation()
self.send_mask1()
self.send_word(self.data_manager.words[i])
self.send_mask2()
self.send_long_view()
self.send_run_tag()
self.send_text(u"Dziękujemy")
print("ALL DONE", l_saver_control.finish_saving())
def send_text(self, text):
self.word_config['message'] = text
self._word_mgr.set_config(self.word_config)
self.send_to_ugm(self._word_mgr.config_to_message(), 0)
def send_fixation(self):
self.word_config['message'] = self.fixation
self._word_mgr.set_config(self.word_config)
self.send_to_ugm(self._word_mgr.config_to_message(), 0)
self.run_tag['fix_start_timestamp'] = time.time()
time.sleep(SLEEP_FIX_MIN + random.random() *
(SLEEP_FIX_MAX - SLEEP_FIX_MIN))
pass
def send_mask1(self):
self.send_mask('mask1_start_timestamp')
def send_mask2(self):
self.send_mask('mask2_start_timestamp')
def send_mask(self, tag_entry):
self.word_config['message'] = self.mask
self.send_to_ugm(str([self.word_config]))
self.run_tag[tag_entry] = time.time()
time.sleep(SLEEP_MASK)
pass
def send_word(self, word):
self.word_config['message'] = word[1]
self.send_to_ugm(str([self.word_config]))
self.run_tag['word_start_timestamp'] = time.time()
self.run_tag['word_message'] = word[1]
self.run_tag['word_group'] = word[0]
time.sleep(SLEEP_WORD)
def send_long_view(self):
self.img_config['image_path'] = self.data_manager.next_image()
self._long_mgr.set_config(self.img_config)
self.send_to_ugm(self._long_mgr.config_to_message(), 0)
start = time.time()
# Now wait for user input
key = keystroke.wait(self.available_keys)
end = time.time()
self.run_tag['key_start_timestamp'] = start
self.run_tag['key_end_timestamp'] = end
self.run_tag['key_answer'] = key
#time.sleep(SLEEP_LONG)
def send_run_tag(self):
now = time.time()
TAGGER.send_tag(now, now, 'experiment_run', self.run_tag)
def send_to_ugm(self, config_value, msg_type=1):
l_type = msg_type
l_msg = variables_pb2.UgmUpdate()
l_msg.type = int(l_type)
l_msg.value = config_value
self._connection.send_message(message=l_msg.SerializeToString(),
type=types.UGM_UPDATE_MESSAGE,
flush=True)
class Experiment(object):
def __init__(self):
self._connection = connect_client(type = peers.LOGIC)
self._long_mgr = UgmConfigManager()
self._long_mgr.update_from_file(LONG_FILE, True)
self._word_mgr = UgmConfigManager()
self._word_mgr.update_from_file(WORD_FILE, True)
self.fixation = '+'
self.mask = 'XXXXXXXXXXXXXX'
self.available_keys = ['1','2','3','4','5']
self.word_config = {'id':5555, 'message':''}
self.img_config = {'id':6666, 'image_path':''}
self.data_manager = DataManager()
self.run_tag = {}
def run(self):
#time.sleep(INIT_SLEEP)
l_saver_control = signal_saver_control.SignalSaverControl()
l_saver_control.start_saving()
self.send_text(u"Gotowy? Aby rozpocząć wciśnij '1'.")
keystroke.wait(['1'])
for i in range(self.data_manager.words_count()):
self.send_fixation()
self.send_mask1()
self.send_word(self.data_manager.words[i])
self.send_mask2()
self.send_long_view()
self.send_run_tag()
self.send_text(u"Dziękujemy")
print("ALL DONE", l_saver_control.finish_saving())
def send_text(self, text):
self.word_config['message'] = text
self._word_mgr.set_config(self.word_config)
self.send_to_ugm(self._word_mgr.config_to_message(), 0)
def send_fixation(self):
self.word_config['message'] = self.fixation
self._word_mgr.set_config(self.word_config)
self.send_to_ugm(self._word_mgr.config_to_message(), 0)
self.run_tag['fix_start_timestamp'] = time.time()
time.sleep(SLEEP_FIX_MIN + random.random()*(SLEEP_FIX_MAX-SLEEP_FIX_MIN))
pass
def send_mask1(self):
self.send_mask('mask1_start_timestamp')
def send_mask2(self):
self.send_mask('mask2_start_timestamp')
def send_mask(self, tag_entry):
self.word_config['message'] = self.mask
self.send_to_ugm(str([self.word_config]))
self.run_tag[tag_entry] = time.time()
time.sleep(SLEEP_MASK)
pass
def send_word(self, word):
self.word_config['message'] = word[1]
self.send_to_ugm(str([self.word_config]))
self.run_tag['word_start_timestamp'] = time.time()
self.run_tag['word_message'] = word[1]
self.run_tag['word_group'] = word[0]
time.sleep(SLEEP_WORD)
def send_long_view(self):
self.img_config['image_path'] = self.data_manager.next_image()
self._long_mgr.set_config(self.img_config)
self.send_to_ugm(self._long_mgr.config_to_message(), 0)
start = time.time()
# Now wait for user input
key = keystroke.wait(self.available_keys)
end = time.time()
self.run_tag['key_start_timestamp'] = start
self.run_tag['key_end_timestamp'] = end
self.run_tag['key_answer'] = key
#time.sleep(SLEEP_LONG)
def send_run_tag(self):
now = time.time()
TAGGER.send_tag(now, now, 'experiment_run', self.run_tag)
def send_to_ugm(self, config_value, msg_type=1):
l_type = msg_type
l_msg = variables_pb2.UgmUpdate()
l_msg.type = int(l_type)
l_msg.value = config_value
self._connection.send_message(
message = l_msg.SerializeToString(),
type=types.UGM_UPDATE_MESSAGE, flush=True)
