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 runBlock(self,**kwargs):
'''
arms the trigger, block mode is close to repeat (with re-arm) or single mode (without re-arm)
rapid block accumulates several events (similar to fast frame modes on other scopes)
arguments: none
keyword arguments (defaults in self.trigger.settings):
preTrigger: fraction of samples before the trigger occurs (0 to 1)
segmentIndex: scope memory segment to store the run result
after successfully arming the trigger, self.trigger.settings is updated
after triggering, the channel records the noSamples and then stops (until re-arming)
'''
settings = {}
for key,current_value in self.settings.items():
settings[key] = kwargs[key] if key in kwargs else current_value
check_kwargs_scope(**kwargs)
cmaxSamples = ctypes.c_int32(self.scope.settings['noSamples'])
self.status["MemorySegments"] = ps.ps5000aMemorySegments(self.chandle, settings['nSegments'], ctypes.byref(cmaxSamples))
assert_pico_ok(self.status["MemorySegments"])
# sets number of captures
self.status["SetNoOfCaptures"] = ps.ps5000aSetNoOfCaptures(self.chandle, settings['nSegments'])
assert_pico_ok(self.status["SetNoOfCaptures"])
_preTriggerSamples = int(self.scope.settings['noSamples']*settings['preTrigger'])
_postTriggerSamples = self.scope.settings['noSamples'] - _preTriggerSamples
_timebase = self.scope.settings['timebase']
_timeIndisposeMs = ctypes.c_int32()
_segmentIndex = settings['segmentIndex']
#additional callback options here, use isready instead
self.status["runBlock"] = ps.ps5000aRunBlock(self.chandle, _preTriggerSamples, _postTriggerSamples,
_timebase, ctypes.byref(_timeIndisposeMs), _segmentIndex, None, None)
assert_pico_ok(self.status["runBlock"])
self.settings = settings
def configMemory(self):
# Creates a overflow location for data
self.overflow = ctypes.c_int16()
# Creates converted types maxsamples
self.cmaxSamples = ctypes.c_int32(self.maxsamples)
# Handle = Chandle
# nMaxSamples = ctypes.byref(cmaxSamples)
self.status["MemorySegments"] = ps.ps5000aMemorySegments(
self.chandle, self.blocks, ctypes.byref(self.cmaxSamples))
assert_pico_ok(self.status["MemorySegments"])
# sets number of captures
self.status["SetNoOfCaptures"] = ps.ps5000aSetNoOfCaptures(
self.chandle, self.blocks)
assert_pico_ok(self.status["SetNoOfCaptures"])
def runRapidBlock(self,**kwargs):
'''
arms the trigger, block mode is close to repeat (with re-arm) or single mode (without re-arm)
rapid block accumulates several events (similar to fast frame modes on other scopes)
arguments: none
keyword arguments (defaults in self.trigger.settings):
preTrigger: fraction of samples before the trigger occurs (0 to 1)
segmentIndex: scope memory segment to store the run result
nSegments: number of samples to capture
after successfully arming the trigger, self.trigger.settings is updated
after triggering, the channel records the noSamples and then stops (until re-arming)
'''
settings = {}
for key,current_value in self.settings.items():
settings[key] = kwargs[key] if key in kwargs else current_value
check_kwargs_scope(**kwargs)
# Handle = Chandle
# nSegments = 10
# nMaxSamples = ctypes.byref(cmaxSamples)
cmaxSamples = ctypes.c_int32(self.scope.settings['noSamples'])
self.status["MemorySegments"] = ps.ps5000aMemorySegments(self.chandle, settings['nSegments'], ctypes.byref(cmaxSamples))
assert_pico_ok(self.status["MemorySegments"])
# sets number of captures
self.status["SetNoOfCaptures"] = ps.ps5000aSetNoOfCaptures(self.chandle, settings['nSegments'])
assert_pico_ok(self.status["SetNoOfCaptures"])
# Starts the block capture
# Handle = chandle
# Number of prTriggerSamples
# Number of postTriggerSamples
# Timebase = 2 = 4ns (see Programmer's guide for more information on timebases)
# time indisposed ms = None (This is not needed within the example)
# Segment index = 0
# LpRead = None
# pParameter = None
_preTriggerSamples = int(self.scope.settings['noSamples']*settings['preTrigger'])
_postTriggerSamples = self.scope.settings['noSamples'] - _preTriggerSamples
_timebase = self.scope.settings['timebase']
_timeIndisposeMs = ctypes.c_int32()
_segmentIndex = settings['segmentIndex']
self.status["runblock"] = ps.ps5000aRunBlock(self.chandle, _preTriggerSamples, _postTriggerSamples,
_timebase, ctypes.byref(_timeIndisposeMs), _segmentIndex, None, None)
assert_pico_ok(self.status["runblock"])
self.settings = settings
def _set_memory_segments(self, num_segments, num_samples):
"""Set up memory segments in the device.
For multiple captures, the device's memory must be divided into
segments, one for each capture. If the memory cannot contain the
required number of samples per segment, an InvalidParameterError is
raised.
:param num_segments: the number of memory segments.
:param num_samples: the number of required samples per capture.
"""
max_samples = ctypes.c_int32()
assert_pico_ok(
ps.ps5000aMemorySegments(self._handle, num_segments,
ctypes.byref(max_samples)))
max_samples = max_samples.value
if max_samples < num_samples:
raise InvalidParameterError(
f"A memory segment can only fit {max_samples}, but "
f"{num_samples} are required.")
# MaxSamples = ctypes.byref(returnedMaxSamples) # Segement index = 0 timeIntervalns = ctypes.c_float() returnedMaxSamples = ctypes.c_int16() status["GetTimebase"] = ps.ps5000aGetTimebase2(chandle, timebase, maxsamples, ctypes.byref(timeIntervalns), ctypes.byref(returnedMaxSamples), 0) assert_pico_ok(status["GetTimebase"]) # Creates a overlow location for data overflow = ctypes.c_int16() # Creates converted types maxsamples cmaxSamples = ctypes.c_int32(maxsamples) # Handle = Chandle # nSegments = 10 # nMaxSamples = ctypes.byref(cmaxSamples) status["MemorySegments"] = ps.ps5000aMemorySegments(chandle, 10, ctypes.byref(cmaxSamples)) assert_pico_ok(status["MemorySegments"]) # sets number of captures status["SetNoOfCaptures"] = ps.ps5000aSetNoOfCaptures(chandle, 10) assert_pico_ok(status["SetNoOfCaptures"]) # Starts the block capture # Handle = chandle # Number of prTriggerSamples # Number of postTriggerSamples # Timebase = 2 = 4ns (see Programmer's guide for more information on timebases) # time indisposed ms = None (This is not needed within the example) # Segment index = 0 # LpRead = None # pParameter = None
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