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): Device.__init__(self, *args, **kwargs['dconfig']) self._serial = None self.port = self.getConfiguration().get('port') if self.port.lower() == 'auto': pports = self.findPorts() if pports: self.port = pports[0] if len(pports) > 1: print2err("Warning: Serial device port configuration set to 'auto'.\nMultiple serial ports found:\n", pports, "\n** Using port ", self.port) self.baud = self.getConfiguration().get('baud') self._parser_config = self.getConfiguration().get('event_parser') self._byte_diff_mode = self._parser_config.get('byte_diff') if self._byte_diff_mode: self._rx_buffer = None else: self._resetParserState() self._rx_buffer = '' self._event_count = 0 self._timeout = None self._serial = None self.setConnectionState(True)
def getEventTable(self,event_type): if self.hdfFile: klassTables=self.hdfFile.root.class_table_mapping deviceEventTable=None event_column=None event_value=None if isinstance(event_type,basestring): if event_type.find('Event')>=0: event_column='class_name' event_value=event_type else: event_value='' tokens=event_type.split('_') for t in tokens: event_value+=t[0].upper()+t[1:].lower() event_value=event_type+'Event' event_value='"%s"'%(event_value) elif isinstance(event_type,(int,long)): event_column='class_id' event_value=event_type else: iohub.print2err("getEventTable error: event_type arguement must be a string or and int") return None result=[row.fetch_all_fields() for row in klassTables.where('({0} == {1}) & (class_type_id == 1)'.format(event_column,event_value))] if len(result)!= 1: iohub.print2err("event_type_id passed to getEventAttribute can only return one row from CLASS_MAPPINGS: ",len(result)) return None tablePathString=result[0][3] return self.hdfFile.getNode(tablePathString) return None
def _handleEvents(self, events): # saves many events to pytables table at once. # EVENTS MUST ALL BE OF SAME TYPE!!!!! try: #ioHub.print2err("_handleEvent: ",self.active_experiment_id,self.active_session_id) if self.checkForExperimentAndSessionIDs(len(events)) is False: return False event=events[0] etype=event[DeviceEvent.EVENT_TYPE_ID_INDEX] #ioHub.print2err("etype: ",etype) eventClass=EventConstants.getClass(etype) etable=self.TABLES[eventClass.IOHUB_DATA_TABLE] #ioHub.print2err("eventClass: etable",eventClass,etable) np_events=[] for event in events: event[DeviceEvent.EVENT_EXPERIMENT_ID_INDEX]=self.active_experiment_id event[DeviceEvent.EVENT_SESSION_ID_INDEX]=self.active_session_id np_events.append(tuple(event)) np_array= N.array(np_events,dtype=eventClass.NUMPY_DTYPE) #ioHub.print2err('np_array:',np_array) etable.append(np_array) self.bufferedFlush(len(np_events)) except ioHubError, e: print2err(e)
def initConditionVariableTable( self, experiment_id, session_id, np_dtype): expcv_table = None expcv_node = self.emrtFile.root.data_collection.condition_variables exp_session = [('EXPERIMENT_ID','i4'),('SESSION_ID','i4')] exp_session.extend(np_dtype) np_dtype = [] for npctype in exp_session: if isinstance(npctype[0], str): nv = [str(npctype[0]),] nv.extend(npctype[1:]) np_dtype.append(tuple(nv)) else: np_dtype.append(npctype) self._EXP_COND_DTYPE = np.dtype(np_dtype) try: expCondTableName = "EXP_CV_%d"%(experiment_id) experimentConditionVariableTable = getattr(self.emrtFile.root.data_collection.condition_variables, _f_get_child)(expCondTableName) self.TABLES['EXP_CV'] = experimentConditionVariableTable except NoSuchNodeError as nsne: try: experimentConditionVariableTable = getattr(self.emrtFile, create_table)(self.emrtFile.root.data_collection.condition_variables, expCondTableName, self._EXP_COND_DTYPE, title='Condition Variable Values for Experiment ID %d' % (experiment_id)) self.TABLES['EXP_CV'] = experimentConditionVariableTable self.emrtFile.flush() except Exception: printExceptionDetailsToStdErr() return False except Exception: print2err( 'Error getting expcv_table for experiment %d, table name: %s' % (experiment_id, expCondTableName)) printExceptionDetailsToStdErr() return False self._activeRunTimeConditionVariableTable = expcv_table return True
def _handleEvents(self, events): try: if self.checkForExperimentAndSessionIDs(len(events)) is False: return False event = events[0] etype = event[DeviceEvent.EVENT_TYPE_ID_INDEX] eventClass = EventConstants.getClass(etype) etable = self.TABLES[eventClass.IOHUB_DATA_TABLE] np_events = [] for event in events: event[DeviceEvent.EVENT_EXPERIMENT_ID_INDEX] = self.active_experiment_id event[DeviceEvent.EVENT_SESSION_ID_INDEX] = self.active_session_id np_events.append(tuple(event)) np_array = np.array(np_events, dtype=eventClass.NUMPY_DTYPE) #ioHub.print2err('np_array:',np_array) etable.append(np_array) self.bufferedFlush(len(np_events)) except ioHubError as e: print2err(e) except Exception: printExceptionDetailsToStdErr()
def getSerialRx(self): try: while self._serial_port.inWaiting()>= 2: request_id = ord(self._serial_port.read(1)) if request_id < T3Request.REQ_COUNTER_START: event_byte_count = ord(self._serial_port.read(1)) time_bytes = [ord(c) for c in self._serial_port.read(6)] remaining_byte_count= event_byte_count-(len(time_bytes)+2) remaining_bytes = [] if remaining_byte_count > 0: remaining_bytes = [ord(c) for c in self._serial_port.read(remaining_byte_count)] if request_id in EVENT_TYPE_2_CLASS: event = EVENT_TYPE_2_CLASS[request_id](request_id, time_bytes, remaining_bytes) self._rx_events.append(event) else: reply=T3Request._readRequestReply(self, request_id) if reply: if reply._type == T3Request.SYNC_TIME_BASE: reply.syncWithT3Time() else: self._request_replies.append(reply) else: print2err("INVALID REQUEST ID in reply:", request_id) except Exception as e: print2err("ERROR During getSerialRx: ",e,". Has ioSync been disconnected?") self.close()
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)) try: # initial dataStore setup if 'data_store' in config and psychopy.iohub._DATA_STORE_AVAILABLE: 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....") resultsFilePath=rootScriptPathDir 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 ....")
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 _sendT3Request(self,request): try: request.tx_time=getTime() tx_count=self._serial_port.write(request.getTxByteArray()) self._serial_port.flush() self._active_requests[request.getID()]=request return tx_count except Exception as e: print2err("ERROR During sendT3Request: ",e,". Has ioSync been disconnected?") self.close()
def _run(self): self._running=True while self._sync(False) is False: sleep(0.5) self._sync(False) while self._running is True: sleep(self.initial_sync_interval) r=self._sync() if r is False: print2err("SYNC FAILED: ioHubTimeGreenSyncManager {0}.".format(self._remote_address)) self._close()
def __init__(self,remote_address,sync_state_target): try: Greenlet.__init__(self) self._sync_socket=None self.initial_sync_interval=0.2 self._remote_address=remote_address while self._sync_socket is None: self._sync_socket=ioHubTimeSyncConnection(remote_address) sleep(1) self.sync_state_target=proxy(sync_state_target) except Exception as e: print2err("** Exception during ioHubTimeGreenSyncManager.__init__: ",self._remote_address) printExceptionDetailsToStdErr()
def _handleEvent(self, event): try: if self.checkForExperimentAndSessionIDs(event) is False: return False etype = event[DeviceEvent.EVENT_TYPE_ID_INDEX] eventClass = EventConstants.getClass(etype) etable = self.TABLES[eventClass.IOHUB_DATA_TABLE] event[DeviceEvent.EVENT_EXPERIMENT_ID_INDEX] = self.active_experiment_id event[DeviceEvent.EVENT_SESSION_ID_INDEX] = self.active_session_id np_array = np.array([tuple(event), ], dtype=eventClass.NUMPY_DTYPE) etable.append(np_array) self.bufferedFlush() except Exception: print2err("Error saving event: ", event) printExceptionDetailsToStdErr()
def handleGetEvents(self,replyTo): try: currentEvents=list(self.iohub.eventBuffer) self.iohub.eventBuffer.clear() if len(currentEvents)>0: currentEvents=sorted(currentEvents, key=itemgetter(DeviceEvent.EVENT_HUB_TIME_INDEX)) self.sendResponse(('GET_EVENTS_RESULT',currentEvents),replyTo) else: self.sendResponse(('GET_EVENTS_RESULT', None),replyTo) return True except Exception, e: print2err("IOHUB_GET_EVENTS_ERROR") printExceptionDetailsToStdErr() self.sendResponse('IOHUB_GET_EVENTS_ERROR', replyTo) return False
def findSyncs(cls): """ Finds serial ports with an ioSync connected. Code from StimSync python source and modified. """ import os available = [] if os.name == "nt": # Windows for i in range(1, 256): try: sport = "COM" + str(i) s = serial.Serial(sport) available.append(sport) s.close() except serial.SerialException: pass else: # Mac / Linux from serial.tools import list_ports available = [port[0] for port in list_ports.comports()] # available = [s for s in available if ".us" in s] if len(available) < 1: print2err("Error: unable to find ioSync. Check Teensy 3 drivers.") return [] # check each available port to see if it has an ioSync running on it test_request_id = 170 tx = bytearray([T3Request.GET_USEC_TIME, test_request_id, 3]) iosync_ports = [] for p in available: try: sport = serial.Serial(p, 115200, timeout=1) sport.flushInput() sport.write(tx) sport.flush() obs = sport.read(8) if ord(obs[0]) == test_request_id or ord(obs[1]) == 8: iosync_ports.append(p) p.close() except Exception: pass return iosync_ports
def getEventTable(self, event_type): """ Returns the DataStore table that contains events of the specified type. **Docstr TBC.** """ if self.hdfFile: klassTables = self.hdfFile.root.class_table_mapping deviceEventTable = None event_column = None event_value = None if isinstance(event_type, basestring): if event_type.find("Event") >= 0: event_column = "class_name" event_value = event_type else: event_value = "" tokens = event_type.split("_") for t in tokens: event_value += t[0].upper() + t[1:].lower() event_value = event_type + "Event" event_value = '"%s"' % (event_value) elif isinstance(event_type, (int, long)): event_column = "class_id" event_value = event_type else: iohub.print2err("getEventTable error: event_type arguement must be a string or and int") return None result = [ row.fetch_all_fields() for row in klassTables.where("({0} == {1}) & (class_type_id == 1)".format(event_column, event_value)) ] if len(result) != 1: iohub.print2err( "event_type_id passed to getEventAttribute can only return one row from CLASS_MAPPINGS: ", len(result), ) return None tablePathString = result[0][3] return self.hdfFile.getNode(tablePathString) return None
def _initializeConditionVariableTable(self,experiment_id,session_id,np_dtype): experimentConditionVariableTable=None exp_session=[('EXPERIMENT_ID','i4'),('SESSION_ID','i4')] exp_session.extend(np_dtype) np_dtype=exp_session print2err('np_dtype: ',np_dtype,' ',type(np_dtype)) self._EXP_COND_DTYPE=N.dtype(np_dtype) try: expCondTableName="EXP_CV_%d"%(experiment_id) experimentConditionVariableTable=self.emrtFile.root.data_collection.condition_variables._f_getChild(expCondTableName) self.TABLES['EXP_CV']=experimentConditionVariableTable except NoSuchNodeError, nsne: try: experimentConditionVariableTable=self.emrtFile.createTable(self.emrtFile.root.data_collection.condition_variables,expCondTableName,self._EXP_COND_DTYPE,title='Condition Variable Values for Experiment ID %d'%(experiment_id)) self.TABLES['EXP_CV']=experimentConditionVariableTable self.emrtFile.flush() except: printExceptionDetailsToStdErr() return False
def checkForSerialEvents(read_time, rx_data, parser_state, **kwargs): """ Must have the following signature: evt_list = someCustomParserName(read_time, rx_data, parser_state, **kwargs) where: read_time: The time when the serial device read() returned with the new rx_data. rx_data: The new serial data received. Any buffering of data across function calls must be done by the function logic itself. parser_state could be used to hold such a buffer if needed. parser_state: A dict which can be used by the function to store any values that need to be accessed across multiple calls to the function. The dict is initially empty. kwargs: The parser_kwargs preference dict read from the event_parser preferences; or an empty dict if parser_kwargs was not found. If events should be generated by iohub, the function must return a list like object, used to provide ioHub with any new serial events that have been found. Each element of the list must be a dict like object, representing a single serial device event found by the parsing function. An event dict can contain the following key, value pairs: data: The string containing the parsed event data. (REQUIRED) time: The timestamp for the event (Optional). If not provided, the return time of the latest serial.read() is used. If the function has detected no serial events, an empty list or None can be returned. :return: list of ioHub serial device events found. None == [] here. """ print2err("checkForSerialEvents called: ", (read_time, rx_data, parser_state, kwargs)) parser_state['last_time'] = read_time serial_events = [] if rx_data == 'TEST': serial_events.append({'data': rx_data}) return serial_events
def addClassMappings(cls,device_class,device_event_ids,event_classes): if cls._classes is None: cls._classes={} #import iohub #iohub.print2err("Adding Device Event Mappings for device: ",device_class.__name__) for event_id in device_event_ids: event_constant_string=cls.getName(event_id) event_class=None for event_class in list(event_classes.values()): if event_class.EVENT_TYPE_ID == event_id: cls._classes[event_id]=event_class cls._classes[event_class]=event_id #iohub.print2err("\tAdding Event Class Mapping: ",event_constant_string, " = ",event_id) break if event_id not in cls._classes: from psychopy.iohub import print2err print2err("\t*** ERROR ADDING EVENT CLASSS MAPPING: Could not find class: ",event_constant_string, " = ",event_id)
def _poll(self): try: logged_time = getTime() if not self.isReportingEvents(): self._last_poll_time = logged_time return False if self.isConnected(): if self._custom_parser: parser_state = self._parser_state newrx = self.read() read_time = getTime() if newrx: try: serial_events = self._custom_parser( read_time, newrx, parser_state, **self._custom_parser_kwargs) for evt in serial_events: if type(evt) == dict: evt_time = evt.get('time', read_time) evt_data = evt.get( 'data', "NO DATA FIELD IN EVENT DICT.") self._createSerialEvent( logged_time, evt_time, evt_data) else: print2err( "ioHub Serial Device Error: Events returned from custom parser must be dict's. Skipping: ", str(evt)) except Exception: print2err( "ioHub Serial Device Error: Exception during parsing function call." ) import traceback, sys traceback.print_exc(file=sys.stderr) print2err("---") elif self._byte_diff_mode: rx = self.read() read_time = getTime() for c in rx: if self._rx_buffer is not None and c != self._rx_buffer: self._createByteChangeSerialEvent( logged_time, read_time, self._rx_buffer, c) self._rx_buffer = c else: parser_state = self._parser_state rx_buffer = self._rx_buffer + self.read() read_time = getTime() prefix = self._parser_config['prefix'] delimiter = self._parser_config['delimiter'] if parser_state['prefix_found'] is False: if prefix and rx_buffer and len(rx_buffer) >= len( prefix): pindex = rx_buffer.find(prefix) if pindex >= 0: rx_buffer = rx_buffer[pindex + len(prefix):] parser_state['prefix_found'] = True if parser_state['delimiter_found'] is False: if delimiter and self._rx_buffer and len( rx_buffer) >= len(delimiter): dindex = rx_buffer.find(delimiter) if dindex >= 0: parser_state['delimiter_found'] = True sindex = dindex eindex = dindex + len(delimiter) parser_state[ 'parsed_event'] += rx_buffer[:sindex] if len(rx_buffer) > eindex: rx_buffer = rx_buffer[eindex:] else: rx_buffer = '' self._rx_buffer = rx_buffer self._createMultiByteSerialEvent( logged_time, read_time) return True if parser_state['bytes_needed'] > 0 and rx_buffer: rxlen = len(rx_buffer) #takebytes = rxlen - parser_state['bytes_needed'] if rxlen > parser_state['bytes_needed']: parser_state[ 'parsed_event'] += rx_buffer[:parser_state[ 'bytes_needed']] parser_state['bytes_needed'] = 0 rx_buffer = rx_buffer[ parser_state['bytes_needed']:] else: parser_state['parsed_event'] += rx_buffer parser_state['bytes_needed'] -= rxlen rx_buffer = '' if parser_state['bytes_needed'] == 0: self._rx_buffer = rx_buffer self._createMultiByteSerialEvent( logged_time, read_time) return True self._rx_buffer = rx_buffer else: read_time = logged_time self._last_poll_time = read_time return True except Exception as e: print2err("--------------------------------") print2err("ERROR in Serial._poll: ", e) printExceptionDetailsToStdErr() print2err("---------------------")
def __init__(self, *args, **kwargs): Device.__init__(self, *args, **kwargs['dconfig']) self._serial = None self.port = self.getConfiguration().get('port') if self.port.lower() == 'auto': pports = self.findPorts() if pports: self.port = pports[0] if len(pports) > 1: print2err( "Warning: Serial device port configuration set " "to 'auto'.\nMultiple serial ports found:\n", pports, "\n** Using port ", self.port) self.baud = self.getConfiguration().get('baud') self.bytesize = self._bytesizes[self.getConfiguration().get( 'bytesize')] self.parity = self._parities[self.getConfiguration().get('parity')] self.stopbits = self._stopbits[self.getConfiguration().get('stopbits')] self._parser_config = self.getConfiguration().get('event_parser') self._byte_diff_mode = None self._custom_parser = None self._custom_parser_kwargs = {} custom_parser_func_str = self._parser_config.get('parser_function') if custom_parser_func_str: # print2err("CUSTOM SERIAL PARSER FUNC STR: ", custom_parser_func_str) # Function referenced by string must have the following signature: # # evt_list = someCustomParserName(read_time, rx_data, parser_state, **kwargs) # # where: # read_time: The time when the serial device read() returned # with the new rx_data. # rx_data: The new serial data received. Any buffering of data # across function calls must be done by the function # logic itself. parser_state could be used to hold # such a buffer if needed. # parser_state: A dict which can be used by the function to # store any values that need to be accessed # across multiple calls to the function. The dict # is initially empty. # kwargs: The parser_kwargs preference dict read from # the event_parser preferences; or an empty dict if # parser_kwargs was not found. # # The function must return a list like object, used to provide ioHub # with any new serial events that have been found. # Each element of the list must be a dict like object, representing # a single serial device event found by the parsing function. # A dict can contain the following key, value pairs: # data: The string containing the parsed event data. (REQUIRED) # time: The timestamp for the event (Optional). If not provided, # the return time of the latest serial.read() is used. # Each event returned by the function generates a SerialInputEvent # with the data field = the dict data value. import importlib, sys try: #print2err("EXP_SCRIPT_DIRECTORY: ",EXP_SCRIPT_DIRECTORY) if EXP_SCRIPT_DIRECTORY not in sys.path: sys.path.append(EXP_SCRIPT_DIRECTORY) mod_name, func_name = custom_parser_func_str.rsplit('.', 1) mod = importlib.import_module(mod_name) self._custom_parser = getattr(mod, func_name) except Exception: print2err( "ioHub Serial Device Error: could not load " "custom_parser function: ", custom_parser_func_str) printExceptionDetailsToStdErr() if self._custom_parser: self._custom_parser_kwargs = self._parser_config.get( 'parser_kwargs', {}) else: self._byte_diff_mode = self._parser_config.get('byte_diff') if self._byte_diff_mode: self._rx_buffer = None else: self._resetParserState() self._rx_buffer = '' self._event_count = 0 self._timeout = None self._serial = None self.setConnectionState(True)
def createEyeEvents(self, last_sample_category, current_sample_category, last_sample, current_sample): start_event = None end_event = None if last_sample_category == 'MIS': # Create end blink event existing_start_event = self.open_parser_events.get('MIS') evt_samples = self.open_parser_events.get('MIS_SAMPLES') if evt_samples: del self.open_parser_events['MIS_SAMPLES'] if existing_start_event: end_event = self.createBlinkEndEventArray(last_sample, existing_start_event, evt_samples) del self.open_parser_events['MIS'] else: pass#print2err("PARSER Warning: Blink Start Event not found; Blink End event being dropped: ", end_event) elif last_sample_category == 'FIX': # Create end fix event existing_start_event = self.open_parser_events.get('FIX') evt_samples = self.open_parser_events.get('FIX_SAMPLES') if evt_samples: del self.open_parser_events['FIX_SAMPLES'] if existing_start_event: end_event = self.createFixationEndEventArray(last_sample, existing_start_event,evt_samples) del self.open_parser_events['FIX'] else: pass#print2err("PARSER Warning: Fixation Start Event not found; Fixation End event being dropped: ", end_event) elif last_sample_category == 'SAC': # Create end sac event existing_start_event = self.open_parser_events.get('SAC') evt_samples = self.open_parser_events.get('SAC_SAMPLES') if evt_samples: del self.open_parser_events['SAC_SAMPLES'] if existing_start_event: end_event = self.createSaccadeEndEventArray(last_sample, existing_start_event,evt_samples) del self.open_parser_events['SAC'] else: pass#print2err("PARSER Warning: Saccade Start Event not found; Saccade End event being dropped: ", end_event) if current_sample_category == 'MIS': # Create start blink event start_event = self.createBlinkStartEventArray(current_sample) self.open_parser_events['MIS_SAMPLES']=[current_sample,] existing_start_event = self.open_parser_events.get('MIS') if existing_start_event: print2err("PARSER ERROR: Blink Start Event already Open and is being dropped: ", existing_start_event) self.open_parser_events['MIS']=current_sample elif current_sample_category == 'FIX': # Create start fix event start_event = self.createFixationStartEventArray(current_sample) self.open_parser_events['FIX_SAMPLES']=[current_sample,] existing_start_event = self.open_parser_events.get('FIX') if existing_start_event: print2err("PARSER ERROR: Fixation Start Event already Open and is being dropped: ", existing_start_event) self.open_parser_events['FIX']=current_sample elif current_sample_category == 'SAC': # Create start sac event start_event = self.createSaccadeStartEventArray(current_sample) self.open_parser_events['SAC_SAMPLES']=[current_sample,] existing_start_event = self.open_parser_events.get('SAC') if existing_start_event: print2err("PARSER ERROR: Saccade Start Event already Open and is being dropped: ", existing_start_event) self.open_parser_events['SAC']=current_sample return end_event, start_event
def sendResponse(self, data, address): packet_data = None try: max_size = MAX_PACKET_SIZE / 2 - 20 packet_data = self.pack(data) 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) packet_data_length = len(packet_data) self.socket.sendto(packet_data, address)
def on_sync_error(self, *args, **kwargs): print2err("TobiiTracker.on_sync_error: ", args, kwargs) return False
def handleExperimentDeviceRequest(self, request, replyTo): request_type = request.pop(0) if request_type == 'EVENT_TX': exp_events = request.pop(0) for eventAsTuple in exp_events: ioServer.deviceDict['Experiment']._nativeEventCallback( eventAsTuple) self.sendResponse(('EVENT_TX_RESULT', len(exp_events)), replyTo) return True elif request_type == 'DEV_RPC': dclass = request.pop(0) dmethod = request.pop(0) args = None kwargs = None if len(request) == 1: args = request[0] elif len(request) == 2: args = request[0] kwargs = request[1] if len(kwargs) == 0: kwargs = None dev = None if dclass.find('.') > 0: for dname, dev in ioServer.deviceDict.iteritems(): if dname.endswith(dclass): dev = ioServer.deviceDict.get(dname, None) break else: dev = ioServer.deviceDict.get(dclass, None) if dev is None: print2err("IOHUB_DEVICE_ERROR") printExceptionDetailsToStdErr() self.sendResponse('IOHUB_DEVICE_ERROR', replyTo) return False try: method = getattr(dev, dmethod) except: print2err("IOHUB_DEVICE_METHOD_ERROR") printExceptionDetailsToStdErr() self.sendResponse('IOHUB_DEVICE_METHOD_ERROR', replyTo) return False result = [] try: if args and kwargs: result = method(*args, **kwargs) elif args: result = method(*args) elif kwargs: result = method(**kwargs) else: result = method() self.sendResponse(('DEV_RPC_RESULT', result), replyTo) return True except Exception, e: print2err("RPC_DEVICE_RUNTIME_ERROR") printExceptionDetailsToStdErr() self.sendResponse('RPC_DEVICE_RUNTIME_ERROR', replyTo) return False
def sendResponse(self,data,address): packet_data=None try: num_packets = -1 packet_data_length = -1 # TODO: Max packet size on OS X seems to be 8192 !! max_size = int(MAX_PACKET_SIZE/2-20) packet_data = self.pack(data) packet_data_length = len(packet_data) if packet_data_length >= max_size: num_packets = int(packet_data_length//max_size)+1 self.sendResponse(('IOHUB_MULTIPACKET_RESPONSE',num_packets),address) for p in range(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 Exception: print2err('Error trying to send data to experiment process:') print2err('max_size: ',max_size) print2err('data length: ',packet_data_length) print2err('num_packets: ',num_packets) print2err("=============================") printExceptionDetailsToStdErr() print2err("=============================") first_data_element="NO_DATA_AVAILABLE" if data: print2err('Data was [{0}]'.format(data)) try: first_data_element=data[0] except Exception: pass packet_data_length=0 if packet_data: packet_data_length=len(packet_data) print2err('packet Data length: ',len(packet_data)) print2err("IOHUB_SERVER_RESPONSE_ERROR") printExceptionDetailsToStdErr() packet_data=self.pack('IOHUB_SERVER_RESPONSE_ERROR') self.socket.sendto(packet_data,address)
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) monitoringEventIDs = [] monitor_events_list = device_config.get('monitor_event_types', []) if isinstance(monitor_events_list, (list, tuple)): for event_class_name in monitor_events_list: event_id = getattr( EventConstants, convertCamelToSnake(event_class_name[:-5], False)) monitoringEventIDs.append(event_id) self.log("{0} Instance Event IDs To Monitor: {1}".format( device_class_name, monitoringEventIDs)) #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, monitoringEventIDs) #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(monitoringEventIDs), )) # add listener for device event queue deviceInstance._addEventListener(deviceInstance, monitoringEventIDs) # 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(monitoringEventIDs))) return deviceInstance, device_config, monitoringEventIDs, event_classes
def updateDataStoreStructure(self, device_instance, event_class_dict): dfilter = Filters(complevel=0, complib='zlib', shuffle=False, fletcher32=False) def eventTableLabel2ClassName(event_table_label): tokens = str(event_table_label[0] + event_table_label[1:].lower() + 'Event').split('_') return ''.join([t[0].upper() + t[1:] for t in tokens]) for event_cls_name, event_cls in event_class_dict.iteritems(): if event_cls.IOHUB_DATA_TABLE: event_table_label = event_cls.IOHUB_DATA_TABLE if event_table_label not in self.TABLES.keys(): try: self.TABLES[ event_table_label] = self.emrtFile.createTable( self._eventGroupMappings[event_table_label], eventTableLabel2ClassName(event_table_label), event_cls.NUMPY_DTYPE, title="%s Data" % (device_instance.__class__.__name__, ), filters=dfilter.copy()) self.flush() #print2err("----------- CREATED TABLES ENTRY ------------") #print2err("\tevent_cls: {0}".format(event_cls)) #print2err("\tevent_cls_name: {0}".format(event_cls_name)) #print2err("\tevent_table_label: {0}".format(event_table_label)) #print2err("\teventTableLabel2ClassName: {0}".format(eventTableLabel2ClassName(event_table_label))) #print2err("\t_eventGroupMappings[event_table_label]: {0}".format(self._eventGroupMappings[event_table_label])) #print2err("----------------------------------------------") except NodeError: self.TABLES[event_table_label] = self._eventGroupMappings[ event_table_label]._f_get_child( eventTableLabel2ClassName(event_table_label) ) # self.emrtFile.createTable(,eventTableLabel2ClassName(event_table_label),event_cls.NUMPY_DTYPE, title="%s Data"%(device_instance.__class__.__name__,),filters=dfilter.copy()) #print2err("----------- USED EXISTING TABLE FOR TABLES ENTRY ------------") #print2err("\tevent_cls: {0}".format(event_cls)) #print2err("\tevent_cls_name: {0}".format(event_cls_name)) #print2err("\tevent_table_label: {0}".format(event_table_label)) #print2err("\teventTableLabel2ClassName: {0}".format(eventTableLabel2ClassName(event_table_label))) #print2err("\t_eventGroupMappings[event_table_label]: {0}".format(self._eventGroupMappings[event_table_label])) #print2err("----------------------------------------------") except Exception, e: print2err("---------------ERROR------------------") print2err( "Exception %s in iohub.datastore.updateDataStoreStructure:" % (e.__class__.__name__)) print2err("\tevent_cls: {0}".format(event_cls)) print2err( "\tevent_cls_name: {0}".format(event_cls_name)) print2err("\tevent_table_label: {0}".format( event_table_label)) print2err("\teventTableLabel2ClassName: {0}".format( eventTableLabel2ClassName(event_table_label))) print2err( "\t_eventGroupMappings[event_table_label]: {0}". format( self._eventGroupMappings[event_table_label])) print2err("\tException: {0}".format(e)) print2err("--------------------------------------") if self.TABLES.has_key(event_table_label): #print2err("---------------ADDING CLASS MAPPING------------------") #print2err("\tevent_cls: {0}".format(event_cls)) #print2err("\tevent_cls_name: {0}".format(event_cls_name)) #print2err("\tevent_table_label: {0}".format(event_table_label)) #print2err("\teventTableLabel2ClassName: {0}".format(eventTableLabel2ClassName(event_table_label))) #print2err("\t_eventGroupMappings[event_table_label]: {0}".format(self._eventGroupMappings[event_table_label])) #print2err("----------------------------------------------") self.addClassMapping(event_cls, self.TABLES[event_table_label]) else: print2err( "---- IOHUB.DATASTORE CANNOT ADD CLASS MAPPING ----") print2err("\t** TABLES missing key: {0}".format( event_table_label)) print2err("\tevent_cls: {0}".format(event_cls)) print2err("\tevent_cls_name: {0}".format(event_cls_name)) print2err("\teventTableLabel2ClassName: {0}".format( eventTableLabel2ClassName(event_table_label))) print2err("----------------------------------------------")
except NoSuchNodeError, nsne: try: experimentConditionVariableTable = self.emrtFile.createTable( self.emrtFile.root.data_collection.condition_variables, expCondTableName, self._EXP_COND_DTYPE, title='Condition Variable Values for Experiment ID %d' % (experiment_id)) self.TABLES['EXP_CV'] = experimentConditionVariableTable self.emrtFile.flush() except Exception: printExceptionDetailsToStdErr() return False except Exception: print2err( 'Error getting experimentConditionVariableTable for experiment %d, table name: %s' % (experiment_id, expCondTableName)) printExceptionDetailsToStdErr() return False self._activeRunTimeConditionVariableTable = experimentConditionVariableTable return True def _addRowToConditionVariableTable(self, experiment_id, session_id, data): if self.emrtFile and 'EXP_CV' in self.TABLES and self._EXP_COND_DTYPE is not None: temp = [experiment_id, session_id] temp.extend(data) data = temp try: etable = self.TABLES['EXP_CV'] #print2err('data: ',data,' ',type(data))
print2err("RPC_RUNTIME_ERROR") printExceptionDetailsToStdErr() self.sendResponse('RPC_RUNTIME_ERROR', replyTo) return False else: print2err("RPC_NOT_CALLABLE_ERROR") printExceptionDetailsToStdErr() self.sendResponse('RPC_NOT_CALLABLE_ERROR', replyTo) return False elif request_type == 'STOP_IOHUB_SERVER': try: self.shutDown() except: printExceptionDetailsToStdErr else: print2err("RPC_NOT_CALLABLE_ERROR") printExceptionDetailsToStdErr() self.sendResponse('RPC_NOT_CALLABLE_ERROR', replyTo) return False def handleGetEvents(self, replyTo): try: currentEvents = list(self.iohub.eventBuffer) self.iohub.eventBuffer.clear() if len(currentEvents) > 0: currentEvents = sorted(currentEvents, key=itemgetter( DeviceEvent.EVENT_HUB_TIME_INDEX)) self.sendResponse(('GET_EVENTS_RESULT', currentEvents), replyTo)
def _poll(self): try: logged_time = getTime() if self.isConnected(): self._mcu.getSerialRx() if logged_time - self._last_sync_time >= self.time_sync_interval: self._mcu._runTimeSync() self._last_sync_time = logged_time if not self.isReportingEvents(): return False confidence_interval = logged_time - self._last_callback_time events = self._mcu.getRxEvents() for event in events: current_MCU_time = event.device_time #self.getSecTime() device_time = event.device_time if event.local_time is None: event.local_time = logged_time delay = logged_time - event.local_time #current_MCU_time-device_time # local_time is in iohub time space already, so delay does not # need to be used to adjust iohub time iohub_time = event.local_time elist = None if event.getTypeInt() == T3Event.ANALOG_INPUT_EVENT: elist = [ EventConstants.UNDEFINED, ] * 19 elist[4] = AnalogInputEvent.EVENT_TYPE_ID for i, v in enumerate(event.ain_channels): elist[(i + 11)] = v elif event.getTypeInt() == T3Event.DIGITAL_INPUT_EVENT: elist = [ EventConstants.UNDEFINED, ] * 12 elist[4] = DigitalInputEvent.EVENT_TYPE_ID elist[-1] = event.getDigitalInputByte() elif event.getTypeInt() == T3Event.THRESHOLD_EVENT: elist = [ EventConstants.UNDEFINED, ] * 19 elist[4] = ThresholdEvent.EVENT_TYPE_ID for i, v in enumerate(event.threshold_state_changed): elist[(i + 11)] = v if elist: elist[0] = 0 elist[1] = 0 elist[2] = 0 elist[3] = Computer._getNextEventID() elist[5] = device_time elist[6] = logged_time elist[7] = iohub_time elist[8] = confidence_interval elist[9] = delay elist[10] = 0 self._addNativeEventToBuffer(elist) replies = self._mcu.getRequestReplies(True) for reply in replies: rid = reply.getID() if rid in self._request_dict: self._response_dict[rid] = reply del self._request_dict[rid] self._last_callback_time = logged_time return True except Exception as e: print2err("--------------------------------") print2err("ERROR in MCU._poll: ", e) printExceptionDetailsToStdErr() print2err("---------------------")
glets.append(gevent.spawn(s.processEventsTasklet,0.01)) sys.stdout.write("IOHUB_READY\n\r\n\r") sys.stdout.flush() #print2err("Computer.psychopy_process: ", Computer.psychopy_process) if Computer.psychopy_process: glets.append(gevent.spawn(s.checkForPsychopyProcess, 0.5)) gevent.joinall(glets) s.log("Server END Time Offset: {0}".format(Computer.global_clock.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 handle(self, request, replyTo): if self._running is False: return False self.feed(request) request = self.unpack() request_type= request.pop(0) if request_type == 'SYNC_REQ': self.sendResponse(['SYNC_REPLY',currentSec()],replyTo) return True elif request_type == 'PING': clienttime=request.pop(0) msg_id=request.pop(0) payload=request.pop(0) ctime=currentSec() self.sendResponse(["PING_BACK",ctime,msg_id,payload,replyTo],replyTo) return True elif request_type == 'GET_EVENTS': return self.handleGetEvents(replyTo) elif request_type == 'EXP_DEVICE': return self.handleExperimentDeviceRequest(request,replyTo) elif request_type == 'RPC': callable_name=request.pop(0) args=None kwargs=None if len(request)==1: args=request.pop(0) if len(request)==1: kwargs=request.pop(0) result=None try: result=getattr(self,callable_name) except Exception: print2err("RPC_ATTRIBUTE_ERROR") printExceptionDetailsToStdErr() self.sendResponse('RPC_ATTRIBUTE_ERROR',replyTo) return False if result and callable(result): funcPtr=result try: if args is None and kwargs is None: result = funcPtr() elif args and kwargs: result = funcPtr(*args,**kwargs) elif args and not kwargs: result = funcPtr(*args) elif not args and kwargs: result = funcPtr(**kwargs) edata=('RPC_RESULT',callable_name,result) self.sendResponse(edata,replyTo) return True except Exception as e: print2err("RPC_RUNTIME_ERROR") printExceptionDetailsToStdErr() self.sendResponse('RPC_RUNTIME_ERROR', replyTo) return False else: print2err("RPC_NOT_CALLABLE_ERROR") printExceptionDetailsToStdErr() self.sendResponse('RPC_NOT_CALLABLE_ERROR', replyTo) return False elif request_type == 'STOP_IOHUB_SERVER': try: self.shutDown() except Exception: printExceptionDetailsToStdErr else: print2err("RPC_NOT_CALLABLE_ERROR") printExceptionDetailsToStdErr() self.sendResponse('RPC_NOT_CALLABLE_ERROR', replyTo) return False
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. if psychopy.iohub._DATA_STORE_AVAILABLE: 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 psychopy.iohub._DATA_STORE_AVAILABLE and 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() ]
class ioHubpyTablesFile(): def __init__(self, fileName, folderPath, fmode='a', ioHubsettings=None): self.fileName = fileName self.folderPath = folderPath self.filePath = os.path.join(folderPath, fileName) self.settings = ioHubsettings self.active_experiment_id = None self.active_session_id = None self.flushCounter = self.settings.get('flush_interval', 32) self._eventCounter = 0 self.TABLES = dict() self._eventGroupMappings = dict() self.emrtFile = openFile(self.filePath, mode=fmode) atexit.register(close_open_data_files, False) if len(self.emrtFile.title) == 0: self.buildOutTemplate() self.flush() else: self.loadTableMappings() def updateDataStoreStructure(self, device_instance, event_class_dict): dfilter = Filters(complevel=0, complib='zlib', shuffle=False, fletcher32=False) def eventTableLabel2ClassName(event_table_label): tokens = str(event_table_label[0] + event_table_label[1:].lower() + 'Event').split('_') return ''.join([t[0].upper() + t[1:] for t in tokens]) for event_cls_name, event_cls in event_class_dict.iteritems(): if event_cls.IOHUB_DATA_TABLE: event_table_label = event_cls.IOHUB_DATA_TABLE if event_table_label not in self.TABLES: self.TABLES[event_table_label] = self.emrtFile.createTable( self._eventGroupMappings[event_table_label], eventTableLabel2ClassName(event_table_label), event_cls.NUMPY_DTYPE, title="%s Data" % (device_instance.__class__.__name__, ), filters=dfilter.copy()) self.flush() self.addClassMapping(event_cls, self.TABLES[event_table_label]) def loadTableMappings(self): # create meta-data tables self._buildEventGroupMappingDict() self.TABLES[ 'EXPERIMENT_METADETA'] = self.emrtFile.root.data_collection.experiment_meta_data self.TABLES[ 'SESSION_METADETA'] = self.emrtFile.root.data_collection.session_meta_data self.TABLES[ 'CLASS_TABLE_MAPPINGS'] = self.emrtFile.root.class_table_mapping # create tables dict of hdf5 path mappings try: self.TABLES[ 'KEYBOARD_KEY'] = self.emrtFile.root.data_collection.events.keyboard.KeyboardKeyEvent except: # Just means the table for this event type has not been created as the event type is not being recorded pass try: self.TABLES[ 'KEYBOARD_CHAR'] = self.emrtFile.root.data_collection.events.keyboard.KeyboardCharEvent except: # Just means the table for this event type has not been created as the event type is not being recorded pass try: self.TABLES[ 'MOUSE_INPUT'] = self.emrtFile.root.data_collection.events.mouse.MouseInputEvent except: # Just means the table for this event type has not been created as the event type is not being recorded pass try: self.TABLES[ 'TOUCH'] = self.emrtFile.root.data_collection.events.touch.TouchEvent except: # Just means the table for this event type has not been created as the event type is not being recorded pass try: self.TABLES[ 'GAMEPAD_STATE_CHANGE'] = self.emrtFile.root.data_collection.events.gamepad.GamepadStateChangeEvent except: # Just means the table for this event type has not been created as the event type is not being recorded pass try: self.TABLES[ 'MESSAGE'] = self.emrtFile.root.data_collection.events.experiment.MessageEvent except: # Just means the table for this event type has not been created as the event type is not being recorded pass try: self.TABLES[ 'LOG'] = self.emrtFile.root.data_collection.events.experiment.LogEvent except: # Just means the table for this event type has not been created as the event type is not being recorded pass try: self.TABLES[ 'MULTI_CHANNEL_ANALOG_INPUT'] = self.emrtFile.root.data_collection.events.analog_input.MultiChannelAnalogInputEvent except: # Just means the table for this event type has not been created as the event type is not being recorded pass try: self.TABLES[ 'MONOCULAR_EYE_SAMPLE'] = self.emrtFile.root.data_collection.events.eyetracker.MonocularEyeSampleEvent except: # Just means the table for this event type has not been created as the event type is not being recorded pass try: self.TABLES[ 'BINOCULAR_EYE_SAMPLE'] = self.emrtFile.root.data_collection.events.eyetracker.BinocularEyeSampleEvent except: # Just means the table for this event type has not been created as the event type is not being recorded pass try: self.TABLES[ 'FIXATION_START'] = self.emrtFile.root.data_collection.events.eyetracker.FixationStartEvent except: # Just means the table for this event type has not been created as the event type is not being recorded pass try: self.TABLES[ 'FIXATION_END'] = self.emrtFile.root.data_collection.events.eyetracker.FixationEndEvent except: # Just means the table for this event type has not been created as the event type is not being recorded pass try: self.TABLES[ 'SACCADE_START'] = self.emrtFile.root.data_collection.events.eyetracker.SaccadeStartEvent except: # Just means the table for this event type has not been created as the event type is not being recorded pass try: self.TABLES[ 'SACCADE_END'] = self.emrtFile.root.data_collection.events.eyetracker.SaccadeEndEvent except: # Just means the table for this event type has not been created as the event type is not being recorded pass try: self.TABLES[ 'BLINK_START'] = self.emrtFile.root.data_collection.events.eyetracker.BlinkStartEvent except: # Just means the table for this event type has not been created as the event type is not being recorded pass try: self.TABLES[ 'BLINK_END'] = self.emrtFile.root.data_collection.events.eyetracker.BlinkEndEvent except: # Just means the table for this event type has not been created as the event type is not being recorded pass def buildOutTemplate(self): self.emrtFile.title = DATA_FILE_TITLE self.emrtFile.FILE_VERSION = FILE_VERSION self.emrtFile.SCHEMA_DESIGNER = SCHEMA_AUTHORS self.emrtFile.SCHEMA_MODIFIED = SCHEMA_MODIFIED_DATE #CREATE GROUPS #self.emrtFile.createGroup(self.emrtFile.root, 'analysis', title='Data Analysis Files, notebooks, scripts and saved results tables.') self.TABLES['CLASS_TABLE_MAPPINGS'] = self.emrtFile.createTable( self.emrtFile.root, 'class_table_mapping', ClassTableMappings, title= 'Mapping of ioHub DeviceEvent Classes to ioHub DataStore Tables.') self.emrtFile.createGroup( self.emrtFile.root, 'data_collection', title='Data Collected using the ioHub Event Framework.') self.flush() self.emrtFile.createGroup( self.emrtFile.root.data_collection, 'events', title='All Events that were Saved During Experiment Sessions.') self.emrtFile.createGroup( self.emrtFile.root.data_collection, 'condition_variables', title= "Tables created to Hold Experiment DV and IV's Values Saved During an Experiment Session." ) self.flush() self.TABLES['EXPERIMENT_METADETA'] = self.emrtFile.createTable( self.emrtFile.root.data_collection, 'experiment_meta_data', ExperimentMetaData, title= 'Information About Experiments Saved to This ioHub DataStore File.' ) self.TABLES['SESSION_METADETA'] = self.emrtFile.createTable( self.emrtFile.root.data_collection, 'session_meta_data', SessionMetaData, title= 'Information About Sessions Saved to This ioHub DataStore File.') self.flush() self.emrtFile.createGroup(self.emrtFile.root.data_collection.events, 'experiment', title='Experiment Device Events.') self.emrtFile.createGroup(self.emrtFile.root.data_collection.events, 'keyboard', title='Keyboard Device Events.') self.emrtFile.createGroup(self.emrtFile.root.data_collection.events, 'mouse', title='Mouse Device Events.') self.emrtFile.createGroup(self.emrtFile.root.data_collection.events, 'touch', title='Touch Device Events.') self.emrtFile.createGroup(self.emrtFile.root.data_collection.events, 'gamepad', title='GamePad Device Events.') self.emrtFile.createGroup(self.emrtFile.root.data_collection.events, 'analog_input', title='AnalogInput Device Events.') self.emrtFile.createGroup(self.emrtFile.root.data_collection.events, 'eyetracker', title='EyeTracker Device Events.') self.flush() self._buildEventGroupMappingDict() def _buildEventGroupMappingDict(self): self._eventGroupMappings[ 'KEYBOARD_KEY'] = self.emrtFile.root.data_collection.events.keyboard self._eventGroupMappings[ 'KEYBOARD_CHAR'] = self.emrtFile.root.data_collection.events.keyboard self._eventGroupMappings[ 'MOUSE_INPUT'] = self.emrtFile.root.data_collection.events.mouse self._eventGroupMappings[ 'TOUCH'] = self.emrtFile.root.data_collection.events.touch self._eventGroupMappings[ 'GAMEPAD_STATE_CHANGE'] = self.emrtFile.root.data_collection.events.gamepad self._eventGroupMappings[ 'MULTI_CHANNEL_ANALOG_INPUT'] = self.emrtFile.root.data_collection.events.analog_input self._eventGroupMappings[ 'MESSAGE'] = self.emrtFile.root.data_collection.events.experiment self._eventGroupMappings[ 'LOG'] = self.emrtFile.root.data_collection.events.experiment self._eventGroupMappings[ 'MONOCULAR_EYE_SAMPLE'] = self.emrtFile.root.data_collection.events.eyetracker self._eventGroupMappings[ 'BINOCULAR_EYE_SAMPLE'] = self.emrtFile.root.data_collection.events.eyetracker self._eventGroupMappings[ 'FIXATION_START'] = self.emrtFile.root.data_collection.events.eyetracker self._eventGroupMappings[ 'FIXATION_END'] = self.emrtFile.root.data_collection.events.eyetracker self._eventGroupMappings[ 'SACCADE_START'] = self.emrtFile.root.data_collection.events.eyetracker self._eventGroupMappings[ 'SACCADE_END'] = self.emrtFile.root.data_collection.events.eyetracker self._eventGroupMappings[ 'BLINK_START'] = self.emrtFile.root.data_collection.events.eyetracker self._eventGroupMappings[ 'BLINK_END'] = self.emrtFile.root.data_collection.events.eyetracker def addClassMapping(self, ioClass, ctable): names = [ x['class_id'] for x in self.TABLES['CLASS_TABLE_MAPPINGS'].where( "(class_id == %d)" % (ioClass.EVENT_TYPE_ID)) ] if len(names) == 0: trow = self.TABLES['CLASS_TABLE_MAPPINGS'].row trow['class_id'] = ioClass.EVENT_TYPE_ID trow['class_type_id'] = 1 # Device or Event etc. trow['class_name'] = ioClass.__name__ trow['table_path'] = ctable._v_pathname trow.append() self.flush() def createOrUpdateExperimentEntry(self, experimentInfoList): #ioHub.print2err("createOrUpdateExperimentEntry called with: ",experimentInfoList) experiment_metadata = self.TABLES['EXPERIMENT_METADETA'] result = [ row for row in experiment_metadata.iterrows() if row['code'] == experimentInfoList[1] ] if len(result) > 0: result = result[0] self.active_experiment_id = result['experiment_id'] return self.active_experiment_id max_id = 0 id_col = experiment_metadata.col('experiment_id') if len(id_col) > 0: max_id = N.amax(id_col) self.active_experiment_id = max_id + 1 experimentInfoList[0] = self.active_experiment_id experiment_metadata.append([ experimentInfoList, ]) self.flush() #ioHub.print2err("Experiment ID set to: ",self.active_experiment_id) return self.active_experiment_id def createExperimentSessionEntry(self, sessionInfoDict): #ioHub.print2err("createExperimentSessionEntry called with: ",sessionInfoDict) session_metadata = self.TABLES['SESSION_METADETA'] max_id = 0 id_col = session_metadata.col('session_id') if len(id_col) > 0: max_id = N.amax(id_col) self.active_session_id = int(max_id + 1) values = (self.active_session_id, self.active_experiment_id, sessionInfoDict['code'], sessionInfoDict['name'], sessionInfoDict['comments'], sessionInfoDict['user_variables']) session_metadata.append([ values, ]) self.flush() #ioHub.print2err("Session ID set to: ",self.active_session_id) return self.active_session_id def _initializeConditionVariableTable(self, experiment_id, session_id, np_dtype): experimentConditionVariableTable = None exp_session = [('EXPERIMENT_ID', 'i4'), ('SESSION_ID', 'i4')] exp_session.extend(np_dtype) np_dtype = exp_session #print2err('np_dtype: ',np_dtype,' ',type(np_dtype)) self._EXP_COND_DTYPE = N.dtype(np_dtype) try: expCondTableName = "EXP_CV_%d" % (experiment_id) experimentConditionVariableTable = self.emrtFile.root.data_collection.condition_variables._f_getChild( expCondTableName) self.TABLES['EXP_CV'] = experimentConditionVariableTable except NoSuchNodeError, nsne: try: experimentConditionVariableTable = self.emrtFile.createTable( self.emrtFile.root.data_collection.condition_variables, expCondTableName, self._EXP_COND_DTYPE, title='Condition Variable Values for Experiment ID %d' % (experiment_id)) self.TABLES['EXP_CV'] = experimentConditionVariableTable self.emrtFile.flush() except: printExceptionDetailsToStdErr() return False except Exception: print2err( 'Error getting experimentConditionVariableTable for experiment %d, table name: %s' % (experiment_id, expCondTableName)) printExceptionDetailsToStdErr() return False
def handleExperimentDeviceRequest(self,request,replyTo): request_type= request.pop(0) if request_type == 'EVENT_TX': exp_events=request.pop(0) for eventAsTuple in exp_events: ioServer.deviceDict['Experiment']._nativeEventCallback(eventAsTuple) self.sendResponse(('EVENT_TX_RESULT',len(exp_events)),replyTo) return True elif request_type == 'DEV_RPC': dclass=request.pop(0) dmethod=request.pop(0) args=None kwargs=None if len(request)==1: args=request[0] elif len(request)==2: args=request[0] kwargs=request[1] if len(kwargs)==0: kwargs=None dev=None if dclass.find('.') > 0: for dname, dev in ioServer.deviceDict.items(): if dname.endswith(dclass): dev=ioServer.deviceDict.get(dname,None) break else: dev=ioServer.deviceDict.get(dclass,None) if dev is None: print2err("IOHUB_DEVICE_ERROR") printExceptionDetailsToStdErr() self.sendResponse('IOHUB_DEVICE_ERROR', replyTo) return False try: method=getattr(dev,dmethod) except Exception: print2err("IOHUB_DEVICE_METHOD_ERROR") printExceptionDetailsToStdErr() self.sendResponse('IOHUB_DEVICE_METHOD_ERROR', replyTo) return False result=[] try: if args and kwargs: result=method(*args, **kwargs) elif args: result=method(*args) elif kwargs: result=method(**kwargs) else: result=method() self.sendResponse(('DEV_RPC_RESULT',result),replyTo) return True except Exception as e: print2err("RPC_DEVICE_RUNTIME_ERROR") printExceptionDetailsToStdErr() self.sendResponse('RPC_DEVICE_RUNTIME_ERROR', replyTo) return False elif request_type == 'GET_DEVICE_LIST': try: dev_list=[] for d in self.iohub.devices: dev_list.append((d.name,d.__class__.__name__)) self.sendResponse(('GET_DEV_LIST_RESULT',len(dev_list),dev_list),replyTo) return True except Exception as e: print2err("RPC_DEVICE_RUNTIME_ERROR") printExceptionDetailsToStdErr() self.sendResponse('RPC_DEVICE_RUNTIME_ERROR', replyTo) return False elif request_type == 'GET_DEV_INTERFACE': dclass=request.pop(0) data=None if dclass in ['EyeTracker','DAQ']: for dname, hdevice in ioServer.deviceDict.items(): if dname.endswith(dclass): data=hdevice._getRPCInterface() break else: dev=ioServer.deviceDict.get(dclass,None) if dev: data=dev._getRPCInterface() if data: self.sendResponse(('GET_DEV_INTERFACE',data),replyTo) return True else: print2err("GET_DEV_INTERFACE_ERROR") printExceptionDetailsToStdErr() self.sendResponse('GET_DEV_INTERFACE_ERROR', replyTo) return False elif request_type == 'ADD_DEVICE': dclass_name=request.pop(0) dconfig_dict=request.pop(1) # add device to ioSever here data=self.iohub.createNewMonitoredDevice(dclass_name,dconfig_dict) # end adding device to server if data: self.sendResponse(('ADD_DEVICE',data),replyTo) return True else: print2err("ADD_DEVICE_ERROR") printExceptionDetailsToStdErr() self.sendResponse('ADD_DEVICE_ERROR', replyTo) return False else: print2err("DEVICE_RPC_TYPE_NOT_SUPPORTED_ERROR") printExceptionDetailsToStdErr() self.sendResponse('DEVICE_RPC_TYPE_NOT_SUPPORTED_ERROR', replyTo) return False
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)) try: # initial dataStore setup if 'data_store' in config and psychopy.iohub._DATA_STORE_AVAILABLE: 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....") resultsFilePath = rootScriptPathDir 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 ....") # Add PubSub device listeners to other event types try: for d in self.devices: if d.__class__.__name__ == "EventPublisher": monitored_event_ids = d._event_listeners.keys() for eid in monitored_event_ids: event_device_class = EventConstants.getClass( eid).PARENT_DEVICE for ed in self.devices: if ed.__class__ == event_device_class: ed._addEventListener(d, [ eid, ]) break except Exception, e: print2err("Error PubSub Device listener association ....") printExceptionDetailsToStdErr() raise e
def on_external_framerate_change(self, *args, **kwargs): print2err("NOTE: Tobii System Sampling Rate Changed.") return False
def _poll(self): try: logged_time = getTime() if not self.isReportingEvents(): self._last_poll_time = logged_time return False if self.isConnected(): if self._byte_diff_mode: rx = self.read() read_time = getTime() for c in rx: if self._rx_buffer is not None and c != self._rx_buffer: self._createByteChangeSerialEvent( logged_time, read_time, self._rx_buffer, c) self._rx_buffer = c else: parser_state = self._parser_state rx_buffer = self._rx_buffer + self.read() read_time = getTime() prefix = self._parser_config['prefix'] delimiter = self._parser_config['delimiter'] if parser_state['prefix_found'] is False: if prefix and rx_buffer and len(rx_buffer) >= len( prefix): pindex = rx_buffer.find(prefix) if pindex >= 0: rx_buffer = rx_buffer[pindex + len(prefix):] parser_state['prefix_found'] = True if parser_state['delimiter_found'] is False: if delimiter and self._rx_buffer and len( rx_buffer) >= len(delimiter): dindex = rx_buffer.find(delimiter) if dindex >= 0: parser_state['delimiter_found'] = True sindex = dindex eindex = dindex + len(delimiter) parser_state[ 'parsed_event'] += rx_buffer[:sindex] if len(rx_buffer) > eindex: rx_buffer = rx_buffer[eindex:] else: rx_buffer = '' self._rx_buffer = rx_buffer self._createMultiByteSerialEvent( logged_time, read_time) return True if parser_state['bytes_needed'] > 0 and rx_buffer: rxlen = len(rx_buffer) #takebytes = rxlen - parser_state['bytes_needed'] if rxlen > parser_state['bytes_needed']: parser_state[ 'parsed_event'] += rx_buffer[:parser_state[ 'bytes_needed']] parser_state['bytes_needed'] = 0 rx_buffer = rx_buffer[ parser_state['bytes_needed']:] else: parser_state['parsed_event'] += rx_buffer parser_state['bytes_needed'] -= rxlen rx_buffer = '' if parser_state['bytes_needed'] == 0: self._rx_buffer = rx_buffer self._createMultiByteSerialEvent( logged_time, read_time) return True self._rx_buffer = rx_buffer else: read_time = logged_time self._last_poll_time = read_time return True except Exception, e: print2err("--------------------------------") print2err("ERROR in Serial._poll: ", e) printExceptionDetailsToStdErr() print2err("---------------------")
def updateDataStoreStructure(self, device_instance, event_class_dict): dfilter = tables.Filters(complevel=0, complib='zlib', shuffle=False, fletcher32=False) for event_cls_name, event_cls in event_class_dict.items(): if event_cls.IOHUB_DATA_TABLE: event_table_label = event_cls.IOHUB_DATA_TABLE if event_table_label not in self.TABLES: try: self.TABLES[ event_table_label] = self.emrtFile.createTable( self.groupNodeForEvent(event_cls), self.eventTableLabel2ClassName( event_table_label), event_cls.NUMPY_DTYPE, title='%s Data' % (device_instance.__class__.__name__, ), filters=dfilter.copy()) self.flush() except tables.NodeError: self.TABLES[ event_table_label] = self.groupNodeForEvent( event_cls)._f_get_child( self.eventTableLabel2ClassName( event_table_label)) except Exception as e: print2err('---------------ERROR------------------') print2err( 'Exception %s in iohub.datastore.updateDataStoreStructure:' % (e.__class__.__name__)) print2err('\tevent_cls: {0}'.format(event_cls)) print2err( '\tevent_cls_name: {0}'.format(event_cls_name)) print2err('\tevent_table_label: {0}'.format( event_table_label)) print2err('\teventTableLabel2ClassName: {0}'.format( self.eventTableLabel2ClassName(event_table_label))) print2err('\tgroupNodeForEvent(event_cls): {0}'.format( self.groupNodeForEvent(event_cls))) print2err('\nException:') printExceptionDetailsToStdErr() print2err('--------------------------------------') if event_table_label in self.TABLES: self.addClassMapping(event_cls, self.TABLES[event_table_label]) else: print2err( '---- IOHUB.DATASTORE CANNOT ADD CLASS MAPPING ----') print2err('\t** TABLES missing key: {0}'.format( event_table_label)) print2err('\tevent_cls: {0}'.format(event_cls)) print2err('\tevent_cls_name: {0}'.format(event_cls_name)) print2err('\teventTableLabel2ClassName: {0}'.format( self.eventTableLabel2ClassName(event_table_label))) print2err('----------------------------------------------')
def on_x_series_physical_config_change(self, *args, **kwargs): print2err("NOTE: Tobii X Series Physical Settings Changed.") return False
def on_head_box_change(self, *args, **kwargs): print2err("NOTE: Tobii Head Movement Box Changed.") return False
def run(rootScriptPathDir,configFilePath): psychopy.iohub.EXP_SCRIPT_DIRECTORY = rootScriptPathDir import tempfile tdir=tempfile.gettempdir() cdir,cfile=os.path.split(configFilePath) if tdir==cdir: tf=open(configFilePath) ioHubConfig=json.loads(tf.read()) tf.close() os.remove(configFilePath) else: ioHubConfig=load(open(configFilePath,'r'), Loader=Loader) hub_defaults_config=load(open(os.path.join(psychopy.iohub.IO_HUB_DIRECTORY,'default_config.yaml'),'r'), Loader=Loader) updateDict(ioHubConfig,hub_defaults_config) try: s = ioServer(rootScriptPathDir, ioHubConfig) except Exception as e: printExceptionDetailsToStdErr() sys.stdout.flush() try: s.shutdown() except Exception: pass return -1 try: s.log('Receiving datagrams on :9000') s.udpService.start() if Computer.system == 'win32': gevent.spawn(s.pumpMsgTasklet, s.config.get('windows_msgpump_interval', 0.00375)) if hasattr(gevent,'run'): for m in s.deviceMonitors: m.start() gevent.spawn(s.processEventsTasklet, 0.01) sys.stdout.write("IOHUB_READY\n\r\n\r") #print2err("Computer.psychopy_process: ", Computer.psychopy_process) if Computer.psychopy_process: gevent.spawn(s.checkForPsychopyProcess, 0.5) sys.stdout.flush() gevent.run() else: glets=[] if Computer.system == 'win32': glets.append(gevent.spawn(s.pumpMsgTasklet, s.config.get('windows_msgpump_interval', 0.00375))) for m in s.deviceMonitors: m.start() glets.append(m) glets.append(gevent.spawn(s.processEventsTasklet,0.01)) sys.stdout.write("IOHUB_READY\n\r\n\r") sys.stdout.flush() #print2err("Computer.psychopy_process: ", Computer.psychopy_process) if Computer.psychopy_process: glets.append(gevent.spawn(s.checkForPsychopyProcess, 0.5)) gevent.joinall(glets) s.log("Server END Time Offset: {0}".format(Computer.global_clock.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 Exception: pass return -1