def test_decode_stalled():
a = np.array( [0x04, # 0 sample (chan 0), framecount coming
], dtype=np.uint16)
result = cDecode.process( a )
(N,samples,channels,did_overflow,framestamp)=result
assert N==0
assert len(samples)==0
assert len(channels)==0
assert did_overflow==0
assert framestamp is None
def test_decode1():
a = np.array( [0x00, # 0 sample (chan 0)
0x04, # 0 sample (chan 0), framecount coming
0x01, # framecount word 1
0x00, # framecount word 2
0x00, # framecount word 3
0x00, # framecount word 4
0x02, # tcnt word
0x00, # 0 sample (chan 0)
], dtype=np.uint16)
result = cDecode.process( a )
(N,samples,channels,did_overflow,framestamp)=result
assert N==7
expected_samples = np.array([0,0],dtype=np.uint16)
expected_channels = np.array([0,0],dtype=np.uint8)
assert np.allclose(samples,expected_samples)
assert samples.shape==expected_samples.shape
assert samples.dtype==expected_samples.dtype
assert np.allclose(channels,expected_channels)
assert channels.shape==expected_channels.shape
assert channels.dtype==expected_channels.dtype
def update_analog_input(self):
"""call this function frequently to avoid overruns"""
new_data_raw = self._trigger_device.get_analog_input_buffer_rawLE()
self.ain_raw_word_queue.put( new_data_raw )
data_raw = np.hstack((new_data_raw,self.old_data_raw))
newdata_all = []
chan_all = []
any_overflow = False
#cum_framestamps = []
while len(data_raw):
result = cDecode.process( data_raw )
(N,samples,channels,did_overflow,framestamp)=result
if N==0:
# no data was able to be processed
break
data_raw = data_raw[N:]
newdata_all.append( samples )
chan_all.append( channels )
if did_overflow:
any_overflow = True
# Save framestamp data.
# This is not done yet:
## if framestamp is not None:
## cum_framestamps.append( framestamp )
self.old_data_raw = data_raw # save unprocessed data for next run
if any_overflow:
# XXX should move to logging the error.
raise AnalogDataOverflowedError()
if len(chan_all)==0:
# no data
return
chan_all=np.hstack(chan_all)
newdata_all=np.hstack(newdata_all)
USB_channel_numbers = np.unique(chan_all)
#print len(newdata_all),'new samples on channels',USB_channel_numbers
## F_OSC = 8000000.0 # 8 MHz
## adc_prescaler = 128
## downsample = 20 # maybe 21?
## n_chan = 3
## F_samp = F_OSC/adc_prescaler/downsample/n_chan
## dt=1.0/F_samp
## ## print '%.1f Hz sampling. %.3f msec dt'%(F_samp,dt*1e3)
## MAXLEN_SEC=0.3
## #MAXLEN = int(MAXLEN_SEC/dt)
MAXLEN = 5000 #int(MAXLEN_SEC/dt)
## ## print 'MAXLEN',MAXLEN
## ## print
for USB_chan in USB_channel_numbers:
vi=self.viewer.usb_device_number2index[USB_chan]
cond = chan_all==USB_chan
newdata = newdata_all[cond]
oldidx = self.viewer.channels[vi].index
olddata = self.viewer.channels[vi].data
if len(oldidx):
baseidx = oldidx[-1]+1
else:
baseidx = 0.0
newidx = np.arange(len(newdata),dtype=np.float)+baseidx
tmpidx = np.hstack( (oldidx,newidx) )
tmpdata = np.hstack( (olddata,newdata) )
if len(tmpidx) > MAXLEN:
# clip to MAXLEN
self.viewer.channels[vi].index = tmpidx[-MAXLEN:]
self.viewer.channels[vi].data = tmpdata[-MAXLEN:]
else:
self.viewer.channels[vi].index = tmpidx
self.viewer.channels[vi].data = tmpdata
def easy_decode(data_raw, gain, offset, top):
"""decode output of CamTrig device
**Arguments**
data_raw : array of uint16
The raw data from the device
gain : float
The gain of the CamTrig device's clock relative to host clock
offset : float
The offset of the CamTrig device's clock relative to host clock
top : int
The maximum timer value on CamTrig
**Returns**
r : recarray
The decoded results
"""
newdata_all = []
chan_all = []
any_overflow = False
cum_timestamps = []
timestamp_idxs = []
current_index = 0
prevdata = None
prevchan = None
# Decode all data in this loop
while len(data_raw):
result = cDecode.process(data_raw)
(N, samples, channels, did_overflow, framestamp) = result
if N == 0:
# no data was able to be processed
print 'no data break'
break
data_raw = data_raw[N:]
newdata_all.append(samples)
chan_all.append(channels)
current_index += len(samples)
if framestamp is not None:
frame, tcnt = framestamp
f = frame + float(tcnt) / float(top)
cum_timestamps.append(f * gain + offset)
timestamp_idxs.append(current_index - 1) # index of last sample
if did_overflow:
any_overflow = True
if not len(newdata_all):
return None
newdata_all = np.hstack(newdata_all)
chan_all = np.hstack(chan_all)
# Now sanitize the results
cum_timestamps = np.array(cum_timestamps)
timestamp_idxs = np.array(timestamp_idxs)
# XXX this assumes that no samples are missing... do piecewise if not true.
gain2, offset2, resids2 = get_gain_offset_resids(input=timestamp_idxs,
output=cum_timestamps)
timestamps_all = np.arange(len(newdata_all)) * gain2 + offset2
USB_channels = np.unique(chan_all).tolist()
USB_channels.sort()
arrays = []
names = []
shortest = np.inf
timestamps = None
for chan in USB_channels:
cond = chan_all == chan
if timestamps is None:
# Ignore the minute timestamp differences between channels
timestamps = timestamps_all[cond]
this_data = newdata_all[cond]
shortest = min(shortest, len(this_data))
arrays.append(this_data)
names.append(str(chan))
arrays.append(timestamps)
names.append('timestamps')
for i in range(len(arrays)):
if len(arrays[i]) > shortest:
arrays[i] = arrays[i][:shortest] # trim all to same length
r = np.core.records.fromarrays(arrays, names=names)
return r
def easy_decode(data_raw, gain, offset, top):
"""decode output of CamTrig device
**Arguments**
data_raw : array of uint16
The raw data from the device
gain : float
The gain of the CamTrig device's clock relative to host clock
offset : float
The offset of the CamTrig device's clock relative to host clock
top : int
The maximum timer value on CamTrig
**Returns**
r : recarray
The decoded results
"""
newdata_all = []
chan_all = []
any_overflow = False
cum_timestamps = []
timestamp_idxs = []
current_index = 0
prevdata = None
prevchan = None
# Decode all data in this loop
while len(data_raw):
result = cDecode.process(data_raw)
(N, samples, channels, did_overflow, framestamp) = result
if N == 0:
# no data was able to be processed
print "no data break"
break
data_raw = data_raw[N:]
newdata_all.append(samples)
chan_all.append(channels)
current_index += len(samples)
if framestamp is not None:
frame, tcnt = framestamp
f = frame + float(tcnt) / float(top)
cum_timestamps.append(f * gain + offset)
timestamp_idxs.append(current_index - 1) # index of last sample
if did_overflow:
any_overflow = True
if not len(newdata_all):
return None
newdata_all = np.hstack(newdata_all)
chan_all = np.hstack(chan_all)
# Now sanitize the results
cum_timestamps = np.array(cum_timestamps)
timestamp_idxs = np.array(timestamp_idxs)
# XXX this assumes that no samples are missing... do piecewise if not true.
gain2, offset2, resids2 = get_gain_offset_resids(input=timestamp_idxs, output=cum_timestamps)
timestamps_all = np.arange(len(newdata_all)) * gain2 + offset2
USB_channels = np.unique(chan_all).tolist()
USB_channels.sort()
arrays = []
names = []
shortest = np.inf
timestamps = None
for chan in USB_channels:
cond = chan_all == chan
if timestamps is None:
# Ignore the minute timestamp differences between channels
timestamps = timestamps_all[cond]
this_data = newdata_all[cond]
shortest = min(shortest, len(this_data))
arrays.append(this_data)
names.append(str(chan))
arrays.append(timestamps)
names.append("timestamps")
for i in range(len(arrays)):
if len(arrays[i]) > shortest:
arrays[i] = arrays[i][:shortest] # trim all to same length
r = np.core.records.fromarrays(arrays, names=names)
return r
def update_analog_input(self):
"""call this function frequently to avoid overruns"""
new_data_raw = self._trigger_device.get_analog_input_buffer_rawLE()
data_raw = np.hstack((new_data_raw, self.old_data_raw))
self.ain_data_raw = new_data_raw
newdata_all = []
chan_all = []
any_overflow = False
#cum_framestamps = []
while len(data_raw):
result = cDecode.process(data_raw)
(N, samples, channels, did_overflow, framestamp) = result
if N == 0:
# no data was able to be processed
break
data_raw = data_raw[N:]
newdata_all.append(samples)
chan_all.append(channels)
if did_overflow:
any_overflow = True
# Save framestamp data.
# This is not done yet:
## if framestamp is not None:
## cum_framestamps.append( framestamp )
self.old_data_raw = data_raw # save unprocessed data for next run
if any_overflow:
# XXX should move to logging the error.
self.ain_overflowed = 1
raise AnalogDataOverflowedError()
if len(chan_all) == 0:
# no data
return
chan_all = np.hstack(chan_all)
newdata_all = np.hstack(newdata_all)
USB_channel_numbers = np.unique(chan_all)
#print len(newdata_all),'new samples on channels',USB_channel_numbers
## F_OSC = 8000000.0 # 8 MHz
## adc_prescaler = 128
## downsample = 20 # maybe 21?
## n_chan = 3
## F_samp = F_OSC/adc_prescaler/downsample/n_chan
## dt=1.0/F_samp
## ## print '%.1f Hz sampling. %.3f msec dt'%(F_samp,dt*1e3)
## MAXLEN_SEC=0.3
## #MAXLEN = int(MAXLEN_SEC/dt)
MAXLEN = 5000 #int(MAXLEN_SEC/dt)
## ## print 'MAXLEN',MAXLEN
## ## print
for USB_chan in USB_channel_numbers:
vi = self.viewer.usb_device_number2index[USB_chan]
cond = chan_all == USB_chan
newdata = newdata_all[cond]
oldidx = self.viewer.channels[vi].index
olddata = self.viewer.channels[vi].data
if len(oldidx):
baseidx = oldidx[-1] + 1
else:
baseidx = 0.0
newidx = np.arange(len(newdata), dtype=np.float) + baseidx
tmpidx = np.hstack((oldidx, newidx))
tmpdata = np.hstack((olddata, newdata))
if len(tmpidx) > MAXLEN:
# clip to MAXLEN
self.viewer.channels[vi].index = tmpidx[-MAXLEN:]
self.viewer.channels[vi].data = tmpdata[-MAXLEN:]
else:
self.viewer.channels[vi].index = tmpidx
self.viewer.channels[vi].data = tmpdata