def button_1_callback(self):
'''Write your function here if it's simple. If it is more complex, you might want to import it from a separate
document and call it here.'''
if not DataFileObj.data_collect_flag:
if not DataFileObj.is_data_file_created():
# Create the file
DataFileObj.update_file_name(globls.subject_name)
DataFileObj.update_header_into_data_file()
globls.dump_log('start saving data')
globls.custom_button[0].configure(text="Stop Save")
globls.update_cont_data(1)
DataFileObj.update_data_collect_flag(True)
# print(globls.DUMP_DATA_CONTINUALLY)
else:
globls.dump_log('stop saving data')
globls.DUMP_DATA_CONTINUALLY = 0
DataFileObj.update_data_collect_flag(False)
globls.update_cont_data(0)
globls.custom_button[0].configure(text="Start Save")
# DataFileObj.dump_data_to_file()
# DataFileObj.total_data_dumped_to_file()
DataFileObj.reset_file_name()
return
def button_2_callback(self):
globls.dump_log('Gate is opened')
data_str = '6 100 /'
data_recv_ts = time.time()
data = data_str + """{}""".format('q' *
(1024 - len(data_str.encode())))
DataFileObj.save_raw_eye_taskdata(data_recv_ts,
0,
0,
0,
0,
task_data=data)
return
def send_data(sock, dest_addr, data_string, msg=None):
data = data_string
tmp_msg = ''
if dest_addr:
data = data_padder(data_string)
try:
sock.sendto(data, dest_addr)
if msg is not None:
tmp_msg = tmp_msg + msg
globls.dump_log('{}. length {}. Data {}'.format(
tmp_msg, len(data), data_string))
return data
except Exception as e:
log.exception(e)
tmp_msg = 'Exception Sending ' + msg if msg else ''
else:
tmp_msg = 'Matlab socket not initilized to Send ' + msg if msg else ''
globls.dump_log('Error: {}'.format(tmp_msg))
return data
def button_3_callback(self):
if globls.Shocked:
globls.update_shock_flag(0)
globls.ManualShock = 0
globls.shock_off()
globls.custom_button[2].configure(text="Shock Off")
globls.dump_log('Shock Stopped')
data_str = '6 200 /'
data_recv_ts = time.time()
data = data_str + """{}""".format('q' *
(1024 - len(data_str.encode())))
DataFileObj.save_raw_eye_taskdata(data_recv_ts,
0,
0,
0,
0,
task_data=data)
else:
globls.update_shock_flag(1)
globls.ManualShock = 1
globls.shock_on()
globls.custom_button[2].configure(text="Shock On")
globls.dump_log('Shock Started')
data_str = '6 201 /'
data_recv_ts = time.time()
data = data_str + """{}""".format('q' *
(1024 - len(data_str.encode())))
DataFileObj.save_raw_eye_taskdata(data_recv_ts,
0,
0,
0,
0,
task_data=data)
return
def receiver(self):
'''
Receiver loop to check the incoming packets
:return:
'''
# globls.dump_log("Running Matlab thread")
globls.dump_log('Listening to 3rd party messages')
while globls.is_program_running:
try:
bin_data, addr = globls.arbitrator_sock.recvfrom(
globls.constant['data_size_length'])
data = bin_data.decode()
data_recv_ts = time.time()
# process the variables
if len(data):
# Check if there is any delimiter in the message '/' if yes then split
cmd_lists = data.split(
globls.constant['message_delimiter'])
# Data before / is valid data read and remove the space
cmd_list = cmd_lists[0].split()
if int(cmd_list[0]) == Constant.COMMAND_WORD_CONNECTION:
if int(cmd_list[1]) == Constant.CONNECTION_START:
# send the UDP packet to initiate the connection
data = '{} {}/{} {}/{} {}/{} {}/{} {}/'.format(
Constant.COMMAND_WORD_CONNECTION,
Constant.CONNECTION_ACK, const.SCREEN_HEIGHT,
globls.arbitrator_display['screen_height_mm'],
const.SCREEN_DISTANCE, globls.
arbitrator_display['screen_distance_mm'],
const.SCREEN_WIDTH,
globls.arbitrator_display['screen_width_mm'],
const.SCREEN_IOD,
globls.arbitrator_display['iod_mm'])
util.send_data(globls.arbitrator_sock,
globls.arbitrator_sock_addr, data,
'Connection Ack Message')
globls.update_load_subject_task_config_flag(True)
elif int(cmd_list[1]) == Constant.CONNECTION_ACK:
globls.connection_state = Constant.CONNECTION_ACK
# Update this flag to ensure that the user knows what is the next step after connection is up
globls.update_load_subject_task_config_flag(True)
# util.send_screen_parameters()
# print cmd_list
elif int(cmd_list[0]) == Constant.DISPLAY_COMMAND_WORD:
config = [int(cmd_list[1]), cmd_list[2]]
# print(config)
globls.update_displayable_config(config)
# Process the exit call
elif (int(cmd_list[0]) == Constant.COMMAND_WORD_CONTROL
and int(cmd_list[1]) == Constant.CONTROL_EXIT):
print('breaking code (arbitrator_server: line 99)')
break
elif int(cmd_list[0]) == Constant.EYE_IN_OUT_REQUEST:
eye_in_out = copy.copy(globls.eye_in_or_out)
# if (eye_in_out[0] != globls.last_sent_eye_in_out[0]
# or eye_in_out[1] != globls.last_sent_eye_in_out[1]):
# '{LEye_Status} {in/out}
# {LEye_X_gain} {LEye_X_offset}
# {LEye_Y_gain} {LEye_Y_offset}/...
# {REye_Status} {in/out}
# {REye_X_gain} {REye_X_offset}
# {REye_Y_gain} {REye_Y_offset}/'
data = '{} {} {} {} {} {}/{} {} {} {} {} {}/'.format(
Constant.LEFT_EYE_STATUS,
globls.eye_in_or_out[0],
globls.offset_gain_config[
ConfigLabels.LEFT_EYE_GAIN_X],
globls.offset_gain_config[
ConfigLabels.LEFT_EYE_OFFSET_X],
globls.offset_gain_config[
ConfigLabels.LEFT_EYE_GAIN_Y],
globls.offset_gain_config[
ConfigLabels.LEFT_EYE_OFFSET_Y],
Constant.RIGHT_EYE_STATUS,
globls.eye_in_or_out[1],
globls.offset_gain_config[
ConfigLabels.RIGHT_EYE_GAIN_X],
globls.offset_gain_config[
ConfigLabels.RIGHT_EYE_OFFSET_X],
globls.offset_gain_config[
ConfigLabels.RIGHT_EYE_GAIN_Y],
globls.offset_gain_config[
ConfigLabels.RIGHT_EYE_OFFSET_Y],
)
# if (eye_in_out[0] != globls.last_sent_eye_in_out[0]
# or eye_in_out[1] != globls.last_sent_eye_in_out[1]):
# data = '{} {}/{} {}/'.format(Constant.LEFT_EYE_STATUS, globls.eye_in_or_out[0],
# Constant.RIGHT_EYE_STATUS, globls.eye_in_or_out[1])
util.send_data(globls.arbitrator_sock_eye,
globls.arbitrator_sock_addr_eye, data)
# print "EYE in or out ", data
globls.update_last_sent_eye_in_out(eye_in_out)
elif int(cmd_list[0]
) == Constant.LATCHED_EYE_IN_OUT_REQUEST:
globls.latched_eye = 1
globls.caught = 0 # if just starting latched eye request, couldn't have caught eye out!
globls.dump_log('Initiating latched eye request')
elif int(cmd_list[0]) == Constant.END_LATCHED_EYE:
globls.latched_eye = 0
globls.caught = 0 # matlab finally caught your message about version violation
globls.dump_log('Ending latched eye request')
elif int(cmd_list[0]) == Constant.VERGENCE_REQUEST:
points = list(map(float, cmd_list[1:6]))
value = self.eye_check.vergence_error(points)
# if value != globls.last_vergence_error_sent:
data = '{} {}/'.format(Constant.VERGENCE_STATUS, value)
util.send_data(globls.arbitrator_sock_eye,
globls.arbitrator_sock_addr_eye, data)
# print "Vergence error ", data
globls.update_last_sent_vergence_error(value)
elif int(cmd_list[0]) == Constant.SCREEN_WINDOW_WIDTH:
globls.update_arbitrator_server_screen_resolution(
width=int(cmd_list[1]))
globls.dump_log(
'Received the screen width and scale factor to display on GUI: {}'
.format(
globls.arbitrator_display['x_scale_factor']))
elif int(cmd_list[0]) == Constant.SCREEN_WINDOW_HEIGHT:
globls.update_arbitrator_server_screen_resolution(
height=int(cmd_list[1]))
globls.dump_log(
'Received the screen Height and scale factor to display on GUI: {}'
.format(
globls.arbitrator_display['y_scale_factor']))
elif int(cmd_list[0]) == Constant.CENTRE_OF_WINDOWS:
# print cmd_list
# 100 number list of X Y Z diameter
# Maximum 30 points
no_of_points = int(cmd_list[1])
config = []
lst = cmd_list[2:]
# pair the data and give it to UI for updation
for i in range(0, len(lst), 6):
config.append([
float(lst[i]),
float(lst[i + 1]),
float(lst[i + 2]),
float(lst[i + 3]), lst[i + 4], lst[i + 5]
])
if len(config
) == Constant.MAXIMUM_CENTRE_OF_WINDOW:
break
globls.dump_log('Points to draw {}'.format(cmd_list))
globls.update_centre_point(no_of_points, config)
elif int(cmd_list[0]) == Constant.WINDOW_ON:
# print cmd_list
globls.update_centre_window_on_off(True)
globls.dump_log('Window On')
elif int(cmd_list[0]) == Constant.WINDOW_OFF:
# print cmd_list
globls.update_centre_window_on_off(False)
globls.dump_log('Window Off')
# Reset this to -1, -1 so that next time this is queried from
# Arbitrator server new values are sent
globls.update_last_sent_eye_in_out([-1, -1])
elif int(cmd_list[0]) == Constant.REWARD_ON:
# print cmd_list
self.DIO_obj.write_digital_bit(1)
#self.DIO_obj.reward_on()
globls.dump_log('Reward On')
elif int(cmd_list[0]) == Constant.REWARD_OFF:
# print cmd_list
self.DIO_obj.write_digital_bit(0)
#self.DIO_obj.reward_off()
globls.dump_log('Reward Off')
elif int(cmd_list[0]) == Constant.VERGENCE_ON:
# print cmd_list
globls.udpdate_vergence_display(True)
globls.dump_log('Vergence On')
elif int(cmd_list[0]) == Constant.VERGENCE_OFF:
# print cmd_list
globls.udpdate_vergence_display(False)
globls.dump_log('Vergence Off')
# Reset this to -1 so that next time this is queried from
# Arbitrator server new values are sent
globls.update_last_sent_vergence_error(-1)
elif int(cmd_list[0]) == Constant.DRAW_EVENTS:
tempnum = len(cmd_lists) - 1
globls.update_drawing_object_on(1)
globls.update_drawing_object_number(tempnum)
for i in range(0, tempnum):
templist = cmd_lists[i].split()
if i == 0:
tempx = float(templist[2])
tempy = float(templist[3])
if tempx == -1 and tempy == -1:
if not globls.Shocked:
globls.shock_on()
data_str = '6 201 /'
temp_data = data_str + """{}""".format(
'q' *
(1024 - len(data_str.encode())))
DataFileObj.save_raw_eye_taskdata(
data_recv_ts,
0,
0,
0,
0,
task_data=temp_data)
globls.update_shock_flag(1)
else:
# globls.prt.setData(0)
if not globls.ManualShock:
if globls.Shocked:
globls.shock_off()
data_str = '6 200 /'
temp_data = data_str + """{}""".format(
'q' * (1024 -
len(data_str.encode())))
globls.update_shock_flag(0)
DataFileObj.save_raw_eye_taskdata(
data_recv_ts,
0,
0,
0,
0,
task_data=temp_data)
else:
tempx = float(templist[1])
tempy = float(templist[2])
globls.update_drawing_object_pos(i, 0, tempx)
globls.update_drawing_object_pos(i, 1, tempy)
elif int(cmd_list[0]) == Constant.EVENTS:
globls.dump_log('event {}'.format(cmd_list))
if not globls.DUMP_DATA_CONTINUALLY:
if int(cmd_list[1]) == Constant.EVENT_START:
# Start the data save
DataFileObj.update_data_collect_flag(True)
# Dump auto offset data
globls.auto_offset_dump_data = 1
# Make sure primer and flag is still off
globls.auto_offset_update_primer = 0
globls.auto_offset_update_flag = 0
elif int(cmd_list[1]) == Constant.EVENT_STOP:
# This needs to be saved here as we dump the saved data to file
# And data collection falg will be reset
DataFileObj.save_raw_eye_taskdata(
data_recv_ts,
globls.last_raw_eye_data[0],
globls.last_raw_eye_data[1],
globls.last_raw_eye_data[2],
globls.last_raw_eye_data[3],
task_data=data)
# Stop saving the data and dump tp file
# Flag to stop saving the data is set inside this function
DataFileObj.dump_data_to_file()
globls.update_last_sent_vergence_error(-1)
globls.update_last_sent_eye_in_out([-1, -1])
# Dump auto offset data
globls.auto_offset_dump_data = 1
# Set update flag so offsets can now be changed
globls.auto_offset_update_flag = 1
# Check for fixation acquired and hold time acquired to start/stop auto eye offset
elif int(
cmd_list[1]) == Constant.FIXATION_ACQUIRED:
# Set "stop data collection" flag to false
globls.auto_offset_stop_collect = 0
# Set "start data collection" flag to true
globls.auto_offset_start_collect = 1
# Make sure primer is still off
globls.auto_offset_update_primer = 0
elif int(cmd_list[1]
) == Constant.FIXATION_HOLD_COMPLETE:
# Set "start data collection" flag to false
globls.auto_offset_start_collect = 0
# Set "stop data collection" flag to true
globls.auto_offset_stop_collect = 1
elif int(cmd_list[1]
) == Constant.SACCADE_TARGET_ACQUIRED:
# Set primer flag to update offsets after this trial is over
globls.auto_offset_update_primer = 1
# Save the data from 3rd party server
DataFileObj.save_raw_eye_taskdata(
data_recv_ts,
globls.last_raw_eye_data[0],
globls.last_raw_eye_data[1],
globls.last_raw_eye_data[2],
globls.last_raw_eye_data[3],
task_data=data)
# # Save the data from 3rd party server
# if globls.DUMP_DATA_CONTINUALLY:
# DataFileObj.dump_data_continually(data_recv_ts, data)
# except socket.timeout:
# pass
except Exception as e:
log.exception(e)
globls.arbitrator_sock.close()
print('globls.arbitrator_sock was closed (arbitrator_serve: line 290)')
def button_4_callback(self):
globls.dump_log(
'Add a custom button function in button_funs.py for the correct button callback!'
)
return
def total_data_dumped_to_file(self):
globls.dump_log('Total data written to file is {}'.format(
self.total_records))
def digital_reader(self):
pylink = importlib.import_module('pylink')
'''
Read the eye data from eyelink
:return:
'''
try:
self.EyeTrack = pylink.EyeLink(
globls.config_param['eyelink_service']['ip'])
self.EyeTrack.sendCommand(
"link_sample_data = LEFT,RIGHT,GAZE,AREA")
self.EyeTrack.startRecording(0, 0, 1, 1)
globls.dump_log("Initiated digital eye data reader")
last_read_eye_time = 0
while globls.is_program_running:
# Sleep for 1 ms
time.sleep(.001)
dt = self.EyeTrack.getNewestSample(
) # check for new sample update
eye_recv_data_ts = time.time()
if dt is not None:
cur_eye_time = dt.getTime()
if float(cur_eye_time) != float(last_read_eye_time):
eye_closed = False
lx = ly = rx = ry = 0
if dt.getRightEye() and dt.getLeftEye():
lx, ly = dt.getLeftEye().getGaze()
rx, ry = dt.getRightEye().getGaze()
elif dt.getRightEye() and not dt.getLeftEye():
rx, ry = dt.getRightEye().getGaze()
lx, ly = rx, ry
elif dt.getLeftEye() and not dt.getRightEye():
lx, ly = dt.getLeftEye().getGaze()
rx, ry = lx, ly
pupilsize_left = dt.getLeftEye().getPupilSize()
pupilsize_right = dt.getRightEye().getPupilSize()
# # Do not update values if eye is closed or if eye is not avaialble
# if (pupilsize_left < globls.pupil_size['left'] or
# pupilsize_right > globls.pupil_size['right']):
# eye_closed = True
# print pupilsize_left, globls.pupil_size['right']
# convert this to coordinate (0, 0) at center
eyepos_lx, eyepos_ly = util.shift_to_centre(lx, ly)
eyepos_lx, eyepos_ly = util.convert_pix_to_mm(
eyepos_lx, eyepos_ly)
# convert this to coordinate (0, 0) at center
eyepos_rx, eyepos_ry = util.shift_to_centre(rx, ry)
eyepos_rx, eyepos_ry = util.convert_pix_to_mm(
eyepos_rx, eyepos_ry)
# Write eye data to list storing left and right X, Y and Z data
# data that we get from eyelink has only left and right eye
globls.update_last_raw_eye_data(
eyepos_lx, eyepos_ly, eyepos_rx, eyepos_ry)
DataFileObj.save_raw_eye_taskdata(
eye_recv_data_ts, eyepos_lx, eyepos_ly, eyepos_rx,
eyepos_ry)
# Get the mean of the raw eye data and later apply offset gain for the mean data
left_mean_x, left_mean_y, right_mean_x, right_mean_y = \
self.update_getmean_eye_sample(eyepos_lx, eyepos_ly,
eyepos_rx, eyepos_ry, eye_closed)
# apply offset and gain
left_og_x, left_og_y, right_og_x, right_og_y = \
self.get_offset_gain_applied_eye_data(left_mean_x, left_mean_y, right_mean_x,
right_mean_y)
# update the offset and gain applied for drawing eye on canvas
globls.update_offset_gain_applied_eye_data(
left_og_x, left_og_y, right_og_x, right_og_y)
# If eye closed, then do not check eye in out or vergence error
if eye_closed:
return
# Validate the eye is in or out depending on the task
self.eye_check.eye_in_out()
# print "Eye position ", eyepos_lx, left_mean_x, left_og_x
last_read_eye_time = cur_eye_time
except Exception as e:
log.exception(e)
globls.dump_log(
'Exception reading eye link data from eyelink tracker {}'.
format(e))
def analog_reader(self):
analog_module = importlib.import_module('analog')
analog = getattr(module, 'Analog')
'''
Read the eye data from Analog device
:return:
'''
try:
globls.dump_log("Initiated Analog eye data reader")
self.analog_reader_obj = analog()
while globls.is_program_running:
time.sleep(.001)
eye_closed = False
pupilsize_left, pupilsize_right = 2000, 2000
temp_eye_data = []
temp_eye_pos_channel_data = globls.eye_recording_method_obj.get_eye_positions_channel(
)
for channel in temp_eye_pos_channel_data:
temp_eye_data.append(
self.analog_reader_obj.get_channel_analog_value(
int(channel)))
eye_recv_data_ts = time.time()
eyepos_lx, eyepos_ly = temp_eye_data[0], temp_eye_data[1]
eyepos_rx, eyepos_ry = temp_eye_data[0], temp_eye_data[1]
# Do not update values if eye is closed or if eye is not avaialble
if (pupilsize_left < globls.pupil_size['left']
or pupilsize_right < globls.pupil_size['right']):
eye_closed = True
# Write eye data to list storing left and right X, Y and Z data
# data that we get from eyelink has only left and right eye
globls.update_last_raw_eye_data(eyepos_lx, eyepos_ly,
eyepos_rx, eyepos_ry)
DataFileObj.save_raw_eye_taskdata(eye_recv_data_ts, eyepos_lx,
eyepos_ly, eyepos_rx,
eyepos_ry)
# Get the mean of the raw eye data and later apply offset gain for the mean data
left_mean_x, left_mean_y, right_mean_x, right_mean_y = \
self.update_getmean_eye_sample(eyepos_lx, eyepos_ly,
eyepos_rx, eyepos_ry, eye_closed)
# apply offset and gain
left_og_x, left_og_y, right_og_x, right_og_y = \
self.get_offset_gain_applied_eye_data(left_mean_x, left_mean_y, right_mean_x,
right_mean_y)
globls.update_offset_gain_applied_eye_data(
left_og_x, left_og_y, right_og_x, right_og_y)
# If eye closed, then do not check eye in out
if eye_closed:
return
# Validate the eye is in or out depending on the task
self.eye_check.eye_in_out()
except Exception as e:
log.exception(e)
def receiver(self):
'''
Receiver loop to check the incoming packets
:return:
'''
# globls.dump_log("Running Matlab thread")
globls.dump_log('Listening to 3rd party messages')
while globls.is_program_running:
try:
data, addr = globls.arbitrator_sock.recvfrom(globls.constant['data_size_length'])
data_recv_ts = time.time()
# process the variables
if len(data):
# Check if there is any delimiter in the message '/' if yes then split
cmd_lists = data.split(globls.constant['message_delimiter'])
# Data before / is valid data read and remove the space
cmd_list = cmd_lists[0].split()
if int(cmd_list[0]) == Constant.COMMAND_WORD_CONNECTION:
if int(cmd_list[1]) == Constant.CONNECTION_START:
# send the UDP packet to initiate the connection
data = '{} {}/{} {}/{} {}/{} {}/{} {}/'.format(Constant.COMMAND_WORD_CONNECTION,
Constant.CONNECTION_ACK,
const.SCREEN_HEIGHT,
globls.arbitrator_display[
'screen_height_mm'],
const.SCREEN_DISTANCE,
globls.arbitrator_display[
'screen_distance_mm'],
const.SCREEN_WIDTH,
globls.arbitrator_display['screen_width_mm'],
const.SCREEN_IOD,
globls.arbitrator_display['iod_mm'])
util.send_data(globls.arbitrator_sock, globls.arbitrator_sock_addr, data,
'Connection Ack Message')
globls.update_load_subject_task_config_flag(True)
elif int(cmd_list[1]) == Constant.CONNECTION_ACK:
globls.connection_state = Constant.CONNECTION_ACK
# Update this flag to ensure that the user knows what is the next step after connection is up
globls.update_load_subject_task_config_flag(True)
# util.send_screen_parameters()
# print cmd_list
elif int(cmd_list[0]) == Constant.DISPLAY_COMMAND_WORD:
config = [int(cmd_list[1]), cmd_list[2]]
globls.update_displayable_config(config)
# Process the exit call
elif (int(cmd_list[0]) == Constant.COMMAND_WORD_CONTROL and
int(cmd_list[1]) == Constant.CONTROL_EXIT):
break
elif int(cmd_list[0]) == Constant.EYE_IN_OUT_REQUEST:
eye_in_out = copy.copy(globls.eye_in_or_out)
# if (eye_in_out[0] != globls.last_sent_eye_in_out[0]
# or eye_in_out[1] != globls.last_sent_eye_in_out[1]):
data = '{} {}/{} {}/'.format(Constant.LEFT_EYE_STATUS, globls.eye_in_or_out[0],
Constant.RIGHT_EYE_STATUS, globls.eye_in_or_out[1])
util.send_data(globls.arbitrator_sock_eye, globls.arbitrator_sock_addr_eye, data)
# print "EYE in or out ", data
globls.update_last_sent_eye_in_out(eye_in_out)
elif int(cmd_list[0]) == Constant.VERGENCE_REQUEST:
points = map(float, cmd_list[1:6])
value = self.eye_check.vergence_error(points)
# if value != globls.last_vergence_error_sent:
data = '{} {}/'.format(Constant.VERGENCE_STATUS, value)
util.send_data(globls.arbitrator_sock_eye, globls.arbitrator_sock_addr_eye, data)
# print "Vergence error ", data
globls.update_last_sent_vergence_error(value)
elif int(cmd_list[0]) == Constant.SCREEN_WINDOW_WIDTH:
globls.update_arbitrator_server_screen_resolution(width=int(cmd_list[1]))
globls.dump_log('Received the screen width and scale factor to display on GUI: {}'.
format(globls.arbitrator_display['x_scale_factor']))
elif int(cmd_list[0]) == Constant.SCREEN_WINDOW_HEIGHT:
globls.update_arbitrator_server_screen_resolution(height=int(cmd_list[1]))
globls.dump_log('Received the screen Height and scale factor to display on GUI: {}'.
format(globls.arbitrator_display['y_scale_factor']))
elif int(cmd_list[0]) == Constant.CENTRE_OF_WINDOWS:
# print cmd_list
# 100 number list of X Y Z diameter
# Maximum 30 points
no_of_points = int(cmd_list[1])
config = []
lst = cmd_list[2:]
# pair the data and give it to UI for updation
for i in range(0, len(lst), 6):
config.append([float(lst[i]), float(lst[i + 1]), float(lst[i + 2]),
float(lst[i + 3]), lst[i + 4], lst[i + 5]])
if len(config) == Constant.MAXIMUM_CENTRE_OF_WINDOW:
break
globls.dump_log('Points to draw {}'.format(cmd_list))
globls.update_centre_point(no_of_points, config)
elif int(cmd_list[0]) == Constant.WINDOW_ON:
# print cmd_list
globls.update_centre_window_on_off(True)
globls.dump_log('Window On')
elif int(cmd_list[0]) == Constant.WINDOW_OFF:
# print cmd_list
globls.update_centre_window_on_off(False)
globls.dump_log('Window Off')
# Reset this to -1, -1 so that next time this is queried from
# Arbitrator server new values are sent
globls.update_last_sent_eye_in_out([-1, -1])
# elif int(cmd_list[0]) == Constant.REWARD_ON:
# # print cmd_list
# self.DIO_obj.write_digital_bit(1)
# #self.DIO_obj.reward_on()
# globls.dump_log('Reward On')
# elif int(cmd_list[0]) == Constant.REWARD_OFF:
# # print cmd_list
# self.DIO_obj.write_digital_bit(0)
# #self.DIO_obj.reward_off()
# globls.dump_log('Reward Off')
elif int(cmd_list[0]) == Constant.VERGENCE_ON:
# print cmd_list
globls.udpdate_vergence_display(True)
globls.dump_log('Vergence On')
elif int(cmd_list[0]) == Constant.VERGENCE_OFF:
# print cmd_list
globls.udpdate_vergence_display(False)
globls.dump_log('Vergence Off')
# Reset this to -1 so that next time this is queried from
# Arbitrator server new values are sent
globls.update_last_sent_vergence_error(-1)
elif int(cmd_list[0]) == Constant.DRAW_EVENTS:
tempnum = len(cmd_lists)-1
globls.update_drawing_object_on(1)
globls.update_drawing_object_number(tempnum)
for i in range(0, tempnum):
templist = cmd_lists[i].split()
if i == 0:
tempx = float(templist[2])
tempy = float(templist[3])
data_str = '6 9 /'
temp_data = data_str+"""{}""".format('q'*( 1024 - len(data_str.encode())))
DataFileObj.save_raw_eye_taskdata(data_recv_ts, 0,0,0,0, task_data=temp_data)
else:
tempx = float(templist[1])
tempy = float(templist[2])
globls.update_drawing_object_pos(i, 0, tempx)
globls.update_drawing_object_pos(i, 1, tempy)
# elif int(cmd_list[0]) == Constant.EVENTS:
# globls.dump_log('event {}'.format(cmd_list))
# if not globls.DUMP_DATA_CONTINUALLY:
# if int(cmd_list[1]) == Constant.EVENT_START:
# # Start the data save
# DataFileObj.update_data_collect_flag(True)
#
# elif int(cmd_list[1]) == Constant.EVENT_STOP:
# # This needs to be saved here as we dump the saved data to file
# # And data collection falg will be reset
# DataFileObj.save_raw_eye_taskdata(
# data_recv_ts,
# globls.last_raw_eye_data[0], globls.last_raw_eye_data[1],
# globls.last_raw_eye_data[2], globls.last_raw_eye_data[3],
# task_data=data)
#
# # Stop saving the data and dump tp file
# # Flag to stop saving the data is set inside this function
# DataFileObj.dump_data_to_file()
# globls.update_last_sent_vergence_error(-1)
# globls.update_last_sent_eye_in_out([-1, -1])
# Save the data from 3rd party server
if globls.DUMP_DATA_CONTINUALLY:
DataFileObj.dump_data_continually(data_recv_ts, data)
# except socket.timeout:
# pass
except Exception as e:
log.exception(e)
globls.arbitrator_sock.close()
