def spinDownTest(self): # OK, we have collected the number of requested getEvents, that have returned >0 events # so _close psychopy window self.psychoWindow.close() # disable high priority in both processes Computer.disableHighPriority()
def pumpMsgTasklet(self, sleep_interval): import pythoncom while self._running: stime=Computer.getTime() if pythoncom.PumpWaitingMessages() == 1: break dur = sleep_interval - (Computer.getTime()-stime) gevent.sleep(max(0.0, dur))
def pumpMsgTasklet(self, sleep_interval): import pythoncom while self._running: stime = Computer.getTime() if pythoncom.PumpWaitingMessages() == 1: break dur = sleep_interval - (Computer.getTime() - stime) gevent.sleep(max(0.0, dur))
def test_getTime(self): ta = Computer.currentSec() tb = Computer.currentTime() tc = Computer.getTime() tp = getTime() assert ta < tb < tc < tp assert tp - ta < 0.002
def checkForEvents(self): # get the time we request events from the ioHub stime=Computer.currentTime() r = self.hub.getEvents() if r and len(r) > 0: # so there were events returned in the request, so include this getEvent request in the tally etime=Computer.currentTime() dur=etime-stime return r, dur*1000.0 return None,None
def checkForEvents(self): # get the time we request events from the ioHub stime = Computer.getTime() r = self.hub.getEvents() if r and len(r) > 0: # so there were events returned in the request, so include this getEvent request in the tally etime = Computer.getTime() dur = etime - stime return r, dur * 1000.0 return None, None
def test_getTime(self): ta = Computer.currentSec() tb = Computer.currentTime() tc = Computer.getTime() tp = getTime() assert ta <= tb <= tc <= tp assert tp - ta < 0.002 ta = getTime() tb = self.io.getTime() tc = self.io.getTime() tp = getTime() assert ta <= tb <= tc <= tp assert tp - ta < 0.01
def _createByteChangeSerialEvent(self, logged_time, read_time, prev_byte, new_byte): self._event_count += 1 confidence_interval = read_time - self._last_poll_time prev_byte = ord(prev_byte) new_byte = ord(new_byte) try: if new_byte != 0: # Button was pressed button = N.where(self._button_bytes == new_byte)[0][0] button_event = 'press' else: # Button was released button = N.where(self._button_bytes == prev_byte)[0][0] button_event = 'release' except: # Handles when data rx does not match either N.where within the try return events = [ 0, 0, 0, Computer._getNextEventID(), EventConstants.PSTBOX_BUTTON, read_time, logged_time, read_time, confidence_interval, 0.0, 0, self.port, button, button_event ] self._addNativeEventToBuffer(events)
def local2RemoteTime(self, local_time=None): """ Converts a local time (sec.msec format) to the corresponding remote computer time, using the current offset and drift measures. """ if local_time is None: local_time = Computer.currentSec() return self.getDrift() * local_time + self.getOffset()
def local2RemoteTime(self,local_time=None): """ Converts a local time (sec.msec format) to the corresponding remote computer time, using the current offset and drift measures. """ if local_time is None: local_time=Computer.currentSec() return self.getDrift()*local_time+self.getOffset()
def startHubProcess(): io = launchHubServer() assert io != None io_proc = Computer.getIoHubProcess() io_proc_pid = io_proc.pid assert io_proc != None and io_proc_pid > 0 return io
def run(self, *args): """ The run method contains your experiment logic. It is equal to what would be in your main psychopy experiment script.py file in a standard psychopy experiment setup. That is all there is too it really. """ run_demo = True kb = self.hub.devices.kb evt_sub = self.hub.devices.evt_sub # This demo does not display a PsychoPy window, instead it just prints # keyboard event info. received from the local keyboard device and keyboard # events received from the RemoteEventSubscriber device. Inform the user of this... # msg_dialog = MessageDialog( "This demo does not create a PsychoPy window.\nInstead local and subscribed keyboard event info is simply printed to stdout.\n\nOnce the demo has started, press 'ESCAPE' to quit.\n\nPress OK to continue or Cancel to abort the demo.", title="PsychoPy.ioHub PUB - SUB Event Demo", dialogType=MessageDialog.IMPORTANT_DIALOG, display_index=0) if msg_dialog.show() == MessageDialog.OK_RESULT: # wait until 'ESCAPE' is pressed, or quit after 15 seconds of no kb events. self.hub.clearEvents('all') last_event_time = Computer.getTime() while run_demo is True and Computer.getTime( ) - last_event_time < 15.0: local_kb_events = kb.getEvents() for event in local_kb_events: print('* Local KB Event: {etime}\t{ekey}\t{edelay}'.format( etime=event.time, ekey=event.key, edelay=event.delay)) last_event_time = event.time if event.key == u'ESCAPE': run_demo = False break subscribed_kb_events = evt_sub.getEvents() for event in subscribed_kb_events: print('# Subscribed KB Event: {etime}\t{ekey}\t{edelay}'. format(etime=event.time, ekey=event.key, edelay=event.delay)) self.hub.wait(0.1)
def _createMultiByteSerialEvent(self, logged_time, read_time): self._event_count += 1 confidence_interval = read_time - self._last_poll_time elist = [ 0, 0, 0, Computer._getNextEventID(), EventConstants.SERIAL_INPUT, read_time, logged_time, read_time, confidence_interval, 0.0, 0, self.port, self._parser_state['parsed_event'] ] self._addNativeEventToBuffer(elist) self._resetParserState()
def test_processorCounts(self): get_puc = Computer.getProcessingUnitCount() cc = Computer.core_count puc = Computer.processing_unit_count assert puc == get_puc assert type(cc) is int assert type(puc) is int assert puc > 0 assert cc > 0 assert cc <= puc
def sync(self): sync_count = self.sync_batch_size sync_data = [ 'SYNC_REQ', ] feed = self.feed unpack = self.unpack pack = self.pack recvfrom = self.sock.recvfrom rcvBufferLength = self._rcvBufferLength remote_address = self.remote_iohub_address sendto = self.sock.sendto min_delay = 1000.0 min_local_time = 0.0 min_remote_time = 0.0 for s in xrange(sync_count): # send sync request sync_start = Computer.currentSec() sendto(pack(sync_data), remote_address) sync_start2 = Computer.currentSec() # get reply feed(recvfrom(rcvBufferLength)[0]) sync_rep, remote_time = unpack() sync_end = Computer.currentSec() rtt = sync_end - (sync_start + sync_start2) / 2.0 old_delay = min_delay min_delay = min(min_delay, rtt) if old_delay != min_delay: min_local_time = (sync_end + sync_start) / 2.0 min_remote_time = remote_time return min_delay, min_local_time, min_remote_time
def _createByteChangeSerialEvent(self, logged_time, read_time, prev_byte, new_byte): self._event_count += 1 confidence_interval = read_time - self._last_poll_time elist = [ 0, 0, 0, Computer._getNextEventID(), EventConstants.SERIAL_BYTE_CHANGE, read_time, logged_time, read_time, confidence_interval, 0.0, 0, self.port, ord(prev_byte), ord(new_byte) ] self._addNativeEventToBuffer(elist)
def sync(self): sync_count=self.sync_batch_size sync_data=['SYNC_REQ',] feed=self.feed unpack=self.unpack pack=self.pack recvfrom=self.sock.recvfrom rcvBufferLength=self._rcvBufferLength remote_address=self.remote_iohub_address sendto=self.sock.sendto min_delay=1000.0 min_local_time=0.0 min_remote_time=0.0 for s in range(sync_count): # send sync request sync_start=Computer.currentSec() sendto(pack(sync_data),remote_address) sync_start2=Computer.currentSec() # get reply feed(recvfrom(rcvBufferLength)[0]) sync_rep,remote_time=unpack() sync_end=Computer.currentSec() rtt=sync_end-(sync_start+sync_start2)/2.0 old_delay=min_delay min_delay=min(min_delay,rtt) if old_delay!=min_delay: min_local_time=(sync_end+sync_start)/2.0 min_remote_time=remote_time return min_delay, min_local_time, min_remote_time
def run(self,*args): """ The run method contains your experiment logic. It is equal to what would be in your main psychopy experiment script.py file in a standard psychopy experiment setup. That is all there is too it really. """ run_demo=True kb=self.hub.devices.kb evt_sub=self.hub.devices.evt_sub # This demo does not display a PsychoPy window, instead it just prints # keyboard event info. received from the local keyboard device and keyboard # events received from the RemoteEventSubscriber device. Inform the user of this... # msg_dialog=MessageDialog("This demo does not create a PsychoPy window.\nInstead local and subscribed keyboard event info is simply printed to stdout.\n\nOnce the demo has started, press 'ESCAPE' to quit.\n\nPress OK to continue or Cancel to abort the demo.", title="PsychoPy.ioHub PUB - SUB Event Demo", dialogType=MessageDialog.IMPORTANT_DIALOG,display_index=0) if msg_dialog.show() == MessageDialog.OK_RESULT: # wait until 'ESCAPE' is pressed, or quit after 15 seconds of no kb events. self.hub.clearEvents('all') last_event_time=Computer.getTime() while run_demo is True and Computer.getTime()-last_event_time<15.0: local_kb_events=kb.getEvents() for event in local_kb_events: print('* Local KB Event: {etime}\t{ekey}\t{edelay}'.format( etime=event.time,ekey=event.key,edelay=event.delay)) last_event_time=event.time if event.key == u'ESCAPE': run_demo=False break subscribed_kb_events=evt_sub.getEvents() for event in subscribed_kb_events: print('# Subscribed KB Event: {etime}\t{ekey}\t{edelay}'.format( etime=event.time, ekey=event.key,edelay=event.delay)) self.hub.wait(0.1)
def test_getProcesses(self): assert Computer.is_iohub_process is False assert Computer.psychopy_process == Computer.getCurrentProcess() assert Computer.current_process == Computer.psychopy_process assert Computer.iohub_process == Computer.getIoHubProcess() assert Computer.iohub_process.pid == Computer.iohub_process_id assert Computer.getCurrentProcess().is_running() assert Computer.getIoHubProcess().is_running() assert Computer.getIoHubProcess().parent() == Computer.getCurrentProcess()
def _createMultiByteSerialEvent(self, logged_time, read_time): self._event_count += 1 confidence_interval = read_time - self._last_poll_time elist=[0, 0, 0, Computer._getNextEventID(), EventConstants.SERIAL_INPUT, read_time, logged_time, read_time, confidence_interval, 0.0, 0, self.port, self._parser_state['parsed_event'] ] self._addNativeEventToBuffer(elist) self._resetParserState()
def _createByteChangeSerialEvent(self, logged_time, read_time, prev_byte, new_byte): self._event_count += 1 confidence_interval = read_time - self._last_poll_time elist=[0, 0, 0, Computer._getNextEventID(), EventConstants.SERIAL_BYTE_CHANGE, read_time, logged_time, read_time, confidence_interval, 0.0, 0, self.port, ord(prev_byte), ord(new_byte) ] self._addNativeEventToBuffer(elist)
def stopHubProcess(): from psychopy.iohub.client import ioHubConnection io = ioHubConnection.getActiveConnection() assert io != None io_proc = Computer.getIoHubProcess() io_proc_pid = io_proc.pid assert io_proc != None and psutil.pid_exists(io_proc_pid) # Stop iohub server, ending process. io.quit() # Enure iohub proc has terminated. assert not psutil.pid_exists(io_proc_pid) assert ioHubConnection.getActiveConnection() is None
def test_procPriority(self): psycho_proc = Computer.psychopy_process iohub_proc = Computer.getIoHubProcess() psycho_priority = Computer.getProcessPriority(psycho_proc) iohub_priority = Computer.getProcessPriority(iohub_proc) assert psycho_priority == 'normal' assert iohub_priority == 'normal' priority_change_ok = Computer.enableHighPriority() new_psycho_priority = Computer.getProcessPriority(psycho_proc) assert priority_change_ok == False or new_psycho_priority == 'high' priority_change_ok = self.io.enableHighPriority() new_io_priority = Computer.getProcessPriority(iohub_proc) assert priority_change_ok == False or new_io_priority == 'high' priority_change_ok = Computer.disableHighPriority() new_psycho_priority = Computer.getProcessPriority(psycho_proc) assert priority_change_ok == False or new_psycho_priority == 'normal' priority_change_ok = self.io.disableHighPriority() new_io_priority = Computer.getProcessPriority(iohub_proc) assert priority_change_ok == False or new_io_priority == 'normal'
def setProcessAffinity(self, processorList): return Computer.setCurrentProcessAffinity(processorList)
#------------------------------------------------------------ #-- Save results to CSV file # def saveResults(results, outFN): results = pd.DataFrame(results) results.to_csv(outFN, index=False, encoding='latin-1') print("Results were saved to " + outFN) #========================================================================= # Main program #========================================================================= # Set the python process to high priority Computer.enableHighPriority() if not os.path.isdir(BASE_PATH): print( 'Error: the path is wrong (%s). Either you changed the app path or I don' 't know this computer' % BASE_PATH) core.quit() #-- Ask user what to run [configFN, subjID, configFnComment, saveOutput] = getUserInput() print("Starting...") #-- Setup monitorSize = (1024, 768) win = visual.Window(size=monitorSize,
def disableHighPriority(self): return Computer.disableHighPriority()
def processEventsTasklet(self, sleep_interval): while self._running: stime = Computer.getTime() self.processDeviceEvents() dur = sleep_interval - (Computer.getTime() - stime) gevent.sleep(max(0.0, dur))
def setPriority(self, level='normal', disable_gc=False): """ See Computer.setPriority documentation, where current process will be the ioHub Server process. """ return Computer.setPriority(level, disable_gc)
def disableHighPriority(self): Computer.disableHighPriority()
def test_procPriority(self): local_priority = Computer.getPriority() iohub_priority_rpc = self.io.getPriority() assert local_priority == 'normal' assert iohub_priority_rpc == 'normal' priority_level = Computer.setPriority('high', True) assert priority_level == 'high' priority_level = self.io.setPriority('high', True) assert priority_level == 'high' priority_level = Computer.setPriority('normal') assert priority_level == 'normal' priority_level = self.io.setPriority('normal') assert priority_level == 'normal' priority_level = Computer.setPriority('realtime') assert priority_level == 'realtime' priority_level = self.io.setPriority('realtime') assert priority_level == 'realtime' priority_level = Computer.setPriority('normal') assert priority_level == 'normal' priority_level = self.io.setPriority('normal') assert priority_level == 'normal' # >> Deprecated functionality tests psycho_proc = Computer.psychopy_process iohub_proc = Computer.getIoHubProcess() psycho_priority = Computer.getProcessPriority(psycho_proc) iohub_priority = Computer.getProcessPriority(iohub_proc) assert psycho_priority == 'normal' assert local_priority == psycho_priority assert iohub_priority == 'normal' assert iohub_priority == iohub_priority_rpc priority_change_ok = Computer.enableHighPriority() new_psycho_priority = Computer.getProcessPriority(psycho_proc) assert priority_change_ok == False or new_psycho_priority == 'high' priority_change_ok = self.io.enableHighPriority() new_io_priority = Computer.getProcessPriority(iohub_proc) assert priority_change_ok == False or new_io_priority == 'high' priority_change_ok = Computer.disableHighPriority() new_psycho_priority = Computer.getProcessPriority(psycho_proc) assert priority_change_ok == False or new_psycho_priority == 'normal' priority_change_ok = self.io.disableHighPriority() new_io_priority = Computer.getProcessPriority(iohub_proc) assert priority_change_ok == False or new_io_priority == 'normal'
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("---------------------")
def enableHighPriority(self, disable_gc=True): Computer.enableHighPriority(disable_gc)
def getProcessAffinity(self): return Computer.getCurrentProcessAffinity()
def enableHighPriority(self,disable_gc=True): Computer.enableHighPriority(disable_gc)
def processEventsTasklet(self,sleep_interval): while self._running: stime=Computer.getTime() self.processDeviceEvents() dur = sleep_interval - (Computer.getTime()-stime) gevent.sleep(max(0.0, dur))
def getPriority(self): """ See Computer.getPriority documentation, where current process will be the ioHub Server process. """ return Computer.getPriority()
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() MCU._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.DIGITAL_INPUT_EVENT: elist= [EventConstants.UNDEFINED,]*12 elist[4]=DigitalInputEvent.EVENT_TYPE_ID elist[-1]=event.getDigitalInputByte() elif 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 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.keys(): self._response_dict[rid]=reply del self._request_dict[rid] self._last_callback_time=logged_time return True except Exception, e: print2err("--------------------------------") print2err("ERROR in MCU._poll: ",e) printExceptionDetailsToStdErr() print2err("---------------------")