def shutdown(self):
try:
self._running=False
if Computer.system=='linux2':
if self._hookManager:
self._hookManager.cancel()
while len(self.deviceMonitors) > 0:
m=self.deviceMonitors.pop(0)
m.running=False
if self.eventBuffer:
self.clearEventBuffer()
try:
self.closeDataStoreFile()
except:
pass
while len(self.devices) > 0:
d=self.devices.pop(0)
try:
if d is not None:
d._close()
except:
pass
gevent.sleep()
except:
print2err("Error in ioSever.shutdown():")
printExceptionDetailsToStdErr()
def __init__(self, *args, **kwargs):
"""
"""
AnalogInputDevice.__init__(self, *args, **kwargs)
self._labjack=None
if self.model_name in self._SUPPORTED_MODELS.keys():
try:
self._labjack = self._SUPPORTED_MODELS[self.model_name]()
self._calibration_data=self._labjack.getCalibrationData()
self._labjack.streamConfig( NumChannels = self.input_channel_count,
ChannelNumbers = range(self.input_channel_count),
ChannelOptions = [ 0 ]*self.input_channel_count,
SettlingFactor = self.settling_factor,
ResolutionIndex = self.resolution_index,
SampleFrequency = self.channel_sampling_rate)
self._data_streaming_thread=LabJackDataReader(self)
self._data_streaming_thread.start()
except:
print2err("ERROR DURING LABJACK INIT")
printExceptionDetailsToStdErr()
else:
print2err("AnalogInput Model %s is not supported. Supported models are %s, using model_name parameter."%(self.model_name,str(self._SUPPORTED_MODELS.keys()),))
raise ioDeviceError(self,"AnalogInput Model not supported: %s"%(self.model_name))
sys.exit(0)
self._scan_count=0
def _nativeEventCallback(self,labjack_data):
if not self.isReportingEvents():
return False
logged_time=Computer.getTime()
start_pre,start_post,analog_data=labjack_data
str_proto='AIN%d'
channel_index_list=range(self.input_channel_count)
ain=[]
ain_counts=[]
for c in channel_index_list:
ai=analog_data[str_proto%c]
ain.append(ai)
ain_counts.append(len(ai))
#ioHub.print2err("Channel Counts: {0} {1}".format(logged_time,ain_counts))
ain_counts=tuple(ain_counts)
if ain_counts[0] != ain_counts[-1]:
err_str="Channel Sample Count Mismatch: "
for c in channel_index_list:
err_str+='{%d}, '%c
err_str=err_str[:-2]
print2err(err_str.format(*ain_counts))
device_time=0.0
iohub_time=0.0
delay=0.0
confidence_interval=start_post-start_pre
event =[
0, # exp id
0, # session id
0, #device id (not currently used)
0, # event id
MultiChannelAnalogInputEvent.EVENT_TYPE_ID, # event type
device_time, # device time
logged_time, # logged time
iohub_time, # hub time
confidence_interval, # confidence interval
delay, # delay
0 # filter_id
]
for s in range(ain_counts[0]):
multi_channel_event=list(event)
multi_channel_event[3]=Computer._getNextEventID()
multi_channel_event[5]=float(self._scan_count)/float(self.channel_sampling_rate) #device_time
multi_channel_event[7]=multi_channel_event[5]+start_post # iohub time
multi_channel_event[9]=logged_time-multi_channel_event[7] #delay
multi_channel_event.extend([ain[a][s] for a in channel_index_list])
self._addNativeEventToBuffer(multi_channel_event)
self._scan_count+=1
self._last_callback_time=logged_time
return True
def shutDown(self):
try:
self.disableHighPriority()
self.iohub.shutdown()
self._running=False
self.stop()
except:
print2err("Error in ioSever.shutdown():")
printExceptionDetailsToStdErr()
sys.exit(1)
def run(self):
getTime=Computer.getTime
try:
self.running = True
while self.running:
# wait for threading event to become True
self.stream_start_time_pre=None
self.stream_start_time_post=None
self.stream_stop_time=None
self.request_count = 0
self.channel_array_read_count = 0
self.missed_count = 0
self.error_count = 0
self.stream_data_event.wait(None)
# start streaming
self.stream_start_time_pre = getTime()
self.labjack_device.streamStart()
self.stream_start_time_post = getTime()
# Stream until either the ioHub server has set running to False,
# or until threading event is False again
while self.running and self.isStreamingData():
# Calling with convert = False,
# because we are going to convert in the main thread.
returnDict = self.labjack_device.streamData(convert = False).next()
# record and print any errors during streaming
if returnDict['errors'] != 0:
self.error_count+=returnDict['errors']
print2err('ERRORS DURING LABJACK STREAMING: current: {0} total: {1}'.format(returnDict['errors'],self.error_count))
if returnDict['missed'] != 0:
self.missed_count+=returnDict['missed']
print2err('DROPPED SAMPLES DURING LABJACK STREAMING: current: {0} total: {1}'.format(returnDict['missing'],self.missed_count))
# put a copy of the new analog input events in the queue for pickup by the ioHub Device Poll
self.iohub_device._nativeEventCallback([self.stream_start_time_pre,
self.stream_start_time_post,
copy.deepcopy(self.labjack_device.processStreamData(returnDict['result']))])
self.request_count += 1
self.labjack_device.streamStop()
self.stream_stop_time=getTime()
total = self.request_count * self.labjack_device.packetsPerRequest * self.labjack_device.streamSamplesPerPacket
total -= self.missed_count
run_time = self.stream_stop_time-self.stream_start_time_post
print2err("%s samples / %s seconds = %s Hz" % ( total, run_time, float(total)/run_time ))
self.iohub_device=None
self.labjack_device=None
except:
print2err("ERROR IN THREAD RUN:")
printExceptionDetailsToStdErr()
def enableEventReporting(self, enable):
try:
current = self.isReportingEvents()
if current == enable:
return enable
if AnalogInputDevice.enableEventReporting(self, enable) is True:
self._scan_count=0
self._data_streaming_thread.enableDataStreaming(True)
else:
self._data_streaming_thread.enableDataStreaming(False)
except:
print2err("----- LabJack AnalogInput enableEventReporting ERROR ----")
printExceptionDetailsToStdErr()
print2err("---------------------------------------------------------")
def enableEventReporting(self, enable):
try:
current = self.isReportingEvents()
if current == enable:
return enable
if AnalogInputDevice.enableEventReporting(self, enable) is True:
self._scan_count = 0
self._data_streaming_thread.enableDataStreaming(True)
else:
self._data_streaming_thread.enableDataStreaming(False)
except:
print2err(
"----- LabJack AnalogInput enableEventReporting ERROR ----")
printExceptionDetailsToStdErr()
print2err(
"---------------------------------------------------------")
def __init__(self, *args, **kwargs):
"""
"""
AnalogInputDevice.__init__(self, *args, **kwargs)
self._labjack = None
if self.model_name in self._SUPPORTED_MODELS.keys():
try:
self._labjack = self._SUPPORTED_MODELS[self.model_name]()
self._calibration_data = self._labjack.getCalibrationData()
self._labjack.streamConfig(
NumChannels=self.input_channel_count,
ChannelNumbers=range(self.input_channel_count),
ChannelOptions=[0] * self.input_channel_count,
SettlingFactor=self.settling_factor,
ResolutionIndex=self.resolution_index,
SampleFrequency=self.channel_sampling_rate)
delay_offset = self.getConfiguration().get('delay_offset')
if delay_offset is not None:
self.setDelayOffset(delay_offset)
self._data_streaming_thread = LabJackDataReader(self)
self._data_streaming_thread.start()
except Exception:
print2err("ERROR DURING LABJACK INIT")
printExceptionDetailsToStdErr()
else:
print2err(
"AnalogInput Model %s is not supported. Supported models are %s, using model_name parameter."
% (
self.model_name,
str(self._SUPPORTED_MODELS.keys()),
))
raise ioDeviceError(
self,
"AnalogInput Model not supported: %s" % (self.model_name))
sys.exit(0)
self._scan_count = 0
def _processDeviceEventIteration(self):
for device in self.devices:
try:
events=device._getNativeEventBuffer()
#if events and len(events)>0:
# ioHub.print2err("_processDeviceEventIteration.....", device._event_listeners)
while len(events)>0:
evt=events.popleft()
e=device._getIOHubEventObject(evt)
if e is not None:
for l in device._getEventListeners(e[DeviceEvent.EVENT_TYPE_ID_INDEX]):
l._handleEvent(e)
except:
printExceptionDetailsToStdErr()
print2err("Error in processDeviceEvents: ", device, " : ", len(events), " : ", e)
print2err("Event type ID: ",e[DeviceEvent.EVENT_TYPE_ID_INDEX], " : " , EventConstants.getName(e[DeviceEvent.EVENT_TYPE_ID_INDEX]))
print2err("--------------------------------------")
def addDeviceToMonitor(self,device_class_name,device_config):
device_class_name=str(device_class_name)
self.log("Handling Device: %s"%(device_class_name,))
#print2err("addDeviceToMonitor:\n\tdevice_class: {0}\n\texperiment_device_config:{1}\n".format(device_class_name,device_config))
DeviceClass=None
class_name_start=device_class_name.rfind('.')
iohub_sub_mod='psychopy.iohub.'
iohub_submod_path_length=len(iohub_sub_mod)
device_module_path=iohub_sub_mod+'devices.'
if class_name_start>0:
device_module_path="{0}{1}".format(device_module_path,device_class_name[:class_name_start].lower())
device_class_name=device_class_name[class_name_start+1:]
else:
device_module_path="{0}{1}".format(device_module_path,device_class_name.lower())
#print2err("Processing device, device_class_name: {0}, device_module_path: {1}".format(device_class_name, device_module_path))
dconfigPath=os.path.join(IO_HUB_DIRECTORY,device_module_path[iohub_submod_path_length:].replace('.',os.path.sep),"default_%s.yaml"%(device_class_name.lower()))
# print2err("dconfigPath: {0}, device_module_path: {1}\n".format(dconfigPath,device_module_path))
# print2err("Loading Device Defaults file:\n\tdevice_class: {0}\n\tdeviceConfigFile:{1}\n".format(device_class_name,dconfigPath))
self.log("Loading Device Defaults file: %s"%(device_class_name,))
_dclass,default_device_config=load(file(dconfigPath,'r'), Loader=Loader).popitem()
#print2err("Device Defaults:\n\tdevice_class: {0}\n\tdefault_device_config:{1}\n".format(device_class_name,default_device_config))
self.processDeviceConfigDictionary(device_module_path, device_class_name, device_config,default_device_config)
if device_module_path in self._all_device_config_errors:
# Complete device config verification.
print2err("**** ERROR: DEVICE CONFIG ERRORS FOUND ! NOT LOADING DEVICE: ",device_module_path)
device_config_errors=self._all_device_config_errors[device_module_path]
for error_type,errors in device_config_errors.iteritems():
print2err("%s count %d:"%(error_type,len(errors)))
for error in errors:
print2err("\t{0}".format(error))
print2err("\n")
return None
DeviceClass,device_class_name,event_classes=import_device(device_module_path,device_class_name)
#print2err("Updated Experiment Device Config:\n\tdevice_class: {0}\n\tdevice_config:{1}\n".format(device_class_name,default_device_config))
if device_config.get('enable',True):
self.log("Searching Device Path: %s"%(device_class_name,))
self.log("Creating Device: %s"%(device_class_name,))
#print2err("Creating Device: %s"%(device_class_name,))
if DeviceClass._iohub_server is None:
DeviceClass._iohub_server=self
if device_class_name != 'Display' and DeviceClass._display_device is None:
DeviceClass._display_device=ioServer.deviceDict['Display']
deviceInstance=DeviceClass(dconfig=device_config)
self.log("Device Instance Created: %s"%(device_class_name,))
#print2err("Device Instance Created: %s"%(device_class_name,))
self.devices.append(deviceInstance)
ioServer.deviceDict[device_class_name]=deviceInstance
if 'device_timer' in device_config:
interval = device_config['device_timer']['interval']
self.log("%s has requested a timer with period %.5f"%(device_class_name, interval))
dPoller=DeviceMonitor(deviceInstance,interval)
self.deviceMonitors.append(dPoller)
eventIDs=[]
monitor_events_list=device_config.get('monitor_event_types',[])
if isinstance(monitor_events_list,(list,tuple)):
for event_class_name in monitor_events_list:
eventIDs.append(getattr(EventConstants,convertCamelToSnake(event_class_name[:-5],False)))
self.log("{0} Instance Event IDs To Monitor: {1}".format(device_class_name,eventIDs))
#ioHub.print2err("{0} Instance Event IDs To Monitor: {1}".format(device_class_name,eventIDs))
# add event listeners for streaming events
if device_config.get('stream_events') is True:
self.log("Online event access is being enabled for: %s"%device_class_name)
# add listener for global event queue
deviceInstance._addEventListener(self,eventIDs)
#ioHub.print2err("ioServer event stream listener added: device=%s eventIDs=%s"%(device_class_name,eventIDs))
self.log("Standard event stream listener added for ioServer for event ids %s"%(str(eventIDs),))
# add listener for device event queue
deviceInstance._addEventListener(deviceInstance,eventIDs)
# ioHub.print2err("%s event stream listener added: eventIDs=%s"%(device_class_name,eventIDs))
self.log("Standard event stream listener added for class %s for event ids %s"%(device_class_name,str(eventIDs)))
return deviceInstance,device_config,eventIDs,event_classes
for m in s.deviceMonitors:
m.start()
gevent.spawn(s.processDeviceEvents, 0.001)
sys.stdout.write("IOHUB_READY\n\r\n\r")
sys.stdout.flush()
gevent.run()
s.log(
"Server END Time Offset: {0}".format(
Computer.globalClock.getLastResetTime()), 'DEBUG')
except Exception as e:
print2err("Error occurred during ioServer.start(): ", str(e))
printExceptionDetailsToStdErr()
print2err("------------------------------")
sys.stdout.write("IOHUB_FAILED\n\r\n\r")
sys.stdout.flush()
try:
s.shutdown()
except:
pass
return -1
if __name__ == '__main__':
s.udpService.start()
for m in s.deviceMonitors:
m.start()
gevent.spawn(s.processDeviceEvents,0.001)
sys.stdout.write("IOHUB_READY\n\r\n\r")
sys.stdout.flush()
gevent.run()
s.log("Server END Time Offset: {0}".format(Computer.globalClock.getLastResetTime()),'DEBUG')
except Exception as e:
print2err("Error occurred during ioServer.start(): ",str(e))
printExceptionDetailsToStdErr()
print2err("------------------------------")
sys.stdout.write("IOHUB_FAILED\n\r\n\r")
sys.stdout.flush()
try:
s.shutdown()
except:
pass
return -1
if __name__ == '__main__':
prog=sys.argv[0]
def _nativeEventCallback(self, labjack_data):
if not self.isReportingEvents():
return False
logged_time = Computer.getTime()
start_pre, start_post, analog_data = labjack_data
#=print2err ('ain_keys: ',analog_data.keys())
str_proto = 'AIN%d'
channel_index_list = range(self.input_channel_count)
ain = [
[],
] * self.input_channel_count
ain_counts = [
0,
] * self.input_channel_count
for c in channel_index_list:
ain[c] = analog_data[str_proto % c]
ain_counts[c] = len(ain[c])
ain_counts = tuple(ain_counts)
if ain_counts[0] != ain_counts[-1]:
#print2err('Channel Count Mismatch: ',ain_counts)
missing_channel_count = 0
if ain_counts[0] > ain_counts[-1]:
#print2err('Last sample in packet incomplete: ', ain_counts[-1])
missing_channel_count = ain_counts[0] - ain_counts[-1]
if missing_channel_count > 1:
print2err(
'**** UNHANDLED: > 1 sample in packet does not have 8 channels: ',
ain_counts)
print2err('Dropping all samples in packet')
print2err('-----------')
return
self._part_sample = [
0.0,
] * self.input_channel_count
for ci in channel_index_list:
if ain_counts[ci] > ain_counts[-1]:
self._part_sample[ci] = ain[ci][-1]
ain[ci] = ain[ci][:-1]
#print2err('Part Sample Created: {0}'.format(self._part_sample))
#print2err('-----------')
elif ain_counts[0] < ain_counts[-1]:
#print2err('First sample in packet incomplete: ', ain_counts[0])
missing_channel_count = ain_counts[-1] - ain_counts[0]
if missing_channel_count > 1:
print2err(
'**** UNHANDLED: > 1 sample in packet does not have 8 channels: ',
ain_counts)
print2err('Dropping all samples in packet')
print2err('-----------')
return
if self._part_sample is None:
print2err('**** Part Sample is None')
print2err('**** Dropping first sample in packet')
print2err('-----------')
for ci in channel_index_list:
if ain_counts[ci] > ain_counts[0]:
ain[ci] = ain[ci][1:]
else:
for ci in channel_index_list:
if ain_counts[ci] > ain_counts[0]:
self._part_sample[ci] = ain[ci][0]
ain[ci] = ain[ci][1:]
for ci in channel_index_list:
temp = ain[ci]
ain[ci] = [
self._part_sample[ci],
]
ain[ci].extend(temp)
#print2err('Inserted completed sample {0}'.format(self._part_sample))
#print2err('-----------')
self._part_sample = None
else:
print2err(
'**** UNHANDLED: Both first and last sampless do not have 8 channels: ',
ain_counts)
print2err('Dropping all samples in packet')
print2err('-----------')
return
device_time = 0.0
iohub_time = 0.0
delay = 0.0
confidence_interval = start_post - start_pre
event = [
0, # exp id
0, # session id
0, #device id (not currently used)
0, # event id
MultiChannelAnalogInputEvent.EVENT_TYPE_ID, # event type
device_time, # device time
logged_time, # logged time
iohub_time, # hub time
confidence_interval, # confidence interval
delay, # delay
0 # filter_id
]
for s in range(len(ain[0])):
multi_channel_event = list(event)
multi_channel_event[3] = Computer._getNextEventID()
multi_channel_event[5] = float(self._scan_count) / float(
self.channel_sampling_rate) #device_time
multi_channel_event[7] = multi_channel_event[
5] + start_post + self.getDelayOffset() # iohub time
multi_channel_event[9] = (logged_time - multi_channel_event[7]
) - self.getDelayOffset() #delay
multi_channel_event.extend([ain[a][s] for a in channel_index_list])
self._addNativeEventToBuffer(multi_channel_event)
self._scan_count += 1
self._last_callback_time = logged_time
return True
def run(self):
getTime = Computer.getTime
try:
self.running = True
while self.running:
# wait for threading event to become True
self.stream_start_time_pre = None
self.stream_start_time_post = None
self.stream_stop_time = None
self.request_count = 0
self.channel_array_read_count = 0
self.missed_count = 0
self.error_count = 0
self.stream_data_event.wait(None)
# start streaming
self.stream_start_time_pre = getTime()
self.labjack_device.streamStart()
self.stream_start_time_post = getTime()
# Stream until either the ioHub server has set running to False,
# or until threading event is False again
while self.running and self.isStreamingData():
# Calling with convert = False,
# because we are going to convert in the main thread.
returnDict = self.labjack_device.streamData(
convert=False).next()
# record and print any errors during streaming
if returnDict['errors'] != 0:
self.error_count += returnDict['errors']
print2err(
'ERRORS DURING LABJACK STREAMING: current: {0} total: {1}'
.format(returnDict['errors'], self.error_count))
if returnDict['missed'] != 0:
self.missed_count += returnDict['missed']
print2err(
'DROPPED SAMPLES DURING LABJACK STREAMING: current: {0} total: {1}'
.format(returnDict['missed'], self.missed_count))
# put a copy of the new analog input events in the queue for pickup by the ioHub Device Poll
self.iohub_device._nativeEventCallback([
self.stream_start_time_pre,
self.stream_start_time_post,
copy.deepcopy(
self.labjack_device.processStreamData(
returnDict['result']))
])
self.request_count += 1
self.labjack_device.streamStop()
self.stream_stop_time = getTime()
total = self.request_count * self.labjack_device.packetsPerRequest * self.labjack_device.streamSamplesPerPacket
total -= self.missed_count
run_time = self.stream_stop_time - self.stream_start_time_post
#print2err("%s samples / %s seconds = %s Hz" % ( total, run_time, float(total)/run_time ))
self.iohub_device = None
self.labjack_device = None
except Exception:
print2err("ERROR IN THREAD RUN:")
printExceptionDetailsToStdErr()
def _nativeEventCallback(self, labjack_data):
if not self.isReportingEvents():
return False
logged_time = Computer.getTime()
start_pre, start_post, analog_data = labjack_data
# =print2err ('ain_keys: ',analog_data.keys())
str_proto = "AIN%d"
channel_index_list = range(self.input_channel_count)
ain = [[]] * self.input_channel_count
ain_counts = [0] * self.input_channel_count
for c in channel_index_list:
ain[c] = analog_data[str_proto % c]
ain_counts[c] = len(ain[c])
ain_counts = tuple(ain_counts)
if ain_counts[0] != ain_counts[-1]:
# print2err('Channel Count Mismatch: ',ain_counts)
missing_channel_count = 0
if ain_counts[0] > ain_counts[-1]:
# print2err('Last sample in packet incomplete: ', ain_counts[-1])
missing_channel_count = ain_counts[0] - ain_counts[-1]
if missing_channel_count > 1:
print2err("**** UNHANDLED: > 1 sample in packet does not have 8 channels: ", ain_counts)
print2err("Dropping all samples in packet")
print2err("-----------")
return
self._part_sample = [0.0] * self.input_channel_count
for ci in channel_index_list:
if ain_counts[ci] > ain_counts[-1]:
self._part_sample[ci] = ain[ci][-1]
ain[ci] = ain[ci][:-1]
# print2err('Part Sample Created: {0}'.format(self._part_sample))
# print2err('-----------')
elif ain_counts[0] < ain_counts[-1]:
# print2err('First sample in packet incomplete: ', ain_counts[0])
missing_channel_count = ain_counts[-1] - ain_counts[0]
if missing_channel_count > 1:
print2err("**** UNHANDLED: > 1 sample in packet does not have 8 channels: ", ain_counts)
print2err("Dropping all samples in packet")
print2err("-----------")
return
if self._part_sample is None:
print2err("**** Part Sample is None")
print2err("**** Dropping first sample in packet")
print2err("-----------")
for ci in channel_index_list:
if ain_counts[ci] > ain_counts[0]:
ain[ci] = ain[ci][1:]
else:
for ci in channel_index_list:
if ain_counts[ci] > ain_counts[0]:
self._part_sample[ci] = ain[ci][0]
ain[ci] = ain[ci][1:]
for ci in channel_index_list:
temp = ain[ci]
ain[ci] = [self._part_sample[ci]]
ain[ci].extend(temp)
# print2err('Inserted completed sample {0}'.format(self._part_sample))
# print2err('-----------')
self._part_sample = None
else:
print2err("**** UNHANDLED: Both first and last sampless do not have 8 channels: ", ain_counts)
print2err("Dropping all samples in packet")
print2err("-----------")
return
device_time = 0.0
iohub_time = 0.0
delay = 0.0
confidence_interval = start_post - start_pre
event = [
0, # exp id
0, # session id
0, # device id (not currently used)
0, # event id
MultiChannelAnalogInputEvent.EVENT_TYPE_ID, # event type
device_time, # device time
logged_time, # logged time
iohub_time, # hub time
confidence_interval, # confidence interval
delay, # delay
0, # filter_id
]
for s in range(len(ain[0])):
multi_channel_event = list(event)
multi_channel_event[3] = Computer._getNextEventID()
multi_channel_event[5] = float(self._scan_count) / float(self.channel_sampling_rate) # device_time
multi_channel_event[7] = multi_channel_event[5] + start_post # iohub time
multi_channel_event[9] = logged_time - multi_channel_event[7] # delay
multi_channel_event.extend([ain[a][s] for a in channel_index_list])
self._addNativeEventToBuffer(multi_channel_event)
self._scan_count += 1
self._last_callback_time = logged_time
return True
def sendResponse(self,data,address):
packet_data=None
try:
max_size=MAX_PACKET_SIZE/2-20
packet_data=self.pack(data)+'\r\n'
packet_data_length=len(packet_data)
if packet_data_length>= max_size:
num_packets=len(packet_data)/max_size+1
self.sendResponse(('IOHUB_MULTIPACKET_RESPONSE',num_packets),address)
for p in xrange(num_packets-1):
self.socket.sendto(packet_data[p*max_size:(p+1)*max_size],address)
self.socket.sendto(packet_data[(p+1)*max_size:packet_data_length],address)
else:
self.socket.sendto(packet_data,address)
except:
print2err('Error trying to send data to experiment process:')
print2err('data length:',len(data))
print2err("=============================")
printExceptionDetailsToStdErr()
print2err("=============================")
first_data_element="NO_DATA_AVAILABLE"
if data:
print2err('Data was [{0}]'.format(data))
try:
first_data_element=data[0]
except:
pass
packet_data_length=0
if packet_data:
packet_data_length=len(packet_data)
print2err('packet Data length: ',len(packet_data))
data=createErrorResult('IOHUB_SERVER_RESPONSE_ERROR',
msg="The ioHub Server Failed to send the intended response.",
first_data_element=str(first_data_element),
packet_data_length=packet_data_length,
max_packet_size=max_size)
packet_data=self.pack(data)+'\r\n'
packet_data_length=len(packet_data)
self.socket.sendto(packet_data,address)
def _nativeEventCallback(self, labjack_data):
if not self.isReportingEvents():
return False
logged_time = Computer.getTime()
start_pre, start_post, analog_data = labjack_data
str_proto = 'AIN%d'
channel_index_list = range(self.input_channel_count)
ain = []
ain_counts = []
for c in channel_index_list:
ai = analog_data[str_proto % c]
ain.append(ai)
ain_counts.append(len(ai))
#ioHub.print2err("Channel Counts: {0} {1}".format(logged_time,ain_counts))
ain_counts = tuple(ain_counts)
if ain_counts[0] != ain_counts[-1]:
err_str = "Channel Sample Count Mismatch: "
for c in channel_index_list:
err_str += '{%d}, ' % c
err_str = err_str[:-2]
print2err(err_str.format(*ain_counts))
device_time = 0.0
iohub_time = 0.0
delay = 0.0
confidence_interval = start_post - start_pre
event = [
0, # exp id
0, # session id
0, #device id (not currently used)
0, # event id
MultiChannelAnalogInputEvent.EVENT_TYPE_ID, # event type
device_time, # device time
logged_time, # logged time
iohub_time, # hub time
confidence_interval, # confidence interval
delay, # delay
0 # filter_id
]
for s in range(ain_counts[0]):
multi_channel_event = list(event)
multi_channel_event[3] = Computer._getNextEventID()
multi_channel_event[5] = float(self._scan_count) / float(
self.channel_sampling_rate)
multi_channel_event[7] = multi_channel_event[4] + start_post
multi_channel_event[9] = logged_time - multi_channel_event[6]
multi_channel_event.extend([ain[a][s] for a in channel_index_list])
self._addNativeEventToBuffer(multi_channel_event)
self._scan_count += 1
self._last_callback_time = logged_time
return True
def createNewMonitoredDevice(self,device_class_name,deviceConfig):
#print2err("#### createNewMonitoredDevice: ",device_class_name)
self._all_device_config_errors=dict()
try:
device_instance=None
device_config=None
device_event_ids=None
event_classes=None
device_instance_and_config=self.addDeviceToMonitor(device_class_name,deviceConfig)
if device_instance_and_config:
device_instance,device_config,device_event_ids,event_classes=device_instance_and_config
DeviceConstants.addClassMapping(device_instance.__class__)
EventConstants.addClassMappings(device_instance.__class__,device_event_ids,event_classes)
else:
print2err('## Device was not started by the ioHub Server: ',device_class_name)
raise ioHubError("Device config validation failed")
except:
print2err("Error during device creation ....")
printExceptionDetailsToStdErr()
raise ioHubError("Error during device creation ....")
# Update DataStore Structure if required.
try:
if self.emrt_file is not None:
self.emrt_file.updateDataStoreStructure(device_instance,event_classes)
except:
print2err("Error while updating datastore for device addition:",device_instance,device_event_ids)
printExceptionDetailsToStdErr()
self.log("Adding ioServer and DataStore event listeners......")
# add event listeners for saving events
if self.emrt_file is not None:
if device_config['save_events']:
device_instance._addEventListener(self.emrt_file,device_event_ids)
self.log("DataStore listener for device added: device: %s eventIDs: %s"%(device_instance.__class__.__name__,device_event_ids))
#print2err("DataStore listener for device added: device: %s eventIDs: %s"%(device_instance.__class__.__name__,device_event_ids))
else:
#print2err("DataStore saving disabled for device: %s"%(device_instance.__class__.__name__,))
self.log("DataStore saving disabled for device: %s"%(device_instance.__class__.__name__,))
else:
#print2err("DataStore Not Evabled. No events will be saved.")
self.log("DataStore Not Enabled. No events will be saved.")
# Add Device Monitor for Keyboard or Mouse device type
deviceDict=ioServer.deviceDict
iohub=self
if device_class_name in ('Mouse','Keyboard'):
if Computer.system == 'win32':
if self._hookDevice is None:
iohub.log("Creating pyHook Monitors....")
#print2err("Creating pyHook Monitor....")
class pyHookDevice(object):
def __init__(self):
import pyHook
self._hookManager=pyHook.HookManager()
self._mouseHooked=False
self._keyboardHooked=False
if device_class_name == 'Mouse':
#print2err("Hooking Mouse.....")
self._hookManager.MouseAll = deviceDict['Mouse']._nativeEventCallback
self._hookManager.HookMouse()
self._mouseHooked=True
elif device_class_name == 'Keyboard':
#print2err("Hooking Keyboard.....")
self._hookManager.KeyAll = deviceDict['Keyboard']._nativeEventCallback
self._hookManager.HookKeyboard()
self._keyboardHooked=True
#iohub.log("WindowsHook PumpEvents Periodic Timer Created.")
def _poll(self):
import pythoncom
# PumpWaitingMessages returns 1 if a WM_QUIT message was received, else 0
if pythoncom.PumpWaitingMessages() == 1:
raise KeyboardInterrupt()
#print2err("Creating pyHook Monitor......")
self._hookDevice=pyHookDevice()
hookMonitor=DeviceMonitor(self._hookDevice,0.00375)
self.deviceMonitors.append(hookMonitor)
#print2err("Created pyHook Monitor.")
else:
#print2err("UPDATING pyHook Monitor....")
if device_class_name == 'Mouse' and self._hookDevice._mouseHooked is False:
#print2err("Hooking Mouse.....")
self._hookDevice._hookManager.MouseAll = deviceDict['Mouse']._nativeEventCallback
self._hookDevice._hookManager.HookMouse()
self._hookDevice._mouseHooked=True
elif device_class_name == 'Keyboard' and self._hookDevice._keyboardHooked is False:
#print2err("Hooking Keyboard.....")
self._hookDevice._hookManager.KeyAll = deviceDict['Keyboard']._nativeEventCallback
self._hookDevice._hookManager.HookKeyboard()
self._hookDevice._keyboardHooked=True
#print2err("Finished Updating pyHook Monitor.")
elif Computer.system == 'linux2':
# TODO: consider switching to xlib-ctypes implementation of xlib
# https://github.com/garrybodsworth/pyxlib-ctypes
from .devices import pyXHook
if self._hookManager is None:
#iohub.log("Creating pyXHook Monitors....")
self._hookManager = pyXHook.HookManager()
self._hookManager._mouseHooked=False
self._hookManager._keyboardHooked=False
if device_class_name == 'Keyboard':
#print2err("Hooking Keyboard.....")
self._hookManager.HookKeyboard()
self._hookManager.KeyDown = deviceDict['Keyboard']._nativeEventCallback
self._hookManager.KeyUp = deviceDict['Keyboard']._nativeEventCallback
self._hookManager._keyboardHooked=True
elif device_class_name == 'Mouse':
#print2err("Hooking Mouse.....")
self._hookManager.HookMouse()
self._hookManager.MouseAllButtonsDown = deviceDict['Mouse']._nativeEventCallback
self._hookManager.MouseAllButtonsUp = deviceDict['Mouse']._nativeEventCallback
self._hookManager.MouseAllMotion = deviceDict['Mouse']._nativeEventCallback
self._hookManager._mouseHooked=True
#print2err("Starting pyXHook.HookManager.....")
self._hookManager.start()
#iohub.log("pyXHook Thread Created.")
#print2err("pyXHook.HookManager thread created.")
else:
#iohub.log("Updating pyXHook Monitor....")
if device_class_name == 'Keyboard' and self._hookManager._keyboardHooked is False:
#print2err("Hooking Keyboard.....")
self._hookManager.HookKeyboard()
self._hookManager.KeyDown = deviceDict['Keyboard']._nativeEventCallback
self._hookManager.KeyUp = deviceDict['Keyboard']._nativeEventCallback
self._hookManager._keyboardHooked=True
if device_class_name == 'Mouse' and self._hookManager._mouseHooked is False:
#print2err("Hooking Mouse.....")
self._hookManager.HookMouse()
self._hookManager.MouseAllButtonsDown = deviceDict['Mouse']._nativeEventCallback
self._hookManager.MouseAllButtonsUp = deviceDict['Mouse']._nativeEventCallback
self._hookManager.MouseAllMotion = deviceDict['Mouse']._nativeEventCallback
self._hookManager._mouseHooked=True
#iohub.log("Finished Updating pyXHook Monitor....")
else: # OSX
if self._hookDevice is None:
self._hookDevice=[]
if device_class_name == 'Mouse' and 'Mouse' not in self._hookDevice:
#print2err("Hooking OSX Mouse.....")
mouseHookMonitor=DeviceMonitor(deviceDict['Mouse'],0.004)
self.deviceMonitors.append(mouseHookMonitor)
deviceDict['Mouse']._CGEventTapEnable(deviceDict['Mouse']._tap, True)
self._hookDevice.append('Mouse')
#print2err("Done Hooking OSX Mouse.....")
if device_class_name == 'Keyboard' and 'Keyboard' not in self._hookDevice:
#print2err("Hooking OSX Keyboard.....")
kbHookMonitor=DeviceMonitor(deviceDict['Keyboard'],0.004)
self.deviceMonitors.append(kbHookMonitor)
deviceDict['Keyboard']._CGEventTapEnable(deviceDict['Keyboard']._tap, True)
self._hookDevice.append('Keyboard')
#print2err("DONE Hooking OSX Keyboard.....")
return [device_class_name, device_config['name'], device_instance._getRPCInterface()]
def __init__(self, rootScriptPathDir, config=None):
self._session_id=None
self._experiment_id=None
self.log("Server Time Offset: {0}".format(Computer.globalClock.getLastResetTime()))
self._hookManager=None
self.emrt_file=None
self.config=config
self.devices=[]
self.deviceMonitors=[]
self.sessionInfoDict=None
self.experimentInfoList=None
self.filterLookupByInput={}
self.filterLookupByOutput={}
self.filterLookupByName={}
self._hookDevice=None
ioServer.eventBuffer=deque(maxlen=config.get('global_event_buffer',2048))
self._running=True
# start UDP service
self.udpService=udpServer(self,':%d'%config.get('udp_port',9000))
from .. import iohub
# read temp paths file
iohub.data_paths=None
try:
expJsonPath=os.path.join(rootScriptPathDir,'exp.paths')
f=open(expJsonPath,'r')
iohub.data_paths=json.loads(f.read())
f.flush()
f.close()
os.remove(expJsonPath)
except:
pass
try:
# initial dataStore setup
if 'data_store' in config:
experiment_datastore_config=config.get('data_store')
default_datastore_config_path=os.path.join(IO_HUB_DIRECTORY,'datastore','default_datastore.yaml')
#print2err('default_datastore_config_path: ',default_datastore_config_path)
_dslabel,default_datastore_config=load(file(default_datastore_config_path,'r'), Loader=Loader).popitem()
for default_key,default_value in default_datastore_config.iteritems():
if default_key not in experiment_datastore_config:
experiment_datastore_config[default_key]=default_value
if experiment_datastore_config.get('enable', True):
#print2err("Creating ioDataStore....")
if iohub.data_paths is None:
resultsFilePath=rootScriptPathDir
else:
resultsFilePath=iohub.data_paths[u'IOHUB_DATA']
self.createDataStoreFile(experiment_datastore_config.get('filename','events')+'.hdf5',resultsFilePath,'a',experiment_datastore_config)
#print2err("Created ioDataStore.")
except:
print2err("Error during ioDataStore creation....")
printExceptionDetailsToStdErr()
#built device list and config from initial yaml config settings
try:
for iodevice in config.get('monitor_devices',()):
for device_class_name,deviceConfig in iodevice.iteritems():
#print2err("======================================================")
#print2err("Started load process for: {0}".format(device_class_name))
self.createNewMonitoredDevice(device_class_name,deviceConfig)
except:
print2err("Error during device creation ....")
printExceptionDetailsToStdErr()
raise ioHubError("Error during device creation ....")
