def __init__(self, serialNumber=None, connect=True): """Load DLLs.""" self.handle = None if platform.system() == 'Linux': from ctypes import cdll # ok I don't know what is wrong with my installer, # but I need to include .so.2 self.lib = cdll.LoadLibrary("lib" + self.LIBNAME + ".so.2") elif platform.system() == 'Darwin': from picoscope.darwin_utils import LoadLibraryDarwin self.lib = LoadLibraryDarwin("lib" + self.LIBNAME + ".dylib") else: from ctypes import windll self.lib = windll.LoadLibrary(str(self.LIBNAME + ".dll")) super(PS4000, self).__init__(serialNumber, connect) # check to see which model we have and use special functions if needed unit_number = self.getUnitInfo('VariantInfo') if unit_number == '4262': self.getTimestepFromTimebase = self._getTimestepFromTimebase4262 self.getTimeBaseNum = self._getTimeBaseNum4262 elif unit_number in {'4223', '4224', '4423', '4424'}: self.getTimestepFromTimebase = self._getTimestepFromTimebase4223 self.getTimeBaseNum = self._getTimeBaseNum4223 else: raise NotImplementedError('Timebase functions have not been ' 'written for the ' + unit_number)
def __init__(self, serialNumber=None, connect=True): """Load DLL etc.""" if platform.system() == 'Linux': from ctypes import cdll self.lib = cdll.LoadLibrary("lib" + self.LIBNAME + ".so") elif platform.system() == 'Darwin': from picoscope.darwin_utils import LoadLibraryDarwin self.lib = LoadLibraryDarwin("lib" + self.LIBNAME + ".dylib") else: from ctypes import windll self.lib = windll.LoadLibrary(str(self.LIBNAME + ".dll")) super(PS3000, self).__init__(serialNumber, connect)
def __init__(self, serialNumber=None, connect=True): """Load DLLs.""" if platform.system() == 'Linux': from ctypes import cdll # ok I don't know what is wrong with my installer, # but I need to include .so.2 self.lib = cdll.LoadLibrary("lib" + self.LIBNAME + ".so.2") elif platform.system() == 'Darwin': from picoscope.darwin_utils import LoadLibraryDarwin self.lib = LoadLibraryDarwin("lib" + self.LIBNAME + ".dylib") else: from ctypes import windll self.lib = windll.LoadLibrary(str(self.LIBNAME + ".dll")) super(PS6000, self).__init__(serialNumber, connect)
def __init__(self, serialNumber=None, connect=True): """Load DLLs.""" self.handle = None if platform.system() == 'Linux': from ctypes import cdll # ok I don't know what is wrong with my installer, # but I need to include .so.2 self.lib = cdll.LoadLibrary("lib" + self.LIBNAME + ".so.2") elif platform.system() == 'Darwin': from picoscope.darwin_utils import LoadLibraryDarwin self.lib = LoadLibraryDarwin("lib" + self.LIBNAME + ".dylib") else: from ctypes import windll self.lib = windll.LoadLibrary(str(self.LIBNAME + ".dll")) super(PS4000, self).__init__(serialNumber, connect) # check to see which model we have and use special functions if needed unit_number = self.getUnitInfo('VariantInfo') if unit_number == '4262': self.getTimestepFromTimebase = self._getTimestepFromTimebase4262 self.getTimeBaseNum = self._getTimeBaseNum4262 elif unit_number in {'4223', '4224', '4423', '4424'}: self.getTimestepFromTimebase = self._getTimestepFromTimebase4223 self.getTimeBaseNum = self._getTimeBaseNum4223 else: raise NotImplementedError('Timebase functions have not been ' 'written for the ' + unit_number)
def __init__(self, serialNumber=None, connect=True): """Load DLL etc.""" if platform.system() == 'Linux': from ctypes import cdll self.lib = cdll.LoadLibrary("lib" + self.LIBNAME + ".so") elif platform.system() == 'Darwin': from picoscope.darwin_utils import LoadLibraryDarwin self.lib = LoadLibraryDarwin("lib" + self.LIBNAME + ".dylib") else: from ctypes import windll from ctypes.util import find_library self.lib = windll.LoadLibrary( find_library(str(self.LIBNAME + ".dll")) ) self.resolution = self.ADC_RESOLUTIONS["8"] super(PS5000a, self).__init__(serialNumber, connect)
def __init__(self, serialNumber=None, connect=True): """Load DLLs.""" self.handle = None if platform.system() == 'Linux': from ctypes import cdll # ok I don't know what is wrong with my installer, # but I need to include .so.2 self.lib = cdll.LoadLibrary("lib" + self.LIBNAME + ".so.2") elif platform.system() == 'Darwin': from picoscope.darwin_utils import LoadLibraryDarwin self.lib = LoadLibraryDarwin("lib" + self.LIBNAME + ".dylib") else: from ctypes import windll from ctypes.util import find_library self.lib = windll.LoadLibrary( find_library(str(self.LIBNAME + ".dll"))) self.resolution = self.ADC_RESOLUTIONS["12"] super(PS4000a, self).__init__(serialNumber, connect)
def __init__(self, serialNumber=None, connect=True): """Load DLL etc.""" if platform.system() == 'Linux': from ctypes import cdll self.lib = cdll.LoadLibrary("lib" + self.LIBNAME + ".so") elif platform.system() == 'Darwin': from picoscope.darwin_utils import LoadLibraryDarwin self.lib = LoadLibraryDarwin("lib" + self.LIBNAME + ".dylib") else: from ctypes import windll self.lib = windll.LoadLibrary(str(self.LIBNAME + ".dll")) super(PS3000, self).__init__(serialNumber, connect)
def __init__(self, serialNumber=None, connect=True): """Load DLLs.""" if platform.system() == 'Linux': from ctypes import cdll # ok I don't know what is wrong with my installer, # but I need to include .so.2 self.lib = cdll.LoadLibrary("lib" + self.LIBNAME + ".so.2") elif platform.system() == 'Darwin': from picoscope.darwin_utils import LoadLibraryDarwin self.lib = LoadLibraryDarwin("lib" + self.LIBNAME + ".dylib") else: from ctypes import windll self.lib = windll.LoadLibrary(str(self.LIBNAME + ".dll")) super(PS6000, self).__init__(serialNumber, connect)
class PS4000a(_PicoscopeBase): """The following are low-level functions for the PS4000A.""" LIBNAME = "ps4000a" MAX_VALUE = 32764 MIN_VALUE = -32764 # EXT/AUX seems to have an input impedance of 50 ohm (PS6403B) EXT_MAX_VALUE = 32767 EXT_MIN_VALUE = -32767 EXT_RANGE_VOLTS = 1 # I don't think that the 50V range is allowed, but I left it there anyway # The 10V and 20V ranges are only allowed in high impedence modes CHANNEL_RANGE = [{"rangeV": 20E-3, "apivalue": 1, "rangeStr": "20 mV"}, {"rangeV": 50E-3, "apivalue": 2, "rangeStr": "50 mV"}, {"rangeV": 100E-3, "apivalue": 3, "rangeStr": "100 mV"}, {"rangeV": 200E-3, "apivalue": 4, "rangeStr": "200 mV"}, {"rangeV": 500E-3, "apivalue": 5, "rangeStr": "500 mV"}, {"rangeV": 1.0, "apivalue": 6, "rangeStr": "1 V"}, {"rangeV": 2.0, "apivalue": 7, "rangeStr": "2 V"}, {"rangeV": 5.0, "apivalue": 8, "rangeStr": "5 V"}, {"rangeV": 10.0, "apivalue": 9, "rangeStr": "10 V"}, {"rangeV": 20.0, "apivalue": 10, "rangeStr": "20 V"}, {"rangeV": 50.0, "apivalue": 11, "rangeStr": "50 V"}, ] NUM_CHANNELS = 8 CHANNELS = {"A": 0, "B": 1, "C": 2, "D": 3, "E": 4, "F": 5, "G": 6, "H": 7, "MaxChannels": 8} ADC_RESOLUTIONS = {"8": 0, "12": 1, "14": 2, "15": 3, "16": 4} CHANNEL_COUPLINGS = {"DC50": 2, "DC": 1, "AC": 0} WAVE_TYPES = {"Sine": 0, "Square": 1, "Triangle": 2, "RampUp": 3, "RampDown": 4, "Sinc": 5, "Gaussian": 6, "HalfSine": 7, "DCVoltage": 8, "WhiteNoise": 9} SWEEP_TYPES = {"Up": 0, "Down": 1, "UpDown": 2, "DownUp": 3} TIME_UNITS = {"femtoseconds": 0, "picoseconds": 1, "nanoseconds": 2, "microseconds": 3, "milliseconds": 4, "seconds": 5} def __init__(self, serialNumber=None, connect=True): """Load DLLs.""" self.handle = None if platform.system() == 'Linux': from ctypes import cdll # ok I don't know what is wrong with my installer, # but I need to include .so.2 self.lib = cdll.LoadLibrary("lib" + self.LIBNAME + ".so.2") elif platform.system() == 'Darwin': from picoscope.darwin_utils import LoadLibraryDarwin self.lib = LoadLibraryDarwin("lib" + self.LIBNAME + ".dylib") else: from ctypes import windll self.lib = windll.LoadLibrary(str(self.LIBNAME + ".dll")) self.resolution = self.ADC_RESOLUTIONS["12"] super(PS4000a, self).__init__(serialNumber, connect) def _lowLevelOpenUnit(self, sn): c_handle = c_int16() if sn is not None: serialNullTermStr = create_string_buffer(str(sn)) else: serialNullTermStr = None # Passing None is the same as passing NULL m = self.lib.ps4000aOpenUnit(byref(c_handle), serialNullTermStr) self.checkResult(m) self.handle = c_handle.value self.model = self.getUnitInfo('VariantInfo') def _lowLevelOpenUnitAsync(self, sn): c_status = c_int16() if sn is not None: serialNullTermStr = create_string_buffer(sn) else: serialNullTermStr = None # Passing None is the same as passing NULL m = self.lib.ps4000aOpenUnitAsync(byref(c_status), serialNullTermStr) self.checkResult(m) return c_status.value def _lowLevelOpenUnitProgress(self): complete = c_int16() progressPercent = c_int16() handle = c_int16() m = self.lib.ps4000aOpenUnitProgress(byref(handle), byref(progressPercent), byref(complete)) self.checkResult(m) if complete.value != 0: self.handle = handle.value # if we only wanted to return one value, we could do somethign like # progressPercent = progressPercent * (1 - 0.1 * complete) return (progressPercent.value, complete.value) def _lowLevelCloseUnit(self): m = self.lib.ps4000aCloseUnit(c_int16(self.handle)) self.checkResult(m) def _lowLevelEnumerateUnits(self): count = c_int16(0) serials = c_int8(0) serialLth = c_int16(0) m = self.lib.ps4000aEnumerateUnits(byref(count), byref(serials), byref(serialLth)) self.checkResult(m) # a serial number is rouhgly 8 characters # an extra character for the comma # and an extra one for the space after the comma? # the extra two also work for the null termination serialLth = c_int16(count.value * (8 + 2)) serials = create_string_buffer(serialLth.value + 1) m = self.lib.ps4000aEnumerateUnits(byref(count), serials, byref(serialLth)) self.checkResult(m) serialList = str(serials.value.decode('utf-8')).split(',') serialList = [x.strip() for x in serialList] return serialList def _lowLevelSetChannel(self, chNum, enabled, coupling, VRange, VOffset, BWLimited): m = self.lib.ps4000aSetChannel(c_int16(self.handle), c_enum(chNum), c_int16(enabled), c_enum(coupling), c_enum(VRange), c_float(VOffset)) self.checkResult(m) def _lowLevelStop(self): m = self.lib.ps4000aStop(c_int16(self.handle)) self.checkResult(m) def _lowLevelGetUnitInfo(self, info): s = create_string_buffer(256) requiredSize = c_int16(0) m = self.lib.ps4000aGetUnitInfo(c_int16(self.handle), byref(s), c_int16(len(s)), byref(requiredSize), c_enum(info)) self.checkResult(m) if requiredSize.value > len(s): s = create_string_buffer(requiredSize.value + 1) m = self.lib.ps4000aGetUnitInfo(c_int16(self.handle), byref(s), c_int16(len(s)), byref(requiredSize), c_enum(info)) self.checkResult(m) # should this bee ascii instead? # I think they are equivalent... return s.value.decode('utf-8') def _lowLevelFlashLed(self, times): m = self.lib.ps4000aFlashLed(c_int16(self.handle), c_int16(times)) self.checkResult(m) def _lowLevelSetSimpleTrigger(self, enabled, trigsrc, threshold_adc, direction, delay, timeout_ms): m = self.lib.ps4000aSetSimpleTrigger( c_int16(self.handle), c_int16(enabled), c_enum(trigsrc), c_int16(threshold_adc), c_enum(direction), c_uint32(delay), c_int16(timeout_ms)) self.checkResult(m) def _lowLevelRunBlock(self, numPreTrigSamples, numPostTrigSamples, timebase, oversample, segmentIndex): timeIndisposedMs = c_int32() m = self.lib.ps4000aRunBlock( c_int16(self.handle), c_int32(numPreTrigSamples), c_int32(numPostTrigSamples), c_uint32(timebase), byref(timeIndisposedMs), c_uint32(segmentIndex), c_void_p(), c_void_p()) self.checkResult(m) return timeIndisposedMs.value def _lowLevelIsReady(self): ready = c_int16() m = self.lib.ps4000aIsReady(c_int16(self.handle), byref(ready)) self.checkResult(m) if ready.value: return True else: return False def _lowLevelGetTimebase(self, tb, noSamples, oversample, segmentIndex): """Return (timeIntervalSeconds, maxSamples).""" maxSamples = c_int32() sampleRate = c_float() m = self.lib.ps4000aGetTimebase2(c_int16(self.handle), c_uint32(tb), c_int32(noSamples), byref(sampleRate), byref(maxSamples), c_uint32(segmentIndex)) self.checkResult(m) return (sampleRate.value / 1.0E9, maxSamples.value) def getTimeBaseNum(self, sampleTimeS): """ Convert the sample interval (float of seconds) to the corresponding integer timebase value as defined by the API. See "Timebases" section of the PS4000a programmers guide for more information. """ if self.model == '4828': maxSampleTime = (((2 ** 32 - 1) + 1) / 8E7) if sampleTimeS <= 12.5E-9: timebase = 0 else: # Otherwise in range 2^32-1 if sampleTimeS > maxSampleTime: sampleTimeS = maxSampleTime timebase = math.floor((sampleTimeS * 2e7) + 1) elif self.model == '4444': maxSampleTime = (((2 ** 32 - 1) - 2) / 5.0E7) if (sampleTimeS <= 2.5E-9 and self.resolution == self.ADC_RESOLUTIONS["12"]): timebase = 0 elif (sampleTimeS <= 20E-9 and self.resolution == self.ADC_RESOLUTIONS["14"]): timebase = 3 else: # Otherwise in range 2^32-1 if sampleTimeS > maxSampleTime: sampleTimeS = maxSampleTime timebase = math.floor((sampleTimeS * 5.0E7) + 2) else: # The original case from non "A" series warnings.warn("The model PS4000a you are using may not be " "fully supported", stacklevel=2) maxSampleTime = (((2 ** 32 - 1) - 4) / 2e7) if sampleTimeS <= 12.5E-9: timebase = math.floor(math.log(sampleTimeS * 8E7, 2)) timebase = max(timebase, 0) else: # Otherwise in range 2^32-1 if sampleTimeS > maxSampleTime: sampleTimeS = maxSampleTime timebase = math.floor((sampleTimeS * 2e7) + 1) # is this cast needed? timebase = int(timebase) return timebase def getTimestepFromTimebase(self, timebase): """Return timebase to sampletime as seconds.""" if self.model == '4828': dt = (timebase + 1) / 8.0E7 elif self.model == '4444': if timebase < 3: dt = 2.5 ** timebase / 4.0E8 else: dt = (timebase - 2) / 5.0E7 else: # The original case from non "A" series warnings.warn("The model PS4000a you are using may not be " "fully supported", stacklevel=2) if timebase < 3: dt = 2. ** timebase / 8e7 else: dt = (timebase - 1) / 2e7 return dt return dt def _lowLevelSetDataBuffer(self, channel, data, downSampleMode, segmentIndex): """Set the data buffer. Be sure to call _lowLevelClearDataBuffer when you are done with the data array or else subsequent calls to GetValue will still use the same array. segmentIndex is unused, but required by other versions of the API (eg PS5000a) """ dataPtr = data.ctypes.data_as(POINTER(c_int16)) numSamples = len(data) m = self.lib.ps4000aSetDataBuffer(c_int16(self.handle), c_enum(channel), dataPtr, c_uint32(numSamples), c_uint32(segmentIndex), c_uint32(downSampleMode)) self.checkResult(m) def _lowLevelClearDataBuffer(self, channel, segmentIndex): m = self.lib.ps4000aSetDataBuffer(c_int16(self.handle), c_enum(channel), c_void_p(), c_uint32(0), c_uint32(0), c_enum(0)) self.checkResult(m) def _lowLevelGetValues(self, numSamples, startIndex, downSampleRatio, downSampleMode, segmentIndex): numSamplesReturned = c_uint32() numSamplesReturned.value = numSamples overflow = c_int16() m = self.lib.ps4000aGetValues( c_int16(self.handle), c_uint32(startIndex), byref(numSamplesReturned), c_uint32(downSampleRatio), c_enum(downSampleMode), c_uint16(segmentIndex), byref(overflow)) self.checkResult(m) return (numSamplesReturned.value, overflow.value) def _lowLevelSetDeviceResolution(self, resolution): self.resolution = resolution m = self.lib.ps4000aSetDeviceResolution( c_int16(self.handle), c_enum(resolution)) self.checkResult(m) def _lowLevelGetValuesBulk(self, numSamples, fromSegment, toSegment, downSampleRatio, downSampleMode, overflow): """Copy data from several memory segments at once.""" overflowPoint = overflow.ctypes.data_as(POINTER(c_int16)) m = self.lib.ps4000aGetValuesBulk( c_int16(self.handle), byref(c_int32(numSamples)), c_int32(fromSegment), c_int32(toSegment), c_int32(downSampleRatio), c_enum(downSampleMode), overflowPoint ) self.checkResult(m) def _lowLevelSetDataBufferBulk(self, channel, data, segmentIndex, downSampleMode): """Just calls setDataBuffer with argument order changed. For compatibility with current picobase.py. """ self._lowLevelSetDataBuffer(channel, data, downSampleMode, segmentIndex) #################################################################### # Untested functions below # # # #################################################################### def _lowLevelSetSigGenBuiltInSimple(self, offsetVoltage, pkToPk, waveType, frequency, shots, triggerType, triggerSource, stopFreq, increment, dwellTime, sweepType, numSweeps): if stopFreq is None: stopFreq = frequency m = self.lib.ps4000aSetSigGenBuiltIn( c_int16(self.handle), c_int32(int(offsetVoltage * 1000000)), c_int32(int(pkToPk * 1000000)), c_int16(waveType), c_float(frequency), c_float(stopFreq), c_float(increment), c_float(dwellTime), c_enum(sweepType), c_enum(0), c_uint32(shots), c_uint32(numSweeps), c_enum(triggerType), c_enum(triggerSource), c_int16(0)) self.checkResult(m) def _lowLevelGetMaxDownSampleRatio(self, noOfUnaggregatedSamples, downSampleRatioMode, segmentIndex): maxDownSampleRatio = c_uint32() m = self.lib.ps4000aGetMaxDownSampleRatio( c_int16(self.handle), c_uint32(noOfUnaggregatedSamples), byref(maxDownSampleRatio), c_enum(downSampleRatioMode), c_uint16(segmentIndex)) self.checkResult(m) return maxDownSampleRatio.value def _lowLevelGetNoOfCaptures(self): nCaptures = c_uint32() m = self.lib.ps4000aGetNoOfCaptures(c_int16(self.handle), byref(nCaptures)) self.checkResult(m) return nCaptures.value def _lowLevelGetTriggerTimeOffset(self, segmentIndex): time = c_uint64() timeUnits = c_enum() m = self.lib.ps4000aGetTriggerTimeOffset64( c_int16(self.handle), byref(time), byref(timeUnits), c_uint16(segmentIndex)) self.checkResult(m) if timeUnits.value == 0: # PS4000a_FS return time.value * 1E-15 elif timeUnits.value == 1: # PS4000a_PS return time.value * 1E-12 elif timeUnits.value == 2: # PS4000a_NS return time.value * 1E-9 elif timeUnits.value == 3: # PS4000a_US return time.value * 1E-6 elif timeUnits.value == 4: # PS4000a_MS return time.value * 1E-3 elif timeUnits.value == 5: # PS4000a_S return time.value * 1E0 else: raise TypeError("Unknown timeUnits %d" % timeUnits.value) def _lowLevelMemorySegments(self, nSegments): nMaxSamples = c_uint32() m = self.lib.ps4000aMemorySegments(c_int16(self.handle), c_uint16(nSegments), byref(nMaxSamples)) self.checkResult(m) return nMaxSamples.value def _lowLevelSetDataBuffers(self, channel, bufferMax, bufferMin, downSampleRatioMode): bufferMaxPtr = bufferMax.ctypes.data_as(POINTER(c_int16)) bufferMinPtr = bufferMin.ctypes.data_as(POINTER(c_int16)) bufferLth = len(bufferMax) m = self.lib.ps4000aSetDataBuffers( c_int16(self.handle), c_enum(channel), bufferMaxPtr, bufferMinPtr, c_uint32(bufferLth)) self.checkResult(m) def _lowLevelClearDataBuffers(self, channel): m = self.lib.ps4000aSetDataBuffers( c_int16(self.handle), c_enum(channel), c_void_p(), c_void_p(), c_uint32(0)) self.checkResult(m) def _lowLevelSetNoOfCaptures(self, nCaptures): m = self.lib.ps4000aSetNoOfCaptures( c_int16(self.handle), c_uint16(nCaptures)) self.checkResult(m) # ETS Functions def _lowLevelSetEts(self): pass def _lowLevelSetEtsTimeBuffer(self): pass def _lowLevelSetEtsTimeBuffers(self): pass def _lowLevelSetExternalClock(self): pass # Complicated triggering # need to understand structs for this one to work def _lowLevelIsTriggerOrPulseWidthQualifierEnabled(self): pass def _lowLevelGetValuesTriggerTimeOffsetBulk(self): pass def _lowLevelSetTriggerChannelConditions(self): pass def _lowLevelSetTriggerChannelDirections(self): pass def _lowLevelSetTriggerChannelProperties(self): pass def _lowLevelSetPulseWidthQualifier(self): pass def _lowLevelSetTriggerDelay(self): pass # Async functions # would be nice, but we would have to learn to implement callbacks def _lowLevelGetValuesAsync(self): pass def _lowLevelGetValuesBulkAsync(self): pass # overlapped functions def _lowLevelGetValuesOverlapped(self): pass def _lowLevelGetValuesOverlappedBulk(self): pass # Streaming related functions def _lowLevelGetStreamingLatestValues(self, lpPs4000Ready, pParameter=c_void_p()): m = self.lib.ps4000aGetStreamingLatestValues( c_uint16(self.handle), lpPs4000Ready, pParameter) self.checkResult(m) def _lowLevelNoOfStreamingValues(self): noOfValues = c_uint32() m = self.lib.ps4000aNoOfStreamingValues(c_int16(self.handle), byref(noOfValues)) self.checkResult(m) return noOfValues.value def _lowLevelRunStreaming(self, sampleInterval, sampleIntervalTimeUnits, maxPreTriggerSamples, maxPostTriggerSamples, autoStop, downSampleRatio, downSampleRatioMode, overviewBufferSize): m = self.lib.ps4000aRunStreaming( c_int16(self.handle), byref(c_uint32(sampleInterval)), c_enum(sampleIntervalTimeUnits), c_uint32(maxPreTriggerSamples), c_uint32(maxPostTriggerSamples), c_int16(autoStop), c_uint32(downSampleRatio), c_enum(downSampleRatioMode), c_uint32(overviewBufferSize)) self.checkResult(m) def _lowLevelStreamingReady(self): pass
class PS5000a(_PicoscopeBase): """The following are low-level functions for the PS5000.""" LIBNAME = "ps5000a" NUM_CHANNELS = 4 CHANNELS = {"A": 0, "B": 1, "C": 2, "D": 3, "External": 4, "MaxChannels": 4, "TriggerAux": 5} ADC_RESOLUTIONS = {"8": 0, "12": 1, "14": 2, "15": 3, "16": 4} CHANNEL_RANGE = [{"rangeV": 10E-3, "apivalue": 0, "rangeStr": "10 mV"}, {"rangeV": 20E-3, "apivalue": 1, "rangeStr": "20 mV"}, {"rangeV": 50E-3, "apivalue": 2, "rangeStr": "50 mV"}, {"rangeV": 100E-3, "apivalue": 3, "rangeStr": "100 mV"}, {"rangeV": 200E-3, "apivalue": 4, "rangeStr": "200 mV"}, {"rangeV": 500E-3, "apivalue": 5, "rangeStr": "500 mV"}, {"rangeV": 1.0, "apivalue": 6, "rangeStr": "1 V"}, {"rangeV": 2.0, "apivalue": 7, "rangeStr": "2 V"}, {"rangeV": 5.0, "apivalue": 8, "rangeStr": "5 V"}, {"rangeV": 10.0, "apivalue": 9, "rangeStr": "10 V"}, {"rangeV": 20.0, "apivalue": 10, "rangeStr": "20 V"}, {"rangeV": 50.0, "apivalue": 11, "rangeStr": "50 V"}, ] CHANNEL_COUPLINGS = {"DC": 1, "AC": 0} # has_sig_gen = True WAVE_TYPES = {"Sine": 0, "Square": 1, "Triangle": 2, "RampUp": 3, "RampDown": 4, "Sinc": 5, "Gaussian": 6, "HalfSine": 7, "DCVoltage": 8, "WhiteNoise": 9} SWEEP_TYPES = {"Up": 0, "Down": 1, "UpDown": 2, "DownUp": 3} SIGGEN_TRIGGER_TYPES = {"Rising": 0, "Falling": 1, "GateHigh": 2, "GateLow": 3} SIGGEN_TRIGGER_SOURCES = {"None": 0, "ScopeTrig": 1, "AuxIn": 2, "ExtIn": 3, "SoftTrig": 4, "TriggerRaw": 5} # This is actually different depending on the AB/CD models # I wonder how we could detect the difference between the oscilloscopes # I believe we can obtain this information from the setInfo function # by readign the hardware version # for the PS6403B version, the hardware version is "1 1", # an other possibility is that the PS6403B shows up as 6403 when using # VARIANT_INFO and others show up as PS6403X where X = A,C or D AWGPhaseAccumulatorSize = 32 AWGDACInterval = 5E-9 # in seconds AWGDACFrequency = 1 / AWGDACInterval AWG_INDEX_MODES = {"Single": 0, "Dual": 1, "Quad": 2} MAX_VALUE_8BIT = 32512 MIN_VALUE_8BIT = -32512 MAX_VALUE_OTHER = 32767 MIN_VALUE_OTHER = -32767 EXT_RANGE_VOLTS = 5 def __init__(self, serialNumber=None, connect=True): """Load DLL etc.""" if platform.system() == 'Linux': from ctypes import cdll self.lib = cdll.LoadLibrary("lib" + self.LIBNAME + ".so") elif platform.system() == 'Darwin': from picoscope.darwin_utils import LoadLibraryDarwin self.lib = LoadLibraryDarwin("lib" + self.LIBNAME + ".dylib") else: from ctypes import windll self.lib = windll.LoadLibrary(str(self.LIBNAME + ".dll")) self.resolution = self.ADC_RESOLUTIONS["8"] super(PS5000a, self).__init__(serialNumber, connect) def _lowLevelOpenUnit(self, sn): c_handle = c_int16() if sn is not None: serialNullTermStr = create_string_buffer(sn) else: serialNullTermStr = None # Passing None is the same as passing NULL m = self.lib.ps5000aOpenUnit(byref(c_handle), serialNullTermStr, self.resolution) self.handle = c_handle.value # This will check if the power supply is not connected # and change the power supply accordingly # Personally (me = Mark), I don't like this # since the user should address this immediately, and we # shouldn't let this go as a soft error # but I think this should do for now if m == 0x11A: self.changePowerSource(m) else: self.checkResult(m) # B models have different AWG buffer sizes # 5242B, 5442B: 2**14 # 5243B, 5443B: 2**15 # 5444B, 5244B: 3 * 2**14 # Model 5444B identifies itself properly in VariantInfo, I will assume # the others do as well. self.model = self.getUnitInfo('VariantInfo') # print("Checking variant, found: " + str(self.model)) if self.model in ('5244B', '5444B'): self.AWGBufferAddressWidth = math.log(3 * 2**14, 2) self.AWGMaxVal = 32767 self.AWGMinVal = -32768 self.AWGMaxSamples = 49152 elif self.model in ('5243B', '5443B'): self.AWGBufferAddressWidth = 15 self.AWGMaxVal = 32767 self.AWGMinVal = -32768 self.AWGMaxSamples = 2**self.AWGBufferAddressWidth else: # This is what the previous PS5000a used for all scopes. # I am leaving it the same, although I think the AWGMaxVal and # AWGMinVal issue was fixed and should be -32768 to 32767 for all # 5000 models self.AWGBufferAddressWidth = 14 # Note this is NOT what is written in the Programming guide as of # version # 10_5_0_28 # This issue was acknowledged in this thread # http://www.picotech.com/support/topic13217.html self.AWGMaxVal = 0x0FFF self.AWGMinVal = 0x0000 self.AWGMaxSamples = 2**self.AWGBufferAddressWidth def _lowLevelCloseUnit(self): m = self.lib.ps5000aCloseUnit(c_int16(self.handle)) self.checkResult(m) def _lowLevelSetChannel(self, chNum, enabled, coupling, VRange, VOffset, bandwidth): m = self.lib.ps5000aSetChannel(c_int16(self.handle), c_enum(chNum), c_int16(enabled), c_enum(coupling), c_enum(VRange), c_float(VOffset)) self.checkResult(m) # The error this might through are # INVALID_HANDLE # INVALID_CHANNEL # INVALID_BANDWIDTH # Invalid bandwidth is the only case that could go wrong. # The others would be thrown above (assuming no race condition: # i.e. unplugging the scope in between this call. # I decided to keep the logic below to avoid a possible error # picobase/SetChannel should be changed to the following # Set the channel # save the new channel settings # check if ps5000a # change the bandwidth separately # changing the bandwidth would be it's own function (implemented below) if bandwidth: m = self.lib.ps5000aSetBandwidthFilter(c_int16(self.handle), c_enum(chNum), c_enum(1)) else: m = self.lib.ps5000aSetBandwidthFilter(c_int16(self.handle), c_enum(chNum), c_enum(0)) self.checkResult(m) def _lowLevelSetBandwidthFilter(self, channel, bandwidth): m = self.lib.ps5000aSetBandwidthFilter(c_int16(self.handle), c_enum(channel), c_enum(bandwidth)) self.checkResult(m) def _lowLevelStop(self): m = self.lib.ps5000aStop(c_int16(self.handle)) self.checkResult(m) def _lowLevelGetUnitInfo(self, info): s = create_string_buffer(256) requiredSize = c_int16(0) m = self.lib.ps5000aGetUnitInfo(c_int16(self.handle), byref(s), c_int16(len(s)), byref(requiredSize), c_enum(info)) self.checkResult(m) if requiredSize.value > len(s): s = create_string_buffer(requiredSize.value + 1) m = self.lib.ps5000aGetUnitInfo(c_int16(self.handle), byref(s), c_int16(len(s)), byref(requiredSize), c_enum(info)) self.checkResult(m) # should this bee ascii instead? # I think they are equivalent... return s.value.decode('utf-8') def _lowLevelFlashLed(self, times): m = self.lib.ps5000aFlashLed(c_int16(self.handle), c_int16(times)) self.checkResult(m) def _lowLevelSetSimpleTrigger(self, enabled, trigsrc, threshold_adc, direction, timeout_ms, auto): m = self.lib.ps5000aSetSimpleTrigger( c_int16(self.handle), c_int16(enabled), c_enum(trigsrc), c_int16(threshold_adc), c_enum(direction), c_uint32(timeout_ms), c_int16(auto)) self.checkResult(m) def _lowLevelRunBlock(self, numPreTrigSamples, numPostTrigSamples, timebase, oversample, segmentIndex): # Oversample is NOT used! timeIndisposedMs = c_int32() m = self.lib.ps5000aRunBlock( c_int16(self.handle), c_uint32(numPreTrigSamples), c_uint32(numPostTrigSamples), c_uint32(timebase), byref(timeIndisposedMs), c_uint32(segmentIndex), c_void_p(), c_void_p()) self.checkResult(m) return timeIndisposedMs.value def _lowLevelIsReady(self): ready = c_int16() m = self.lib.ps5000aIsReady(c_int16(self.handle), byref(ready)) self.checkResult(m) if ready.value: return True else: return False def _lowLevelPingUnit(self): m = self.lib.ps5000aPingUnit(c_int16(self.handle)) return m def _lowLevelGetTimebase(self, tb, noSamples, oversample, segmentIndex): """Return (timeIntervalSeconds, maxSamples).""" maxSamples = c_int32() sampleRate = c_float() m = self.lib.ps5000aGetTimebase2(c_int16(self.handle), c_uint32(tb), c_uint32(noSamples), byref(sampleRate), byref(maxSamples), c_uint32(segmentIndex)) self.checkResult(m) return (sampleRate.value / 1.0E9, maxSamples.value) def getTimeBaseNum(self, sampleTimeS): """Convert sample time in S to something to pass to API Call.""" if self.resolution == self.ADC_RESOLUTIONS["8"]: maxSampleTime = (((2 ** 32 - 1) - 2) / 125000000) if sampleTimeS < 8.0E-9: st = math.floor(math.log(sampleTimeS * 1E9, 2)) st = max(st, 0) else: if sampleTimeS > maxSampleTime: sampleTimeS = maxSampleTime st = math.floor((sampleTimeS * 125000000) + 2) elif self.resolution == self.ADC_RESOLUTIONS["12"]: maxSampleTime = (((2 ** 32 - 1) - 3) / 62500000) if sampleTimeS < 16.0E-9: st = math.floor(math.log(sampleTimeS * 5E8, 2)) + 1 st = max(st, 1) else: if sampleTimeS > maxSampleTime: sampleTimeS = maxSampleTime st = math.floor((sampleTimeS * 62500000) + 3) elif (self.resolution == self.ADC_RESOLUTIONS["14"]) or ( self.resolution == self.ADC_RESOLUTIONS["15"]): maxSampleTime = (((2 ** 32 - 1) - 2) / 125000000) if sampleTimeS > maxSampleTime: sampleTimeS = maxSampleTime st = math.floor((sampleTimeS * 125000000) + 2) st = max(st, 3) elif self.resolution == self.ADC_RESOLUTIONS["16"]: maxSampleTime = (((2 ** 32 - 1) - 3) / 62500000) if sampleTimeS > maxSampleTime: sampleTimeS = maxSampleTime st = math.floor((sampleTimeS * 62500000) + 3) st = max(st, 3) else: raise ValueError("Invalid Resolution for Device?") # is this cast needed? st = int(st) return st def getTimestepFromTimebase(self, timebase): """Return Timestep from timebase.""" if self.resolution == self.ADC_RESOLUTIONS["8"]: if timebase < 3: dt = 2. ** timebase / 1.0E9 else: dt = (timebase - 2.0) / 125000000. elif self.resolution == self.ADC_RESOLUTIONS["12"]: if timebase < 4: dt = 2. ** (timebase - 1) / 5.0E8 else: dt = (timebase - 3.0) / 62500000. elif (self.resolution == self.ADC_RESOLUTIONS["14"]) or ( self.resolution == self.ADC_RESOLUTIONS["15"]): dt = (timebase - 2.0) / 125000000. elif self.resolution == self.ADC_RESOLUTIONS["16"]: dt = (timebase - 3.0) / 62500000. return dt def _lowLevelSetAWGSimpleDeltaPhase(self, waveform, deltaPhase, offsetVoltage, pkToPk, indexMode, shots, triggerType, triggerSource): """Waveform should be an array of shorts.""" waveformPtr = waveform.ctypes.data_as(POINTER(c_int16)) m = self.lib.ps5000aSetSigGenArbitrary( c_int16(self.handle), c_uint32(int(offsetVoltage * 1E6)), # offset voltage in microvolts c_uint32(int(pkToPk * 1E6)), # pkToPk in microvolts c_uint32(int(deltaPhase)), # startDeltaPhase c_uint32(int(deltaPhase)), # stopDeltaPhase c_uint32(0), # deltaPhaseIncrement c_uint32(0), # dwellCount waveformPtr, # arbitraryWaveform c_int32(len(waveform)), # arbitraryWaveformSize c_enum(0), # sweepType for deltaPhase c_enum(0), # operation (adding random noise and whatnot) c_enum(indexMode), # single, dual, quad c_uint32(shots), c_uint32(0), # sweeps c_uint32(triggerType), c_uint32(triggerSource), c_int16(0)) # extInThreshold self.checkResult(m) def _lowLevelSetDataBuffer(self, channel, data, downSampleMode, segmentIndex): """Set the data buffer. Be sure to call _lowLevelClearDataBuffer when you are done with the data array or else subsequent calls to GetValue will still use the same array. """ dataPtr = data.ctypes.data_as(POINTER(c_int16)) numSamples = len(data) m = self.lib.ps5000aSetDataBuffer(c_int16(self.handle), c_enum(channel), dataPtr, c_int32(numSamples), c_uint32(segmentIndex), c_enum(downSampleMode)) self.checkResult(m) def _lowLevelSetDataBufferBulk(self, channel, data, segmentIndex, downSampleMode): """Just calls setDataBuffer with argument order changed. For compatibility with current picobase.py. """ self._lowLevelSetDataBuffer(channel, data, downSampleMode, segmentIndex) def _lowLevelClearDataBuffer(self, channel, segmentIndex): m = self.lib.ps5000aSetDataBuffer(c_int16(self.handle), c_enum(channel), c_void_p(), c_uint32(0), c_uint32(segmentIndex), c_enum(0)) self.checkResult(m) def _lowLevelGetValues(self, numSamples, startIndex, downSampleRatio, downSampleMode, segmentIndex): numSamplesReturned = c_uint32() numSamplesReturned.value = numSamples overflow = c_int16() m = self.lib.ps5000aGetValues( c_int16(self.handle), c_uint32(startIndex), byref(numSamplesReturned), c_uint32(downSampleRatio), c_enum(downSampleMode), c_uint32(segmentIndex), byref(overflow)) self.checkResult(m) return (numSamplesReturned.value, overflow.value) def _lowLevelSetSigGenBuiltInSimple(self, offsetVoltage, pkToPk, waveType, frequency, shots, triggerType, triggerSource, stopFreq, increment, dwellTime, sweepType, numSweeps): # TODO, I just noticed that V2 exists # Maybe change to V2 in the future if stopFreq is None: stopFreq = frequency m = self.lib.ps5000aSetSigGenBuiltIn( c_int16(self.handle), c_int32(int(offsetVoltage * 1000000)), c_int32(int(pkToPk * 1000000)), c_int16(waveType), c_float(frequency), c_float(stopFreq), c_float(increment), c_float(dwellTime), c_enum(sweepType), c_enum(0), c_uint32(shots), c_uint32(numSweeps), c_enum(triggerType), c_enum(triggerSource), c_int16(0)) self.checkResult(m) def _lowLevelSetDeviceResolution(self, resolution): self.resolution = resolution m = self.lib.ps5000aSetDeviceResolution( c_int16(self.handle), c_enum(resolution)) self.checkResult(m) def _lowLevelChangePowerSource(self, powerstate): m = self.lib.ps5000aChangePowerSource( c_int16(self.handle), c_enum(powerstate)) self.checkResult(m) # Morgan's additions def _lowLevelGetValuesBulk(self, numSamples, fromSegment, toSegment, downSampleRatio, downSampleMode, overflow): """Copy data from several memory segments at once.""" overflowPoint = overflow.ctypes.data_as(POINTER(c_int16)) m = self.lib.ps5000aGetValuesBulk( c_int16(self.handle), byref(c_int32(numSamples)), c_int32(fromSegment), c_int32(toSegment), c_int32(downSampleRatio), c_enum(downSampleMode), overflowPoint ) self.checkResult(m) def _lowLevelSetNoOfCaptures(self, numCaptures): m = self.lib.ps5000aSetNoOfCaptures( c_int16(self.handle), c_uint32(numCaptures)) self.checkResult(m) def _lowLevelMemorySegments(self, numSegments): maxSamples = c_int32() m = self.lib.ps5000aMemorySegments( c_int16(self.handle), c_uint32(numSegments), byref(maxSamples)) self.checkResult(m) return maxSamples.value def _lowLevelGetValuesTriggerTimeOffsetBulk(self, fromSegment, toSegment): """Supposedly gets the trigger times for a bunch of segments at once. For block mode. Can't get it to work yet, however. """ import numpy as np nSegments = toSegment - fromSegment + 1 # time = c_int64() times = np.ascontiguousarray( np.zeros(nSegments, dtype=np.int64) ) timeUnits = np.ascontiguousarray( np.zeros(nSegments, dtype=np.int32) ) m = self.lib.ps5000aGetValuesTriggerTimeOffsetBulk64( c_int16(self.handle), times.ctypes.data_as(POINTER(c_int64)), timeUnits.ctypes.data_as(POINTER(c_enum)), c_uint32(fromSegment), c_uint32(toSegment) ) self.checkResult(m) # timeUnits=np.array([self.TIME_UNITS[tu] for tu in timeUnits]) return times, timeUnits
class PS3000a(_PicoscopeBase): """The following are low-level functions for the PS3000a.""" LIBNAME = "ps3000a" NUM_CHANNELS = 4 CHANNELS = { "A": 0, "B": 1, "C": 2, "D": 3, "External": 4, "MaxChannels": 4, "TriggerAux": 5 } ADC_RESOLUTIONS = {"8": 0, "12": 1, "14": 2, "15": 3, "16": 4} CHANNEL_RANGE = [ { "rangeV": 10E-3, "apivalue": 0, "rangeStr": "10 mV" }, { "rangeV": 20E-3, "apivalue": 1, "rangeStr": "20 mV" }, { "rangeV": 50E-3, "apivalue": 2, "rangeStr": "50 mV" }, { "rangeV": 100E-3, "apivalue": 3, "rangeStr": "100 mV" }, { "rangeV": 200E-3, "apivalue": 4, "rangeStr": "200 mV" }, { "rangeV": 500E-3, "apivalue": 5, "rangeStr": "500 mV" }, { "rangeV": 1.0, "apivalue": 6, "rangeStr": "1 V" }, { "rangeV": 2.0, "apivalue": 7, "rangeStr": "2 V" }, { "rangeV": 5.0, "apivalue": 8, "rangeStr": "5 V" }, { "rangeV": 10.0, "apivalue": 9, "rangeStr": "10 V" }, { "rangeV": 20.0, "apivalue": 10, "rangeStr": "20 V" }, { "rangeV": 50.0, "apivalue": 11, "rangeStr": "50 V" }, ] CHANNEL_COUPLINGS = {"DC": 1, "AC": 0} # has_sig_gen = True WAVE_TYPES = { "Sine": 0, "Square": 1, "Triangle": 2, "RampUp": 3, "RampDown": 4, "Sinc": 5, "Gaussian": 6, "HalfSine": 7, "DCVoltage": 8, "WhiteNoise": 9 } SWEEP_TYPES = {"Up": 0, "Down": 1, "UpDown": 2, "DownUp": 3} SIGGEN_TRIGGER_TYPES = { "Rising": 0, "Falling": 1, "GateHigh": 2, "GateLow": 3 } SIGGEN_TRIGGER_SOURCES = { "None": 0, "ScopeTrig": 1, "AuxIn": 2, "ExtIn": 3, "SoftTrig": 4, "TriggerRaw": 5 } # This is actually different depending on the AB/CD models # I wonder how we could detect the difference between the oscilloscopes # I believe we can obtain this information from the setInfo function # by readign the hardware version # for the PS6403B version, the hardware version is "1 1", # an other possibility is that the PS6403B shows up as 6403 when using # VARIANT_INFO and others show up as PS6403X where X = A,C or D AWGPhaseAccumulatorSize = 32 AWGBufferAddressWidth = 14 AWGMaxSamples = 2**AWGBufferAddressWidth AWGDACInterval = 5E-9 # in seconds AWGDACFrequency = 1 / AWGDACInterval # Note this is NOT what is written in the Programming guide as of version # 10_5_0_28 # This issue was acknowledged in this thread # http://www.picotech.com/support/topic13217.html AWGMaxVal = 32767 AWGMinVal = -32767 AWG_INDEX_MODES = {"Single": 0, "Dual": 1, "Quad": 2} MAX_VALUE_8BIT = 32512 MIN_VALUE_8BIT = -32512 MAX_VALUE_OTHER = 32767 MIN_VALUE_OTHER = -32767 EXT_RANGE_VOLTS = 5 def __init__(self, serialNumber=None, connect=True): """Load DLL etc.""" if platform.system() == 'Linux': from ctypes import cdll self.lib = cdll.LoadLibrary("lib" + self.LIBNAME + ".so") elif platform.system() == 'Darwin': from picoscope.darwin_utils import LoadLibraryDarwin self.lib = LoadLibraryDarwin("lib" + self.LIBNAME + ".dylib") else: from ctypes import windll from ctypes.util import find_library self.lib = windll.LoadLibrary( find_library(str(self.LIBNAME + ".dll"))) self.resolution = self.ADC_RESOLUTIONS["8"] super(PS3000a, self).__init__(serialNumber, connect) def _lowLevelOpenUnit(self, serialNumber): c_handle = c_int16() if serialNumber is not None: serialNumberStr = create_string_buffer( bytes(serialNumber, encoding='utf-8')) else: serialNumberStr = None # Passing None is the same as passing NULL m = self.lib.ps3000aOpenUnit(byref(c_handle), serialNumberStr) self.handle = c_handle.value # copied over from ps5000a: # This will check if the power supply is not connected # and change the power supply accordingly # Personally (me = Mark), I don't like this # since the user should address this immediately, and we # shouldn't let this go as a soft error # but I think this should do for now if m == 0x11A: self.changePowerSource("PICO_POWER_SUPPLY_NOT_CONNECTED") else: self.checkResult(m) def _lowLevelCloseUnit(self): m = self.lib.ps3000aCloseUnit(c_int16(self.handle)) self.checkResult(m) def _lowLevelEnumerateUnits(self): count = c_int16(0) m = self.lib.ps3000aEnumerateUnits(byref(count), None, None) self.checkResult(m) # a serial number is rouhgly 8 characters # an extra character for the comma # and an extra one for the space after the comma? # the extra two also work for the null termination serialLth = c_int16(count.value * (8 + 2)) serials = create_string_buffer(serialLth.value + 1) m = self.lib.ps3000aEnumerateUnits(byref(count), serials, byref(serialLth)) self.checkResult(m) serialList = str(serials.value.decode('utf-8')).split(',') serialList = [x.strip() for x in serialList] return serialList def _lowLevelSetChannel(self, chNum, enabled, coupling, VRange, VOffset, BWLimited): m = self.lib.ps3000aSetChannel(c_int16(self.handle), c_enum(chNum), c_int16(enabled), c_enum(coupling), c_enum(VRange), c_float(VOffset)) self.checkResult(m) m = self.lib.ps3000aSetBandwidthFilter(c_int16(self.handle), c_enum(chNum), c_enum(BWLimited)) self.checkResult(m) def _lowLevelStop(self): m = self.lib.ps3000aStop(c_int16(self.handle)) self.checkResult(m) def _lowLevelGetUnitInfo(self, info): s = create_string_buffer(256) requiredSize = c_int16(0) m = self.lib.ps3000aGetUnitInfo(c_int16(self.handle), byref(s), c_int16(len(s)), byref(requiredSize), c_enum(info)) self.checkResult(m) if requiredSize.value > len(s): s = create_string_buffer(requiredSize.value + 1) m = self.lib.ps3000aGetUnitInfo(c_int16(self.handle), byref(s), c_int16(len(s)), byref(requiredSize), c_enum(info)) self.checkResult(m) # should this bee ascii instead? # I think they are equivalent... return s.value.decode('utf-8') def _lowLevelFlashLed(self, times): m = self.lib.ps3000aFlashLed(c_int16(self.handle), c_int16(times)) self.checkResult(m) def _lowLevelSetSimpleTrigger(self, enabled, trigsrc, threshold_adc, direction, delay, auto): m = self.lib.ps3000aSetSimpleTrigger(c_int16(self.handle), c_int16(enabled), c_enum(trigsrc), c_int16(threshold_adc), c_enum(direction), c_uint32(delay), c_int16(auto)) self.checkResult(m) def _lowLevelSetNoOfCaptures(self, numCaptures): m = self.lib.ps3000aSetNoOfCaptures(c_int16(self.handle), c_uint16(numCaptures)) self.checkResult(m) def _lowLevelMemorySegments(self, numSegments): maxSamples = c_int32() m = self.lib.ps3000aMemorySegments(c_int16(self.handle), c_uint16(numSegments), byref(maxSamples)) self.checkResult(m) return maxSamples.value def _lowLevelGetMaxSegments(self): maxSegments = c_int16() m = self.lib.ps3000aGetMaxSegments(c_int16(self.handle), byref(maxSegments)) self.checkResult(m) return maxSegments.value def _lowLevelRunBlock(self, numPreTrigSamples, numPostTrigSamples, timebase, oversample, segmentIndex, callback, pParameter): # NOT: Oversample is NOT used! timeIndisposedMs = c_int32() m = self.lib.ps3000aRunBlock(c_int16(self.handle), c_uint32(numPreTrigSamples), c_uint32(numPostTrigSamples), c_uint32(timebase), c_int16(oversample), byref(timeIndisposedMs), c_uint32(segmentIndex), c_void_p(), c_void_p()) # According to the documentation, 'callback, pParameter' should work # instead of the last two c_void_p parameters. self.checkResult(m) return timeIndisposedMs.value def _lowLevelIsReady(self): ready = c_int16() m = self.lib.ps3000aIsReady(c_int16(self.handle), byref(ready)) self.checkResult(m) if ready.value: return True else: return False def _lowlevelPingUnit(self): m = self.lib.ps3000aPingUnit(c_int16(self.handle)) return m def _lowLevelGetTimebase(self, tb, noSamples, oversample, segmentIndex): """Return (timeIntervalSeconds, maxSamples).""" maxSamples = c_int32() intervalNanoSec = c_float() m = self.lib.ps3000aGetTimebase2(c_int16(self.handle), c_uint32(tb), c_uint32(noSamples), byref(intervalNanoSec), c_int16(oversample), byref(maxSamples), c_uint32(segmentIndex)) self.checkResult(m) # divide by 1e9 to return interval in seconds return (intervalNanoSec.value * 1e-9, maxSamples.value) def getTimeBaseNum(self, sampleTimeS): """Convert sample time in S to something to pass to API Call.""" maxSampleTime = (((2**32 - 1) - 2) / 125000000) if sampleTimeS < 8.0E-9: st = math.floor(math.log(sampleTimeS * 1E9, 2)) st = max(st, 0) else: if sampleTimeS > maxSampleTime: sampleTimeS = maxSampleTime st = math.floor((sampleTimeS * 125000000) + 2) # is this cast needed? st = int(st) return st def getTimestepFromTimebase(self, timebase): """Take API timestep code and returns the sampling period. API timestep is an integer from 0-32 """ if timebase < 3: dt = 2.**timebase / 1.0E9 else: dt = (timebase - 2.0) / 125000000. return dt def _lowLevelSetAWGSimpleDeltaPhase(self, waveform, deltaPhase, offsetVoltage, pkToPk, indexMode, shots, triggerType, triggerSource): """Waveform should be an array of shorts.""" waveformPtr = waveform.ctypes.data_as(POINTER(c_int16)) m = self.lib.ps3000aSetSigGenArbitrary( c_int16(self.handle), c_uint32(int(offsetVoltage * 1E6)), # offset voltage in microvolts c_uint32(int(pkToPk * 1E6)), # pkToPk in microvolts c_uint32(int(deltaPhase)), # startDeltaPhase c_uint32(int(deltaPhase)), # stopDeltaPhase c_uint32(0), # deltaPhaseIncrement c_uint32(0), # dwellCount waveformPtr, # arbitraryWaveform c_int32(len(waveform)), # arbitraryWaveformSize c_enum(0), # sweepType for deltaPhase c_enum(0), # operation (adding random noise and whatnot) c_enum(indexMode), # single, dual, quad c_uint32(shots), c_uint32(0), # sweeps c_uint32(triggerType), c_uint32(triggerSource), c_int16(0)) # extInThreshold self.checkResult(m) def _lowLevelSetDataBuffer(self, channel, data, downSampleMode, segmentIndex): """Set the data buffer. Be sure to call _lowLevelClearDataBuffer when you are done with the data array or else subsequent calls to GetValue will still use the same array. """ dataPtr = data.ctypes.data_as(POINTER(c_int16)) numSamples = len(data) m = self.lib.ps3000aSetDataBuffer(c_int16(self.handle), c_enum(channel), dataPtr, c_int32(numSamples), c_uint32(segmentIndex), c_enum(downSampleMode)) self.checkResult(m) def _lowLevelSetDataBufferBulk(self, channel, data, segmentIndex, downSampleMode): """Set the bulk data buffer. In ps3000a, ps3000aSetDataBuffer combines the functionality of psX000YSetDataBuffer and psX000YSetDataBufferBulk. Since the rapid block functions in picoscope.py call the Bulk version, a delegator is needed. Note that the order of segmentIndex and downSampleMode is reversed. """ self._lowLevelSetDataBuffer(channel, data, downSampleMode, segmentIndex) def _lowLevelSetMultipleDataBuffers(self, channel, data, downSampleMode): max_segments = self._lowLevelGetMaxSegments() if data.shape[0] < max_segments: raise ValueError("data array has fewer rows than current number " + "of memory segments") if data.shape[1] < self.maxSamples: raise ValueError("data array has fewer columns than maxSamples") for i in range(max_segments): m = self._lowLevelSetDataBuffer(channel, data[i, :], downSampleMode, i) self.checkResult(m) def _lowLevelClearDataBuffer(self, channel, segmentIndex): m = self.lib.ps3000aSetDataBuffer(c_int16(self.handle), c_enum(channel), c_void_p(), c_uint32(0), c_uint32(segmentIndex), c_enum(0)) self.checkResult(m) def _lowLevelGetValues(self, numSamples, startIndex, downSampleRatio, downSampleMode, segmentIndex): numSamplesReturned = c_uint32() numSamplesReturned.value = numSamples overflow = c_int16() m = self.lib.ps3000aGetValues(c_int16(self.handle), c_uint32(startIndex), byref(numSamplesReturned), c_uint32(downSampleRatio), c_enum(downSampleMode), c_uint32(segmentIndex), byref(overflow)) self.checkResult(m) return (numSamplesReturned.value, overflow.value) def _lowLevelGetValuesBulk(self, numSamples, fromSegment, toSegment, downSampleRatio, downSampleMode, overflow): m = self.lib.ps3000aGetValuesBulk( c_int16(self.handle), byref(c_uint32(numSamples)), c_uint32(fromSegment), c_uint32(toSegment), c_uint32(downSampleRatio), c_int16(downSampleMode), overflow.ctypes.data_as(POINTER(c_int16))) self.checkResult(m) return overflow, numSamples def _lowLevelSetSigGenBuiltInSimple(self, offsetVoltage, pkToPk, waveType, frequency, shots, triggerType, triggerSource, stopFreq, increment, dwellTime, sweepType, numSweeps): # TODO, I just noticed that V2 exists # Maybe change to V2 in the future if stopFreq is None: stopFreq = frequency m = self.lib.ps3000aSetSigGenBuiltIn( c_int16(self.handle), c_int32(int(offsetVoltage * 1000000)), c_int32(int(pkToPk * 1000000)), c_int16(waveType), c_float(frequency), c_float(stopFreq), c_float(increment), c_float(dwellTime), c_enum(sweepType), c_enum(0), c_uint32(shots), c_uint32(numSweeps), c_enum(triggerType), c_enum(triggerSource), c_int16(0)) self.checkResult(m) def _lowLevelChangePowerSource(self, powerstate): m = self.lib.ps3000aChangePowerSource(c_int16(self.handle), c_enum(powerstate)) self.checkResult(m) def _lowLevelSigGenSoftwareControl(self, triggerType): m = self.lib.ps3000aSigGenSoftwareControl(c_int16(self.handle), c_enum(triggerType)) self.checkResult(m)
class PS5000a(_PicoscopeBase): """The following are low-level functions for the PS5000.""" LIBNAME = "ps5000a" NUM_CHANNELS = 4 CHANNELS = {"A": 0, "B": 1, "C": 2, "D": 3, "External": 4, "MaxChannels": 4, "TriggerAux": 5} ADC_RESOLUTIONS = {"8": 0, "12": 1, "14": 2, "15": 3, "16": 4} CHANNEL_RANGE = [{"rangeV": 10E-3, "apivalue": 0, "rangeStr": "10 mV"}, {"rangeV": 20E-3, "apivalue": 1, "rangeStr": "20 mV"}, {"rangeV": 50E-3, "apivalue": 2, "rangeStr": "50 mV"}, {"rangeV": 100E-3, "apivalue": 3, "rangeStr": "100 mV"}, {"rangeV": 200E-3, "apivalue": 4, "rangeStr": "200 mV"}, {"rangeV": 500E-3, "apivalue": 5, "rangeStr": "500 mV"}, {"rangeV": 1.0, "apivalue": 6, "rangeStr": "1 V"}, {"rangeV": 2.0, "apivalue": 7, "rangeStr": "2 V"}, {"rangeV": 5.0, "apivalue": 8, "rangeStr": "5 V"}, {"rangeV": 10.0, "apivalue": 9, "rangeStr": "10 V"}, {"rangeV": 20.0, "apivalue": 10, "rangeStr": "20 V"}, {"rangeV": 50.0, "apivalue": 11, "rangeStr": "50 V"}, ] CHANNEL_COUPLINGS = {"DC": 1, "AC": 0} # has_sig_gen = True WAVE_TYPES = {"Sine": 0, "Square": 1, "Triangle": 2, "RampUp": 3, "RampDown": 4, "Sinc": 5, "Gaussian": 6, "HalfSine": 7, "DCVoltage": 8, "WhiteNoise": 9} SWEEP_TYPES = {"Up": 0, "Down": 1, "UpDown": 2, "DownUp": 3} SIGGEN_TRIGGER_TYPES = {"Rising": 0, "Falling": 1, "GateHigh": 2, "GateLow": 3} SIGGEN_TRIGGER_SOURCES = {"None": 0, "ScopeTrig": 1, "AuxIn": 2, "ExtIn": 3, "SoftTrig": 4, "TriggerRaw": 5} # This is actually different depending on the AB/CD models # I wonder how we could detect the difference between the oscilloscopes # I believe we can obtain this information from the setInfo function # by readign the hardware version # for the PS6403B version, the hardware version is "1 1", # an other possibility is that the PS6403B shows up as 6403 when using # VARIANT_INFO and others show up as PS6403X where X = A,C or D AWGPhaseAccumulatorSize = 32 AWGDACInterval = 5E-9 # in seconds AWGDACFrequency = 1 / AWGDACInterval AWG_INDEX_MODES = {"Single": 0, "Dual": 1, "Quad": 2} MAX_VALUE_8BIT = 32512 MIN_VALUE_8BIT = -32512 MAX_VALUE_OTHER = 32767 MIN_VALUE_OTHER = -32767 EXT_RANGE_VOLTS = 5 def __init__(self, serialNumber=None, connect=True): """Load DLL etc.""" if platform.system() == 'Linux': from ctypes import cdll self.lib = cdll.LoadLibrary("lib" + self.LIBNAME + ".so") elif platform.system() == 'Darwin': from picoscope.darwin_utils import LoadLibraryDarwin self.lib = LoadLibraryDarwin("lib" + self.LIBNAME + ".dylib") else: from ctypes import windll self.lib = windll.LoadLibrary(str(self.LIBNAME + ".dll")) self.resolution = self.ADC_RESOLUTIONS["8"] super(PS5000a, self).__init__(serialNumber, connect) def _lowLevelOpenUnit(self, sn): c_handle = c_int16() if sn is not None: serialNullTermStr = create_string_buffer(sn) else: serialNullTermStr = None # Passing None is the same as passing NULL m = self.lib.ps5000aOpenUnit(byref(c_handle), serialNullTermStr, self.resolution) self.handle = c_handle.value # This will check if the power supply is not connected # and change the power supply accordingly # Personally (me = Mark), I don't like this # since the user should address this immediately, and we # shouldn't let this go as a soft error # but I think this should do for now if m == 0x11A: self.changePowerSource(m) else: self.checkResult(m) # B models have different AWG buffer sizes # 5242B, 5442B: 2**14 # 5243B, 5443B: 2**15 # 5444B, 5244B: 3 * 2**14 # Model 5444B identifies itself properly in VariantInfo, I will assume # the others do as well. self.model = self.getUnitInfo('VariantInfo') # print("Checking variant, found: " + str(self.model)) if self.model in ('5244B', '5444B'): self.AWGBufferAddressWidth = math.log(3 * 2**14, 2) self.AWGMaxVal = 32767 self.AWGMinVal = -32768 self.AWGMaxSamples = 49152 elif self.model in ('5243B', '5443B'): self.AWGBufferAddressWidth = 15 self.AWGMaxVal = 32767 self.AWGMinVal = -32768 self.AWGMaxSamples = 2**self.AWGBufferAddressWidth else: # This is what the previous PS5000a used for all scopes. # I am leaving it the same, although I think the AWGMaxVal and # AWGMinVal issue was fixed and should be -32768 to 32767 for all # 5000 models self.AWGBufferAddressWidth = 14 # Note this is NOT what is written in the Programming guide as of # version # 10_5_0_28 # This issue was acknowledged in this thread # http://www.picotech.com/support/topic13217.html self.AWGMaxVal = 0x0FFF self.AWGMinVal = 0x0000 self.AWGMaxSamples = 2**self.AWGBufferAddressWidth def _lowLevelCloseUnit(self): m = self.lib.ps5000aCloseUnit(c_int16(self.handle)) self.checkResult(m) def _lowLevelSetChannel(self, chNum, enabled, coupling, VRange, VOffset, bandwidth): m = self.lib.ps5000aSetChannel(c_int16(self.handle), c_enum(chNum), c_int16(enabled), c_enum(coupling), c_enum(VRange), c_float(VOffset)) self.checkResult(m) # The error this might through are # INVALID_HANDLE # INVALID_CHANNEL # INVALID_BANDWIDTH # Invalid bandwidth is the only case that could go wrong. # The others would be thrown above (assuming no race condition: # i.e. unplugging the scope in between this call. # I decided to keep the logic below to avoid a possible error # picobase/SetChannel should be changed to the following # Set the channel # save the new channel settings # check if ps5000a # change the bandwidth separately # changing the bandwidth would be it's own function (implemented below) if bandwidth: m = self.lib.ps5000aSetBandwidthFilter(c_int16(self.handle), c_enum(chNum), c_enum(1)) else: m = self.lib.ps5000aSetBandwidthFilter(c_int16(self.handle), c_enum(chNum), c_enum(0)) self.checkResult(m) def _lowLevelSetBandwidthFilter(self, channel, bandwidth): m = self.lib.ps5000aSetBandwidthFilter(c_int16(self.handle), c_enum(channel), c_enum(bandwidth)) self.checkResult(m) def _lowLevelStop(self): m = self.lib.ps5000aStop(c_int16(self.handle)) self.checkResult(m) def _lowLevelGetUnitInfo(self, info): s = create_string_buffer(256) requiredSize = c_int16(0) m = self.lib.ps5000aGetUnitInfo(c_int16(self.handle), byref(s), c_int16(len(s)), byref(requiredSize), c_enum(info)) self.checkResult(m) if requiredSize.value > len(s): s = create_string_buffer(requiredSize.value + 1) m = self.lib.ps5000aGetUnitInfo(c_int16(self.handle), byref(s), c_int16(len(s)), byref(requiredSize), c_enum(info)) self.checkResult(m) # should this bee ascii instead? # I think they are equivalent... return s.value.decode('utf-8') def _lowLevelFlashLed(self, times): m = self.lib.ps5000aFlashLed(c_int16(self.handle), c_int16(times)) self.checkResult(m) def _lowLevelSetSimpleTrigger(self, enabled, trigsrc, threshold_adc, direction, delay, timeout_ms): m = self.lib.ps5000aSetSimpleTrigger( c_int16(self.handle), c_int16(enabled), c_enum(trigsrc), c_int16(threshold_adc), c_enum(direction), c_uint32(delay), c_int16(timeout_ms)) self.checkResult(m) def _lowLevelRunBlock(self, numPreTrigSamples, numPostTrigSamples, timebase, oversample, segmentIndex): # Oversample is NOT used! timeIndisposedMs = c_int32() m = self.lib.ps5000aRunBlock( c_int16(self.handle), c_uint32(numPreTrigSamples), c_uint32(numPostTrigSamples), c_uint32(timebase), byref(timeIndisposedMs), c_uint32(segmentIndex), c_void_p(), c_void_p()) self.checkResult(m) return timeIndisposedMs.value def _lowLevelIsReady(self): ready = c_int16() m = self.lib.ps5000aIsReady(c_int16(self.handle), byref(ready)) self.checkResult(m) if ready.value: return True else: return False def _lowLevelPingUnit(self): m = self.lib.ps5000aPingUnit(c_int16(self.handle)) return m def _lowLevelGetTimebase(self, tb, noSamples, oversample, segmentIndex): """Return (timeIntervalSeconds, maxSamples).""" maxSamples = c_int32() sampleRate = c_float() m = self.lib.ps5000aGetTimebase2(c_int16(self.handle), c_uint32(tb), c_uint32(noSamples), byref(sampleRate), byref(maxSamples), c_uint32(segmentIndex)) self.checkResult(m) return (sampleRate.value / 1.0E9, maxSamples.value) def getTimeBaseNum(self, sampleTimeS): """Convert sample time in S to something to pass to API Call.""" if self.resolution == self.ADC_RESOLUTIONS["8"]: maxSampleTime = (((2 ** 32 - 1) - 2) / 125000000) if sampleTimeS < 8.0E-9: st = math.floor(math.log(sampleTimeS * 1E9, 2)) st = max(st, 0) else: if sampleTimeS > maxSampleTime: sampleTimeS = maxSampleTime st = math.floor((sampleTimeS * 125000000) + 2) elif self.resolution == self.ADC_RESOLUTIONS["12"]: maxSampleTime = (((2 ** 32 - 1) - 3) / 62500000) if sampleTimeS < 16.0E-9: st = math.floor(math.log(sampleTimeS * 5E8, 2)) + 1 st = max(st, 1) else: if sampleTimeS > maxSampleTime: sampleTimeS = maxSampleTime st = math.floor((sampleTimeS * 62500000) + 3) elif (self.resolution == self.ADC_RESOLUTIONS["14"]) or ( self.resolution == self.ADC_RESOLUTIONS["15"]): maxSampleTime = (((2 ** 32 - 1) - 2) / 125000000) if sampleTimeS > maxSampleTime: sampleTimeS = maxSampleTime st = math.floor((sampleTimeS * 125000000) + 2) st = max(st, 3) elif self.resolution == self.ADC_RESOLUTIONS["16"]: maxSampleTime = (((2 ** 32 - 1) - 3) / 62500000) if sampleTimeS > maxSampleTime: sampleTimeS = maxSampleTime st = math.floor((sampleTimeS * 62500000) + 3) st = max(st, 3) else: raise ValueError("Invalid Resolution for Device?") # is this cast needed? st = int(st) return st def getTimestepFromTimebase(self, timebase): """Return Timestep from timebase.""" if self.resolution == self.ADC_RESOLUTIONS["8"]: if timebase < 3: dt = 2. ** timebase / 1.0E9 else: dt = (timebase - 2.0) / 125000000. elif self.resolution == self.ADC_RESOLUTIONS["12"]: if timebase < 4: dt = 2. ** (timebase - 1) / 5.0E8 else: dt = (timebase - 3.0) / 62500000. elif (self.resolution == self.ADC_RESOLUTIONS["14"]) or ( self.resolution == self.ADC_RESOLUTIONS["15"]): dt = (timebase - 2.0) / 125000000. elif self.resolution == self.ADC_RESOLUTIONS["16"]: dt = (timebase - 3.0) / 62500000. return dt def _lowLevelSetAWGSimpleDeltaPhase(self, waveform, deltaPhase, offsetVoltage, pkToPk, indexMode, shots, triggerType, triggerSource): """Waveform should be an array of shorts.""" waveformPtr = waveform.ctypes.data_as(POINTER(c_int16)) m = self.lib.ps5000aSetSigGenArbitrary( c_int16(self.handle), c_uint32(int(offsetVoltage * 1E6)), # offset voltage in microvolts c_uint32(int(pkToPk * 1E6)), # pkToPk in microvolts c_uint32(int(deltaPhase)), # startDeltaPhase c_uint32(int(deltaPhase)), # stopDeltaPhase c_uint32(0), # deltaPhaseIncrement c_uint32(0), # dwellCount waveformPtr, # arbitraryWaveform c_int32(len(waveform)), # arbitraryWaveformSize c_enum(0), # sweepType for deltaPhase c_enum(0), # operation (adding random noise and whatnot) c_enum(indexMode), # single, dual, quad c_uint32(shots), c_uint32(0), # sweeps c_uint32(triggerType), c_uint32(triggerSource), c_int16(0)) # extInThreshold self.checkResult(m) def _lowLevelSetDataBuffer(self, channel, data, downSampleMode, segmentIndex): """Set the data buffer. Be sure to call _lowLevelClearDataBuffer when you are done with the data array or else subsequent calls to GetValue will still use the same array. """ dataPtr = data.ctypes.data_as(POINTER(c_int16)) numSamples = len(data) m = self.lib.ps5000aSetDataBuffer(c_int16(self.handle), c_enum(channel), dataPtr, c_int32(numSamples), c_uint32(segmentIndex), c_enum(downSampleMode)) self.checkResult(m) def _lowLevelSetDataBufferBulk(self, channel, data, segmentIndex, downSampleMode): """Just calls setDataBuffer with argument order changed. For compatibility with current picobase.py. """ self._lowLevelSetDataBuffer(channel, data, downSampleMode, segmentIndex) def _lowLevelClearDataBuffer(self, channel, segmentIndex): m = self.lib.ps5000aSetDataBuffer(c_int16(self.handle), c_enum(channel), c_void_p(), c_uint32(0), c_uint32(segmentIndex), c_enum(0)) self.checkResult(m) def _lowLevelGetValues(self, numSamples, startIndex, downSampleRatio, downSampleMode, segmentIndex): numSamplesReturned = c_uint32() numSamplesReturned.value = numSamples overflow = c_int16() m = self.lib.ps5000aGetValues( c_int16(self.handle), c_uint32(startIndex), byref(numSamplesReturned), c_uint32(downSampleRatio), c_enum(downSampleMode), c_uint32(segmentIndex), byref(overflow)) self.checkResult(m) return (numSamplesReturned.value, overflow.value) def _lowLevelSetSigGenBuiltInSimple(self, offsetVoltage, pkToPk, waveType, frequency, shots, triggerType, triggerSource, stopFreq, increment, dwellTime, sweepType, numSweeps): # TODO, I just noticed that V2 exists # Maybe change to V2 in the future if stopFreq is None: stopFreq = frequency m = self.lib.ps5000aSetSigGenBuiltIn( c_int16(self.handle), c_int32(int(offsetVoltage * 1000000)), c_int32(int(pkToPk * 1000000)), c_int16(waveType), c_float(frequency), c_float(stopFreq), c_float(increment), c_float(dwellTime), c_enum(sweepType), c_enum(0), c_uint32(shots), c_uint32(numSweeps), c_enum(triggerType), c_enum(triggerSource), c_int16(0)) self.checkResult(m) def _lowLevelSetDeviceResolution(self, resolution): self.resolution = resolution m = self.lib.ps5000aSetDeviceResolution( c_int16(self.handle), c_enum(resolution)) self.checkResult(m) def _lowLevelChangePowerSource(self, powerstate): m = self.lib.ps5000aChangePowerSource( c_int16(self.handle), c_enum(powerstate)) self.checkResult(m) # Morgan's additions def _lowLevelGetValuesBulk(self, numSamples, fromSegment, toSegment, downSampleRatio, downSampleMode, overflow): """Copy data from several memory segments at once.""" overflowPoint = overflow.ctypes.data_as(POINTER(c_int16)) m = self.lib.ps5000aGetValuesBulk( c_int16(self.handle), byref(c_int32(numSamples)), c_int32(fromSegment), c_int32(toSegment), c_int32(downSampleRatio), c_enum(downSampleMode), overflowPoint ) self.checkResult(m) def _lowLevelSetNoOfCaptures(self, numCaptures): m = self.lib.ps5000aSetNoOfCaptures( c_int16(self.handle), c_uint32(numCaptures)) self.checkResult(m) def _lowLevelMemorySegments(self, numSegments): maxSamples = c_int32() m = self.lib.ps5000aMemorySegments( c_int16(self.handle), c_uint32(numSegments), byref(maxSamples)) self.checkResult(m) return maxSamples.value def _lowLevelGetValuesTriggerTimeOffsetBulk(self, fromSegment, toSegment): """Supposedly gets the trigger times for a bunch of segments at once. For block mode. Can't get it to work yet, however. """ import numpy as np nSegments = toSegment - fromSegment + 1 # time = c_int64() times = np.ascontiguousarray( np.zeros(nSegments, dtype=np.int64) ) timeUnits = np.ascontiguousarray( np.zeros(nSegments, dtype=np.int32) ) m = self.lib.ps5000aGetValuesTriggerTimeOffsetBulk64( c_int16(self.handle), times.ctypes.data_as(POINTER(c_int64)), timeUnits.ctypes.data_as(POINTER(c_enum)), c_uint32(fromSegment), c_uint32(toSegment) ) self.checkResult(m) # timeUnits=np.array([self.TIME_UNITS[tu] for tu in timeUnits]) return times, timeUnits
class PS3000(_PicoscopeBase): """The following are low-level functions for the PS3000.""" LIBNAME = "ps3000" NUM_CHANNELS = 2 CHANNELS = {"A": 0, "B": 1, "MaxChannels": 2} THRESHOLD_TYPE = {"Rising": 0, "Falling": 1} CHANNEL_RANGE = [ {"rangeV": 20E-3, "apivalue": 1, "rangeStr": "20 mV"}, {"rangeV": 50E-3, "apivalue": 2, "rangeStr": "50 mV"}, {"rangeV": 100E-3, "apivalue": 3, "rangeStr": "100 mV"}, {"rangeV": 200E-3, "apivalue": 4, "rangeStr": "200 mV"}, {"rangeV": 500E-3, "apivalue": 5, "rangeStr": "500 mV"}, {"rangeV": 1.0, "apivalue": 6, "rangeStr": "1 V"}, {"rangeV": 2.0, "apivalue": 7, "rangeStr": "2 V"}, {"rangeV": 5.0, "apivalue": 8, "rangeStr": "5 V"}, {"rangeV": 10.0, "apivalue": 9, "rangeStr": "10 V"}, {"rangeV": 20.0, "apivalue": 10, "rangeStr": "20 V"}, ] CHANNEL_COUPLINGS = {"DC": 1, "AC": 0} # has_sig_gen = True WAVE_TYPES = {"Sine": 0, "Square": 1, "Triangle": 2, "RampUp": 3, "RampDown": 4, "DCVoltage": 5} SWEEP_TYPES = {"Up": 0, "Down": 1, "UpDown": 2, "DownUp": 3} TIME_UNITS = {"FS": 0, "PS": 1, "NS": 2, "US": 3, "MS": 4, "S": 5} MAX_VALUE = 32767 MIN_VALUE = -32767 MAX_TIMEBASES = 19 UNIT_INFO_TYPES = {"DriverVersion": 0x0, "USBVersion": 0x1, "HardwareVersion": 0x2, "VariantInfo": 0x3, "BatchAndSerial": 0x4, "CalDate": 0x5, "ErrorCode": 0x6, "KernelVersion": 0x7} channelBuffersPtr = [c_void_p(), c_void_p()] channelBuffersLen = [0, 0] # SIGGEN_TRIGGER_TYPES = {"Rising": 0, "Falling": 1, # "GateHigh": 2, "GateLow": 3} # SIGGEN_TRIGGER_SOURCES = {"None": 0, "ScopeTrig": 1, "AuxIn": 2, # "ExtIn": 3, "SoftTrig": 4, "TriggerRaw": 5} def __init__(self, serialNumber=None, connect=True): """Load DLL etc.""" if platform.system() == 'Linux': from ctypes import cdll self.lib = cdll.LoadLibrary("lib" + self.LIBNAME + ".so") elif platform.system() == 'Darwin': from picoscope.darwin_utils import LoadLibraryDarwin self.lib = LoadLibraryDarwin("lib" + self.LIBNAME + ".dylib") else: from ctypes import windll self.lib = windll.LoadLibrary(str(self.LIBNAME + ".dll")) super(PS3000, self).__init__(serialNumber, connect) def _lowLevelOpenUnit(self, sn): if sn is not None: raise ValueError("PS3000 Doesn't Support Open by Serial Number") m = self.lib.ps3000_open_unit() if m < 0: raise IOError("Failed to Find PS3000 Unit. " + "Should you be using PS3000a driver?") self.handle = m self.suggested_time_units = self.TIME_UNITS["NS"] def _lowLevelCloseUnit(self): m = self.lib.ps3000_close_unit(c_int16(self.handle)) self.checkResult(m) def _lowLevelSetChannel(self, chNum, enabled, coupling, VRange, VOffset, BWLimited): m = self.lib.ps3000_set_channel( c_int16(self.handle), c_enum(chNum), c_int16(enabled), c_enum(coupling), c_enum(VRange)) self.checkResult(m) def _lowLevelStop(self): m = self.lib.ps3000_stop(c_int16(self.handle)) self.checkResult(m) def _lowLevelGetUnitInfo(self, info): s = create_string_buffer(256) m = self.lib.ps3000_get_unit_info( c_int16(self.handle), byref(s), c_int16(len(s)), c_enum(info)) self.checkResult(m) # should this bee ascii instead? # I think they are equivalent... return s.value.decode('utf-8') def _lowLevelFlashLed(self, times): m = self.lib.ps3000_flash_led(c_int16(self.handle)) self.checkResult(m) def _lowLevelSetSimpleTrigger(self, enabled, trigsrc, threshold_adc, direction, delay, timeout_ms): # TODO: Fix 'auto' which is where trigger occurs in block. # Delay is not used m = self.lib.ps3000_set_trigger( c_int16(self.handle), c_enum(trigsrc), c_int16(threshold_adc), c_enum(direction), c_int16(delay), c_int16(timeout_ms)) self.checkResult(m) def _lowLevelRunBlock(self, numPreTrigSamples, numPostTrigSamples, timebase, oversample, segmentIndex): # NOT: Oversample is NOT used! # TODO: Fix 'delay' which is where trigger occurs in block if numPreTrigSamples > 0: raise ValueError("numPreTrigSamples isn't supported on PS3000") timeIndisposedMs = c_int32() m = self.lib.ps3000_run_block( c_int16(self.handle), c_uint32(numPostTrigSamples), c_uint32(timebase), c_int16(1), byref(timeIndisposedMs)) self.checkResult(m) return timeIndisposedMs.value def _lowLevelIsReady(self): ready = c_int16() ready = self.lib.ps3000_ready(c_int16(self.handle)) if ready > 0: return True elif ready == 0: return False else: raise IOError("ps3000_ready returned %d" % ready.value) def _lowLevelGetTimebase(self, tb, noSamples, oversample, segmentIndex): """Return (timeIntervalSeconds, maxSamples).""" maxSamples = c_int32() time_interval = c_int32() time_units = c_int16() m = self.lib.ps3000_get_timebase( c_int16(self.handle), c_int16(tb), c_uint32(noSamples), byref(time_interval), byref(time_units), c_int16(1), byref(maxSamples)) self.checkResult(m) self.suggested_time_units = time_units.value return (time_interval.value / 1.0E9, maxSamples.value) def getTimeBaseNum(self, sampleTimeS): """ps3000 doesn't seem to have published formula like other scopes.""" time_interval = c_int32() timebases = [None] * self.MAX_TIMEBASES # Convert to nS sampleTimenS = sampleTimeS * 1E9 tb = 0 while tb < self.MAX_TIMEBASES: rv = self.lib.ps3000_get_timebase( c_int16(self.handle), c_int16(tb), c_uint32(512), byref(time_interval), c_void_p(), c_int16(1), c_void_p()) if rv != 0: timebases[tb] = time_interval.value tb += 1 # Figure out closest option besterror = 1E99 bestindx = 0 for indx, val in enumerate(timebases): if val is not None: error = sampleTimenS - val if abs(error) < besterror: besterror = abs(error) bestindx = indx return bestindx def getTimestepFromTimebase(self, timebase): """Return timestep from Timebase.""" time_interval = c_int32() m = self.lib.ps3000_get_timebase( c_int16(self.handle), c_int16(timebase), c_uint32(512), byref(time_interval), c_void_p(), c_int16(1), c_void_p()) self.checkResult(m) return (time_interval.value / 1.0E9) def _lowLevelSetDataBuffer(self, channel, data, downSampleMode, segmentIndex): dataPtr = data.ctypes.data_as(POINTER(c_int16)) numSamples = len(data) self.channelBuffersPtr[channel] = dataPtr self.channelBuffersLen[channel] = numSamples def _lowLevelClearDataBuffer(self, channel, segmentIndex): self.channelBuffersPtr[channel] = c_void_p() self.channelBuffersLen[channel] = 0 def _lowLevelGetValues(self, numSamples, startIndex, downSampleRatio, downSampleMode, segmentIndex): # TODO: # Check overflow in channelBuffersLen against numSamples, # but need to not raise error if channelBuffersPtr is void overflow = c_int16() rv = self.lib.ps3000_get_values( c_int16(self.handle), self.channelBuffersPtr[0], self.channelBuffersPtr[1], c_void_p(), c_void_p(), byref(overflow), c_int32(numSamples)) self.checkResult(rv) return (rv, overflow.value) def _lowLevelSetSigGenBuiltInSimple(self, offsetVoltage, pkToPk, waveType, frequency, shots, triggerType, triggerSource, stopFreq, increment, dwellTime, sweepType, numSweeps): if stopFreq is None: stopFreq = frequency m = self.lib.ps3000_set_sig_gen_built_in( c_int16(self.handle), c_int32(int(offsetVoltage * 1000000)), c_int32(int(pkToPk * 1000000)), c_int16(waveType), c_float(frequency), c_float(stopFreq), c_float(increment), c_float(dwellTime), c_enum(sweepType), c_uint32(numSweeps)) self.checkResult(m) def checkResult(self, ec): """Check result of function calls, raise exception if not 0.""" # PS3000 differs from other drivers in that non-zero is good if ec == 0: raise IOError('Error calling %s' % (inspect.stack()[1][3])) return 0
class PS3000(_PicoscopeBase): """The following are low-level functions for the PS3000.""" LIBNAME = "ps3000" NUM_CHANNELS = 2 CHANNELS = {"A": 0, "B": 1, "MaxChannels": 2} THRESHOLD_TYPE = {"Rising": 0, "Falling": 1} CHANNEL_RANGE = [ { "rangeV": 20E-3, "apivalue": 1, "rangeStr": "20 mV" }, { "rangeV": 50E-3, "apivalue": 2, "rangeStr": "50 mV" }, { "rangeV": 100E-3, "apivalue": 3, "rangeStr": "100 mV" }, { "rangeV": 200E-3, "apivalue": 4, "rangeStr": "200 mV" }, { "rangeV": 500E-3, "apivalue": 5, "rangeStr": "500 mV" }, { "rangeV": 1.0, "apivalue": 6, "rangeStr": "1 V" }, { "rangeV": 2.0, "apivalue": 7, "rangeStr": "2 V" }, { "rangeV": 5.0, "apivalue": 8, "rangeStr": "5 V" }, { "rangeV": 10.0, "apivalue": 9, "rangeStr": "10 V" }, { "rangeV": 20.0, "apivalue": 10, "rangeStr": "20 V" }, ] CHANNEL_COUPLINGS = {"DC": 1, "AC": 0} # has_sig_gen = True WAVE_TYPES = { "Sine": 0, "Square": 1, "Triangle": 2, "RampUp": 3, "RampDown": 4, "DCVoltage": 5 } SWEEP_TYPES = {"Up": 0, "Down": 1, "UpDown": 2, "DownUp": 3} TIME_UNITS = {"FS": 0, "PS": 1, "NS": 2, "US": 3, "MS": 4, "S": 5} MAX_VALUE = 32767 MIN_VALUE = -32767 MAX_TIMEBASES = 19 UNIT_INFO_TYPES = { "DriverVersion": 0x0, "USBVersion": 0x1, "HardwareVersion": 0x2, "VariantInfo": 0x3, "BatchAndSerial": 0x4, "CalDate": 0x5, "ErrorCode": 0x6, "KernelVersion": 0x7 } channelBuffersPtr = [c_void_p(), c_void_p()] channelBuffersLen = [0, 0] # SIGGEN_TRIGGER_TYPES = {"Rising": 0, "Falling": 1, # "GateHigh": 2, "GateLow": 3} # SIGGEN_TRIGGER_SOURCES = {"None": 0, "ScopeTrig": 1, "AuxIn": 2, # "ExtIn": 3, "SoftTrig": 4, "TriggerRaw": 5} def __init__(self, serialNumber=None, connect=True): """Load DLL etc.""" if platform.system() == 'Linux': from ctypes import cdll self.lib = cdll.LoadLibrary("lib" + self.LIBNAME + ".so") elif platform.system() == 'Darwin': from picoscope.darwin_utils import LoadLibraryDarwin self.lib = LoadLibraryDarwin("lib" + self.LIBNAME + ".dylib") else: from ctypes import windll self.lib = windll.LoadLibrary(str(self.LIBNAME + ".dll")) super(PS3000, self).__init__(serialNumber, connect) def _lowLevelOpenUnit(self, sn): if sn is not None: raise ValueError("PS3000 Doesn't Support Open by Serial Number") m = self.lib.ps3000_open_unit() if m < 0: raise IOError("Failed to Find PS3000 Unit. " + "Should you be using PS3000a driver?") self.handle = m self.suggested_time_units = self.TIME_UNITS["NS"] def _lowLevelCloseUnit(self): m = self.lib.ps3000_close_unit(c_int16(self.handle)) self.checkResult(m) def _lowLevelSetChannel(self, chNum, enabled, coupling, VRange, VOffset, BWLimited): m = self.lib.ps3000_set_channel(c_int16(self.handle), c_enum(chNum), c_int16(enabled), c_enum(coupling), c_enum(VRange)) self.checkResult(m) def _lowLevelStop(self): m = self.lib.ps3000_stop(c_int16(self.handle)) self.checkResult(m) def _lowLevelGetUnitInfo(self, info): s = create_string_buffer(256) m = self.lib.ps3000_get_unit_info(c_int16(self.handle), byref(s), c_int16(len(s)), c_enum(info)) self.checkResult(m) # should this bee ascii instead? # I think they are equivalent... return s.value.decode('utf-8') def _lowLevelFlashLed(self, times): m = self.lib.ps3000_flash_led(c_int16(self.handle)) self.checkResult(m) def _lowLevelSetSimpleTrigger(self, enabled, trigsrc, threshold_adc, direction, delay, timeout_ms): # TODO: Fix 'auto' which is where trigger occurs in block. # Delay is not used m = self.lib.ps3000_set_trigger(c_int16(self.handle), c_enum(trigsrc), c_int16(threshold_adc), c_enum(direction), c_int16(delay), c_int16(timeout_ms)) self.checkResult(m) def _lowLevelRunBlock(self, numPreTrigSamples, numPostTrigSamples, timebase, oversample, segmentIndex): # NOT: Oversample is NOT used! # TODO: Fix 'delay' which is where trigger occurs in block if numPreTrigSamples > 0: raise ValueError("numPreTrigSamples isn't supported on PS3000") timeIndisposedMs = c_int32() m = self.lib.ps3000_run_block(c_int16(self.handle), c_uint32(numPostTrigSamples), c_uint32(timebase), c_int16(1), byref(timeIndisposedMs)) self.checkResult(m) return timeIndisposedMs.value def _lowLevelIsReady(self): ready = c_int16() ready = self.lib.ps3000_ready(c_int16(self.handle)) if ready > 0: return True elif ready == 0: return False else: raise IOError("ps3000_ready returned %d" % ready.value) def _lowLevelGetTimebase(self, tb, noSamples, oversample, segmentIndex): """Return (timeIntervalSeconds, maxSamples).""" maxSamples = c_int32() time_interval = c_int32() time_units = c_int16() m = self.lib.ps3000_get_timebase(c_int16(self.handle), c_int16(tb), c_uint32(noSamples), byref(time_interval), byref(time_units), c_int16(1), byref(maxSamples)) self.checkResult(m) self.suggested_time_units = time_units.value return (time_interval.value / 1.0E9, maxSamples.value) def getTimeBaseNum(self, sampleTimeS): """ps3000 doesn't seem to have published formula like other scopes.""" time_interval = c_int32() timebases = [None] * self.MAX_TIMEBASES # Convert to nS sampleTimenS = sampleTimeS * 1E9 tb = 0 while tb < self.MAX_TIMEBASES: rv = self.lib.ps3000_get_timebase(c_int16(self.handle), c_int16(tb), c_uint32(512), byref(time_interval), c_void_p(), c_int16(1), c_void_p()) if rv != 0: timebases[tb] = time_interval.value tb += 1 # Figure out closest option besterror = 1E99 bestindx = 0 for indx, val in enumerate(timebases): if val is not None: error = sampleTimenS - val if abs(error) < besterror: besterror = abs(error) bestindx = indx return bestindx def getTimestepFromTimebase(self, timebase): """Return timestep from Timebase.""" time_interval = c_int32() m = self.lib.ps3000_get_timebase(c_int16(self.handle), c_int16(timebase), c_uint32(512), byref(time_interval), c_void_p(), c_int16(1), c_void_p()) self.checkResult(m) return (time_interval.value / 1.0E9) def _lowLevelSetDataBuffer(self, channel, data, downSampleMode, segmentIndex): dataPtr = data.ctypes.data_as(POINTER(c_int16)) numSamples = len(data) self.channelBuffersPtr[channel] = dataPtr self.channelBuffersLen[channel] = numSamples def _lowLevelClearDataBuffer(self, channel, segmentIndex): self.channelBuffersPtr[channel] = c_void_p() self.channelBuffersLen[channel] = 0 def _lowLevelGetValues(self, numSamples, startIndex, downSampleRatio, downSampleMode, segmentIndex): # TODO: # Check overflow in channelBuffersLen against numSamples, # but need to not raise error if channelBuffersPtr is void overflow = c_int16() rv = self.lib.ps3000_get_values(c_int16(self.handle), self.channelBuffersPtr[0], self.channelBuffersPtr[1], c_void_p(), c_void_p(), byref(overflow), c_int32(numSamples)) self.checkResult(rv) return (rv, overflow.value) def _lowLevelSetSigGenBuiltInSimple(self, offsetVoltage, pkToPk, waveType, frequency, shots, triggerType, triggerSource, stopFreq, increment, dwellTime, sweepType, numSweeps): if stopFreq is None: stopFreq = frequency m = self.lib.ps3000_set_sig_gen_built_in( c_int16(self.handle), c_int32(int(offsetVoltage * 1000000)), c_int32(int(pkToPk * 1000000)), c_int16(waveType), c_float(frequency), c_float(stopFreq), c_float(increment), c_float(dwellTime), c_enum(sweepType), c_uint32(numSweeps)) self.checkResult(m) def checkResult(self, ec): """Check result of function calls, raise exception if not 0.""" # PS3000 differs from other drivers in that non-zero is good if ec == 0: raise IOError('Error calling %s' % (inspect.stack()[1][3])) return 0
class PS4000(_PicoscopeBase): """The following are low-level functions for the PS4000.""" LIBNAME = "ps4000" MAX_VALUE = 32764 MIN_VALUE = -32764 # AWG stuff here: AWGMaxSamples = 4096 AWGDACInterval = 1 / 192000 # [s] AWGDACFrequency = 192000 # [Hz] AWGPhaseAccumulatorSize = 32 AWGMaxVal = 32767 AWGMinVal = -32768 AWG_INDEX_MODES = {"Single": 0, "Dual": 1, "Quad": 2} AWGBufferAddressWidth = 12 AWGMaxSamples = 2**AWGBufferAddressWidth SIGGEN_TRIGGER_TYPES = { "Rising": 0, "Falling": 1, "GateHigh": 2, "GateLow": 3 } SIGGEN_TRIGGER_SOURCES = { "None": 0, "ScopeTrig": 1, "AuxIn": 2, "ExtIn": 3, "SoftTrig": 4 } # EXT/AUX seems to have an imput impedence of 50 ohm (PS6403B) EXT_MAX_VALUE = 32767 EXT_MIN_VALUE = -32767 EXT_RANGE_VOLTS = 1 # I don't think that the 50V range is allowed, but I left it there anyway # The 10V and 20V ranges are only allowed in high impedence modes CHANNEL_RANGE = [ { "rangeV": 20E-3, "apivalue": 1, "rangeStr": "20 mV" }, { "rangeV": 50E-3, "apivalue": 2, "rangeStr": "50 mV" }, { "rangeV": 100E-3, "apivalue": 3, "rangeStr": "100 mV" }, { "rangeV": 200E-3, "apivalue": 4, "rangeStr": "200 mV" }, { "rangeV": 500E-3, "apivalue": 5, "rangeStr": "500 mV" }, { "rangeV": 1.0, "apivalue": 6, "rangeStr": "1 V" }, { "rangeV": 2.0, "apivalue": 7, "rangeStr": "2 V" }, { "rangeV": 5.0, "apivalue": 8, "rangeStr": "5 V" }, { "rangeV": 10.0, "apivalue": 9, "rangeStr": "10 V" }, { "rangeV": 20.0, "apivalue": 10, "rangeStr": "20 V" }, { "rangeV": 50.0, "apivalue": 11, "rangeStr": "50 V" }, ] NUM_CHANNELS = 4 CHANNELS = {"A": 0, "B": 1, "C": 2, "D": 3, "EXT": 4} CHANNEL_COUPLINGS = {"DC50": 2, "DC": 1, "AC": 0} WAVE_TYPES = { "Sine": 0, "Square": 1, "Triangle": 2, "RampUp": 3, "RampDown": 4, "Sinc": 5, "Gaussian": 6, "HalfSine": 7, "DCVoltage": 8, "WhiteNoise": 9 } SWEEP_TYPES = {"Up": 0, "Down": 1, "UpDown": 2, "DownUp": 3} def __init__(self, serialNumber=None, connect=True): """Load DLLs.""" self.handle = None if platform.system() == 'Linux': from ctypes import cdll # ok I don't know what is wrong with my installer, # but I need to include .so.2 self.lib = cdll.LoadLibrary("lib" + self.LIBNAME + ".so.2") elif platform.system() == 'Darwin': from picoscope.darwin_utils import LoadLibraryDarwin self.lib = LoadLibraryDarwin("lib" + self.LIBNAME + ".dylib") else: from ctypes import windll self.lib = windll.LoadLibrary(str(self.LIBNAME + ".dll")) super(PS4000, self).__init__(serialNumber, connect) # check to see which model we have and use special functions if needed unit_number = self.getUnitInfo('VariantInfo') if unit_number == '4262': self.getTimestepFromTimebase = self._getTimestepFromTimebase4262 self.getTimeBaseNum = self._getTimeBaseNum4262 elif unit_number in {'4223', '4224', '4423', '4424'}: self.getTimestepFromTimebase = self._getTimestepFromTimebase4223 self.getTimeBaseNum = self._getTimeBaseNum4223 else: raise NotImplementedError('Timebase functions have not been ' 'written for the ' + unit_number) def _lowLevelOpenUnit(self, sn): c_handle = c_int16() if sn is not None: serialNullTermStr = create_string_buffer(sn) else: serialNullTermStr = None # Passing None is the same as passing NULL m = self.lib.ps4000OpenUnit(byref(c_handle), serialNullTermStr) self.checkResult(m) self.handle = c_handle.value def _lowLevelOpenUnitAsync(self, sn): c_status = c_int16() if sn is not None: serialNullTermStr = create_string_buffer(sn) else: serialNullTermStr = None # Passing None is the same as passing NULL m = self.lib.ps4000OpenUnitAsync(byref(c_status), serialNullTermStr) self.checkResult(m) return c_status.value def _lowLevelOpenUnitProgress(self): complete = c_int16() progressPercent = c_int16() handle = c_int16() m = self.lib.ps4000OpenUnitProgress(byref(handle), byref(progressPercent), byref(complete)) self.checkResult(m) if complete.value != 0: self.handle = handle.value # if we only wanted to return one value, we could do somethign like # progressPercent = progressPercent * (1 - 0.1 * complete) return (progressPercent.value, complete.value) def _lowLevelCloseUnit(self): m = self.lib.ps4000CloseUnit(c_int16(self.handle)) self.checkResult(m) def _lowLevelEnumerateUnits(self): count = c_int16(0) m = self.lib.ps4000EnumerateUnits(byref(count), None, None) self.checkResult(m) # a serial number is rouhgly 8 characters # an extra character for the comma # and an extra one for the space after the comma? # the extra two also work for the null termination serialLth = c_int16(count.value * (8 + 2)) serials = create_string_buffer(serialLth.value + 1) m = self.lib.ps4000EnumerateUnits(byref(count), serials, byref(serialLth)) self.checkResult(m) serialList = str(serials.value.decode('utf-8')).split(',') serialList = [x.strip() for x in serialList] return serialList def _lowLevelSetChannel(self, chNum, enabled, coupling, VRange, VOffset, BWLimited): m = self.lib.ps4000SetChannel(c_int16(self.handle), c_enum(chNum), c_int16(enabled), c_enum(coupling), c_enum(VRange), c_float(VOffset), c_enum(BWLimited)) self.checkResult(m) def _lowLevelStop(self): m = self.lib.ps4000Stop(c_int16(self.handle)) self.checkResult(m) def _lowLevelGetUnitInfo(self, info): s = create_string_buffer(256) requiredSize = c_int16(0) m = self.lib.ps4000GetUnitInfo(c_int16(self.handle), byref(s), c_int16(len(s)), byref(requiredSize), c_enum(info)) self.checkResult(m) if requiredSize.value > len(s): s = create_string_buffer(requiredSize.value + 1) m = self.lib.ps4000GetUnitInfo(c_int16(self.handle), byref(s), c_int16(len(s)), byref(requiredSize), c_enum(info)) self.checkResult(m) # should this bee ascii instead? # I think they are equivalent... return s.value.decode('utf-8') def _lowLevelFlashLed(self, times): m = self.lib.ps4000FlashLed(c_int16(self.handle), c_int16(times)) self.checkResult(m) def _lowLevelSetSimpleTrigger(self, enabled, trigsrc, threshold_adc, direction, delay, timeout_ms): m = self.lib.ps4000SetSimpleTrigger(c_int16(self.handle), c_int16(enabled), c_enum(trigsrc), c_int16(threshold_adc), c_enum(direction), c_uint32(delay), c_int16(timeout_ms)) self.checkResult(m) def _lowLevelRunBlock(self, numPreTrigSamples, numPostTrigSamples, timebase, oversample, segmentIndex): timeIndisposedMs = c_int32() m = self.lib.ps4000RunBlock(c_int16(self.handle), c_uint32(numPreTrigSamples), c_uint32(numPostTrigSamples), c_uint32(timebase), c_int16(oversample), byref(timeIndisposedMs), c_uint16(segmentIndex), c_void_p(), c_void_p()) self.checkResult(m) return timeIndisposedMs.value def _lowLevelIsReady(self): ready = c_int16() m = self.lib.ps4000IsReady(c_int16(self.handle), byref(ready)) self.checkResult(m) if ready.value: return True else: return False def _lowLevelGetTimebase(self, tb, noSamples, oversample, segmentIndex): """Return (timeIntervalSeconds, maxSamples).""" maxSamples = c_int32() sampleRate = c_float() m = self.lib.ps4000GetTimebase2(c_int16(self.handle), c_uint32(tb), c_uint32(noSamples), byref(sampleRate), c_int16(oversample), byref(maxSamples), c_uint16(segmentIndex)) self.checkResult(m) return (sampleRate.value / 1.0E9, maxSamples.value) def getTimeBaseNum(self, sampleTimeS): """Return sample time in seconds to timebase as int for API calls.""" raise NotImplementedError('Timebase functions have not been ' 'written for the scope.') def getTimestepFromTimebase(self, timebase): """Return timebase to sampletime as seconds.""" raise NotImplementedError('Timebase functions have not been ' 'written for the scope.') def _getTimeBaseNum4223(self, sampleTimeS): """Return sample time in seconds to timebase as int for API calls.""" maxSampleTime = (((2**32 - 1) - 4) / 2e7) if sampleTimeS <= 12.5E-9: timebase = math.floor(math.log(sampleTimeS * 8E7, 2)) timebase = max(timebase, 0) else: # Otherwise in range 2^32-1 if sampleTimeS > maxSampleTime: sampleTimeS = maxSampleTime timebase = math.floor((sampleTimeS * 2e7) + 1) # is this cast needed? timebase = int(timebase) return timebase def _getTimestepFromTimebase4223(self, timebase): """Return timebase to sampletime as seconds.""" if timebase < 3: dt = 2.**timebase / 8e7 else: dt = (timebase - 1) / 2e7 return dt def _getTimestepFromTimebase4262(self, timebase): """Return timebase to sampletime as seconds for ps4262.""" someConstant = 10000000.0 return (timebase + 1) / someConstant def _getTimeBaseNum4262(self, sampleTimeS): """Return timebase for the ps4262. Return sample time in seconds to timebase as int for API calls for ps4262. """ someConstant = 10000000.0 maxSampleTime = ((2**30) / someConstant) minSampleTime = 1 / someConstant if sampleTimeS <= minSampleTime: timebase = 0 elif sampleTimeS >= maxSampleTime: timebase = (2**30) else: timebase = round(sampleTimeS * someConstant) - 1 # is this cast needed? timebase = int(timebase) return timebase def _lowLevelSetDataBuffer(self, channel, data, downSampleMode, segmentIndex): """Set the data buffer. Be sure to call _lowLevelClearDataBuffer when you are done with the data array or else subsequent calls to GetValue will still use the same array. segmentIndex is unused, but required by other versions of the API (eg PS5000a) """ dataPtr = data.ctypes.data_as(POINTER(c_int16)) numSamples = len(data) m = self.lib.ps4000SetDataBuffer(c_int16(self.handle), c_enum(channel), dataPtr, c_uint32(numSamples)) self.checkResult(m) def _lowLevelClearDataBuffer(self, channel, segmentIndex): m = self.lib.ps4000SetDataBuffer(c_int16(self.handle), c_enum(channel), c_void_p(), c_uint32(0), c_enum(0)) self.checkResult(m) def _lowLevelGetValues(self, numSamples, startIndex, downSampleRatio, downSampleMode, segmentIndex): numSamplesReturned = c_uint32() numSamplesReturned.value = numSamples overflow = c_int16() m = self.lib.ps4000GetValues(c_int16(self.handle), c_uint32(startIndex), byref(numSamplesReturned), c_uint32(downSampleRatio), c_enum(downSampleMode), c_uint16(segmentIndex), byref(overflow)) self.checkResult(m) return (numSamplesReturned.value, overflow.value) def _lowLevelSetAWGSimpleDeltaPhase(self, waveform, deltaPhase, offsetVoltage, pkToPk, indexMode, shots, triggerType, triggerSource): """Waveform should be an array of shorts.""" waveformPtr = waveform.ctypes.data_as(POINTER(c_int16)) m = self.lib.ps4000SetSigGenArbitrary( c_int16(self.handle), c_uint32(int(offsetVoltage * 1E6)), # offset voltage in microvolts c_uint32(int(pkToPk * 1E6)), # pkToPk in microvolts c_uint32(int(deltaPhase)), # startDeltaPhase c_uint32(int(deltaPhase)), # stopDeltaPhase c_uint32(0), # deltaPhaseIncrement c_uint32(0), # dwellCount waveformPtr, # arbitraryWaveform c_int32(len(waveform)), # arbitraryWaveformSize c_enum(0), # sweepType for deltaPhase c_enum(0), # operation (adding random noise and whatnot) c_enum(indexMode), # single, dual, quad c_uint32(shots), c_uint32(0), # sweeps c_uint32(triggerType), c_uint32(triggerSource), c_int16(0)) # extInThreshold self.checkResult(m) def _lowLevelSetSigGenBuiltInSimple(self, offsetVoltage, pkToPk, waveType, frequency, shots, triggerType, triggerSource, stopFreq, increment, dwellTime, sweepType, numSweeps): if stopFreq is None: stopFreq = frequency m = self.lib.ps4000SetSigGenBuiltIn( c_int16(self.handle), c_int32(int(offsetVoltage * 1000000)), c_int32(int(pkToPk * 1000000)), c_int16(waveType), c_float(frequency), c_float(stopFreq), c_float(increment), c_float(dwellTime), c_enum(sweepType), c_enum(0), c_uint32(shots), c_uint32(numSweeps), c_enum(triggerType), c_enum(triggerSource), c_int16(0)) self.checkResult(m) def _lowLevelSigGenSoftwareControl(self, triggerType): m = self.lib.ps4000SigGenSoftwareControl(c_int16(self.handle), c_enum(triggerType)) self.checkResult(m) # use VRange=5 for +/- 500mV signal range # OR # VRange=8 for +/- 5V range def _lowLevelSetExtTriggerRange(self, VRange): m = self.lib.ps4000SetExtTriggerRange(c_int16(self.handle), c_enum(VRange)) self.checkResult(m) #################################################################### # Untested functions below # # # #################################################################### def _lowLevelGetMaxDownSampleRatio(self, noOfUnaggregatedSamples, downSampleRatioMode, segmentIndex): maxDownSampleRatio = c_uint32() m = self.lib.ps4000GetMaxDownSampleRatio( c_int16(self.handle), c_uint32(noOfUnaggregatedSamples), byref(maxDownSampleRatio), c_enum(downSampleRatioMode), c_uint16(segmentIndex)) self.checkResult(m) return maxDownSampleRatio.value def _lowLevelGetNoOfCaptures(self): nCaptures = c_uint32() m = self.lib.ps4000GetNoOfCaptures(c_int16(self.handle), byref(nCaptures)) self.checkResult(m) return nCaptures.value def _lowLevelGetTriggerTimeOffset(self, segmentIndex): time = c_uint64() timeUnits = c_enum() m = self.lib.ps4000GetTriggerTimeOffset64(c_int16(self.handle), byref(time), byref(timeUnits), c_uint16(segmentIndex)) self.checkResult(m) if timeUnits.value == 0: # PS4000_FS return time.value * 1E-15 elif timeUnits.value == 1: # PS4000_PS return time.value * 1E-12 elif timeUnits.value == 2: # PS4000_NS return time.value * 1E-9 elif timeUnits.value == 3: # PS4000_US return time.value * 1E-6 elif timeUnits.value == 4: # PS4000_MS return time.value * 1E-3 elif timeUnits.value == 5: # PS4000_S return time.value * 1E0 else: raise TypeError("Unknown timeUnits %d" % timeUnits.value) def _lowLevelMemorySegments(self, nSegments): nMaxSamples = c_uint32() m = self.lib.ps4000MemorySegments(c_int16(self.handle), c_uint16(nSegments), byref(nMaxSamples)) self.checkResult(m) return nMaxSamples.value def _lowLevelSetDataBuffers(self, channel, bufferMax, bufferMin, downSampleRatioMode): bufferMaxPtr = bufferMax.ctypes.data_as(POINTER(c_int16)) bufferMinPtr = bufferMin.ctypes.data_as(POINTER(c_int16)) bufferLth = len(bufferMax) m = self.lib.ps4000SetDataBuffers(c_int16(self.handle), c_enum(channel), bufferMaxPtr, bufferMinPtr, c_uint32(bufferLth)) self.checkResult(m) def _lowLevelClearDataBuffers(self, channel): m = self.lib.ps4000SetDataBuffers(c_int16(self.handle), c_enum(channel), c_void_p(), c_void_p(), c_uint32(0)) self.checkResult(m) # Bulk values. # These would be nice, but the user would have to provide us # with an array. # we would have to make sure that it is contiguous amonts other things def _lowLevelGetValuesBulk(self, numSamples, fromSegmentIndex, toSegmentIndex, downSampleRatio, downSampleMode, overflow): noOfSamples = c_uint32(numSamples) m = self.lib.ps4000GetValuesBulk( c_int16(self.handle), byref(noOfSamples), c_uint16(fromSegmentIndex), c_uint16(toSegmentIndex), overflow.ctypes.data_as(POINTER(c_int16))) self.checkResult(m) return noOfSamples.value def _lowLevelSetDataBufferBulk(self, channel, buffer, waveform, downSampleRatioMode): bufferPtr = buffer.ctypes.data_as(POINTER(c_int16)) bufferLth = len(buffer) m = self.lib.ps4000SetDataBufferBulk(c_int16(self.handle), c_enum(channel), bufferPtr, c_uint32(bufferLth), c_uint16(waveform)) self.checkResult(m) def _lowLevelSetNoOfCaptures(self, nCaptures): m = self.lib.ps4000SetNoOfCaptures(c_int16(self.handle), c_uint16(nCaptures)) self.checkResult(m) # ETS Functions def _lowLevelSetEts(): pass def _lowLevelSetEtsTimeBuffer(): pass def _lowLevelSetEtsTimeBuffers(): pass def _lowLevelSetExternalClock(): pass # Complicated triggering # need to understand structs for this one to work def _lowLevelIsTriggerOrPulseWidthQualifierEnabled(): pass def _lowLevelGetValuesTriggerTimeOffsetBulk(): pass def _lowLevelSetTriggerChannelConditions(): pass def _lowLevelSetTriggerChannelDirections(): pass def _lowLevelSetTriggerChannelProperties(): pass def _lowLevelSetPulseWidthQualifier(): pass def _lowLevelSetTriggerDelay(): pass # Async functions # would be nice, but we would have to learn to implement callbacks def _lowLevelGetValuesAsync(): pass def _lowLevelGetValuesBulkAsync(): pass # overlapped functions def _lowLevelGetValuesOverlapped(): pass def _lowLevelGetValuesOverlappedBulk(): pass # Streaming related functions def _lowLevelGetStreamingLatestValues(): pass def _lowLevelNoOfStreamingValues(self): noOfValues = c_uint32() m = self.lib.ps4000NoOfStreamingValues(c_int16(self.handle), byref(noOfValues)) self.checkResult(m) return noOfValues.value def _lowLevelRunStreaming(): pass def _lowLevelStreamingReady(): pass
class PS4000(_PicoscopeBase): """The following are low-level functions for the PS4000.""" LIBNAME = "ps4000" MAX_VALUE = 32764 MIN_VALUE = -32764 # AWG stuff here: AWGMaxSamples = 4096 AWGDACInterval = 1 / 192000 # [s] AWGDACFrequency = 192000 # [Hz] AWGPhaseAccumulatorSize = 32 AWGMaxVal = 32767 AWGMinVal = -32768 AWG_INDEX_MODES = {"Single": 0, "Dual": 1, "Quad": 2} AWGBufferAddressWidth = 12 AWGMaxSamples = 2 ** AWGBufferAddressWidth SIGGEN_TRIGGER_TYPES = {"Rising": 0, "Falling": 1, "GateHigh": 2, "GateLow": 3} SIGGEN_TRIGGER_SOURCES = {"None": 0, "ScopeTrig": 1, "AuxIn": 2, "ExtIn": 3, "SoftTrig": 4} # EXT/AUX seems to have an imput impedence of 50 ohm (PS6403B) EXT_MAX_VALUE = 32767 EXT_MIN_VALUE = -32767 EXT_RANGE_VOLTS = 1 # I don't think that the 50V range is allowed, but I left it there anyway # The 10V and 20V ranges are only allowed in high impedence modes CHANNEL_RANGE = [{"rangeV": 20E-3, "apivalue": 1, "rangeStr": "20 mV"}, {"rangeV": 50E-3, "apivalue": 2, "rangeStr": "50 mV"}, {"rangeV": 100E-3, "apivalue": 3, "rangeStr": "100 mV"}, {"rangeV": 200E-3, "apivalue": 4, "rangeStr": "200 mV"}, {"rangeV": 500E-3, "apivalue": 5, "rangeStr": "500 mV"}, {"rangeV": 1.0, "apivalue": 6, "rangeStr": "1 V"}, {"rangeV": 2.0, "apivalue": 7, "rangeStr": "2 V"}, {"rangeV": 5.0, "apivalue": 8, "rangeStr": "5 V"}, {"rangeV": 10.0, "apivalue": 9, "rangeStr": "10 V"}, {"rangeV": 20.0, "apivalue": 10, "rangeStr": "20 V"}, {"rangeV": 50.0, "apivalue": 11, "rangeStr": "50 V"}, ] NUM_CHANNELS = 4 CHANNELS = {"A": 0, "B": 1, "C": 2, "D": 3, "EXT": 4} CHANNEL_COUPLINGS = {"DC50": 2, "DC": 1, "AC": 0} WAVE_TYPES = {"Sine": 0, "Square": 1, "Triangle": 2, "RampUp": 3, "RampDown": 4, "Sinc": 5, "Gaussian": 6, "HalfSine": 7, "DCVoltage": 8, "WhiteNoise": 9} SWEEP_TYPES = {"Up": 0, "Down": 1, "UpDown": 2, "DownUp": 3} def __init__(self, serialNumber=None, connect=True): """Load DLLs.""" self.handle = None if platform.system() == 'Linux': from ctypes import cdll # ok I don't know what is wrong with my installer, # but I need to include .so.2 self.lib = cdll.LoadLibrary("lib" + self.LIBNAME + ".so.2") elif platform.system() == 'Darwin': from picoscope.darwin_utils import LoadLibraryDarwin self.lib = LoadLibraryDarwin("lib" + self.LIBNAME + ".dylib") else: from ctypes import windll self.lib = windll.LoadLibrary(str(self.LIBNAME + ".dll")) super(PS4000, self).__init__(serialNumber, connect) # check to see which model we have and use special functions if needed unit_number = self.getUnitInfo('VariantInfo') if unit_number == '4262': self.getTimestepFromTimebase = self._getTimestepFromTimebase4262 self.getTimeBaseNum = self._getTimeBaseNum4262 elif unit_number in {'4223', '4224', '4423', '4424'}: self.getTimestepFromTimebase = self._getTimestepFromTimebase4223 self.getTimeBaseNum = self._getTimeBaseNum4223 else: raise NotImplementedError('Timebase functions have not been ' 'written for the ' + unit_number) def _lowLevelOpenUnit(self, sn): c_handle = c_int16() if sn is not None: serialNullTermStr = create_string_buffer(sn) else: serialNullTermStr = None # Passing None is the same as passing NULL m = self.lib.ps4000OpenUnit(byref(c_handle), serialNullTermStr) self.checkResult(m) self.handle = c_handle.value def _lowLevelOpenUnitAsync(self, sn): c_status = c_int16() if sn is not None: serialNullTermStr = create_string_buffer(sn) else: serialNullTermStr = None # Passing None is the same as passing NULL m = self.lib.ps4000OpenUnitAsync(byref(c_status), serialNullTermStr) self.checkResult(m) return c_status.value def _lowLevelOpenUnitProgress(self): complete = c_int16() progressPercent = c_int16() handle = c_int16() m = self.lib.ps4000OpenUnitProgress(byref(handle), byref(progressPercent), byref(complete)) self.checkResult(m) if complete.value != 0: self.handle = handle.value # if we only wanted to return one value, we could do somethign like # progressPercent = progressPercent * (1 - 0.1 * complete) return (progressPercent.value, complete.value) def _lowLevelCloseUnit(self): m = self.lib.ps4000CloseUnit(c_int16(self.handle)) self.checkResult(m) def _lowLevelEnumerateUnits(self): count = c_int16(0) m = self.lib.ps4000EnumerateUnits(byref(count), None, None) self.checkResult(m) # a serial number is rouhgly 8 characters # an extra character for the comma # and an extra one for the space after the comma? # the extra two also work for the null termination serialLth = c_int16(count.value * (8 + 2)) serials = create_string_buffer(serialLth.value + 1) m = self.lib.ps4000EnumerateUnits(byref(count), serials, byref(serialLth)) self.checkResult(m) serialList = str(serials.value.decode('utf-8')).split(',') serialList = [x.strip() for x in serialList] return serialList def _lowLevelSetChannel(self, chNum, enabled, coupling, VRange, VOffset, BWLimited): m = self.lib.ps4000SetChannel(c_int16(self.handle), c_enum(chNum), c_int16(enabled), c_enum(coupling), c_enum(VRange), c_float(VOffset), c_enum(BWLimited)) self.checkResult(m) def _lowLevelStop(self): m = self.lib.ps4000Stop(c_int16(self.handle)) self.checkResult(m) def _lowLevelGetUnitInfo(self, info): s = create_string_buffer(256) requiredSize = c_int16(0) m = self.lib.ps4000GetUnitInfo(c_int16(self.handle), byref(s), c_int16(len(s)), byref(requiredSize), c_enum(info)) self.checkResult(m) if requiredSize.value > len(s): s = create_string_buffer(requiredSize.value + 1) m = self.lib.ps4000GetUnitInfo(c_int16(self.handle), byref(s), c_int16(len(s)), byref(requiredSize), c_enum(info)) self.checkResult(m) # should this bee ascii instead? # I think they are equivalent... return s.value.decode('utf-8') def _lowLevelFlashLed(self, times): m = self.lib.ps4000FlashLed(c_int16(self.handle), c_int16(times)) self.checkResult(m) def _lowLevelSetSimpleTrigger(self, enabled, trigsrc, threshold_adc, direction, delay, timeout_ms): m = self.lib.ps4000SetSimpleTrigger( c_int16(self.handle), c_int16(enabled), c_enum(trigsrc), c_int16(threshold_adc), c_enum(direction), c_uint32(delay), c_int16(timeout_ms)) self.checkResult(m) def _lowLevelRunBlock(self, numPreTrigSamples, numPostTrigSamples, timebase, oversample, segmentIndex): timeIndisposedMs = c_int32() m = self.lib.ps4000RunBlock( c_int16(self.handle), c_uint32(numPreTrigSamples), c_uint32(numPostTrigSamples), c_uint32(timebase), c_int16(oversample), byref(timeIndisposedMs), c_uint16(segmentIndex), c_void_p(), c_void_p()) self.checkResult(m) return timeIndisposedMs.value def _lowLevelIsReady(self): ready = c_int16() m = self.lib.ps4000IsReady(c_int16(self.handle), byref(ready)) self.checkResult(m) if ready.value: return True else: return False def _lowLevelGetTimebase(self, tb, noSamples, oversample, segmentIndex): """Return (timeIntervalSeconds, maxSamples).""" maxSamples = c_int32() sampleRate = c_float() m = self.lib.ps4000GetTimebase2(c_int16(self.handle), c_uint32(tb), c_uint32(noSamples), byref(sampleRate), c_int16(oversample), byref(maxSamples), c_uint16(segmentIndex)) self.checkResult(m) return (sampleRate.value / 1.0E9, maxSamples.value) def getTimeBaseNum(self, sampleTimeS): """Return sample time in seconds to timebase as int for API calls.""" raise NotImplementedError('Timebase functions have not been ' 'written for the scope.') def getTimestepFromTimebase(self, timebase): """Return timebase to sampletime as seconds.""" raise NotImplementedError('Timebase functions have not been ' 'written for the scope.') def _getTimeBaseNum4223(self, sampleTimeS): """Return sample time in seconds to timebase as int for API calls.""" maxSampleTime = (((2 ** 32 - 1) - 4) / 2e7) if sampleTimeS <= 12.5E-9: timebase = math.floor(math.log(sampleTimeS * 8E7, 2)) timebase = max(timebase, 0) else: # Otherwise in range 2^32-1 if sampleTimeS > maxSampleTime: sampleTimeS = maxSampleTime timebase = math.floor((sampleTimeS * 2e7) + 1) # is this cast needed? timebase = int(timebase) return timebase def _getTimestepFromTimebase4223(self, timebase): """Return timebase to sampletime as seconds.""" if timebase < 3: dt = 2. ** timebase / 8e7 else: dt = (timebase - 1) / 2e7 return dt def _getTimestepFromTimebase4262(self, timebase): """Return timebase to sampletime as seconds for ps4262.""" someConstant = 10000000.0 return (timebase+1) / someConstant def _getTimeBaseNum4262(self, sampleTimeS): """Return timebase for the ps4262. Return sample time in seconds to timebase as int for API calls for ps4262. """ someConstant = 10000000.0 maxSampleTime = ((2 ** 30) / someConstant) minSampleTime = 1 / someConstant if sampleTimeS <= minSampleTime: timebase = 0 elif sampleTimeS >= maxSampleTime: timebase = (2 ** 30) else: timebase = round(sampleTimeS * someConstant) - 1 # is this cast needed? timebase = int(timebase) return timebase def _lowLevelSetDataBuffer(self, channel, data, downSampleMode, segmentIndex): """Set the data buffer. Be sure to call _lowLevelClearDataBuffer when you are done with the data array or else subsequent calls to GetValue will still use the same array. segmentIndex is unused, but required by other versions of the API (eg PS5000a) """ dataPtr = data.ctypes.data_as(POINTER(c_int16)) numSamples = len(data) m = self.lib.ps4000SetDataBuffer(c_int16(self.handle), c_enum(channel), dataPtr, c_uint32(numSamples)) self.checkResult(m) def _lowLevelClearDataBuffer(self, channel, segmentIndex): m = self.lib.ps4000SetDataBuffer(c_int16(self.handle), c_enum(channel), c_void_p(), c_uint32(0), c_enum(0)) self.checkResult(m) def _lowLevelGetValues(self, numSamples, startIndex, downSampleRatio, downSampleMode, segmentIndex): numSamplesReturned = c_uint32() numSamplesReturned.value = numSamples overflow = c_int16() m = self.lib.ps4000GetValues( c_int16(self.handle), c_uint32(startIndex), byref(numSamplesReturned), c_uint32(downSampleRatio), c_enum(downSampleMode), c_uint16(segmentIndex), byref(overflow)) self.checkResult(m) return (numSamplesReturned.value, overflow.value) def _lowLevelSetAWGSimpleDeltaPhase(self, waveform, deltaPhase, offsetVoltage, pkToPk, indexMode, shots, triggerType, triggerSource): """Waveform should be an array of shorts.""" waveformPtr = waveform.ctypes.data_as(POINTER(c_int16)) m = self.lib.ps4000SetSigGenArbitrary( c_int16(self.handle), c_uint32(int(offsetVoltage * 1E6)), # offset voltage in microvolts c_uint32(int(pkToPk * 1E6)), # pkToPk in microvolts c_uint32(int(deltaPhase)), # startDeltaPhase c_uint32(int(deltaPhase)), # stopDeltaPhase c_uint32(0), # deltaPhaseIncrement c_uint32(0), # dwellCount waveformPtr, # arbitraryWaveform c_int32(len(waveform)), # arbitraryWaveformSize c_enum(0), # sweepType for deltaPhase c_enum(0), # operation (adding random noise and whatnot) c_enum(indexMode), # single, dual, quad c_uint32(shots), c_uint32(0), # sweeps c_uint32(triggerType), c_uint32(triggerSource), c_int16(0)) # extInThreshold self.checkResult(m) def _lowLevelSetSigGenBuiltInSimple(self, offsetVoltage, pkToPk, waveType, frequency, shots, triggerType, triggerSource, stopFreq, increment, dwellTime, sweepType, numSweeps): if stopFreq is None: stopFreq = frequency m = self.lib.ps4000SetSigGenBuiltIn( c_int16(self.handle), c_int32(int(offsetVoltage * 1000000)), c_int32(int(pkToPk * 1000000)), c_int16(waveType), c_float(frequency), c_float(stopFreq), c_float(increment), c_float(dwellTime), c_enum(sweepType), c_enum(0), c_uint32(shots), c_uint32(numSweeps), c_enum(triggerType), c_enum(triggerSource), c_int16(0)) self.checkResult(m) def _lowLevelSigGenSoftwareControl(self, triggerType): m = self.lib.ps4000SigGenSoftwareControl( c_int16(self.handle), c_enum(triggerType)) self.checkResult(m) # use VRange=5 for +/- 500mV signal range # OR # VRange=8 for +/- 5V range def _lowLevelSetExtTriggerRange(self, VRange): m = self.lib.ps4000SetExtTriggerRange( c_int16(self.handle), c_enum(VRange)) self.checkResult(m) #################################################################### # Untested functions below # # # #################################################################### def _lowLevelGetMaxDownSampleRatio(self, noOfUnaggregatedSamples, downSampleRatioMode, segmentIndex): maxDownSampleRatio = c_uint32() m = self.lib.ps4000GetMaxDownSampleRatio( c_int16(self.handle), c_uint32(noOfUnaggregatedSamples), byref(maxDownSampleRatio), c_enum(downSampleRatioMode), c_uint16(segmentIndex)) self.checkResult(m) return maxDownSampleRatio.value def _lowLevelGetNoOfCaptures(self): nCaptures = c_uint32() m = self.lib.ps4000GetNoOfCaptures( c_int16(self.handle), byref(nCaptures)) self.checkResult(m) return nCaptures.value def _lowLevelGetTriggerTimeOffset(self, segmentIndex): time = c_uint64() timeUnits = c_enum() m = self.lib.ps4000GetTriggerTimeOffset64( c_int16(self.handle), byref(time), byref(timeUnits), c_uint16(segmentIndex)) self.checkResult(m) if timeUnits.value == 0: # PS4000_FS return time.value * 1E-15 elif timeUnits.value == 1: # PS4000_PS return time.value * 1E-12 elif timeUnits.value == 2: # PS4000_NS return time.value * 1E-9 elif timeUnits.value == 3: # PS4000_US return time.value * 1E-6 elif timeUnits.value == 4: # PS4000_MS return time.value * 1E-3 elif timeUnits.value == 5: # PS4000_S return time.value * 1E0 else: raise TypeError("Unknown timeUnits %d" % timeUnits.value) def _lowLevelMemorySegments(self, nSegments): nMaxSamples = c_uint32() m = self.lib.ps4000MemorySegments(c_int16(self.handle), c_uint16(nSegments), byref(nMaxSamples)) self.checkResult(m) return nMaxSamples.value def _lowLevelSetDataBuffers(self, channel, bufferMax, bufferMin, downSampleRatioMode): bufferMaxPtr = bufferMax.ctypes.data_as(POINTER(c_int16)) bufferMinPtr = bufferMin.ctypes.data_as(POINTER(c_int16)) bufferLth = len(bufferMax) m = self.lib.ps4000SetDataBuffers( c_int16(self.handle), c_enum(channel), bufferMaxPtr, bufferMinPtr, c_uint32(bufferLth)) self.checkResult(m) def _lowLevelClearDataBuffers(self, channel): m = self.lib.ps4000SetDataBuffers( c_int16(self.handle), c_enum(channel), c_void_p(), c_void_p(), c_uint32(0)) self.checkResult(m) # Bulk values. # These would be nice, but the user would have to provide us # with an array. # we would have to make sure that it is contiguous amonts other things def _lowLevelGetValuesBulk(self, numSamples, fromSegmentIndex, toSegmentIndex, downSampleRatio, downSampleMode, overflow): noOfSamples = c_uint32(numSamples) m = self.lib.ps4000GetValuesBulk( c_int16(self.handle), byref(noOfSamples), c_uint16(fromSegmentIndex), c_uint16(toSegmentIndex), overflow.ctypes.data_as(POINTER(c_int16))) self.checkResult(m) return noOfSamples.value def _lowLevelSetDataBufferBulk(self, channel, buffer, waveform, downSampleRatioMode): bufferPtr = buffer.ctypes.data_as(POINTER(c_int16)) bufferLth = len(buffer) m = self.lib.ps4000SetDataBufferBulk( c_int16(self.handle), c_enum(channel), bufferPtr, c_uint32(bufferLth), c_uint16(waveform)) self.checkResult(m) def _lowLevelSetNoOfCaptures(self, nCaptures): m = self.lib.ps4000SetNoOfCaptures( c_int16(self.handle), c_uint16(nCaptures)) self.checkResult(m) # ETS Functions def _lowLevelSetEts(): pass def _lowLevelSetEtsTimeBuffer(): pass def _lowLevelSetEtsTimeBuffers(): pass def _lowLevelSetExternalClock(): pass # Complicated triggering # need to understand structs for this one to work def _lowLevelIsTriggerOrPulseWidthQualifierEnabled(): pass def _lowLevelGetValuesTriggerTimeOffsetBulk(): pass def _lowLevelSetTriggerChannelConditions(): pass def _lowLevelSetTriggerChannelDirections(): pass def _lowLevelSetTriggerChannelProperties(): pass def _lowLevelSetPulseWidthQualifier(): pass def _lowLevelSetTriggerDelay(): pass # Async functions # would be nice, but we would have to learn to implement callbacks def _lowLevelGetValuesAsync(): pass def _lowLevelGetValuesBulkAsync(): pass # overlapped functions def _lowLevelGetValuesOverlapped(): pass def _lowLevelGetValuesOverlappedBulk(): pass # Streaming related functions def _lowLevelGetStreamingLatestValues(): pass def _lowLevelNoOfStreamingValues(self): noOfValues = c_uint32() m = self.lib.ps4000NoOfStreamingValues( c_int16(self.handle), byref(noOfValues)) self.checkResult(m) return noOfValues.value def _lowLevelRunStreaming(): pass def _lowLevelStreamingReady(): pass
class PS3000a(_PicoscopeBase): """The following are low-level functions for the PS3000a.""" LIBNAME = "ps3000a" NUM_CHANNELS = 4 CHANNELS = {"A": 0, "B": 1, "C": 2, "D": 3, "External": 4, "MaxChannels": 4, "TriggerAux": 5} ADC_RESOLUTIONS = {"8": 0, "12": 1, "14": 2, "15": 3, "16": 4} CHANNEL_RANGE = [{"rangeV": 10E-3, "apivalue": 0, "rangeStr": "10 mV"}, {"rangeV": 20E-3, "apivalue": 1, "rangeStr": "20 mV"}, {"rangeV": 50E-3, "apivalue": 2, "rangeStr": "50 mV"}, {"rangeV": 100E-3, "apivalue": 3, "rangeStr": "100 mV"}, {"rangeV": 200E-3, "apivalue": 4, "rangeStr": "200 mV"}, {"rangeV": 500E-3, "apivalue": 5, "rangeStr": "500 mV"}, {"rangeV": 1.0, "apivalue": 6, "rangeStr": "1 V"}, {"rangeV": 2.0, "apivalue": 7, "rangeStr": "2 V"}, {"rangeV": 5.0, "apivalue": 8, "rangeStr": "5 V"}, {"rangeV": 10.0, "apivalue": 9, "rangeStr": "10 V"}, {"rangeV": 20.0, "apivalue": 10, "rangeStr": "20 V"}, {"rangeV": 50.0, "apivalue": 11, "rangeStr": "50 V"}, ] CHANNEL_COUPLINGS = {"DC": 1, "AC": 0} # has_sig_gen = True WAVE_TYPES = {"Sine": 0, "Square": 1, "Triangle": 2, "RampUp": 3, "RampDown": 4, "Sinc": 5, "Gaussian": 6, "HalfSine": 7, "DCVoltage": 8, "WhiteNoise": 9} SWEEP_TYPES = {"Up": 0, "Down": 1, "UpDown": 2, "DownUp": 3} SIGGEN_TRIGGER_TYPES = {"Rising": 0, "Falling": 1, "GateHigh": 2, "GateLow": 3} SIGGEN_TRIGGER_SOURCES = {"None": 0, "ScopeTrig": 1, "AuxIn": 2, "ExtIn": 3, "SoftTrig": 4, "TriggerRaw": 5} # This is actually different depending on the AB/CD models # I wonder how we could detect the difference between the oscilloscopes # I believe we can obtain this information from the setInfo function # by readign the hardware version # for the PS6403B version, the hardware version is "1 1", # an other possibility is that the PS6403B shows up as 6403 when using # VARIANT_INFO and others show up as PS6403X where X = A,C or D AWGPhaseAccumulatorSize = 32 AWGBufferAddressWidth = 14 AWGMaxSamples = 2 ** AWGBufferAddressWidth AWGDACInterval = 5E-9 # in seconds AWGDACFrequency = 1 / AWGDACInterval # Note this is NOT what is written in the Programming guide as of version # 10_5_0_28 # This issue was acknowledged in this thread # http://www.picotech.com/support/topic13217.html AWGMaxVa = 32767 AWGMinVal = -32767 AWG_INDEX_MODES = {"Single": 0, "Dual": 1, "Quad": 2} MAX_VALUE_8BIT = 32512 MIN_VALUE_8BIT = -32512 MAX_VALUE_OTHER = 32767 MIN_VALUE_OTHER = -32767 EXT_RANGE_VOLTS = 5 def __init__(self, serialNumber=None, connect=True): """Load DLL etc.""" if platform.system() == 'Linux': from ctypes import cdll self.lib = cdll.LoadLibrary("lib" + self.LIBNAME + ".so") elif platform.system() == 'Darwin': from picoscope.darwin_utils import LoadLibraryDarwin self.lib = LoadLibraryDarwin("lib" + self.LIBNAME + ".dylib") else: from ctypes import windll self.lib = windll.LoadLibrary(str(self.LIBNAME + ".dll")) self.resolution = self.ADC_RESOLUTIONS["8"] super(PS3000a, self).__init__(serialNumber, connect) def _lowLevelOpenUnit(self, sn): c_handle = c_int16() if sn is not None: serialNullTermStr = byref(create_string_buffer(sn)) else: serialNullTermStr = None # Passing None is the same as passing NULL m = self.lib.ps3000aOpenUnit(byref(c_handle), serialNullTermStr) self.handle = c_handle.value # copied over from ps5000a: # This will check if the power supply is not connected # and change the power supply accordingly # Personally (me = Mark), I don't like this # since the user should address this immediately, and we # shouldn't let this go as a soft error # but I think this should do for now if m == 0x11A: self.changePowerSource("PICO_POWER_SUPPLY_NOT_CONNECTED") else: self.checkResult(m) def _lowLevelCloseUnit(self): m = self.lib.ps3000aCloseUnit(c_int16(self.handle)) self.checkResult(m) def _lowLevelEnumerateUnits(self): count = c_int16(0) m = self.lib.ps3000aEnumerateUnits(byref(count), None, None) self.checkResult(m) # a serial number is rouhgly 8 characters # an extra character for the comma # and an extra one for the space after the comma? # the extra two also work for the null termination serialLth = c_int16(count.value * (8 + 2)) serials = create_string_buffer(serialLth.value + 1) m = self.lib.ps3000aEnumerateUnits(byref(count), serials, byref(serialLth)) self.checkResult(m) serialList = str(serials.value.decode('utf-8')).split(',') serialList = [x.strip() for x in serialList] return serialList def _lowLevelSetChannel(self, chNum, enabled, coupling, VRange, VOffset, BWLimited): m = self.lib.ps3000aSetChannel(c_int16(self.handle), c_enum(chNum), c_int16(enabled), c_enum(coupling), c_enum(VRange), c_float(VOffset)) self.checkResult(m) def _lowLevelStop(self): m = self.lib.ps3000aStop(c_int16(self.handle)) self.checkResult(m) def _lowLevelGetUnitInfo(self, info): s = create_string_buffer(256) requiredSize = c_int16(0) m = self.lib.ps3000aGetUnitInfo(c_int16(self.handle), byref(s), c_int16(len(s)), byref(requiredSize), c_enum(info)) self.checkResult(m) if requiredSize.value > len(s): s = create_string_buffer(requiredSize.value + 1) m = self.lib.ps3000aGetUnitInfo(c_int16(self.handle), byref(s), c_int16(len(s)), byref(requiredSize), c_enum(info)) self.checkResult(m) # should this bee ascii instead? # I think they are equivalent... return s.value.decode('utf-8') def _lowLevelFlashLed(self, times): m = self.lib.ps3000aFlashLed(c_int16(self.handle), c_int16(times)) self.checkResult(m) def _lowLevelSetSimpleTrigger(self, enabled, trigsrc, threshold_adc, direction, delay, auto): m = self.lib.ps3000aSetSimpleTrigger( c_int16(self.handle), c_int16(enabled), c_enum(trigsrc), c_int16(threshold_adc), c_enum(direction), c_uint32(delay), c_int16(auto)) self.checkResult(m) def _lowLevelSetNoOfCaptures(self, numCaptures): m = self.lib.ps3000aSetNoOfCaptures(c_int16(self.handle), c_uint16(numCaptures)) self.checkResult(m) def _lowLevelMemorySegments(self, numSegments): maxSamples = c_int32() m = self.lib.ps3000aMemorySegments(c_int16(self.handle), c_uint16(numSegments), byref(maxSamples)) self.checkResult(m) return maxSamples.value def _lowLevelGetMaxSegments(self): maxSegments = c_int16() m = self.lib.ps3000aGetMaxSegments(c_int16(self.handle), byref(maxSegments)) self.checkResult(m) return maxSegments.value def _lowLevelRunBlock(self, numPreTrigSamples, numPostTrigSamples, timebase, oversample, segmentIndex): # NOT: Oversample is NOT used! timeIndisposedMs = c_int32() m = self.lib.ps3000aRunBlock( c_int16(self.handle), c_uint32(numPreTrigSamples), c_uint32(numPostTrigSamples), c_uint32(timebase), c_int16(oversample), byref(timeIndisposedMs), c_uint32(segmentIndex), c_void_p(), c_void_p()) self.checkResult(m) return timeIndisposedMs.value def _lowLevelIsReady(self): ready = c_int16() m = self.lib.ps3000aIsReady(c_int16(self.handle), byref(ready)) self.checkResult(m) if ready.value: return True else: return False def _lowlevelPingUnit(self): m = self.lib.ps3000aPingUnit(c_int16(self.handle)) return m def _lowLevelGetTimebase(self, tb, noSamples, oversample, segmentIndex): """Return (timeIntervalSeconds, maxSamples).""" maxSamples = c_int32() intervalNanoSec = c_float() m = self.lib.ps3000aGetTimebase2(c_int16(self.handle), c_uint32(tb), c_uint32(noSamples), byref(intervalNanoSec), c_int16(oversample), byref(maxSamples), c_uint32(segmentIndex)) self.checkResult(m) # divide by 1e9 to return interval in seconds return (intervalNanoSec.value * 1e-9, maxSamples.value) def getTimeBaseNum(self, sampleTimeS): """Convert sample time in S to something to pass to API Call.""" maxSampleTime = (((2 ** 32 - 1) - 2) / 125000000) if sampleTimeS < 8.0E-9: st = math.floor(math.log(sampleTimeS * 1E9, 2)) st = max(st, 0) else: if sampleTimeS > maxSampleTime: sampleTimeS = maxSampleTime st = math.floor((sampleTimeS * 125000000) + 2) # is this cast needed? st = int(st) return st def getTimestepFromTimebase(self, timebase): """Take API timestep code and returns the sampling period. API timestep is an integer from 0-32 """ if timebase < 3: dt = 2. ** timebase / 1.0E9 else: dt = (timebase - 2.0) / 125000000. return dt def _lowLevelSetAWGSimpleDeltaPhase(self, waveform, deltaPhase, offsetVoltage, pkToPk, indexMode, shots, triggerType, triggerSource): """Waveform should be an array of shorts.""" waveformPtr = waveform.ctypes.data_as(POINTER(c_int16)) m = self.lib.ps3000aSetSigGenArbitrary( c_int16(self.handle), c_uint32(int(offsetVoltage * 1E6)), # offset voltage in microvolts c_uint32(int(pkToPk * 1E6)), # pkToPk in microvolts c_uint32(int(deltaPhase)), # startDeltaPhase c_uint32(int(deltaPhase)), # stopDeltaPhase c_uint32(0), # deltaPhaseIncrement c_uint32(0), # dwellCount waveformPtr, # arbitraryWaveform c_int32(len(waveform)), # arbitraryWaveformSize c_enum(0), # sweepType for deltaPhase c_enum(0), # operation (adding random noise and whatnot) c_enum(indexMode), # single, dual, quad c_uint32(shots), c_uint32(0), # sweeps c_uint32(triggerType), c_uint32(triggerSource), c_int16(0)) # extInThreshold self.checkResult(m) def _lowLevelSetDataBuffer(self, channel, data, downSampleMode, segmentIndex): """Set the data buffer. Be sure to call _lowLevelClearDataBuffer when you are done with the data array or else subsequent calls to GetValue will still use the same array. """ dataPtr = data.ctypes.data_as(POINTER(c_int16)) numSamples = len(data) m = self.lib.ps3000aSetDataBuffer( c_int16(self.handle), c_enum(channel), dataPtr, c_int32(numSamples), c_uint32(segmentIndex), c_enum(downSampleMode)) self.checkResult(m) def _lowLevelSetDataBufferBulk(self, channel, data, segmentIndex, downSampleMode): """Set the bulk data buffer. In ps3000a, ps3000aSetDataBuffer combines the functionality of psX000YSetDataBuffer and psX000YSetDataBufferBulk. Since the rapid block functions in picoscope.py call the Bulk version, a delegator is needed. Note that the order of segmentIndex and downSampleMode is reversed. """ self._lowLevelSetDataBuffer(channel, data, downSampleMode, segmentIndex) def _lowLevelSetMultipleDataBuffers(self, channel, data, downSampleMode): max_segments = self._lowLevelGetMaxSegments() if data.shape[0] < max_segments: raise ValueError("data array has fewer rows than current number " + "of memory segments") if data.shape[1] < self.maxSamples: raise ValueError("data array has fewer columns than maxSamples") for i in range(max_segments): m = self._lowLevelSetDataBuffer(channel, data[i, :], downSampleMode, i) self.checkResult(m) def _lowLevelClearDataBuffer(self, channel, segmentIndex): m = self.lib.ps3000aSetDataBuffer(c_int16(self.handle), c_enum(channel), c_void_p(), c_uint32(0), c_uint32(segmentIndex), c_enum(0)) self.checkResult(m) def _lowLevelGetValues(self, numSamples, startIndex, downSampleRatio, downSampleMode, segmentIndex): numSamplesReturned = c_uint32() numSamplesReturned.value = numSamples overflow = c_int16() m = self.lib.ps3000aGetValues( c_int16(self.handle), c_uint32(startIndex), byref(numSamplesReturned), c_uint32(downSampleRatio), c_enum(downSampleMode), c_uint32(segmentIndex), byref(overflow)) self.checkResult(m) return (numSamplesReturned.value, overflow.value) def _lowLevelGetValuesBulk(self, numSamples, fromSegment, toSegment, downSampleRatio, downSampleMode, overflow): m = self.lib.ps3000aGetValuesBulk( c_int16(self.handle), byref(c_uint32(numSamples)), c_uint32(fromSegment), c_uint32(toSegment), c_uint32(downSampleRatio), c_int16(downSampleMode), overflow.ctypes.data_as(POINTER(c_int16)) ) self.checkResult(m) return overflow, numSamples def _lowLevelSetSigGenBuiltInSimple(self, offsetVoltage, pkToPk, waveType, frequency, shots, triggerType, triggerSource, stopFreq, increment, dwellTime, sweepType, numSweeps): # TODO, I just noticed that V2 exists # Maybe change to V2 in the future if stopFreq is None: stopFreq = frequency m = self.lib.ps3000aSetSigGenBuiltIn( c_int16(self.handle), c_int32(int(offsetVoltage * 1000000)), c_int32(int(pkToPk * 1000000)), c_int16(waveType), c_float(frequency), c_float(stopFreq), c_float(increment), c_float(dwellTime), c_enum(sweepType), c_enum(0), c_uint32(shots), c_uint32(numSweeps), c_enum(triggerType), c_enum(triggerSource), c_int16(0)) self.checkResult(m) def _lowLevelChangePowerSource(self, powerstate): m = self.lib.ps3000aChangePowerSource( c_int16(self.handle), c_enum(powerstate)) self.checkResult(m)
class PS5000(_PicoscopeBase): """The following are low-level functions for the PS5000.""" LIBNAME = "ps5000" MAX_VALUE = 32521 MIN_VALUE = -32521 # EXT/AUX seems to have an imput impedence of 50 ohm (PS6403B) EXT_MAX_VALUE = 32767 EXT_MIN_VALUE = -32767 EXT_RANGE_VOLTS = 1 # The 10V and 20V ranges are only allowed in high impedence modes CHANNEL_RANGE = [{ "rangeV": 10E-3, "apivalue": 1, "rangeStr": "10 mV" }, { "rangeV": 20E-3, "apivalue": 2, "rangeStr": "20 mV" }, { "rangeV": 50E-3, "apivalue": 3, "rangeStr": "50 mV" }, { "rangeV": 100E-3, "apivalue": 4, "rangeStr": "100 mV" }, { "rangeV": 200E-3, "apivalue": 5, "rangeStr": "200 mV" }, { "rangeV": 1.0, "apivalue": 6, "rangeStr": "1 V" }, { "rangeV": 2.0, "apivalue": 7, "rangeStr": "2 V" }, { "rangeV": 5.0, "apivalue": 8, "rangeStr": "5 V" }, { "rangeV": 10.0, "apivalue": 9, "rangeStr": "10 V" }, { "rangeV": 20.0, "apivalue": 10, "rangeStr": "20 V" }, { "rangeV": 50.0, "apivalue": 11, "rangeStr": "50 V" }] NUM_CHANNELS = 4 CHANNELS = { "A": 0, "B": 1, "C": 2, "D": 3, "External": 4, "MaxChannels": 4, "TriggerAux": 5 } CHANNEL_COUPLINGS = {"DC": 1, "AC": 0} WAVE_TYPES = { "Sine": 0, "Square": 1, "Triangle": 2, "RampUp": 3, "RampDown": 4, "Sinc": 5, "Gaussian": 6, "HalfSine": 7, "DCVoltage": 8, "WhiteNoise": 9 } SWEEP_TYPES = {"Up": 0, "Down": 1, "UpDown": 2, "DownUp": 3} SIGGEN_TRIGGER_TYPES = { "Rising": 0, "Falling": 1, "GateHigh": 2, "GateLow": 3 } SIGGEN_TRIGGER_SOURCES = { "None": 0, "ScopeTrig": 1, "AuxIn": 2, "ExtIn": 3, "SoftTrig": 4, "TriggerRaw": 5 } # This is actually different depending on the AB/CD models # I wonder how we could detect the difference between the oscilloscopes # I believe we can obtain this information from the setInfo function # by readign the hardware version # for the PS6403B version, the hardware version is "1 1", # an other possibility is that the PS6403B shows up as 6403 when using # VARIANT_INFO and others show up as PS6403X where X = A,C or D AWGPhaseAccumulatorSize = 32 AWGBufferAddressWidth = 14 AWGMaxSamples = 2**AWGBufferAddressWidth AWGDACInterval = 5E-9 # in seconds AWGDACFrequency = 1 / AWGDACInterval # Note this is NOT what is written in the Programming guide as of version # 10_5_0_28 # This issue was acknowledged in this thread # http://www.picotech.com/support/topic13217.html AWGMaxVal = 0x0FFF AWGMinVal = 0x0000 AWG_INDEX_MODES = {"Single": 0, "Dual": 1, "Quad": 2} def __init__(self, serialNumber=None, connect=True): """Load DLLs.""" if platform.system() == 'Linux': from ctypes import cdll # ok I don't know what is wrong with my installer, # but I need to include .so.2 self.lib = cdll.LoadLibrary("lib" + self.LIBNAME + ".so.2") elif platform.system() == 'Darwin': from picoscope.darwin_utils import LoadLibraryDarwin self.lib = LoadLibraryDarwin("lib" + self.LIBNAME + ".dylib") else: from ctypes import windll from ctypes.util import find_library self.lib = windll.LoadLibrary( find_library(str(self.LIBNAME + ".dll"))) super(PS5000, self).__init__(serialNumber, connect) def _lowLevelOpenUnit(self, serialNumber): c_handle = c_int16() if serialNumber is not None: serialNumberStr = create_string_buffer( bytes(serialNumber, encoding='utf-8')) else: serialNumberStr = None # Passing None is the same as passing NULL m = self.lib.ps5000OpenUnit(byref(c_handle), serialNumberStr) self.checkResult(m) self.handle = c_handle.value def _lowLevelOpenUnitAsync(self, serialNumber): c_status = c_int16() if serialNumber is not None: serialNumberStr = create_string_buffer( bytes(serialNumber, encoding='utf-8')) else: serialNumberStr = None # Passing None is the same as passing NULL m = self.lib.ps5000OpenUnitAsync(byref(c_status), serialNumberStr) self.checkResult(m) return c_status.value def _lowLevelOpenUnitProgress(self): complete = c_int16() progressPercent = c_int16() handle = c_int16() m = self.lib.ps5000OpenUnitProgress(byref(handle), byref(progressPercent), byref(complete)) self.checkResult(m) if complete.value != 0: self.handle = handle.value # if we only wanted to return one value, we could do somethign like # progressPercent = progressPercent * (1 - 0.1 * complete) return (progressPercent.value, complete.value) def _lowLevelCloseUnit(self): m = self.lib.ps5000CloseUnit(c_int16(self.handle)) self.checkResult(m) def _lowLevelEnumerateUnits(self): count = c_int16(0) m = self.lib.ps5000EnumerateUnits(byref(count), None, None) self.checkResult(m) # a serial number is rouhgly 8 characters # an extra character for the comma # and an extra one for the space after the comma? # the extra two also work for the null termination serialLth = c_int16(count.value * (8 + 2)) serials = create_string_buffer(serialLth.value + 1) m = self.lib.ps5000EnumerateUnits(byref(count), serials, byref(serialLth)) self.checkResult(m) serialList = str(serials.value.decode('utf-8')).split(',') serialList = [x.strip() for x in serialList] return serialList def _lowLevelSetChannel(self, chNum, enabled, coupling, VRange, VOffset, BWLimited): m = self.lib.ps5000SetChannel(c_int16(self.handle), c_enum(chNum), c_int16(enabled), c_enum(coupling), c_enum(VRange), c_float(VOffset), c_enum(BWLimited)) # 2 for PS6404 self.checkResult(m) def _lowLevelStop(self): m = self.lib.ps5000Stop(c_int16(self.handle)) self.checkResult(m) def _lowLevelGetUnitInfo(self, info): s = create_string_buffer(256) requiredSize = c_int16(0) m = self.lib.ps6000GetUnitInfo(c_int16(self.handle), byref(s), c_int16(len(s)), byref(requiredSize), c_enum(info)) self.checkResult(m) if requiredSize.value > len(s): s = create_string_buffer(requiredSize.value + 1) m = self.lib.ps5000GetUnitInfo(c_int16(self.handle), byref(s), c_int16(len(s)), byref(requiredSize), c_enum(info)) self.checkResult(m) # should this bee ascii instead? # I think they are equivalent... return s.value.decode('utf-8') def _lowLevelFlashLed(self, times): m = self.lib.ps5000FlashLed(c_int16(self.handle), c_int16(times)) self.checkResult(m) def _lowLevelSetSimpleTrigger(self, enabled, trigsrc, threshold_adc, direction, delay, timeout_ms): m = self.lib.ps5000SetSimpleTrigger(c_int16(self.handle), c_int16(enabled), c_enum(trigsrc), c_int16(threshold_adc), c_enum(direction), c_uint32(delay), c_int16(timeout_ms)) self.checkResult(m) def _lowLevelRunBlock(self, numPreTrigSamples, numPostTrigSamples, timebase, oversample, segmentIndex, callback, pParameter): timeIndisposedMs = c_int32() m = self.lib.ps5000RunBlock(c_int16(self.handle), c_uint32(numPreTrigSamples), c_uint32(numPostTrigSamples), c_uint32(timebase), c_int16(oversample), byref(timeIndisposedMs), c_uint32(segmentIndex), c_void_p(), c_void_p()) # According to the documentation, 'callback, pParameter' should work # instead of the last two c_void_p parameters. # However to avoid the potential for serious crashes, we decided to # not include them in this function call. self.checkResult(m) return timeIndisposedMs.value def _lowLevelIsReady(self): ready = c_int16() m = self.lib.ps5000IsReady(c_int16(self.handle), byref(ready)) self.checkResult(m) if ready.value: return True else: return False def _lowLevelGetTimebase(self, tb, noSamples, oversample, segmentIndex): """Return (timeIntervalSeconds, maxSamples).""" maxSamples = c_int32() sampleRate = c_float() m = self.lib.ps5000GetTimebase2(c_int16(self.handle), c_uint32(tb), c_uint32(noSamples), byref(sampleRate), c_int16(oversample), byref(maxSamples), c_uint32(segmentIndex)) self.checkResult(m) return (sampleRate.value / 1.0E9, maxSamples.value) def getTimeBaseNum(self, sampleTimeS): """Return sample time in seconds to timebase as int for API calls.""" maxSampleTime = (((2**32 - 1) - 2) / 125000000) if sampleTimeS < 8E-9: timebase = math.floor(math.log(sampleTimeS * 1E9, 2)) timebase = max(timebase, 0) else: # Otherwise in range 2^32-1 if sampleTimeS > maxSampleTime: sampleTimeS = maxSampleTime timebase = math.floor((sampleTimeS * 125000000) + 2) # is this cast needed? timebase = int(timebase) return timebase def getTimestepFromTimebase(self, timebase): """Return timebase to sampletime as seconds.""" if timebase < 3: dt = 2.**timebase / 1E9 else: dt = (timebase - 2) / 125000000. return dt def _lowLevelSetDataBuffer(self, channel, data, downSampleMode, segmentIndex): """Set the data buffer. Be sure to call _lowLevelClearDataBuffer when you are done with the data array or else subsequent calls to GetValue will still use the same array. segmentIndex is unused, but required by other versions of the API (eg PS5000a) """ dataPtr = data.ctypes.data_as(POINTER(c_int16)) numSamples = len(data) m = self.lib.ps5000SetDataBuffer(c_int16(self.handle), c_enum(channel), dataPtr, c_uint32(numSamples), c_enum(downSampleMode)) self.checkResult(m) def _lowLevelClearDataBuffer(self, channel, segmentIndex): m = self.lib.ps5000SetDataBuffer(c_int16(self.handle), c_enum(channel), c_void_p(), c_uint32(0), c_enum(0)) self.checkResult(m) def _lowLevelGetValues(self, numSamples, startIndex, downSampleRatio, downSampleMode, segmentIndex): numSamplesReturned = c_uint32() numSamplesReturned.value = numSamples overflow = c_int16() m = self.lib.ps5000GetValues(c_int16(self.handle), c_uint32(startIndex), byref(numSamplesReturned), c_uint32(downSampleRatio), c_enum(downSampleMode), c_uint32(segmentIndex), byref(overflow)) self.checkResult(m) return (numSamplesReturned.value, overflow.value) #################################################################### # Untested functions below # # # #################################################################### def _lowLevelSetAWGSimpleDeltaPhase(self, waveform, deltaPhase, offsetVoltage, pkToPk, indexMode, shots, triggerType, triggerSource): """Waveform should be an array of shorts.""" waveformPtr = waveform.ctypes.data_as(POINTER(c_int16)) m = self.lib.ps5000SetSigGenArbitrary( c_int16(self.handle), c_uint32(int(offsetVoltage * 1E6)), # offset voltage in microvolts c_uint32(int(pkToPk * 1E6)), # pkToPk in microvolts c_uint32(int(deltaPhase)), # startDeltaPhase c_uint32(int(deltaPhase)), # stopDeltaPhase c_uint32(0), # deltaPhaseIncrement c_uint32(0), # dwellCount waveformPtr, # arbitraryWaveform c_int32(len(waveform)), # arbitraryWaveformSize c_enum(0), # sweepType for deltaPhase c_enum(0), # operation (adding random noise and whatnot) c_enum(indexMode), # single, dual, quad c_uint32(shots), c_uint32(0), # sweeps c_uint32(triggerType), c_uint32(triggerSource), c_int16(0)) # extInThreshold self.checkResult(m) def _lowLevelSetSigGenBuiltInSimple(self, offsetVoltage, pkToPk, waveType, frequency, shots, triggerType, triggerSource, stopFreq, increment, dwellTime, sweepType, numSweeps): # TODO, I just noticed that V2 exists # Maybe change to V2 in the future if stopFreq is None: stopFreq = frequency m = self.lib.ps5000SetSigGenBuiltIn( c_int16(self.handle), c_int32(int(offsetVoltage * 1000000)), c_int32(int(pkToPk * 1000000)), c_int16(waveType), c_float(frequency), c_float(stopFreq), c_float(increment), c_float(dwellTime), c_enum(sweepType), c_enum(0), c_uint32(shots), c_uint32(numSweeps), c_enum(triggerType), c_enum(triggerSource), c_int16(0)) self.checkResult(m) def _lowLevelGetAnalogueOffset(self, range, coupling): # TODO, populate properties with this function maximumVoltage = c_float() minimumVoltage = c_float() m = self.lib.ps5000GetAnalogueOffset(c_int16(self.handle), c_enum(range), c_enum(coupling), byref(maximumVoltage), byref(minimumVoltage)) self.checkResult(m) return (maximumVoltage.value, minimumVoltage.value) def _lowLevelGetMaxDownSampleRatio(self, noOfUnaggregatedSamples, downSampleRatioMode, segmentIndex): maxDownSampleRatio = c_uint32() m = self.lib.ps5000GetMaxDownSampleRatio( c_int16(self.handle), c_uint32(noOfUnaggregatedSamples), byref(maxDownSampleRatio), c_enum(downSampleRatioMode), c_uint32(segmentIndex)) self.checkResult(m) return maxDownSampleRatio.value def _lowLevelGetNoOfCaptures(self): nCaptures = c_uint32() m = self.lib.ps5000GetNoOfCaptures(c_int16(self.handle), byref(nCaptures)) self.checkResult(m) return nCaptures.value def _lowLevelGetTriggerTimeOffset(self, segmentIndex): time = c_uint64() timeUnits = c_enum() m = self.lib.ps5000GetTriggerTimeOffset64(c_int16(self.handle), byref(time), byref(timeUnits), c_uint32(segmentIndex)) self.checkResult(m) if timeUnits.value == 0: # PS5000_FS return time.value * 1E-15 elif timeUnits.value == 1: # PS5000_PS return time.value * 1E-12 elif timeUnits.value == 2: # PS5000_NS return time.value * 1E-9 elif timeUnits.value == 3: # PS5000_US return time.value * 1E-6 elif timeUnits.value == 4: # PS5000_MS return time.value * 1E-3 elif timeUnits.value == 5: # PS5000_S return time.value * 1E0 else: raise TypeError("Unknown timeUnits %d" % timeUnits.value) def _lowLevelMemorySegments(self, nSegments): nMaxSamples = c_uint32() m = self.lib.ps5000MemorySegments(c_int16(self.handle), c_uint32(nSegments), byref(nMaxSamples)) self.checkResult(m) return nMaxSamples.value def _lowLevelSetDataBuffers(self, channel, bufferMax, bufferMin, downSampleRatioMode): bufferMaxPtr = bufferMax.ctypes.data_as(POINTER(c_int16)) bufferMinPtr = bufferMin.ctypes.data_as(POINTER(c_int16)) bufferLth = len(bufferMax) m = self.lib.ps5000SetDataBuffers(c_int16(self.handle), c_enum(channel), bufferMaxPtr, bufferMinPtr, c_uint32(bufferLth), c_enum(downSampleRatioMode)) self.checkResult(m) def _lowLevelClearDataBuffers(self, channel): m = self.lib.ps5000SetDataBuffers(c_int16(self.handle), c_enum(channel), c_void_p(), c_void_p(), c_uint32(0), c_enum(0)) self.checkResult(m) # Bulk values. # These would be nice, but the user would have to provide us # with an array. # we would have to make sure that it is contiguous amonts other things def _lowLevelGetValuesBulk(self, numSamples, fromSegmentIndex, toSegmentIndex, downSampleRatio, downSampleRatioMode, overflow): noOfSamples = c_uint32(numSamples) m = self.lib.ps5000GetValuesBulk( c_int16(self.handle), byref(noOfSamples), c_uint32(fromSegmentIndex), c_uint32(toSegmentIndex), c_uint32(downSampleRatio), c_enum(downSampleRatioMode), overflow.ctypes.data_as(POINTER(c_int16))) self.checkResult(m) return noOfSamples.value def _lowLevelSetDataBufferBulk(self, channel, buffer, waveform, downSampleRatioMode): bufferPtr = buffer.ctypes.data_as(POINTER(c_int16)) bufferLth = len(buffer) m = self.lib.ps5000SetDataBufferBulk(c_int16(self.handle), c_enum(channel), bufferPtr, c_uint32(bufferLth), c_uint32(waveform), c_enum(downSampleRatioMode)) self.checkResult(m) def _lowLevelSetDataBuffersBulk(self, channel, bufferMax, bufferMin, waveform, downSampleRatioMode): bufferMaxPtr = bufferMax.ctypes.data_as(POINTER(c_int16)) bufferMinPtr = bufferMin.ctypes.data_as(POINTER(c_int16)) bufferLth = len(bufferMax) m = self.lib.ps5000SetDataBuffersBulk(c_int16(self.handle), c_enum(channel), bufferMaxPtr, bufferMinPtr, c_uint32(bufferLth), c_uint32(waveform), c_enum(downSampleRatioMode)) self.checkResult(m) def _lowLevelSetNoOfCaptures(self, nCaptures): m = self.lib.ps5000SetNoOfCaptures(c_int16(self.handle), c_uint32(nCaptures)) self.checkResult(m) # ETS Functions def _lowLevelSetEts(): pass def _lowLevelSetEtsTimeBuffer(): pass def _lowLevelSetEtsTimeBuffers(): pass def _lowLevelSetExternalClock(): pass # Complicated triggering # need to understand structs for this one to work def _lowLevelIsTriggerOrPulseWidthQualifierEnabled(): pass def _lowLevelGetValuesTriggerTimeOffsetBulk(): pass def _lowLevelSetTriggerChannelConditions(): pass def _lowLevelSetTriggerChannelDirections(): pass def _lowLevelSetTriggerChannelProperties(): pass def _lowLevelSetPulseWidthQualifier(): pass def _lowLevelSetTriggerDelay(): pass # Async functions # would be nice, but we would have to learn to implement callbacks def _lowLevelGetValuesAsync(): pass def _lowLevelGetValuesBulkAsync(): pass # overlapped functions def _lowLevelGetValuesOverlapped(): pass def _lowLevelGetValuesOverlappedBulk(): pass # Streaming related functions def _lowLevelGetStreamingLatestValues(): pass def _lowLevelNoOfStreamingValues(self): noOfValues = c_uint32() m = self.lib.ps5000NoOfStreamingValues(c_int16(self.handle), byref(noOfValues)) self.checkResult(m) return noOfValues.value def _lowLevelRunStreaming(): pass def _lowLevelStreamingReady(): pass