Create block example for psospa

Author: neil.hamilton

psospaExamples/psospaBlockExample.py

@@ -0,0 +1,141 @@
+#
+# Copyright (C) 2024 Pico Technology Ltd. See LICENSE file for terms.
+#
+# PSOSPA BLOCK MODE EXAMPLE
+# This example opens a psospa 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.psospa import psospa as ps
+from picosdk.PicoDeviceEnums import picoEnum as enums
+from picosdk.PicoDeviceStructs import picoStruct as structs
+# from picosdk.PicoConnectProbes import picoConnectProbes as probes
+import matplotlib.pyplot as plt
+from picosdk.functions import adc2mVV2, mV2adcV2, assert_pico_ok
+
+# Create chandle and status ready for use
+chandle = ctypes.c_int16()
+status = {}
+
+# Open a psospa driver device
+# returns handle for future API functions
+resolution = enums.PICO_DEVICE_RESOLUTION["PICO_DR_8BIT"]
+status["openUnit"] = ps.psospaOpenUnit(ctypes.byref(chandle), None, resolution, None)
+assert_pico_ok(status["openUnit"])
+
+# Set channel A on
+# handle = chandle
+channelA = enums.PICO_CHANNEL["PICO_CHANNEL_A"]
+coupling = enums.PICO_COUPLING["PICO_DC"]
+rangeMax = 2000000000 #nV
+rangeMin = -rangeMax #nV
+rangeType = 0 #probes.PICO_PROBE_RANGE_INFO["PICO_PROBE_NONE_NV"]
+analogueOffset = 0
+bandwidth = enums.PICO_BANDWIDTH_LIMITER["PICO_BW_FULL"]
+status["setChannelA"] = ps.psospaSetChannelOn(chandle, channelA, coupling, rangeMin, rangeMax, rangeType, analogueOffset, bandwidth)
+assert_pico_ok(status["setChannelA"])
+
+# set channel B-H off
+for x in range (1, 3, 1):
+    channel = x
+    status["setChannel",x] = ps.psospaSetChannelOff(chandle,channel)
+    assert_pico_ok(status["setChannel",x])
+    
+# get max ADC value
+# handle = chandle
+minADC = ctypes.c_int16()
+maxADC = ctypes.c_int16()
+status["getAdcLimits"] = ps.psospaGetAdcLimits(chandle, resolution, ctypes.byref(minADC), ctypes.byref(maxADC))
+assert_pico_ok(status["getAdcLimits"])
+
+# Set simple trigger on channel A, 1 V rising with 1 s autotrigger
+# handle = chandle
+# enable = 1
+source = channelA
+# threshold = 100 mV
+direction = enums.PICO_THRESHOLD_DIRECTION["PICO_RISING"]
+# delay = 0 s
+# autoTriggerMicroSeconds = 1000000 us
+status["setSimpleTrigger"] = ps.psospaSetSimpleTrigger(chandle, 1, source, (mV2adcV2(100,rangeMax,maxADC), direction, 0, 1000000)
+assert_pico_ok(status["setSimpleTrigger"])
+
+# Get fastest available timebase
+# handle = chandle
+enabledChannelFlags = enums.PICO_CHANNEL_FLAGS["PICO_CHANNEL_A_FLAGS"]
+timebase = ctypes.c_uint32(0)
+timeInterval = ctypes.c_double(0)
+# resolution = resolution
+status["getMinimumTimebaseStateless"] = ps.psospaGetMinimumTimebaseStateless(chandle, enabledChannelFlags, ctypes.byref(timebase), ctypes.byref(timeInterval), resolution)
+print("timebase = ", timebase.value)
+print("sample interval =", timeInterval.value, "s")
+
+# Set number of samples to be collected
+noOfPreTriggerSamples = 500000
+noOfPostTriggerSamples = 1000000
+nSamples = noOfPostTriggerSamples + noOfPreTriggerSamples
+
+# Create buffers
+bufferAMax = (ctypes.c_int16 * nSamples)()
+bufferAMin = (ctypes.c_int16 * nSamples)() # used for downsampling which isn't in the scope of this example
+
+# Set data buffers
+# handle = chandle
+# channel = channelA
+# bufferMax = bufferAMax
+# bufferMin = bufferAMin
+# nSamples = nSamples
+dataType = enums.PICO_DATA_TYPE["PICO_INT16_T"]
+waveform = 0
+downSampleMode = enums.PICO_RATIO_MODE["PICO_RATIO_MODE_RAW"]
+clear = enums.PICO_ACTION["PICO_CLEAR_ALL"]
+add = enums.PICO_ACTION["PICO_ADD"]
+action = clear|add # PICO_ACTION["PICO_CLEAR_WAVEFORM_CLEAR_ALL"] | PICO_ACTION["PICO_ADD"]  
+status["setDataBuffers"] = ps.psospaSetDataBuffers(chandle, channelA, ctypes.byref(bufferAMax), ctypes.byref(bufferAMin), nSamples, dataType, waveform, downSampleMode, action)
+assert_pico_ok(status["setDataBuffers"])
+
+# Run block capture
+# handle = chandle
+# timebase = timebase
+timeIndisposedMs = ctypes.c_double(0)
+# segmentIndex = 0
+# lpReady = None   Using IsReady rather than a callback
+# pParameter = None
+status["runBlock"] = ps.psospaRunBlock(chandle, noOfPreTriggerSamples, noOfPostTriggerSamples, timebase, ctypes.byref(timeIndisposedMs), 0, None, None)
+assert_pico_ok(status["runBlock"])
+
+# Check for data collection to finish using psospaIsReady
+ready = ctypes.c_int16(0)
+check = ctypes.c_int16(0)
+while ready.value == check.value:
+    status["isReady"] = ps.psospaIsReady(chandle, ctypes.byref(ready))
+    
+# Get data from scope
+# handle = chandle
+# startIndex = 0
+noOfSamples = ctypes.c_uint64(nSamples)
+# downSampleRatio = 1
+# segmentIndex = 0
+overflow = ctypes.c_int16(0)
+status["getValues"] = ps.psospaGetValues(chandle, 0, ctypes.byref(noOfSamples), 1, downSampleMode, 0, ctypes.byref(overflow))
+assert_pico_ok(status["getValues"])
+
+
+
+# # convert ADC counts data to mV
+adc2mVChAMax =  adc2mVV2(bufferAMax, rangeMax, maxADC)
+
+# Create time data
+time = np.linspace(0, (nSamples -1) * timeInterval.value * 1000000000, nSamples)
+
+# plot data from channel A and B
+plt.plot(time, bufferAMax[:])
+plt.xlabel('Time (ns)')
+plt.ylabel('Voltage (mV)')
+plt.show()
+
+# Close the psospa driver device
+status["closeUnit"] = ps.psospaCloseUnit(chandle)
+assert_pico_ok(status["closeUnit"])
+
+print(status)