class MWPixelClock(object): def __init__(self, conduitName): self.conduit = Conduit(conduitName) self.conduit.initialize() self.conduit.register_local_event_code(0, '#stimDisplayUpdate') self.conduit.register_callback_for_name('#stimDisplayUpdate', self.receive_event) self.codes = [] self.cond = Condition() self.maxCodes = 100 def receive_event(self, event): for s in event.data: if s is None: continue if s.has_key('bit_code'): self.cond.acquire() self.codes.append((s['bit_code'], event.time / 1000000.)) # if len(self.codes) > 2: # #logging.debug('MW bit_code = %i' % s['bit_code']) # #print s['bit_code'] # #logging.debug("MW Delta: %s" % delta_code(self.codes[-1][0], self.codes[-2][0])) while len(self.codes) > self.maxCodes: self.codes.pop(0) self.cond.notifyAll() self.cond.release()
class MWPixelClock(object): def __init__(self, conduitName): self.conduit = Conduit(conduitName) self.conduit.initialize() self.conduit.register_local_event_code(0,'#stimDisplayUpdate') self.conduit.register_callback_for_name('#stimDisplayUpdate', self.receive_event) self.codes = [] self.cond = Condition() self.maxCodes = 100 def receive_event(self, event): for s in event.data: if s is None: continue if s.has_key('bit_code'): self.cond.acquire() self.codes.append((s['bit_code'],event.time/1000000.)) # if len(self.codes) > 2: # #logging.debug('MW bit_code = %i' % s['bit_code']) # #print s['bit_code'] # #logging.debug("MW Delta: %s" % delta_code(self.codes[-1][0], self.codes[-2][0])) while len(self.codes) > self.maxCodes: self.codes.pop(0) self.cond.notifyAll() self.cond.release()
# print offset, cs.matchLength, cs.err # setup stim spike syncer global stimSpikeSyncer stimSpikeSyncer = StimSpikeSyncer() # process_spike(self, channel, time) # get_stim_spikes(self, channel, stimI) # process_event(self, event, conv=1./1000000.) # find_stim(self, stim) # setup psth # setup mworks conduit conduitName = 'server_event_conduit' conduit = IPCClientConduit(conduitName) conduit.initialize() conduit.register_local_event_code(0, '#stimDisplayUpdate') def process_mw_event(event): global stimSpikeSyncer, clockSync if event is None: return else: event.value = event.data stimSpikeSyncer.process_mw_event(event) clockSync.process_mw_event(event) conduit.register_callback_for_name('#stimDisplayUpdate', process_mw_event) # setup spike listener global sl
class Core(object): def __init__(self, config, zmqContext=None): if zmqContext is None: zmqContext = zmq.Context() # make clock synchronizer pathFunc = lambda i: config.get('pixel clock', 'socketTemplate') % i channels = range(config.getint('pixel clock', 'socketStart'), config.getint('pixel clock', 'socketEnd')) #self.clockSync = ClockSync(pathFunc, channels, zmqContext=zmqContext, maxErr=config.getint('pixel clock', 'maxError')) self.clockSync = ClockSync() # make stim spike syncer self.stimSpikeSyncer = StimSpikeSyncer() # make mworks conduit self.mw_conduit = IPCClientConduit(config.get('mworks', 'conduitname')) self.mw_conduit.initialize() self.mw_conduit.register_local_event_code(0, '#stimDisplayUpdate') self.mw_conduit.register_local_event_code(1, '#pixelClockOffset') self.mw_conduit.register_callback_for_name( '#stimDisplayUpdate', self.process_mw_display_event) self.mw_conduit.register_callback_for_name( '#pixelClockOffset', self.process_mw_pixel_clock_event) # make spike listener # pathFunc = lambda i : "tcp://127.0.0.1:%i" % (i+8000) pathFunc = lambda i: config.get('audio', 'socketTemplate') % i channels = range(config.getint('audio', 'socketStart'), config.getint('audio', 'socketEnd')) self.spikeListener = SpikeListener(pathFunc, channels, zmqContext=zmqContext) self.spikeListener.register_callback(self.process_spike) self.sampRate = float(config.getint('audio', 'sampRate')) def process_mw_display_event(self, event): # global stimSpikeSyncer, clockSync if event is None: return else: event.value = event.data self.stimSpikeSyncer.process_mw_event(event) def process_mw_pixel_clock_event(self, event): if event is None: return else: event.value = event.data self.clockSync.process_mw_event(event) def process_spike(self, wb): # global stimSpikeSyncer, clockSync if not (self.clockSync.offset is None): # spikeMWTime = clockSync.clockSync.au_to_mw(wb.time_stamp/44100.) self.stimSpikeSyncer.process_spike( wb.channel_id, self.clockSync.au_to_mw(wb.time_stamp / self.sampRate)) else: logging.warning("Clock not synced!! dropping spike on %i" % wb.channel_id) def update(self): """ Updates the various components of the physio_online core, should be called in the main loop """ logging.debug("Core updating") # global clockSync, sl, stimSpikeSyncer while self.spikeListener.update(): pass # while self.clockSync.update(): # pass # self.clockSync.match() # if self.clockSync.offset is None: # logging.debug("MW: %s" % str([e[1] for e in self.clockSync.mwEvents])) # logging.debug("AU: %s" % str([e[1] for e in self.clockSync.auEvents])) def clear_spikes(self): """ Clears all spikes accumulated so far """ self.stimSpikeSyncer.clear_spikes() def clear_stimuli(self): self.stimSpikeSyncer.clear_stimuli()
# setup mworks conduit def receive_event(event): global mwEventColors, mwTimeOffset, raster #, rasterCond, startTime #print event.time, event.data, event.code # rasterCond.acquire() if mwTimeOffset == None: mwTimeOffset = time.time() - event.time/1000000. # print "MW:", event.code, event.time/1000000. + mwTimeOffset raster.add_event(event.time/1000000. + mwTimeOffset, event.code, mwEventColors[event.code-NChannels]) # # if raster.cursorX == startTime: # raster.reset(raster.newEvents[0][0]) # rasterCond.notifyAll() # rasterCond.release() mwconduit = IPCClientConduit(conduitName) mwconduit.initialize() for (i,eventName) in enumerate(mwEventNames): print "registering %s" % eventName mwconduit.register_callback_for_name(eventName, receive_event) # register local code? mwconduit.register_local_event_code(i+NChannels,eventName) # print len(mwconduit.codec), mwconduit.codec # print len(mwconduit.reverse_codec), mwconduit.reverse_codec # setup spike listener global sl pathFunc = lambda i : "tcp://127.0.0.1:%i" % (i+8000) sl = SpikeListener(pathFunc, xrange(32)) global audioTimeOffset
event = FakeEvent(t, t, 0) #print "Received Event" receive_event('fake', event) #print "Sleeping..." time.sleep(self.iei) if __name__ == "__main__": if fakeProducer: fp = EventProducer(1000, 100) fp.start() else: conduit_resource_name = 'python_bridge_plugin_conduit' client = IPCClientConduit(conduit_resource_name) client.initialize() sys.stdout.write('registering callbacks\n') for i in xrange(len(targetEvents)): eventName = targetEvents[i] #client.register_callback_for_name(eventName, receive_event) client.register_local_event_code(i, targetEvents[i]) client.register_callback_for_name(eventName, receive_event) codeToName[i] = targetEvents[i] #print codeToName sys.stdout.write('waiting for events\n') while 1: update_plot() if fakeProducer: if not fp.is_alive(): #print "Fake event producer is done producing events"