def defaultSetting(self):
self.status["getTimebase2"] = ps.ps5000aGetTimebase2(self.chandle, \
self.timebase, self.maxSamples, byref(self.timeInternalns),\
None, 0)
assert_pico_ok(self.status["getTimebase2"])
self.chs['A'].coupling_type = ps.PS5000A_COUPLING["PS5000A_AC"]
self.chs['A'].range = ps.PS5000A_RANGE["PS5000A_50MV"]
self.status["setChA"] = self.chs['A'].Enable()
assert_pico_ok(self.status["setChA"])
self.chs['B'].coupling_type = ps.PS5000A_COUPLING["PS5000A_AC"]
self.chs['B'].range = ps.PS5000A_RANGE["PS5000A_50MV"]
self.status["setChB"] = self.chs['B'].Enable()
assert_pico_ok(self.status["setChB"])
self.chs['C'].coupling_type = ps.PS5000A_COUPLING["PS5000A_AC"]
self.chs['C'].range = ps.PS5000A_RANGE["PS5000A_50MV"]
self.status["setChC"] = self.chs['C'].Enable()
assert_pico_ok(self.status["setChC"])
self.chs['D'].coupling_type = ps.PS5000A_COUPLING["PS5000A_AC"]
self.chs['D'].range = ps.PS5000A_RANGE["PS5000A_50MV"]
self.status["setChD"] = self.chs['D'].Enable()
assert_pico_ok(self.status["setChD"])
def configurePSD(self, binWidth, spectrumRange, nTimes=None):
spectrumRange = spectrumRange * 2
requiredSamplingInterval = 1 / spectrumRange
requiredMeasureTime = 1 / binWidth
self.maxSamples = ceil(requiredMeasureTime / requiredSamplingInterval)
self.timebase = floor(requiredSamplingInterval * 125000000 + 2) #14bit
#self.timebase = floor(requiredSamplingInterval * 62500000 + 3) #16bit
self.status["getTimebase2"] = ps.ps5000aGetTimebase2(self.chandle, \
self.timebase, self.maxSamples, byref(self.timeInternalns),\
None, 0)
assert_pico_ok(self.status["getTimebase2"])
self.maxSamples = ceil(requiredMeasureTime * 1e9 /
self.timeInternalns.value)
assert self.timeInternalns.value <= requiredSamplingInterval * 1e9
if bool(nTimes):
nMaxSamples = c_long()
ps.ps5000aMemorySegments(self.chandle, 1, byref(nMaxSamples))
print(nMaxSamples)
nMaxSamples.value = math.floor(nMaxSamples.value /
self.nEnabledChannels())
if nTimes == 'Max':
nTimes = math.floor(nMaxSamples.value / (self.maxSamples)) - 25
print(nTimes, self.maxSamples)
assert self.maxSamples * nTimes < nMaxSamples.value
self.maxSamples = nTimes * self.maxSamples
return nTimes, int(self.maxSamples / nTimes)
def getTimebase(self):
self.status["GetTimebase"] = ps.ps5000aGetTimebase2(
self.chandle, self.timebase, self.maxsamples,
ctypes.byref(self.timeIntervalns),
ctypes.byref(self.returnedMaxSamples), 0)
assert_pico_ok(self.status["GetTimebase"])
print("Picoscope sampling interval:" + str(self.timeIntervalns.value) +
" ns")
def set_timewindow(self, Samples, Timebase):
# Get timebase information
# handle = self.chandle
# noSamples = maxSamples
# pointer to timeIntervalNanoseconds = ctypes.byref(timeIntervalns)
# pointer to maxSamples = ctypes.byref(returnedMaxSamples)
# segment index = 0
self.timeIntervalns = ctypes.c_float()
returnedMaxSamples = ctypes.c_int32() # bits used to store data in this timebase?
self.status["getTimebase2"] = ps.ps5000aGetTimebase2(self.chandle, Timebase, Samples, ctypes.byref(self.timeIntervalns), ctypes.byref(returnedMaxSamples), 0) # segmentIndex = 0, used for segmented memory
def setTimebase(self, tb):
self.timebase = tb #value * 10 ns (i.e. 8 == 80ns), depends on resolution
self.timeIntervalns = ctypes.c_float()
returnedMaxSamples = ctypes.c_int32(
) #TODO: maybe need to keep this and check it later somewhere?
segment_index = 0 #???
self.status["getTimebase2"] = ps.ps5000aGetTimebase2(
self.chandle, self.timebase, self.totalSamples,
ctypes.byref(self.timeIntervalns),
ctypes.byref(returnedMaxSamples), segment_index)
assert_pico_ok(self.status["getTimebase2"])
def get_interval_from_timebase(self, timebase, num_samples=1000):
"""Get sampling interval for given timebase.
:param timebase: timebase setting (see programmers guide for reference)
:param num_samples: number of samples required
:returns: sampling interval in nanoseconds
"""
interval = ctypes.c_float()
assert_pico_ok(
ps.ps5000aGetTimebase2(self._handle, timebase, num_samples,
ctypes.byref(interval), None, 0))
return interval.value
def set_timeBase(self,**kwargs):
'''
sets the timebase options. Several options are available:
- directly set the timebase (0 up 2**32-1, machine option)
- set the sampling rate
- set the time interval between samples
arguments: none
keyword arguments (defaults in self.settings):
timebase: the timebase to use (not recommended),
noSamples: the desired number of samples (the actual number of samples may differ),
segmentIndex: scope memory segment to store the run result,
***
sampleRate: the desired sample rate (in samples/s) (the actual sample rate may differ),
--or--
timeIntervalSeconds: the desired time interval between samples (in s) (the actual time interval rate may differ),
***
after successfully setting the trigger, self.settings is updated and contains:
sampleRate: the actual sample rate (in samples/s),
timeIntervalSeconds: the actual time interval between samples (in s),
'''
#handles default values
settings = {}
for key,current_value in self.settings.items():
settings[key] = kwargs[key] if key in kwargs else current_value
#overwrites the timebase with either timeIntervalNanoseconds or sampleRate
#if these two parameters are provided, the conflict is raised
assert not ('sampleRate' in kwargs and 'timeIntervalSeconds' in kwargs)
if 'sampleRate' in kwargs:
value = kwargs['sampleRate']
settings['timebase'] = helper_functions.dichotomic_search(sample_rate[self.resolution],self._minTimeBase,2**32-1,f0=value,tol=1,growing=False)
if 'timeIntervalSeconds' in kwargs:
value = kwargs['timeIntervalSeconds']
settings['timebase'] = helper_functions.dichotomic_search(lambda x: 1./sample_rate[self.resolution](x),self._minTimeBase,2**32-1,f0=value,tol=1,growing=True)
assert type(settings['timebase']) is int, 'timeBase must be an int, use sampleRate or timeIntervalSeconds for convenient setting'
assert settings['timebase'] >= self._minTimeBase and settings['timebase']<2**32
_timebase = settings['timebase']
_noSamples = int(settings['noSamples'])
_timeIntervalNanoseconds = ctypes.c_float()
_maxSamples = ctypes.c_int32()
_segmentIndex = ctypes.c_uint32(settings['segmentIndex'])
self.status["getTimebase2"] = ps.ps5000aGetTimebase2(self.chandle,
_timebase, _noSamples,
ctypes.byref(_timeIntervalNanoseconds),
ctypes.byref(_maxSamples), _segmentIndex)
assert_pico_ok(self.status["getTimebase2"])
settings['timeIntervalSeconds'] = 1e-9*_timeIntervalNanoseconds.value
settings['maxSamples'] = _maxSamples.value
self.settings = settings
def setSamplingParameters(self,
preTrigger_ns,
postTrigger_ns,
timebase=0,
samplingFrequency_kHz=0):
timeInterval_ns = ctypes.c_float()
maxSamples = ctypes.c_int32()
# The timebase is set to 0 by default in order to find the maximum sampling frequency.
# To sample at a lower sampling frequency, it must be specified by the user with the timebase parameter.
# Information on the timebase parameters (depending on various other parameters) can be found in the API doc.
self.timebase = timebase
# if(samplingFrequency_kHz==0):
timebase_invalid = True
while timebase_invalid:
self.status['getTimebase2'] = ps.ps5000aGetTimebase2(
self.chandle, self.timebase, 0, ctypes.byref(timeInterval_ns),
ctypes.byref(maxSamples), 0)
timebase_invalid = self.status['getTimebase2'] == PICO_STATUS[
'PICO_INVALID_TIMEBASE']
if timebase_invalid:
self.timebase += 1
# else:
# # TODO
# print('CUSTOM SAMPLING FREQUENCY NOT YET SUPPORTED')
# return -1
self.preTrigger_ns = preTrigger_ns
self.postTrigger_ns = postTrigger_ns
self.maxSamples = maxSamples.value
self.samplingPeriod_ns = timeInterval_ns.value
self.samplingFrequency_kHz = 1 / self.samplingPeriod_ns * 10**6
self.noSamples = round((self.preTrigger_ns + self.postTrigger_ns) /
self.samplingPeriod_ns)
self.preTrigger_samples = round(
self.noSamples * self.preTrigger_ns /
(self.preTrigger_ns + self.postTrigger_ns))
self.postTrigger_samples = self.noSamples - self.preTrigger_samples
if (self.noSamples > self.maxSamples):
print('TOO MANY SAMPLES')
return -1
else:
return 0
def setTimebase(self, index):
self.clearDatabuffers()
for jindex in range(0, self.numberOfChannels):
self.setDatabuffer(jindex)
# Get timebase information
# handle = chandle
self.timebase = index
# noSamples = maxSamples
# pointer to timeIntervalNanoseconds = ctypes.byref(timeIntervalns)
# pointer to maxSamples = ctypes.byref(returnedMaxSamples)
# segment index = 0
self.timeIntervalns = ctypes.c_float()
self.returnedMaxSamples = ctypes.c_int32()
self.status["getTimebase2"] = ps.ps5000aGetTimebase2(
self.chandle, self.timebase, self.maxSamples,
ctypes.byref(self.timeIntervalns),
ctypes.byref(self.returnedMaxSamples), 0)
assert_pico_ok(self.status["getTimebase2"])
def setSamplingParameters(self,
preTrigger_ns,
postTrigger_ns,
samplingFrequency_kHz=0):
timeInterval_ns = ctypes.c_float()
maxSamples = ctypes.c_int32()
if (samplingFrequency_kHz == 0):
timebase_invalid = True
while timebase_invalid:
self.status['getTimebase2'] = ps.ps5000aGetTimebase2(
self.chandle, self.timebase, 0,
ctypes.byref(timeInterval_ns), ctypes.byref(maxSamples), 0)
timebase_invalid = self.status['getTimebase2'] == PICO_STATUS[
'PICO_INVALID_TIMEBASE']
if timebase_invalid:
self.timebase += 1
else:
# TODO
print('CUSTOM SAMPLING FREQUENCY NOT YET SUPPORTED')
return -1
self.preTrigger_ns = preTrigger_ns
self.postTrigger_ns = postTrigger_ns
self.maxSamples = maxSamples.value
self.samplingPeriod_ns = timeInterval_ns.value
self.samplingFrequency_kHz = 1 / self.samplingPeriod_ns * 10**6
self.noSamples = round((self.preTrigger_ns + self.postTrigger_ns) /
self.samplingPeriod_ns)
self.preTrigger_samples = round(
self.noSamples * self.preTrigger_ns /
(self.preTrigger_ns + self.postTrigger_ns))
self.postTrigger_samples = self.noSamples - self.preTrigger_samples
if (self.noSamples > self.maxSamples):
print('TOO MANY SAMPLES')
return -1
else:
return 0
postTriggerSamples = 2500
totalSamples = preTriggerSamples + postTriggerSamples
# Gets timebase information
# handle = chandle
# timebase = 1252
# Nosample = totalSamples
# TimeIntervalNanoseconds = ctypes.byref(timeIntervalNs)
# MaxSamples = ctypes.byref(returnedMaxSamples)
# Segement index = 0
timebase = 1252
timeIntervalNs = ctypes.c_float()
returnedMaxSamples = ctypes.c_int16()
status["GetTimebase"] = ps.ps5000aGetTimebase2(chandle,
timebase,
totalSamples,
ctypes.byref(timeIntervalNs),
ctypes.byref(returnedMaxSamples),
0)
assert_pico_ok(status["GetTimebase"])
# Create buffers ready for assigning pointers for data collection
bufferDPort0Max = (ctypes.c_int16 * totalSamples)()
bufferDPort0Min = (ctypes.c_int16 * totalSamples)()
# Set the data buffer location for data collection from ps5000a_DIGITAL_PORT0
# handle = chandle
# source = ps5000a_DIGITAL_PORT0 = 0x80
# Buffer max = ctypes.byref(bufferDPort0Max)
# Buffer min = ctypes.byref(bufferDPort0Min)
# Buffer length = totalSamples
# Segment index = 0
# Set number of pre and post trigger samples to be collected
preTriggerSamples = 2500
postTriggerSamples = 2500
maxSamples = preTriggerSamples + postTriggerSamples
# Get timebase information
# handle = chandle
timebase = 8
# noSamples = maxSamples
# pointer to timeIntervalNanoseconds = ctypes.byref(timeIntervalns)
# pointer to maxSamples = ctypes.byref(returnedMaxSamples)
# segment index = 0
timeIntervalns = ctypes.c_float()
returnedMaxSamples = ctypes.c_int32()
status["getTimebase2"] = ps.ps5000aGetTimebase2(
chandle, timebase, maxSamples, ctypes.byref(timeIntervalns),
ctypes.byref(returnedMaxSamples), 0)
assert_pico_ok(status["getTimebase2"])
# Run block capture
# handle = chandle
# number of pre-trigger samples = preTriggerSamples
# number of post-trigger samples = PostTriggerSamples
# timebase = 8 = 80 ns (see Programmer's guide for mre information on timebases)
# time indisposed ms = None (not needed in the example)
# segment index = 0
# lpReady = None (using ps5000aIsReady rather than ps5000aBlockReady)
# pParameter = None
status["runBlock"] = ps.ps5000aRunBlock(chandle, preTriggerSamples,
postTriggerSamples, timebase, None, 0,
None, None)
def readAmplitude(binWidth, spectrumRange, checkRange, nmbOfAvg):
spectrumRange = spectrumRange * 2
requiredMeasureTime = 2 / binWidth
requiredSamplingInterval = 1 / spectrumRange
timebase = floor(requiredSamplingInterval * 62500000 + 3)
timeInternalns = c_float()
returnedMaxSamples = c_int32()
maxSamples = ceil(spectrumRange / binWidth)
status["getTimebase2"] = ps.ps5000aGetTimebase2(chandle, timebase,
maxSamples,
byref(timeInternalns),
byref(returnedMaxSamples),
0)
assert_pico_ok(status["getTimebase2"])
assert timeInternalns.value < requiredSamplingInterval * 1e9
for i in range(nmbOfAvg):
preTriggerSamples = 100
status["runBlock"] = ps.ps5000aRunBlock(chandle, preTriggerSamples,
maxSamples, timebase, None, 0,
None, None)
assert_pico_ok(status["runBlock"])
ready = c_int16(0)
check = c_int16(0)
while ready.value == check.value:
status["isReady"] = ps.ps5000aIsReady(chandle, byref(ready))
bufferA = (c_int16 * maxSamples)()
source = ps.PS5000A_CHANNEL["PS5000A_CHANNEL_A"]
status["setDataBufferA"] = ps.ps5000aSetDataBuffer(
chandle, source, byref(bufferA), maxSamples, 0, 0)
assert_pico_ok(status["setDataBufferA"])
overflow = c_int16()
cmaxSamples = c_uint32(maxSamples)
status["getValues"] = ps.ps5000aGetValues(chandle, 0,
byref(cmaxSamples), 0, 0, 0,
byref(overflow))
assert_pico_ok(status["getValues"])
maxADC = c_int16()
status["maximumValue"] = ps.ps5000aMaximumValue(chandle, byref(maxADC))
assert_pico_ok(status["maximumValue"])
timeSignal = adc2mV(bufferA, chARange, maxADC)
f, newPSD = signal.periodogram(timeSignal,
1 / (timeInternalns.value / 1e9),
window=signal.get_window(
'blackman', len(timeSignal)))
startIndex = f.searchsorted(checkRange[0]) - 1
endIndex = f.searchsorted(checkRange[1]) + 1
f = f[startIndex:endIndex]
newPSD = newPSD[startIndex:endIndex]
if i == 0:
PSD = np.array(newPSD)
else:
PSD = PSD + newPSD
PSD = PSD / nmbOfAvg
PSD = 10 * np.log10(10 * PSD)
PSD = PSD - PSD.mean()
Index, _ = find_peaks(PSD, distance=PSD.size)
return PSD[Index]
def getTimeSignal(self,
channel=None,
check=True,
trigger=None,
triggerThreshold=0,
reportOverflow=True):
# get all channel data but only return required
if check:
nMaxSamples = c_long()
ps.ps5000aMemorySegments(self.chandle, 1, byref(nMaxSamples))
nMaxSamples.value = math.floor(nMaxSamples.value /
self.nEnabledChannels())
if self.maxSamples > nMaxSamples.value:
raise Exception("samples will be larger than memory")
self.status["getTimebase2"] = ps.ps5000aGetTimebase2(self.chandle, \
self.timebase, self.maxSamples, byref(self.timeInternalns),\
None, 0)
assert_pico_ok(self.status["getTimebase2"])
if trigger is not None:
source = ps.PS5000A_CHANNEL["PS5000A_CHANNEL_{trigCh}".format(
trigCh=trigger)]
self.status["trigger"] = ps.ps5000aSetSimpleTrigger(
self.chandle, 1, source, triggerThreshold, 2, 0, 0)
assert_pico_ok(self.status["trigger"])
else:
source = ps.PS5000A_CHANNEL["PS5000A_CHANNEL_{trigCh}".format(
trigCh='D')]
self.status["trigger"] = ps.ps5000aSetSimpleTrigger(
self.chandle, 0, source, triggerThreshold, 2, 0, 0)
assert_pico_ok(self.status["trigger"])
preTriggerSamples = 0
self.status["runBlock"] = ps.ps5000aRunBlock(self.chandle, \
preTriggerSamples, self.maxSamples, self.timebase, None, 0, None, None)
assert_pico_ok(self.status["runBlock"])
ready = c_int16(0)
check = c_int16(0)
while ready.value == check.value:
self.status["isReady"] = ps.ps5000aIsReady(self.chandle,
byref(ready))
time.sleep(1e-3)
for key in self.chs:
if self.chs[key].enabled:
self.chs[key].buffer = (c_int16 * self.maxSamples)()
self.status["setDataBuffer"+key] = ps.ps5000aSetDataBuffer(self.chandle, \
self.chs[key].channel, byref(self.chs[key].buffer), self.maxSamples, 0, 0)
assert_pico_ok(self.status["setDataBuffer" + key])
overflow = c_int16()
cmaxSamples = c_uint32(self.maxSamples)
self.status["getValues"] = ps.ps5000aGetValues(self.chandle, 0 , \
byref(cmaxSamples), 0, 0, 0, byref(overflow))
assert_pico_ok(self.status["getValues"])
overflow = '{0:04b}'.format(overflow.value)
chOF = [bool(int(i)) for i in overflow]
self.chs['A'].overflow = chOF[-1]
self.chs['B'].overflow = chOF[-2]
self.chs['C'].overflow = chOF[-3]
self.chs['D'].overflow = chOF[-4]
channels = ['A', 'B', 'C', 'D']
if reportOverflow:
for i in range(4):
if chOF[-(i + 1)]:
print('channel {0} overflow'.format(channels[i]))
maxADC = c_int16()
self.status["maximumValue"] = ps.ps5000aMaximumValue(
self.chandle, byref(maxADC))
assert_pico_ok(self.status["maximumValue"])
for key in self.chs:
if self.chs[key].enabled:
self.chs[key].timeSignal = (np.array(self.chs[key].buffer) / maxADC.value) * \
self.psVoltageRange[self.chs[key].range] * 1e-3
if channel is not None:
return self.chs[channel].timeSignal
