Create ps5000BlockExample.py

Author: neil.hamilton

ps5000Examples/ps5000BlockExample.py

@@ -0,0 +1,165 @@
+#
+# Copyright (C) 2018 Pico Technology Ltd. See LICENSE file for terms.
+#
+# PS5000 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.ps5000 import ps5000 as ps
+import matplotlib.pyplot as plt
+from picosdk.functions import adc2mV, assert_pico_ok, mV2adc
+
+# Create chandle and status ready for use
+chandle = ctypes.c_int16()
+status = {}
+
+# Open 5000 series PicoScope
+# Returns handle to chandle for use in future API functions
+status["openunit"] = ps.ps5000OpenUnit(ctypes.byref(chandle))
+assert_pico_ok(status["openunit"])
+
+
+# Set up channel A
+# handle = chandle
+channel = ps.PS5000_CHANNEL["PS5000_CHANNEL_A"]
+# enabled = 1
+coupling_type = 1 # DC
+chARange = ps.PS5000_RANGE["PS5000_20V"]
+# analogue offset = 0 V
+status["setChA"] = ps.ps5000SetChannel(chandle, channel, 1, coupling_type, chARange)
+assert_pico_ok(status["setChA"])
+
+# Set up channel B
+# handle = chandle
+channel = ps.PS5000_CHANNEL["PS5000_CHANNEL_B"]
+# enabled = 1
+# coupling_type = ps.PS5000_COUPLING["PS5000_DC"]
+chBRange = ps.PS5000_RANGE["PS5000_2V"]
+# analogue offset = 0 V
+status["setChB"] = ps.ps5000SetChannel(chandle, channel, 1, coupling_type, chBRange)
+assert_pico_ok(status["setChB"])
+
+# find maximum ADC count value
+# handle = chandle
+# pointer to value = ctypes.byref(maxADC)
+maxADC = ctypes.c_int16(32512)
+
+# Set up single trigger
+# handle = chandle
+# enabled = 1
+source = ps.PS5000_CHANNEL["PS5000_CHANNEL_A"]
+threshold = int(mV2adc(500,chARange, maxADC))
+# direction = PS5000_RISING = 2
+# delay = 0 s
+# auto Trigger = 1000 ms
+status["trigger"] = ps.ps5000SetSimpleTrigger(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)
+oversample = 1
+# pointer to maxSamples = ctypes.byref(returnedMaxSamples)
+# segment index = 0
+timeIntervalns = ctypes.c_float()
+returnedMaxSamples = ctypes.c_int32()
+status["getTimebase"] = ps.ps5000GetTimebase(chandle, timebase, maxSamples, ctypes.byref(timeIntervalns), oversample, ctypes.byref(returnedMaxSamples), 0)
+assert_pico_ok(status["getTimebase2"])
+
+# Run block capture
+# handle = chandle
+# number of pre-trigger samples = preTriggerSamples
+# number of post-trigger samples = PostTriggerSamples
+# timebase = 8 = 80 ns (see Programmer's guide for mre information on timebases)
+# oversample = 1
+# time indisposed ms = None (not needed in the example)
+# segment index = 0
+# lpReady = None (using ps5000IsReady rather than ps5000BlockReady)
+# pParameter = None
+status["runBlock"] = ps.ps5000RunBlock(chandle, preTriggerSamples, postTriggerSamples, timebase, oversample, None, 0, None, None)
+assert_pico_ok(status["runBlock"])
+
+# Check for data collection to finish using ps5000IsReady
+ready = ctypes.c_int16(0)
+check = ctypes.c_int16(0)
+while ready.value == check.value:
+    status["isReady"] = ps.ps5000IsReady(chandle, ctypes.byref(ready))
+
+
+# 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.PS5000_CHANNEL["PS5000_CHANNEL_A"]
+# pointer to buffer max = ctypes.byref(bufferAMax)
+# pointer to buffer min = ctypes.byref(bufferAMin)
+# buffer length = maxSamples
+status["setDataBuffersA"] = ps.ps5000SetDataBuffers(chandle, source, ctypes.byref(bufferAMax), ctypes.byref(bufferAMin), maxSamples)
+assert_pico_ok(status["setDataBuffersA"])
+
+# Set data buffer location for data collection from channel B
+# handle = chandle
+source = ps.PS5000_CHANNEL["PS5000_CHANNEL_B"]
+# pointer to buffer max = ctypes.byref(bufferBMax)
+# pointer to buffer min = ctypes.byref(bufferBMin)
+# buffer length = maxSamples
+# segment index = 0
+# ratio mode = PS5000_RATIO_MODE_NONE = 0
+status["setDataBuffersB"] = ps.ps5000SetDataBuffers(chandle, source, ctypes.byref(bufferBMax), ctypes.byref(bufferBMin), maxSamples)
+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 = PS5000_RATIO_MODE_NONE
+# pointer to overflow = ctypes.byref(overflow))
+status["getValues"] = ps.ps5000GetValues(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.ps5000Stop(chandle)
+assert_pico_ok(status["stop"])
+
+# Close unit Disconnect the scope
+# handle = chandle
+status["close"]=ps.ps5000CloseUnit(chandle)
+assert_pico_ok(status["close"])
+
+# display status returns
+print(status)