def test_eeg_OpenBCI():
# in main App
app = QtGui.QApplication([])
dev = OpenBCI()
dev.configure(device_handle='/dev/ttyUSB0')
dev.outputs['chan'].configure(protocol='tcp', interface='127.0.0.1',transfermode='plaindata',)
dev.outputs['aux'].configure(protocol='tcp', interface='127.0.0.1',transfermode='plaindata',)
dev.initialize()
viewer = QOscilloscope()
viewer.configure()
viewer.input.connect(dev.outputs['chan'])
viewer.initialize()
viewer.show()
# dev.print_register_settings()
dev.start()
viewer.start()
def terminate():
viewer.stop()
dev.stop()
viewer.close()
dev.close()
app.quit()
# start for a while
timer = QtCore.QTimer(singleShot=True, interval=100000)
timer.timeout.connect(terminate)
timer.start()
app.exec_()
def test_openephys_gui_relay():
# in main App
app = QtGui.QApplication([])
dev = OpenEphysGUIRelay()
dev.configure(openephys_url='tcp://127.0.0.1:20000')
dev.outputs['signals'].configure()
dev.initialize()
pprint(dev.outputs['signals'].params)
viewer = QOscilloscope()
viewer.configure()
viewer.input.connect(dev.outputs['signals'].params)
viewer.initialize()
viewer.show()
dev.start()
viewer.start()
def terminate():
viewer.stop()
dev.stop()
viewer.close()
dev.close()
app.quit()
# start for a while
timer = QtCore.QTimer(singleShot=True, interval=5000)
#~ timer.timeout.connect(terminate)
#~ timer.start()
app.exec_()
def test_brainampsocket():
# in main App
app = QtGui.QApplication([])
dev = BrainAmpSocket()
#~ dev.configure(brainamp_host = '194.167.217.129', brainamp_port = 51244)
dev.configure(brainamp_host='194.167.217.84', brainamp_port=51244)
dev.outputs['signals'].configure(protocol='tcp', interface='127.0.0.1',transfermode='plaindata',)
dev.outputs['triggers'].configure(protocol='tcp', interface='127.0.0.1',transfermode='plaindata',)
dev.initialize()
viewer = QOscilloscope()
viewer.configure()
viewer.input.connect(dev.outputs['signals'])
viewer.initialize()
viewer.show()
dev.start()
viewer.start()
def terminate():
viewer.stop()
dev.stop()
viewer.close()
dev.close()
app.quit()
# start for a while
timer = QtCore.QTimer(singleShot=True, interval=5000)
timer.timeout.connect(terminate)
#~ timer.start()
app.exec_()
def _initialize(self, **kargs):
QOscilloscope._initialize(self, **kargs)
self.inputs['spikes'].set_buffer(size=self.peak_buffer_size,
double=False)
# poller onpeak
self._last_peak = 0
self.poller_peak = ThreadPollInput(input_stream=self.inputs['spikes'],
return_data=True)
self.poller_peak.new_data.connect(self._on_new_peak)
self.spikes_array = self.inputs['spikes'].buffer.buffer
self.scatters = {}
self.change_catalogue(self.catalogue)
self.params['xsize'] = 1.
self.params['decimation_method'] = 'min_max'
self.params['mode'] = 'scan'
self.params['scale_mode'] = 'same_for_all'
self.params['display_labels'] = True
self.timer_scale = QT.QTimer(singleShot=True, interval=500)
self.timer_scale.timeout.connect(self.auto_scale)
self.timer_scale.start()
def _refresh(self, **kargs):
QOscilloscope._refresh(self, **kargs)
mode = self.params['mode']
gains = np.array([p['gain'] for p in self.by_channel_params.children()])
offsets = np.array([p['offset'] for p in self.by_channel_params.children()])
visibles = np.array([p['visible'] for p in self.by_channel_params.children()], dtype=bool)
head = self._head
full_arr = self.inputs['signals'].get_data(head-self.full_size, head)
if self._last_peak==0:
return
keep = (self.spikes_array['index']>head - self.full_size) & (self.spikes_array['index']<head)
spikes = self.spikes_array[keep]
#~ spikes = self.spikes_array['index'][keep]
spikes_ind = spikes['index'] - (head - self.full_size)
spikes_amplitude = full_arr[spikes_ind, :]
spikes_amplitude[:, visibles] *= gains[visibles]
spikes_amplitude[:, visibles] += offsets[visibles]
if mode=='scroll':
peak_times = self.t_vect_full[spikes_ind]
elif mode =='scan':
#some trick to play with fake time
front = head % self.full_size
ind1 = (spikes['index']%self.full_size)<front
ind2 = (spikes['index']%self.full_size)>front
peak_times = self.t_vect_full[spikes_ind]
peak_times[ind1] += (self.t_vect_full[front] - self.t_vect_full[-1])
peak_times[ind2] += (self.t_vect_full[front] - self.t_vect_full[0])
for i, k in enumerate(self.catalogue['cluster_labels']):
keep = k==spikes['label']
if np.sum(keep)>0:
chan = self.catalogue['max_on_channel'][i]
if visibles[chan]:
self.scatters[k].setData(peak_times[keep], spikes_amplitude[keep, chan])
else:
self.scatters[k].setData([], [])
else:
self.scatters[k].setData([], [])
def _initialize(self, **kargs):
QOscilloscope._initialize(self, **kargs)
self.inputs['spikes'].set_buffer(size=self.peak_buffer_size, double=False)
# poller onpeak
self._last_peak = 0
self.poller_peak = ThreadPollInput(input_stream=self.inputs['spikes'], return_data=True)
self.poller_peak.new_data.connect(self._on_new_peak)
self.spikes_array = self.inputs['spikes'].buffer.buffer
self._default_color = QtGui.QColor('#FFFFFF')#TODO
self.scatters = {}
for k in self.catalogue['cluster_labels']:
color = self.catalogue['cluster_colors'].get(k, (1,1,1))
r, g, b = color
qcolor = QtGui.QColor(r*255, g*255, b*255)
qcolor.setAlpha(150)
scatter = pg.ScatterPlotItem(x=[ ], y= [ ], pen=None, brush=qcolor, size=10, pxMode = True)
self.scatters[k] = scatter
self.plot.addItem(scatter)
def _stop(self, **kargs):
QOscilloscope._stop(self, **kargs)
self.poller_peak.stop()
self.poller_peak.wait()
aimodes={
'Dev1/ai0': 'rse',
'Dev1/ai1': 'rse'
},
airanges=(-5., 5.), #for all channels
magnitude_mode='float32_volt',
aochannels=aochannels,
)
dev.outputs['aichannels'].configure(protocol='tcp',
interface='127.0.0.1',
transfertmode='plaindata')
dev.initialize()
# Create an oscilloscope to display data.
viewer = QOscilloscope()
viewer.configure(with_user_dialog=True)
# Connect audio stream to oscilloscope
viewer.input.connect(dev.output)
viewer.initialize()
viewer.show()
viewer.params['decimation_method'] = 'min_max'
viewer.params['ylim_max'] = 5.
viewer.params['ylim_min'] = -5.
viewer.params['mode'] = 'scan'
# Start both nodes
dev.start()
viewer.start()
def reset_curves_data(self):
QOscilloscope.reset_curves_data(self)
self.t_vect_full = np.arange(0,self.full_size, dtype=float)/self.sample_rate
self.t_vect_full -= self.t_vect_full[-1]
def _stop(self, **kargs):
QOscilloscope._stop(self, **kargs)
self.poller_peak.stop()
self.poller_peak.wait()
def __init__(self, **kargs):
QOscilloscope.__init__(self, **kargs)
def test_OnlinePeeler():
dataio = DataIO(dirname='test_onlinepeeler')
catalogueconstructor = CatalogueConstructor(dataio=dataio)
catalogue = catalogueconstructor.load_catalogue()
#~ print(catalogue)
#~ def print_dict(d):
#~ for k, v in d.items():
#~ if type(v) is dict:
#~ print('k', k, 'dict')
#~ print_dict(v)
#~ else:
#~ print('k', k, type(v))
#~ print_dict(catalogue)
#~ from pyacq.core.rpc.serializer import MsgpackSerializer
#~ serializer = MsgpackSerializer()
#~ serializer.dumps(catalogue)
#~ exit()
sigs = dataio.datasource.array_sources[0]
sigs = sigs.astype('float32')
sample_rate = dataio.sample_rate
in_group_channels = dataio.channel_groups[0]['channels']
#~ print(channel_group)
chunksize = 1024
# Device node
man = pyacq.create_manager(auto_close_at_exit=True)
ng0 = man.create_nodegroup()
#~ ng0 = None
ng1 = man.create_nodegroup()
#~ ng1 = None
dev = make_pyacq_device_from_buffer(sigs, sample_rate, nodegroup=ng0, chunksize=chunksize)
app = pg.mkQApp()
dev.start()
# Node QOscilloscope
oscope = QOscilloscope()
oscope.configure(with_user_dialog=True)
oscope.input.connect(dev.output)
oscope.initialize()
oscope.show()
oscope.start()
oscope.params['decimation_method'] = 'min_max'
oscope.params['mode'] = 'scan'
# Node Peeler
if ng1 is None:
peeler = OnlinePeeler()
else:
ng1.register_node_type_from_module('tridesclous.online', 'OnlinePeeler')
peeler = ng1.create_node('OnlinePeeler')
peeler.configure(catalogue=catalogue, in_group_channels=in_group_channels, chunksize=chunksize)
peeler.input.connect(dev.output)
stream_params = dict(protocol='tcp', interface='127.0.0.1', transfermode='plaindata')
peeler.outputs['signals'].configure(**stream_params)
peeler.outputs['spikes'].configure(**stream_params)
peeler.initialize()
peeler.start()
# Node traceviewer
tviewer = OnlineTraceViewer()
tviewer.configure(peak_buffer_size = 1000, catalogue=catalogue)
tviewer.inputs['signals'].connect(peeler.outputs['signals'])
tviewer.inputs['spikes'].connect(peeler.outputs['spikes'])
tviewer.initialize()
tviewer.show()
tviewer.start()
tviewer.params['xsize'] = 3.
tviewer.params['decimation_method'] = 'min_max'
tviewer.params['mode'] = 'scan'
#~ tviewer.params['mode'] = 'scroll'
tviewer.auto_gain_and_offset(mode=1)
#~ tviewer.gain_zoom(.3)
tviewer.gain_zoom(.1)
def ajust_yrange():
oscope.auto_gain_and_offset(mode=1)
timer = QtCore.QTimer(interval=1000, singleShot=True)
timer.timeout.connect(ajust_yrange)
timer.start()
def terminate():
dev.stop()
oscope.stop()
peeler.stop()
tviewer.stop()
app.quit()
app.exec_()
default_input = dev.default_input_device()
print("\nAvaliable devices:")
for device in dev.list_device_specs():
index = device['index']
star = "*" if index == default_input else " "
print(" %s %d: %s" % (star, index, device['name']))
# Configure PyAudio device with a single (default) input channel.
dev.configure(nb_channel=1, sample_rate=44100., input_device_index=default_input,
format='int16', chunksize=1024)
dev.output.configure(protocol='tcp', interface='127.0.0.1', transfertmode='plaindata')
dev.initialize()
# Create an oscilloscope to display data.
viewer = QOscilloscope()
viewer.configure(with_user_dialog = True)
# Connect audio stream to oscilloscope
viewer.input.connect(dev.output)
viewer.initialize()
viewer.show()
viewer.params['decimation_method'] = 'min_max'
viewer.by_channel_params['Signal0', 'gain'] = 0.001
# Start both nodes
dev.start()
viewer.start()
app.exec_()
def test_blackrock():
#~ ai_channels = [1, ]
ai_channels = [1, 2, 3, 4, 10, 11, 12, 13]
#~ ai_channels = list(range(16, 25))
#~ ai_channels = [20, 21, 22, 23]
#~ ai_channels = [1, 2, 3, 4, 5, 6, 7, 8,
#~ 17, 18, 19, 20, 21, 22, 23, 24,
#~ 33, 34, 35, 36, 37, 38, 39, 40,
#~ 49, 50, 51, 52, 53, 54, 55, 56,
#~ 129,
#~ ]
# in main App
app = QtGui.QApplication([])
# for testing in background
#~ man = create_manager(auto_close_at_exit=True)
#~ ng0 = man.create_nodegroup()
#~ dev = ng0.create_node('Blackrock')
# tested in local Node
dev = Blackrock()
# dev.configure(nInstance=0,szInIP=b"192.168.137.1", ai_channels=ai_channels, apply_config=True)
dev.configure(nInstance=0,
connection_type='central',
ai_channels=ai_channels,
apply_config=False)
dev.outputs['aichannels'].configure(protocol='tcp',
interface='127.0.0.1',
transfertmode='plaindata')
dev.initialize()
global n
n = 0
viewer = QOscilloscope()
viewer.configure(with_user_dialog=True)
viewer.input.connect(dev.output)
viewer.initialize()
viewer.show()
viewer.params['scale_mode'] = 'by_channel'
viewer.params['xsize'] = 1
viewer.params['refresh_interval'] = 100
dev.start()
viewer.start()
def terminate():
global n
print('stop', n)
dev.stop()
viewer.stop()
print('stop OK', n)
if n < 3:
n += 1
print('start', n)
dev.start()
viewer.start()
print('start OK', n)
else:
print('terminate')
dev.close()
viewer.close()
app.quit()
# start and stop 3 times
timer = QtCore.QTimer(singleShot=False, interval=1000)
timer.timeout.connect(terminate)
timer.start()
app.exec_()
def test_blackrock():
#~ ai_channels = [1, ]
ai_channels = [1,2,3, 4, 10, 11, 12, 13]
#~ ai_channels = list(range(16, 25))
#~ ai_channels = [20, 21, 22, 23]
#~ ai_channels = [1, 2, 3, 4, 5, 6, 7, 8,
#~ 17, 18, 19, 20, 21, 22, 23, 24,
#~ 33, 34, 35, 36, 37, 38, 39, 40,
#~ 49, 50, 51, 52, 53, 54, 55, 56,
#~ 129,
#~ ]
# in main App
app = QtGui.QApplication([])
# for testing in background
#~ man = create_manager(auto_close_at_exit=True)
#~ ng0 = man.create_nodegroup()
#~ dev = ng0.create_node('Blackrock')
# tested in local Node
dev = Blackrock()
# dev.configure(nInstance=0,szInIP=b"192.168.137.1", ai_channels=ai_channels, apply_config=True)
dev.configure(nInstance=0, connection_type='central', ai_channels=ai_channels, apply_config=False)
dev.outputs['aichannels'].configure(protocol='tcp', interface='127.0.0.1', transfertmode='plaindata')
dev.initialize()
global n
n = 0
viewer = QOscilloscope()
viewer.configure(with_user_dialog=True)
viewer.input.connect(dev.output)
viewer.initialize()
viewer.show()
viewer.params['scale_mode'] = 'by_channel'
viewer.params['xsize'] = 1
viewer.params['refresh_interval'] = 100
dev.start()
viewer.start()
def terminate():
global n
print('stop', n)
dev.stop()
viewer.stop()
print('stop OK', n)
if n<3:
n += 1
print('start', n)
dev.start()
viewer.start()
print('start OK', n)
else:
print('terminate')
dev.close()
viewer.close()
app.quit()
# start and stop 3 times
timer = QtCore.QTimer(singleShot=False, interval=1000)
timer.timeout.connect(terminate)
timer.start()
app.exec_()
#~ dev0 = NumpyDeviceBuffer()
dev0 = ng0.create_node('NumpyDeviceBuffer')
dev0.configure(nb_channel=nb_channel,
sample_interval=1. / sample_rate,
chunksize=chunksize,
buffer=sigs)
dev0.output.configure(protocol='tcp',
interface='127.0.0.1',
transfermode='plaindata')
dev0.outputs['signals'].configure(protocol='tcp',
interface='127.0.0.1',
transfertmode='plaindata')
dev0.initialize()
oscope0 = QOscilloscope()
oscope0.configure(with_user_dialog=True, max_xsize=60.)
oscope0.input.connect(dev0.output)
oscope0.initialize()
oscope0.params['scale_mode'] = 'by_channel'
rec = RawRecorder()
# global UI settings
show_open_settings_menu = True
#~ auto_scale_on_start = False
# optional control pannel
# controlpanel = CustumControlPanel(...)
# node list
def test_OnlinePeeler():
dataio = DataIO(dirname='test_onlinepeeler')
catalogue = dataio.load_catalogue(chan_grp=0)
sigs = dataio.datasource.array_sources[0]
sigs = sigs.astype('float32')
sample_rate = dataio.sample_rate
in_group_channels = dataio.channel_groups[0]['channels']
#~ print(channel_group)
chunksize = 1024
# Device node
#~ man = create_manager(auto_close_at_exit=True)
#~ ng0 = man.create_nodegroup()
ng0 = None
dev = make_pyacq_device_from_buffer(sigs,
sample_rate,
nodegroup=ng0,
chunksize=chunksize)
app = pg.mkQApp()
dev.start()
# Node QOscilloscope
oscope = QOscilloscope()
oscope.configure(with_user_dialog=True)
oscope.input.connect(dev.output)
oscope.initialize()
oscope.show()
oscope.start()
oscope.params['decimation_method'] = 'min_max'
oscope.params['mode'] = 'scan'
# Node Peeler
peeler = OnlinePeeler()
peeler.configure(catalogue=catalogue,
in_group_channels=in_group_channels,
chunksize=chunksize)
peeler.input.connect(dev.output)
stream_params = dict(protocol='tcp',
interface='127.0.0.1',
transfermode='plaindata')
peeler.outputs['signals'].configure(**stream_params)
peeler.outputs['spikes'].configure(**stream_params)
peeler.initialize()
peeler.start()
# Node traceviewer
tviewer = OnlineTraceViewer()
tviewer.configure(peak_buffer_size=1000,
catalogue=lighter_catalogue(catalogue))
tviewer.inputs['signals'].connect(peeler.outputs['signals'])
tviewer.inputs['spikes'].connect(peeler.outputs['spikes'])
tviewer.initialize()
tviewer.show()
tviewer.start()
tviewer.params['xsize'] = 3.
tviewer.params['decimation_method'] = 'min_max'
tviewer.params['mode'] = 'scan'
# waveform histogram viewer
wviewer = OnlineWaveformHistViewer()
wviewer.configure(peak_buffer_size=1000, catalogue=catalogue)
wviewer.inputs['signals'].connect(peeler.outputs['signals'])
wviewer.inputs['spikes'].connect(peeler.outputs['spikes'])
wviewer.initialize()
wviewer.show()
wviewer.start()
def terminate():
dev.stop()
oscope.stop()
peeler.stop()
tviewer.stop()
app.quit()
if __name__ == '__main__':
app.exec_()
def test_measurementcomputing_USB2533():
app = pg.mkQApp()
dev = MeasurementComputing()
# ai_channel_index = None
ai_channel_index = [0, 10, 47, ]
ai_ranges = (-10, 10)
#~ ai_ranges = (-5, 5)
#~ ai_ranges = (-1, 1)
ai_mode = 'single-ended'
#~ ai_mode = 'differential' # this should bug whith channel>32
dev.configure(board_num=0, sample_rate=10000., ai_channel_index=ai_channel_index, ai_ranges=ai_ranges, ai_mode=ai_mode)
dev.outputs['aichannels'].configure(protocol = 'tcp', interface = '127.0.0.1', transfertmode = 'plaindata')
dev.outputs['dichannels'].configure(protocol = 'tcp', interface = '127.0.0.1', transfertmode = 'plaindata')
dev.initialize()
viewer0 = QOscilloscope()
viewer0.configure()
viewer0.input.connect(dev.outputs['aichannels'])
viewer0.initialize()
viewer0.params['scale_mode'] = 'real_scale'
viewer0.params['xsize'] = 5
viewer0.params['ylim_min'] = -1.5
viewer0.params['ylim_max'] = 1.5
viewer0.params['refresh_interval'] = 100
viewer0.params['show_left_axis'] = True
viewer1 = QDigitalOscilloscope()
viewer1.configure()
viewer1.input.connect(dev.outputs['dichannels'])
viewer1.initialize()
dev.start()
viewer0.start()
viewer0.show()
viewer1.start()
viewer1.show()
def terminate():
viewer0.stop()
viewer1.stop()
dev.stop()
viewer0.close()
viewer1.close()
dev.close()
app.quit()
# start for a while
timer = QtCore.QTimer(singleShot = True, interval = 10000)
timer.timeout.connect(terminate)
#~ timer.start()
app.exec_()
def _close(self, **kargs):
QOscilloscope._close(self, **kargs)
self.output.send(np.random.normal(size=(self.chunksize, 1)).astype('float32'), index=self.head)
# Not necessary for this example, but registering the node class would make it
# easier for us to instantiate this type of node in a remote process via
# Manager.create_node()
register_node_type(NoiseGenerator)
if __name__ == '__main__':
from pyacq.viewers import QOscilloscope
app = QtGui.QApplication([])
# Create a noise generator node
ng = NoiseGenerator()
ng.configure()
ng.output.configure(protocol='inproc', transfermode='sharedmem')
ng.initialize()
# Create an oscilloscope node to view the noise stream
osc = QOscilloscope()
osc.configure(with_user_dialog=True)
osc.input.connect(ng.output)
osc.initialize()
osc.show()
# start both nodes
osc.start()
ng.start()
def reset_curves_data(self):
QOscilloscope.reset_curves_data(self)
self.t_vect_full = np.arange(0, self.full_size,
dtype=float) / self.sample_rate
self.t_vect_full -= self.t_vect_full[-1]
def _refresh(self, **kargs):
if self.visibleRegion().isEmpty():
# when several tabs not need to refresh
return
with self.mutex:
QOscilloscope._refresh(self, **kargs)
mode = self.params['mode']
gains = np.array(
[p['gain'] for p in self.by_channel_params.children()])
offsets = np.array(
[p['offset'] for p in self.by_channel_params.children()])
visibles = np.array(
[p['visible'] for p in self.by_channel_params.children()],
dtype=bool)
head = self._head
full_arr = self.inputs['signals'].get_data(head - self.full_size,
head)
if self._last_peak == 0:
return
keep = (self.spikes_array['index'] > head - self.full_size) & (
self.spikes_array['index'] < head)
spikes = self.spikes_array[keep]
spikes_ind = spikes['index'] - (head - self.full_size)
spikes_ind = spikes_ind[spikes_ind < full_arr.shape[
0]] # to avoid bug if last peak is great than head
real_spikes_amplitude = full_arr[spikes_ind, :]
spikes_amplitude = real_spikes_amplitude.copy()
spikes_amplitude[:, visibles] *= gains[visibles]
spikes_amplitude[:, visibles] += offsets[visibles]
if mode == 'scroll':
peak_times = self.t_vect_full[spikes_ind]
elif mode == 'scan':
#some trick to play with fake time
front = head % self.full_size
ind1 = (spikes['index'] % self.full_size) < front
ind2 = (spikes['index'] % self.full_size) > front
peak_times = self.t_vect_full[spikes_ind]
peak_times[ind1] += (self.t_vect_full[front] -
self.t_vect_full[-1])
peak_times[ind2] += (self.t_vect_full[front] -
self.t_vect_full[0])
for i, k in enumerate(self.all_plotted_labels):
keep = k == spikes['cluster_label']
if np.sum(keep) > 0:
if k >= 0:
chan = self.catalogue['extremum_channel'][i]
if visibles[chan]:
times, amps = peak_times[keep], spikes_amplitude[
keep, chan]
else:
times, amps = [], []
else:
chan_max = np.argmax(np.abs(
real_spikes_amplitude[keep, :]),
axis=1)
keep2 = visibles[chan_max]
chan_max = chan_max[keep2]
keep[keep] &= keep2
times, amps = peak_times[keep], spikes_amplitude[
keep, chan_max]
self.scatters[k].setData(times, amps)
else:
self.scatters[k].setData([], [])
star = "*" if index == default_input else " "
print(" %s %d: %s" % (star, index, device['name']))
# Configure PyAudio device with a single (default) input channel.
dev.configure(nb_channel=1,
sample_rate=44100.,
input_device_index=default_input,
format='int16',
chunksize=1024)
dev.output.configure(protocol='tcp',
interface='127.0.0.1',
transfermode='plaindata')
dev.initialize()
# Create an oscilloscope to display data.
viewer = QOscilloscope()
viewer.configure(with_user_dialog=True)
# Connect audio stream to oscilloscope
viewer.input.connect(dev.output)
viewer.initialize()
viewer.show()
viewer.params['decimation_method'] = 'min_max'
viewer.by_channel_params['Signal0', 'gain'] = 0.001
# Start both nodes
dev.start()
viewer.start()
app.exec_()
def __init__(self, **kargs):
QOscilloscope.__init__(self, **kargs)
self.mutex = Mutex()
def _configure(self, peak_buffer_size = 10000, catalogue=None, **kargs):
QOscilloscope._configure(self, **kargs)
self.peak_buffer_size = peak_buffer_size
self.catalogue = catalogue
assert catalogue is not None
def tridesclous_onlinepeeler():
dataio = DataIO(dirname='tridesclous_onlinepeeler')
catalogue = dataio.load_catalogue(chan_grp=0)
#~ catalogue.pop('clusters')
#~ def print_dict(d):
#~ for k, v in d.items():
#~ if type(v) is dict:
#~ print('k', k, 'dict')
#~ print_dict(v)
#~ else:
#~ print('k', k, type(v))
#~ print_dict(catalogue)
#~ from pyacq.core.rpc.serializer import MsgpackSerializer
#~ serializer = MsgpackSerializer()
#~ b = serializer.dumps(catalogue)
#~ catalogue2 = serializer.loads(b)
#~ print(catalogue2['clusters'])
#~ exit()
sigs = dataio.datasource.array_sources[0]
sigs = sigs.astype('float32').copy()
sample_rate = dataio.sample_rate
in_group_channels = dataio.channel_groups[0]['channels']
#~ print(channel_group)
chunksize = 1024
# Device node
#~ man = pyacq.create_manager(auto_close_at_exit=True)
#~ ng0 = man.create_nodegroup()
ng0 = None
#~ ng1 = man.create_nodegroup()
ng1 = None
#~ ng2 = man.create_nodegroup()
ng2 = None
dev = make_pyacq_device_from_buffer(sigs,
sample_rate,
nodegroup=ng0,
chunksize=chunksize)
#~ print(type(dev))
#~ exit()
#~ print(dev.output.params)
#~ exit()
app = pg.mkQApp()
dev.start()
# Node QOscilloscope
oscope = QOscilloscope()
oscope.configure(with_user_dialog=True)
oscope.input.connect(dev.output)
oscope.initialize()
oscope.show()
oscope.start()
oscope.params['decimation_method'] = 'min_max'
oscope.params['mode'] = 'scan'
oscope.params['scale_mode'] = 'by_channel'
# Node Peeler
if ng1 is None:
peeler = OnlinePeeler()
else:
ng1.register_node_type_from_module('tridesclous.online',
'OnlinePeeler')
peeler = ng1.create_node('OnlinePeeler')
peeler.configure(catalogue=catalogue,
in_group_channels=in_group_channels,
chunksize=chunksize)
#~ print(dev.output.params)
#~ print(peeler.input.connect)
#~ exit()
peeler.input.connect(dev.output)
#~ exit()
stream_params = dict(protocol='tcp',
interface='127.0.0.1',
transfermode='plaindata')
peeler.outputs['signals'].configure(**stream_params)
peeler.outputs['spikes'].configure(**stream_params)
peeler.initialize()
peeler.start()
# Node traceviewer
if ng2 is None:
tviewer = OnlineTraceViewer()
else:
ng2.register_node_type_from_module('tridesclous.online',
'OnlineTraceViewer')
tviewer = ng2.create_node('OnlineTraceViewer')
tviewer.configure(catalogue=catalogue)
tviewer.inputs['signals'].connect(peeler.outputs['signals'])
tviewer.inputs['spikes'].connect(peeler.outputs['spikes'])
tviewer.initialize()
tviewer.show()
tviewer.start()
tviewer.params['xsize'] = 3.
tviewer.params['decimation_method'] = 'min_max'
tviewer.params['mode'] = 'scan'
tviewer.params['scale_mode'] = 'same_for_all'
#~ tviewer.params['mode'] = 'scroll'
#~ tfr_viewer = QTimeFreq()
#~ tfr_viewer.configure(with_user_dialog=True, nodegroup_friends=None)
#~ tfr_viewer.input.connect(dev.output)
#~ tfr_viewer.initialize()
#~ tfr_viewer.show()
#~ tfr_viewer.params['refresh_interval'] = 300
#~ tfr_viewer.params['timefreq', 'f_start'] = 1
#~ tfr_viewer.params['timefreq', 'f_stop'] = 100.
#~ tfr_viewer.params['timefreq', 'deltafreq'] = 5
#~ tfr_viewer.start()
def ajust_yrange():
oscope.auto_scale()
tviewer.auto_scale()
tviewer.params_controller.apply_ygain_zoom(.3)
timer = QtCore.QTimer(interval=1000, singleShot=True)
timer.timeout.connect(ajust_yrange)
timer.start()
def terminate():
dev.stop()
oscope.stop()
peeler.stop()
tviewer.stop()
app.quit()
app.exec_()
def _start(self, **kargs):
QOscilloscope._start(self, **kargs)
self._last_peak = 0
self.poller_peak.start()
def test_OnlinePeeler():
dataio = DataIO(dirname='test_onlinepeeler')
catalogueconstructor = CatalogueConstructor(dataio=dataio)
catalogue = catalogueconstructor.load_catalogue()
#~ print(catalogue)
sigs = dataio.datasource.array_sources[0]
sigs = sigs.astype('float32')
sample_rate = dataio.sample_rate
in_group_channels = dataio.channel_groups[0]['channels']
#~ print(channel_group)
chunksize = 1024
# Device node
#~ man = create_manager(auto_close_at_exit=True)
#~ ng0 = man.create_nodegroup()
ng0 = None
dev = make_pyacq_device_from_buffer(sigs, sample_rate, nodegroup=ng0, chunksize=chunksize)
app = pg.mkQApp()
dev.start()
# Node QOscilloscope
oscope = QOscilloscope()
oscope.configure(with_user_dialog=True)
oscope.input.connect(dev.output)
oscope.initialize()
oscope.show()
oscope.start()
oscope.params['decimation_method'] = 'min_max'
oscope.params['mode'] = 'scan'
# Node Peeler
peeler = OnlinePeeler()
peeler.configure(catalogue=catalogue, in_group_channels=in_group_channels, chunksize=chunksize)
peeler.input.connect(dev.output)
stream_params = dict(protocol='tcp', interface='127.0.0.1', transfermode='plaindata')
peeler.outputs['signals'].configure(**stream_params)
peeler.outputs['spikes'].configure(**stream_params)
peeler.initialize()
peeler.start()
# Node traceviewer
tviewer = OnlineTraceViewer()
tviewer.configure(peak_buffer_size = 1000, catalogue=catalogue)
tviewer.inputs['signals'].connect(peeler.outputs['signals'])
tviewer.inputs['spikes'].connect(peeler.outputs['spikes'])
tviewer.initialize()
tviewer.show()
tviewer.start()
tviewer.params['xsize'] = 3.
tviewer.params['decimation_method'] = 'min_max'
tviewer.params['mode'] = 'scan'
#~ tviewer.params['mode'] = 'scroll'
tviewer.auto_gain_and_offset(mode=1)
#~ tviewer.gain_zoom(.3)
tviewer.gain_zoom(.1)
def terminate():
dev.stop()
oscope.stop()
peeler.stop()
tviewer.stop()
app.quit()
app.exec_()
def _close(self, **kargs):
QOscilloscope._close(self, **kargs)
def test_measurementcomputing_USB1608_FS_PLUS():
app = pg.mkQApp()
dev = MeasurementComputing()
ai_channel_index = None
#ai_channel_index = [0, 2, 3, 4 ]
#ai_channel_index = [0, 1, 2, 3 ]
ai_ranges = (-10, 10)
ai_mode = None
dev.configure(board_num=0,
sample_rate=1000,
ai_channel_index=ai_channel_index,
ai_ranges=ai_ranges,
ai_mode=ai_mode)
dev.outputs['aichannels'].configure(protocol='tcp',
interface='127.0.0.1',
transfertmode='plaindata')
dev.initialize()
#~ viewer = ReceiverWidget()
#~ viewer.configure()
#~ viewer.input.connect(dev.outputs['ai_channel_index'])
#~ viewer.initialize()
viewer = QOscilloscope()
viewer.configure(with_user_dialog=True)
viewer.input.connect(dev.outputs['aichannels'])
viewer.initialize()
viewer.params['scale_mode'] = 'by_channel'
viewer.params['xsize'] = 5
viewer.params['refresh_interval'] = 100
dev.start()
viewer.start()
viewer.show()
def terminate():
viewer0.stop()
viewer1.stop()
dev.stop()
viewer0.close()
viewer1.close()
dev.close()
app.quit()
# start for a while
timer = QtCore.QTimer(singleShot=True, interval=10000)
timer.timeout.connect(terminate)
#~ timer.start()
app.exec_()
def _configure(self, peak_buffer_size=100000, catalogue=None, **kargs):
QOscilloscope._configure(self, **kargs)
self.peak_buffer_size = peak_buffer_size
self.catalogue = catalogue
assert catalogue is not None
def test_measurementcomputing_USB1608_FS_PLUS():
app = pg.mkQApp()
dev = MeasurementComputing()
ai_channel_index = None
#ai_channel_index = [0, 2, 3, 4 ]
#ai_channel_index = [0, 1, 2, 3 ]
ai_ranges = (-10, 10)
ai_mode = None
dev.configure(board_num=0, sample_rate=1000, ai_channel_index=ai_channel_index, ai_ranges=ai_ranges, ai_mode=ai_mode)
dev.outputs['aichannels'].configure(protocol='tcp', interface='127.0.0.1', transfertmode='plaindata')
dev.initialize()
#~ viewer = ReceiverWidget()
#~ viewer.configure()
#~ viewer.input.connect(dev.outputs['ai_channel_index'])
#~ viewer.initialize()
viewer = QOscilloscope()
viewer.configure(with_user_dialog=True)
viewer.input.connect(dev.outputs['aichannels'])
viewer.initialize()
viewer.params['scale_mode'] = 'by_channel'
viewer.params['xsize'] = 5
viewer.params['refresh_interval'] = 100
dev.start()
viewer.start()
viewer.show()
def terminate():
viewer0.stop()
viewer1.stop()
dev.stop()
viewer0.close()
viewer1.close()
dev.close()
app.quit()
# start for a while
timer = QtCore.QTimer(singleShot = True, interval = 10000)
timer.timeout.connect(terminate)
#~ timer.start()
app.exec_()
def test_OnlinePeeler_no_catalogue():
localdir, filenames, params = download_dataset(name='olfactory_bulb')
filename = filenames[0] #only first file
#~ print(params)
sigs = np.fromfile(filename,
dtype=params['dtype']).reshape(-1,
params['total_channel'])
sigs = sigs.astype('float32')
sample_rate = params['sample_rate']
#~ dataio.set_data_source(type='RawData', filenames=filenames, **params)
#~ channel_group = {0:{'channels':[5, 6, 7, 8]}}
#~ dataio.set_channel_groups(channel_group)
#~ print(filenames)
#~ print(sigs.shape)
#~ exit()
channel_indexes = [5, 6, 7, 8]
chunksize = 1024
#case 1 before medians estimation
#~ empty_catalogue = make_empty_catalogue(
#~ channel_indexes=channel_indexes,
#~ n_left=-20, n_right=40, internal_dtype='float32',
#~ peak_detector_params={'relative_threshold': np.inf},
#~ signals_medians = None,
#~ signals_mads = None,
#~ )
#case 2 after medians estimation
preprocessor_params = {}
signals_medians, signals_mads = estimate_medians_mads_after_preprocesing(
sigs[:, channel_indexes],
sample_rate,
preprocessor_params=preprocessor_params)
empty_catalogue = make_empty_catalogue(
channel_indexes=channel_indexes,
n_left=-20,
n_right=40,
internal_dtype='float32',
preprocessor_params=preprocessor_params,
peak_detector_params={'relative_threshold': 10},
clean_waveforms_params={},
signals_medians=signals_medians,
signals_mads=signals_mads,
)
print(empty_catalogue)
#~ print(empty_catalogue['signal_preprocessor_params'])
#~ exit()
#~ in_group_channels = dataio.channel_groups[0]['channels']
#~ print(channel_group)
chunksize = 1024
# Device node
#~ man = create_manager(auto_close_at_exit=True)
#~ ng0 = man.create_nodegroup()
ng0 = None
dev = make_pyacq_device_from_buffer(sigs,
sample_rate,
nodegroup=ng0,
chunksize=chunksize)
#~ exit()
app = pg.mkQApp()
dev.start()
# Node QOscilloscope
oscope = QOscilloscope()
oscope.configure(with_user_dialog=True)
oscope.input.connect(dev.output)
oscope.initialize()
oscope.show()
oscope.start()
oscope.params['decimation_method'] = 'min_max'
oscope.params['mode'] = 'scan'
oscope.params['scale_mode'] = 'by_channel'
# Node Peeler
peeler = OnlinePeeler()
peeler.configure(catalogue=empty_catalogue,
in_group_channels=channel_indexes,
chunksize=chunksize)
peeler.input.connect(dev.output)
stream_params = dict(protocol='tcp',
interface='127.0.0.1',
transfermode='plaindata')
peeler.outputs['signals'].configure(**stream_params)
peeler.outputs['spikes'].configure(**stream_params)
peeler.initialize()
peeler.start()
# Node traceviewer
tviewer = OnlineTraceViewer()
tviewer.configure(peak_buffer_size=1000, catalogue=empty_catalogue)
tviewer.inputs['signals'].connect(peeler.outputs['signals'])
tviewer.inputs['spikes'].connect(peeler.outputs['spikes'])
tviewer.initialize()
tviewer.show()
tviewer.params['xsize'] = 3.
tviewer.params['decimation_method'] = 'min_max'
tviewer.params['mode'] = 'scan'
tviewer.params['scale_mode'] = 'same_for_all'
tviewer.start()
# waveform histogram viewer
wviewer = OnlineWaveformHistViewer()
wviewer.configure(peak_buffer_size=1000, catalogue=empty_catalogue)
wviewer.inputs['signals'].connect(peeler.outputs['signals'])
wviewer.inputs['spikes'].connect(peeler.outputs['spikes'])
wviewer.initialize()
wviewer.show()
wviewer.start()
def auto_scale():
oscope.auto_scale()
tviewer.auto_scale()
def terminate():
dev.stop()
oscope.stop()
peeler.stop()
tviewer.stop()
app.quit()
timer = QT.QTimer(singleShot=True, interval=500)
timer.timeout.connect(auto_scale)
timer.start()
if __name__ == '__main__':
app.exec_()
def _start(self, **kargs):
QOscilloscope._start(self, **kargs)
self._last_peak = 0
self.poller_peak.start()
dev.configure(sample_rate=sr,
chunksize=1000,
aichannels=aichannels,
aimodes = {'Dev1/ai0':'rse', 'Dev1/ai1': 'rse'},
airanges= (-5., 5.),#for all channels
magnitude_mode='float32_volt',
aochannels=aochannels,
)
dev.outputs['aichannels'].configure(protocol='tcp', interface='127.0.0.1', transfertmode='plaindata')
dev.initialize()
# Create an oscilloscope to display data.
viewer = QOscilloscope()
viewer.configure(with_user_dialog = True)
# Connect audio stream to oscilloscope
viewer.input.connect(dev.output)
viewer.initialize()
viewer.show()
viewer.params['decimation_method'] = 'min_max'
viewer.params['ylim_max'] = 5.
viewer.params['ylim_min'] = -5.
viewer.params['mode'] = 'scan'
# Start both nodes
dev.start()
viewer.start()
def test_measurementcomputing_USB2533():
app = pg.mkQApp()
dev = MeasurementComputing()
# ai_channel_index = None
ai_channel_index = [
0,
10,
47,
]
ai_ranges = (-10, 10)
#~ ai_ranges = (-5, 5)
#~ ai_ranges = (-1, 1)
ai_mode = 'single-ended'
#~ ai_mode = 'differential' # this should bug whith channel>32
dev.configure(board_num=0,
sample_rate=10000.,
ai_channel_index=ai_channel_index,
ai_ranges=ai_ranges,
ai_mode=ai_mode)
dev.outputs['aichannels'].configure(protocol='tcp',
interface='127.0.0.1',
transfertmode='plaindata')
dev.outputs['dichannels'].configure(protocol='tcp',
interface='127.0.0.1',
transfertmode='plaindata')
dev.initialize()
viewer0 = QOscilloscope()
viewer0.configure()
viewer0.input.connect(dev.outputs['aichannels'])
viewer0.initialize()
viewer0.params['scale_mode'] = 'real_scale'
viewer0.params['xsize'] = 5
viewer0.params['ylim_min'] = -1.5
viewer0.params['ylim_max'] = 1.5
viewer0.params['refresh_interval'] = 100
viewer0.params['show_left_axis'] = True
viewer1 = QDigitalOscilloscope()
viewer1.configure()
viewer1.input.connect(dev.outputs['dichannels'])
viewer1.initialize()
dev.start()
viewer0.start()
viewer0.show()
viewer1.start()
viewer1.show()
def terminate():
viewer0.stop()
viewer1.stop()
dev.stop()
viewer0.close()
viewer1.close()
dev.close()
app.quit()
# start for a while
timer = QtCore.QTimer(singleShot=True, interval=10000)
timer.timeout.connect(terminate)
#~ timer.start()
app.exec_()
