Create variant of Block example that uses the callback method

Author: neil.hamilton

ps5000aExamples/ps5000aBlockCallbackExample.py

@@ -0,0 +1,197 @@
+#
+# Copyright (C) 2018 Pico Technology Ltd. See LICENSE file for terms.
+#
+# PS5000A BLOCK MODE EXAMPLE
+# This example opens a 5000a driver device, sets up two channels and a trigger then collects a block of data.
+# This data is then plotted as mV against time in ns.
+
+import ctypes
+import numpy as np
+from picosdk.ps5000a import ps5000a as ps
+import matplotlib.pyplot as plt
+from picosdk.functions import adc2mV, assert_pico_ok, mV2adc
+from picosdk.constants import PICO_STATUS
+import time
+
+# Create chandle and status ready for use
+chandle = ctypes.c_int16()
+status = {}
+
+# Open 5000 series PicoScope
+# Resolution set to 12 Bit
+resolution =ps.PS5000A_DEVICE_RESOLUTION["PS5000A_DR_12BIT"]
+# Returns handle to chandle for use in future API functions
+status["openunit"] = ps.ps5000aOpenUnit(ctypes.byref(chandle), None, resolution)
+
+try:
+    assert_pico_ok(status["openunit"])
+except: # PicoNotOkError:
+
+    powerStatus = status["openunit"]
+
+    if powerStatus == 286:
+        status["changePowerSource"] = ps.ps5000aChangePowerSource(chandle, powerStatus)
+    elif powerStatus == 282:
+        status["changePowerSource"] = ps.ps5000aChangePowerSource(chandle, powerStatus)
+    else:
+        raise
+
+    assert_pico_ok(status["changePowerSource"])
+
+# Set up channel A
+# handle = chandle
+channel = ps.PS5000A_CHANNEL["PS5000A_CHANNEL_A"]
+# enabled = 1
+coupling_type = ps.PS5000A_COUPLING["PS5000A_DC"]
+chARange = ps.PS5000A_RANGE["PS5000A_20V"]
+# analogue offset = 0 V
+status["setChA"] = ps.ps5000aSetChannel(chandle, channel, 1, coupling_type, chARange, 0)
+assert_pico_ok(status["setChA"])
+
+# Set up channel B
+# handle = chandle
+channel = ps.PS5000A_CHANNEL["PS5000A_CHANNEL_B"]
+# enabled = 1
+# coupling_type = ps.PS5000A_COUPLING["PS5000A_DC"]
+chBRange = ps.PS5000A_RANGE["PS5000A_2V"]
+# analogue offset = 0 V
+status["setChB"] = ps.ps5000aSetChannel(chandle, channel, 1, coupling_type, chBRange, 0)
+assert_pico_ok(status["setChB"])
+
+# find maximum ADC count value
+# handle = chandle
+# pointer to value = ctypes.byref(maxADC)
+maxADC = ctypes.c_int16()
+status["maximumValue"] = ps.ps5000aMaximumValue(chandle, ctypes.byref(maxADC))
+assert_pico_ok(status["maximumValue"])
+
+# Set up single trigger
+# handle = chandle
+# enabled = 1
+source = ps.PS5000A_CHANNEL["PS5000A_CHANNEL_A"]
+threshold = int(mV2adc(500,chARange, maxADC))
+# direction = PS5000A_RISING = 2
+# delay = 0 s
+# auto Trigger = 1000 ms
+status["trigger"] = ps.ps5000aSetSimpleTrigger(chandle, 1, source, threshold, 2, 0, 1000)
+assert_pico_ok(status["trigger"])
+
+# Set number of pre and post trigger samples to be collected
+preTriggerSamples = 2500
+postTriggerSamples = 2500
+maxSamples = preTriggerSamples + postTriggerSamples
+
+# Get timebase information
+# handle = chandle
+timebase = 8
+# noSamples = maxSamples
+# pointer to timeIntervalNanoseconds = ctypes.byref(timeIntervalns)
+# pointer to maxSamples = ctypes.byref(returnedMaxSamples)
+# segment index = 0
+timeIntervalns = ctypes.c_float()
+returnedMaxSamples = ctypes.c_int32()
+status["getTimebase2"] = ps.ps5000aGetTimebase2(chandle, timebase, maxSamples, ctypes.byref(timeIntervalns), ctypes.byref(returnedMaxSamples), 0)
+assert_pico_ok(status["getTimebase2"])
+
+# setup callback function
+ready = False
+
+def block_callback(handle, statusCallback, param):
+    global wasCalledBack, ready
+    wasCalledBack = True
+    if statusCallback != PICO_STATUS['PICO_CANCELLED']:
+       ready = True
+    
+# Convert the python function into a C function pointer.
+cFuncPtr = ps.BlockReadyType(block_callback)
+
+# Run block capture
+# handle = chandle
+# number of pre-trigger samples = preTriggerSamples
+# number of post-trigger samples = PostTriggerSamples
+# timebase = 8 = 80 ns (see Programmer's guide for mre information on timebases)
+# time indisposed ms = None (not needed in the example)
+# segment index = 0
+# lpReady = cFuncPtr
+# pParameter = None
+status["runBlock"] = ps.ps5000aRunBlock(chandle, preTriggerSamples, postTriggerSamples, timebase, None, 0, cFuncPtr, None)
+assert_pico_ok(status["runBlock"])
+
+# Check for data collection to finish using ps5000aIsReady
+check = ctypes.c_int16(0)
+while ready == False:
+    time.sleep(0.01)
+    
+print("Capture finished")
+
+
+# Create buffers ready for assigning pointers for data collection
+bufferAMax = (ctypes.c_int16 * maxSamples)()
+bufferAMin = (ctypes.c_int16 * maxSamples)() # used for downsampling which isn't in the scope of this example
+bufferBMax = (ctypes.c_int16 * maxSamples)()
+bufferBMin = (ctypes.c_int16 * maxSamples)() # used for downsampling which isn't in the scope of this example
+
+# Set data buffer location for data collection from channel A
+# handle = chandle
+source = ps.PS5000A_CHANNEL["PS5000A_CHANNEL_A"]
+# pointer to buffer max = ctypes.byref(bufferAMax)
+# pointer to buffer min = ctypes.byref(bufferAMin)
+# buffer length = maxSamples
+# segment index = 0
+# ratio mode = PS5000A_RATIO_MODE_NONE = 0
+status["setDataBuffersA"] = ps.ps5000aSetDataBuffers(chandle, source, ctypes.byref(bufferAMax), ctypes.byref(bufferAMin), maxSamples, 0, 0)
+assert_pico_ok(status["setDataBuffersA"])
+
+# Set data buffer location for data collection from channel B
+# handle = chandle
+source = ps.PS5000A_CHANNEL["PS5000A_CHANNEL_B"]
+# pointer to buffer max = ctypes.byref(bufferBMax)
+# pointer to buffer min = ctypes.byref(bufferBMin)
+# buffer length = maxSamples
+# segment index = 0
+# ratio mode = PS5000A_RATIO_MODE_NONE = 0
+status["setDataBuffersB"] = ps.ps5000aSetDataBuffers(chandle, source, ctypes.byref(bufferBMax), ctypes.byref(bufferBMin), maxSamples, 0, 0)
+assert_pico_ok(status["setDataBuffersB"])
+
+# create overflow loaction
+overflow = ctypes.c_int16()
+# create converted type maxSamples
+cmaxSamples = ctypes.c_int32(maxSamples)
+
+# Retried data from scope to buffers assigned above
+# handle = chandle
+# start index = 0
+# pointer to number of samples = ctypes.byref(cmaxSamples)
+# downsample ratio = 0
+# downsample ratio mode = PS5000A_RATIO_MODE_NONE
+# pointer to overflow = ctypes.byref(overflow))
+status["getValues"] = ps.ps5000aGetValues(chandle, 0, ctypes.byref(cmaxSamples), 0, 0, 0, ctypes.byref(overflow))
+assert_pico_ok(status["getValues"])
+
+
+# convert ADC counts data to mV
+adc2mVChAMax =  adc2mV(bufferAMax, chARange, maxADC)
+adc2mVChBMax =  adc2mV(bufferBMax, chBRange, maxADC)
+
+# Create time data
+time = np.linspace(0, (cmaxSamples.value) * timeIntervalns.value, cmaxSamples.value)
+
+# plot data from channel A and B
+plt.plot(time, adc2mVChAMax[:])
+plt.plot(time, adc2mVChBMax[:])
+plt.xlabel('Time (ns)')
+plt.ylabel('Voltage (mV)')
+plt.show()
+
+# Stop the scope
+# handle = chandle
+status["stop"] = ps.ps5000aStop(chandle)
+assert_pico_ok(status["stop"])
+
+# Close unit Disconnect the scope
+# handle = chandle
+status["close"]=ps.ps5000aCloseUnit(chandle)
+assert_pico_ok(status["close"])
+
+# display status returns
+print(status)