def init(self):
exec 'import ctypes' in globals()
exec 'from PyDAQmx import Task' in globals()
exec 'from PyDAQmx.DAQmxConstants import *' in globals()
exec 'from PyDAQmx.DAQmxTypes import *' in globals()
global h5py
import labscript_utils.h5_lock, h5py
global numpy
import numpy
global threading
import threading
global zprocess
import zprocess
global logging
import logging
global time
import time
self.task_running = False
self.daqlock = threading.Lock(
) # not sure if needed, access should be serialised already
self.h5_file = None
self.task = None
self.abort = False
self.all_waits_finished = zprocess.Event('all_waits_finished',
type='post')
self.wait_durations_analysed = zprocess.Event(
'wait_durations_analysed', type='post')
def init(self):
"""Initialises the hardware communication.
This function is automatically called by BLACS
and configures hardware communication with the device.
"""
# fmt: off
global h5py
import labscript_utils.h5_lock, h5py
global serial
import serial
global time
import time
global re
import re
global numpy
import numpy
global zprocess
import zprocess
self.smart_cache = {}
self.cached_pll_params = {}
# fmt: on
self.all_waits_finished = zprocess.Event("all_waits_finished",
type="post")
self.wait_durations_analysed = zprocess.Event(
"wait_durations_analysed", type="post")
self.wait_completed = zprocess.Event("wait_completed", type="post")
self.current_wait = 0
self.wait_table = None
self.measured_waits = None
self.wait_timeout = None
self.h5_file = None
self.started = False
self.prawnblaster = serial.Serial(self.com_port, 115200, timeout=1)
self.check_status()
# configure number of pseudoclocks
self.prawnblaster.write(b"setnumpseudoclocks %d\r\n" %
self.num_pseudoclocks)
assert self.prawnblaster.readline().decode() == "ok\r\n"
# Configure pins
for i, (out_pin, in_pin) in enumerate(zip(self.out_pins,
self.in_pins)):
self.prawnblaster.write(b"setoutpin %d %d\r\n" % (i, out_pin))
assert self.prawnblaster.readline().decode() == "ok\r\n"
self.prawnblaster.write(b"setinpin %d %d\r\n" % (i, in_pin))
assert self.prawnblaster.readline().decode() == "ok\r\n"
def init(self):
from labscript_utils import check_version
check_version('spinapi', '3.1.1', '4')
exec 'from spinapi import *' in globals()
global h5py
import labscript_utils.h5_lock, h5py
global zprocess
import zprocess
self.pb_start = pb_start
self.pb_stop = pb_stop
self.pb_reset = pb_reset
self.pb_close = pb_close
self.pb_read_status = pb_read_status
self.smart_cache = {
'pulse_program': None,
'ready_to_go': False,
'initial_values': None
}
# An event for checking when all waits (if any) have completed, so that
# we can tell the difference between a wait and the end of an experiment.
# The wait monitor device is expected to post such events, which we'll wait on:
self.all_waits_finished = zprocess.Event('all_waits_finished')
self.waits_pending = False
pb_select_board(self.board_number)
pb_init()
pb_core_clock(self.core_clock_freq)
def init(self):
from labscript_utils import check_version
check_version('spinapi', '3.2.0', '4')
exec('from spinapi import *', globals())
global h5py
import labscript_utils.h5_lock, h5py
global zprocess
import zprocess
self.pb_start = pb_start
self.pb_stop = pb_stop
self.pb_reset = pb_reset
self.pb_close = pb_close
self.pb_read_status = pb_read_status
self.smart_cache = {
'pulse_program': None,
'ready_to_go': False,
'initial_values': None
}
# An event for checking when all waits (if any) have completed, so that
# we can tell the difference between a wait and the end of an experiment.
# The wait monitor device is expected to post such events, which we'll wait on:
self.all_waits_finished = zprocess.Event('all_waits_finished')
self.waits_pending = False
pb_select_board(self.board_number)
pb_init()
pb_core_clock(self.core_clock_freq)
# This is only set to True on a per-shot basis, so set it to False
# for manual mode. Set associated attributes to None:
self.time_based_stop_workaround = False
self.time_based_shot_duration = None
self.time_based_shot_end_time = None
def init(self):
global h5py
import labscript_utils.h5_lock, h5py
# global serial; import serial
global time
import time
global zprocess
import zprocess
global ok
import ok # OpalKelly library
# check the import worked correctly
# This handles the difference between v4 and v5 of front panel I think
if not hasattr(ok, 'okCFrontPanel'):
from ok import ok
global numpy
import numpy
self.all_waits_finished = zprocess.Event('all_waits_finished',
type='post')
self.wait_durations_analysed = zprocess.Event(
'wait_durations_analysed', type='post')
self.wait_completed = zprocess.Event('wait_completed', type='post')
self.current_wait = 0
self.wait_table = None
self.measured_waits = None
self.h5_file = None
self.current_value = 0
# Initialise connection to OPAL KELLY Board
self.dev = ok.okCFrontPanel()
if PY2:
self.serial = bytes(self.serial)
assert self.dev.OpenBySerial(self.serial) == self.dev.NoError
try:
assert self.dev.IsFrontPanelEnabled()
except AssertionError:
# Flash the FPGA bit file
self.flash_FPGA()
# ensure the FPGA's state machine is deactivated
assert self.dev.ActivateTriggerIn(0x40, 1) == self.dev.NoError
def init(self):
#exec 'import traceback' in globals()
exec 'from PyDAQmx import Task' in globals()
exec 'from PyDAQmx.DAQmxConstants import *' in globals()
exec 'from PyDAQmx.DAQmxTypes import *' in globals()
global h5py
import labscript_utils.h5_lock, h5py
global numpy
import numpy
global threading
import threading
global zprocess
import zprocess
global logging
import logging
global time
import time
self.task_running = False
self.daqlock = threading.Condition()
# Channel details
self.channels = []
self.rate = 1000.
self.samples_per_channel = 1000
self.ai_start_delay = 25e-9
self.h5_file = ""
self.buffered_channels = []
self.buffered_rate = 0
self.buffered = False
self.buffered_data = None
self.buffered_data_list = []
self.task = None
self.abort = False
# And event for knowing when the wait durations are known, so that we may use them
# to chunk up acquisition data:
self.wait_durations_analysed = zprocess.Event(
'wait_durations_analysed')
self.daqmx_read_thread = threading.Thread(target=self.daqmx_read)
self.daqmx_read_thread.daemon = True
self.daqmx_read_thread.start()
def init(self):
exec 'from spinapi import *' in globals()
import spinapi
version = [
int(v) for v in spinapi.__version__.split('-')[0].split('.')
]
requires_version = (3, 0, 4)
try:
assert version[0] == requires_version[0]
assert version[1] >= requires_version[1]
assert version[2] >= requires_version[2]
except AssertionError:
raise ImportError(
'This PulseBlaster requires at least Python spinapi v%d.%d.%d'
% requires_version)
global h5py
import labscript_utils.h5_lock, h5py
global zprocess
import zprocess
self.pb_start = pb_start
self.pb_stop = pb_stop
self.pb_reset = pb_reset
self.pb_close = pb_close
self.pb_read_status = pb_read_status
self.smart_cache = {
'pulse_program': None,
'ready_to_go': False,
'initial_values': None
}
# An event for checking when all waits (if any) have completed, so that
# we can tell the difference between a wait and the end of an experiment.
# The wait monitor device is expected to post such events, which we'll wait on:
self.all_waits_finished = zprocess.Event('all_waits_finished')
self.waits_pending = False
pb_select_board(self.board_number)
pb_init()
pb_core_clock(self.core_clock_freq)
