def _open_interface(self, serial_number):
open_interfaces = self._get_open_interfaces()
if serial_number in open_interfaces:
#raise InterfaceAlreadyOpen(serial_number)
return
try:
ps = ps3000a.PS3000a(serial_number)
except:
raise InterfaceNotAvailable(serial_number)
self.interfaces[serial_number] = ps
def refresh_available_interfaces(self):
ps = ps3000a.PS3000a(connect=False)
# ps2 = ps5000a.PS5000a(connect=False)
try:
serial_numbers = ps.enumerateUnits()
except:
serial_numbers = []
# try:
# serial_numbers2 = serial_numbers + ps2.enumerateUnits()
# except:
# serial_numbers2 = []
additions = set(serial_numbers) - set(self.interfaces.keys())
# additions2 = set(serial_numbers2) - set(self.interfaces.keys())
for sn in additions:
inst = ps3000a.PS3000a(sn)
self.interfaces[sn] = inst
# for sn in additions2:
# inst = ps5000a.PS5000a(sn)
# self.interfaces[sn] = inst
ps.close()
def config(self):
self.ps = ps3000a.PS3000a(connect=False)
self.ps.open()
self.ps.setChannel("A",
coupling="DC",
VRange=self.ChA_VRange,
VOffset=self.ChA_Offset)
self.ps.setChannel("B",
coupling="DC",
VRange=self.ChB_VRange,
VOffset=self.ChB_Offset)
self.ps.setSamplingInterval(self.sampleInterval, self.samplingDuration)
self.ps.setSimpleTrigger(trigSrc=self.trigSrc,
threshold_V=self.threshold_V,
direction=self.direction,
timeout_ms=self.timeout_ms,
enabled=True,
delay=self.delay)
max_samples_per_segment = self.ps.memorySegments(self.n_captures)
self.samples_per_segment = int(self.samplingDuration /
self.sampleInterval)
self.ps.setNoOfCaptures(self.n_captures)
from picoscope import ps3000a
from time import sleep
import matplotlib.pyplot as plt
import numpy as np
import time
import labrad
import json
cxn = labrad.connect()
SERIAL_NUMBER = "DU009/008"
N_TRIG = 3
DATA_FILENAME = './data.json'
ps = ps3000a.PS3000a(SERIAL_NUMBER)
ps.setChannel("A", coupling="DC", VRange=5.0, probeAttenuation=10)
ps.setChannel("B", enabled=False)
ps.setChannel("C", enabled=False)
ps.setChannel("D", enabled=False)
res = ps.setSamplingFrequency(1e9, int(1e6))
print("Sampling @ %f MHz, %d samples" % (res[0] / 1e6, res[1]))
#Use external trigger to mark when we sample
ps.setSimpleTrigger(trigSrc="External", threshold_V=2, timeout_ms=-1)
samples_per_segment = ps.memorySegments(N_TRIG)
ps.setNoOfCaptures(N_TRIG)
#data = np.zeros((N_TRIG, samples_per_segment), dtype=np.int16)
def go():
ps.runBlock()
app.processEvents()
except KeyboardInterrupt:
break
ps.close()
piStage.CloseConnection()
dataA = np.array(data_out_A, dtype=np.int16)
dataB = np.array(data_out_B, dtype=np.int16)
return dataA, dataB
if __name__ == '__main__':
get_ipython().run_line_magic('matplotlib', 'qt')
from skimage.external.tifffile import imsave
from E727 import *
import traceback
ps = ps3000a.PS3000a(connect=False)
ps.open()
ps.setChannel("A", coupling="DC", VRange=0.02)
ps.setChannel("B", coupling="DC", VRange=0.02)
ps.setSamplingInterval(200e-9, 15e-6)
ps.setSimpleTrigger(trigSrc="External",
threshold_V=0.020,
direction='Rising',
timeout_ms=5,
enabled=True)
#dataA = np.zeros((n_captures, samples_per_segment), dtype=np.int16)
#dataB = np.zeros((n_captures, samples_per_segment), dtype=np.int16)
#t1 = time.time()
#ps.runBlock()
#!/usr/bin/python import picoscope import matplotlib.pyplot as plt import matplotlib import numpy as np import time import math from ctypes import * import scipy.optimize picoscope = reload(picoscope) from picoscope import ps3000a ps3000a = reload(ps3000a) ps = ps3000a.PS3000a() def setFreq(freq): offsetVoltage = 0.0 pkToPk = 3.2 m = ps.lib.ps3000aSetSigGenBuiltInV2( c_int16(ps.handle), c_int32(int(offsetVoltage * 1000000)), c_int32(int(pkToPk * 1000000)), c_int16(0), c_double(freq), c_double(freq), c_double(0.0), c_double(0.0), c_uint(0), c_uint(0), c_uint32(0xFFFFFFFF), c_uint32(0), #shots, sweeps #c_uint32(100), c_uint32(0), #shots, sweeps c_uint(0), c_uint(0), c_int16(0)) if m!= 0:
def _get_available_interfaces(self):
ps = ps3000a.PS3000a(connect=False)
available_interfaces = ps.enumerateUnits()
print(available_interfaces)
ps.close()
return available_interfaces
def __init__(self):
self.ps = ps3000a.PS3000a(connect=False)
def connect(self): self.device = ps3000a.PS3000a()
class Pico_view(QtGui.QMainWindow):
timer = QtCore.QTimer()
q = Queue()
ps = ps3000a.PS3000a(connect=False)
pico = Pico_recorder(q=q)
liveA = []
liveB = []
liveT = []
def __init__(self, parent=None):
QtGui.QMainWindow.__init__(self, parent)
#QtGui.QApplication.setGraphicsSystem('raster')
#app = QtGui.QApplication([])
self.setWindowTitle('pyqtgraph example: PlotWidget')
self.resize(800, 800)
cw = QtGui.QWidget()
self.setCentralWidget(cw)
l = QtGui.QVBoxLayout()
cw.setLayout(l)
pw = pg.PlotWidget(
name='Plot1'
) ## giving the plots names allows us to link their axes together
l.addWidget(pw)
pw1 = pg.PlotWidget(
name='Plot2'
) ## giving the plots names allows us to link their axes together
l.addWidget(pw1)
self.show()
## Create an empty plot curve to be filled later, set its pen
self.curveA = pw.plot()
self.curveA.setPen((255, 0, 0))
self.curveB = pw.plot()
self.curveB.setPen((0, 255, 0))
## Create an empty plot curve to be filled later, set its pen
self.curveA1 = pw1.plot()
self.curveA1.setPen((255, 0, 0))
self.curveB1 = pw1.plot()
self.curveB1.setPen((0, 255, 0))
self.timer.timeout.connect(self.update)
self.timer.start(0.5)
self.pico.start()
#self.pico.join()
#self.actionExit.toggled.connect(self.closeEvent)
def update(self):
#print(data)
if not self.q.empty():
data_q = []
while not self.q.empty():
data_q.append(self.q.get())
#print(data)
L = len(data_q) * self.pico.n_captures
for data in data_q:
self.liveA += data[0].tolist()
self.liveB += data[1].tolist()
self.liveT += np.linspace(data[5], data[4],
len(data[0])).tolist()
dataA = data[2]
dataB = data[3]
if len(self.liveA) > 500:
self.liveA = self.liveA[L:]
self.liveB = self.liveB[L:]
self.liveT = self.liveT[L:]
self.curveA.setData(dataA)
self.curveB.setData(dataB)
self.curveA1.setData(x=self.liveT, y=self.liveA)
self.curveB1.setData(x=self.liveT, y=self.liveB)
app.processEvents()
def closeEvent(self, evnt=None):
#self.pico.close()
self.pico.alive = False
ex.pico.terminate()
data = np.array([self.liveT, self.liveA, self.liveB]).T
np.savetxt('signal' + str(time.time()) + '.txt', data)
def run(self):
ps = ps3000a.PS3000a(connect=False)
ps.open()
n_captures = 100
N = 16
self.n_captures = n_captures
ps.setChannel("A", coupling="DC", VRange=0.5)
ps.setChannel("B", coupling="DC", VRange=0.5)
capture_duration = 0.003
sample_interval = 0.00001
ps.setSamplingInterval(sample_interval, capture_duration)
#ps.setSamplingFrequency(80e6,1000000,2)
#ps.setEts(mode='slow', etsCycles=1,etsInterleave=1)
ps.setSimpleTrigger(trigSrc="B",
threshold_V=-0.350,
direction='Falling',
timeout_ms=100,
enabled=True,
delay=120)
max_samples_per_segment = ps.memorySegments(n_captures)
samples_per_segment = int(capture_duration / sample_interval)
self.samples_per_segment = samples_per_segment
ps.setNoOfCaptures(n_captures)
print('start')
out = []
dataA = np.zeros((self.n_captures, self.samples_per_segment),
dtype=np.int16)
dataB = np.zeros((self.n_captures, self.samples_per_segment),
dtype=np.int16)
for index in range(N):
t0 = time.time()
print('>', index, ' ', end='')
ps.runBlock()
while not ps.isReady():
#pass
time.sleep(0.00001)
#tt=ps.getTriggerTimeOffset(index)
print(time.time() - t0)
k = index + n_captures - 5
k_ = index
t0 = time.time()
ps.getDataRawBulk(channel='A', data=dataA)
ps.getDataRawBulk(channel='B', data=dataB)
dataA1 = dataA[:, 0:ps.noSamples] #.mean(axis=0)
out.append(dataA1.copy()) #.mean(axis=0))
print('<', time.time() - t0)
ps.stop()
#print(" ",i,end='')
#dataA1=dataA[:, 0:ps.noSamples]#.mean(axis=0)
#out.append(dataA)
#dataA=dataA[:, 0:ps.noSamples]#.mean(axis=0)
#dataB=dataB[:, 0:ps.noSamples]#.mean(axis=0)
q.put(out)
print('done')
print('End')
ps.close()
print('close')