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