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 ....")