from typing import TYPE_CHECKING, Any
import numpy as np
from packaging import version
from qcodes import validators
from .ATS import AlazarTechATS
from .utils import TraceParameter
if TYPE_CHECKING:
from qcodes.parameters import Parameter
[docs]
class AlazarTechATS9360(AlazarTechATS):
"""
This class is the driver for the ATS9360 board
it inherits from the ATS base class
"""
samples_divisor = 128
_trigger_holdoff_min_fw_version = '21.07'
def __init__(self, name: str,
dll_path: str = 'C:\\WINDOWS\\System32\\ATSApi.dll',
**kwargs: Any):
super().__init__(name, dll_path=dll_path, **kwargs)
# add parameters
# ----- Parameters for the configuration of the board -----
self.clock_source: TraceParameter = self.add_parameter(
name="clock_source",
parameter_class=TraceParameter,
label="Clock Source",
unit=None,
initial_value="INTERNAL_CLOCK",
val_mapping={
"INTERNAL_CLOCK": 1,
"FAST_EXTERNAL_CLOCK": 2,
"EXTERNAL_CLOCK_10MHz_REF": 7,
},
)
"""Parameter clock_source"""
self.external_sample_rate: TraceParameter = self.add_parameter(
name="external_sample_rate",
parameter_class=TraceParameter,
label="External Sample Rate",
unit="S/s",
vals=validators.MultiType(
validators.Ints(300000000, 1800000000), validators.Enum("UNDEFINED")
),
initial_value="UNDEFINED",
)
"""Parameter external_sample_rate"""
self.sample_rate: TraceParameter = self.add_parameter(
name="sample_rate",
parameter_class=TraceParameter,
label="Internal Sample Rate",
unit="S/s",
initial_value="UNDEFINED",
val_mapping={
1_000: 1,
2_000: 2,
5_000: 4,
10_000: 8,
20_000: 10,
50_000: 12,
100_000: 14,
200_000: 16,
500_000: 18,
1_000_000: 20,
2_000_000: 24,
5_000_000: 26,
10_000_000: 28,
20_000_000: 30,
50_000_000: 34,
100_000_000: 36,
200_000_000: 40,
500_000_000: 48,
800_000_000: 50,
1_000_000_000: 53,
1_200_000_000: 55,
1_500_000_000: 58,
1_800_000_000: 61,
"EXTERNAL_CLOCK": 64,
"UNDEFINED": "UNDEFINED",
},
)
"""Parameter sample_rate"""
self.clock_edge: TraceParameter = self.add_parameter(
name="clock_edge",
parameter_class=TraceParameter,
label="Clock Edge",
unit=None,
initial_value="CLOCK_EDGE_RISING",
val_mapping={"CLOCK_EDGE_RISING": 0, "CLOCK_EDGE_FALLING": 1},
)
"""Parameter clock_edge"""
self.decimation: TraceParameter = self.add_parameter(
name="decimation",
parameter_class=TraceParameter,
label="Decimation",
unit=None,
initial_value=1,
vals=validators.Ints(0, 100000),
)
"""Parameter decimation"""
for i in range(1, self.channels+1):
self.add_parameter(name=f'coupling{i}',
parameter_class=TraceParameter,
label=f'Coupling channel {i}',
unit=None,
initial_value='DC',
val_mapping={'AC': 1, 'DC': 2})
self.add_parameter(name=f'channel_range{i}',
parameter_class=TraceParameter,
label=f'Range channel {i}',
unit='V',
initial_value=0.4,
val_mapping={0.4: 7})
self.add_parameter(name=f'impedance{i}',
parameter_class=TraceParameter,
label=f'Impedance channel {i}',
unit='Ohm',
initial_value=50,
val_mapping={50: 2})
self.add_parameter(name=f'bwlimit{i}',
parameter_class=TraceParameter,
label=f'Bandwidth limit channel {i}',
unit=None,
initial_value='DISABLED',
val_mapping={'DISABLED': 0,
'ENABLED': 1})
self.trigger_operation: TraceParameter = self.add_parameter(
name="trigger_operation",
parameter_class=TraceParameter,
label="Trigger Operation",
unit=None,
initial_value="TRIG_ENGINE_OP_J",
val_mapping={
"TRIG_ENGINE_OP_J": 0,
"TRIG_ENGINE_OP_K": 1,
"TRIG_ENGINE_OP_J_OR_K": 2,
"TRIG_ENGINE_OP_J_AND_K": 3,
"TRIG_ENGINE_OP_J_XOR_K": 4,
"TRIG_ENGINE_OP_J_AND_NOT_K": 5,
"TRIG_ENGINE_OP_NOT_J_AND_K": 6,
},
)
"""Parameter trigger_operation"""
n_trigger_engines = 2
for i in range(1, n_trigger_engines+1):
self.add_parameter(name=f'trigger_engine{i}',
parameter_class=TraceParameter,
label=f'Trigger Engine {i}',
unit=None,
initial_value='TRIG_ENGINE_' + ('J' if i == 1 else 'K'),
val_mapping={'TRIG_ENGINE_J': 0,
'TRIG_ENGINE_K': 1})
self.add_parameter(name=f'trigger_source{i}',
parameter_class=TraceParameter,
label=f'Trigger Source {i}',
unit=None,
initial_value='EXTERNAL',
val_mapping={'CHANNEL_A': 0,
'CHANNEL_B': 1,
'EXTERNAL': 2,
'DISABLE': 3})
self.add_parameter(name=f'trigger_slope{i}',
parameter_class=TraceParameter,
label=f'Trigger Slope {i}',
unit=None,
initial_value='TRIG_SLOPE_POSITIVE',
val_mapping={'TRIG_SLOPE_POSITIVE': 1,
'TRIG_SLOPE_NEGATIVE': 2})
self.add_parameter(name=f'trigger_level{i}',
parameter_class=TraceParameter,
label=f'Trigger Level {i}',
unit=None,
initial_value=140,
vals=validators.Ints(0, 255))
self.external_trigger_coupling: TraceParameter = self.add_parameter(
name="external_trigger_coupling",
parameter_class=TraceParameter,
label="External Trigger Coupling",
unit=None,
initial_value="DC",
val_mapping={"AC": 1, "DC": 2},
)
"""Parameter external_trigger_coupling"""
self.external_trigger_range: TraceParameter = self.add_parameter(
name="external_trigger_range",
parameter_class=TraceParameter,
label="External Trigger Range",
unit=None,
initial_value="ETR_2V5",
val_mapping={"ETR_TTL": 2, "ETR_2V5": 3},
)
"""Parameter external_trigger_range"""
self.trigger_delay: TraceParameter = self.add_parameter(
name="trigger_delay",
parameter_class=TraceParameter,
label="Trigger Delay",
unit="Sample clock cycles",
initial_value=0,
vals=validators.Multiples(divisor=8, min_value=0),
)
"""Parameter trigger_delay"""
# See Table 3 - Trigger Delay Alignment
# TODO: this is either 8 or 16 dependent on the number of channels in use
# NOTE: The board will wait for a for this amount of time for a
# trigger event. If a trigger event does not arrive, then the
# board will automatically trigger. Set the trigger timeout value
# to 0 to force the board to wait forever for a trigger event.
#
# IMPORTANT: The trigger timeout value should be set to zero after
# appropriate trigger parameters have been determined, otherwise
# the board may trigger if the timeout interval expires before a
# hardware trigger event arrives.
self.timeout_ticks: TraceParameter = self.add_parameter(
name="timeout_ticks",
parameter_class=TraceParameter,
label="Timeout Ticks",
unit="10 us",
initial_value=0,
vals=validators.Ints(min_value=0),
)
"""Parameter timeout_ticks"""
self.aux_io_mode: TraceParameter = self.add_parameter(
name="aux_io_mode",
parameter_class=TraceParameter,
label="AUX I/O Mode",
unit=None,
initial_value="AUX_IN_AUXILIARY",
val_mapping={
"AUX_OUT_TRIGGER": 0,
"AUX_IN_TRIGGER_ENABLE": 1,
"AUX_IN_AUXILIARY": 13,
},
)
"""Parameter aux_io_mode"""
self.aux_io_param: TraceParameter = self.add_parameter(
name="aux_io_param",
parameter_class=TraceParameter,
label="AUX I/O Param",
unit=None,
initial_value="NONE",
val_mapping={"NONE": 0, "TRIG_SLOPE_POSITIVE": 1, "TRIG_SLOPE_NEGATIVE": 2},
)
"""Parameter aux_io_param"""
# ----- Parameters for the acquire function -----
self.mode: Parameter = self.add_parameter(
name="mode",
label="Acquisition mode",
unit=None,
initial_value="NPT",
set_cmd=None,
val_mapping={"NPT": 0x200, "TS": 0x400},
)
"""Parameter mode"""
self.samples_per_record: Parameter = self.add_parameter(
name="samples_per_record",
label="Samples per Record",
unit=None,
initial_value=1024,
set_cmd=None,
vals=validators.Multiples(divisor=self.samples_divisor, min_value=256),
)
"""Parameter samples_per_record"""
self.records_per_buffer: Parameter = self.add_parameter(
name="records_per_buffer",
label="Records per Buffer",
unit=None,
initial_value=10,
set_cmd=None,
vals=validators.Ints(min_value=0),
)
"""Parameter records_per_buffer"""
self.buffers_per_acquisition: Parameter = self.add_parameter(
name="buffers_per_acquisition",
label="Buffers per Acquisition",
unit=None,
set_cmd=None,
initial_value=10,
vals=validators.Ints(min_value=0),
)
"""Parameter buffers_per_acquisition"""
self.channel_selection: Parameter = self.add_parameter(
name="channel_selection",
label="Channel Selection",
unit=None,
set_cmd=None,
initial_value="AB",
val_mapping={"A": 1, "B": 2, "AB": 3},
)
"""Parameter channel_selection"""
self.transfer_offset: Parameter = self.add_parameter(
name="transfer_offset",
label="Transfer Offset",
unit="Samples",
set_cmd=None,
initial_value=0,
vals=validators.Ints(min_value=0),
)
"""Parameter transfer_offset"""
self.external_startcapture: Parameter = self.add_parameter(
name="external_startcapture",
label="External Startcapture",
unit=None,
set_cmd=None,
initial_value="ENABLED",
val_mapping={"DISABLED": 0x0, "ENABLED": 0x1},
)
"""Parameter external_startcapture"""
self.enable_record_headers: Parameter = self.add_parameter(
name="enable_record_headers",
label="Enable Record Headers",
unit=None,
set_cmd=None,
initial_value="DISABLED",
val_mapping={"DISABLED": 0x0, "ENABLED": 0x8},
)
"""Parameter enable_record_headers"""
self.alloc_buffers: Parameter = self.add_parameter(
name="alloc_buffers",
label="Alloc Buffers",
unit=None,
set_cmd=None,
initial_value="DISABLED",
val_mapping={"DISABLED": 0x0, "ENABLED": 0x20},
)
"""Parameter alloc_buffers"""
self.fifo_only_streaming: Parameter = self.add_parameter(
name="fifo_only_streaming",
label="Fifo Only Streaming",
unit=None,
set_cmd=None,
initial_value="DISABLED",
val_mapping={"DISABLED": 0x0, "ENABLED": 0x800},
)
"""Parameter fifo_only_streaming"""
self.interleave_samples: Parameter = self.add_parameter(
name="interleave_samples",
label="Interleave Samples",
unit=None,
set_cmd=None,
initial_value="DISABLED",
val_mapping={"DISABLED": 0x0, "ENABLED": 0x1000},
)
"""Parameter interleave_samples"""
self.get_processed_data: Parameter = self.add_parameter(
name="get_processed_data",
label="Get Processed Data",
unit=None,
set_cmd=None,
initial_value="DISABLED",
val_mapping={"DISABLED": 0x0, "ENABLED": 0x2000},
)
"""Parameter get_processed_data"""
self.allocated_buffers: Parameter = self.add_parameter(
name="allocated_buffers",
label="Allocated Buffers",
unit=None,
set_cmd=None,
initial_value=4,
vals=validators.Ints(min_value=0),
)
"""Parameter allocated_buffers"""
self.buffer_timeout: Parameter = self.add_parameter(
name="buffer_timeout",
label="Buffer Timeout",
unit="ms",
set_cmd=None,
initial_value=1000,
vals=validators.Ints(min_value=0),
)
"""Parameter buffer_timeout"""
self.trigger_holdoff: Parameter = self.add_parameter(
name="trigger_holdoff",
label="Trigger Holdoff",
docstring=f"If enabled Alazar will "
f"ignore any additional triggers "
f"while capturing a record. If disabled "
f"a trigger signal during a capture "
f" will result in corrupt data. "
f"Support for this requires at least "
f"firmware version "
f"{self._trigger_holdoff_min_fw_version}",
vals=validators.Bool(),
get_cmd=self._get_trigger_holdoff,
set_cmd=self._set_trigger_holdoff,
)
"""
If enabled Alazar will ignore any additional triggers
while capturing a record.
"""
model = self.get_idn()["model"]
if model != "ATS9360":
raise Exception(
f"The Alazar board kind is not 'ATS9360',"
f" found '{model!s}' instead."
)
def _get_trigger_holdoff(self) -> bool:
fwversion = self.get_idn()['firmware']
if not isinstance(fwversion, str) or version.parse(fwversion) < version.parse(
self._trigger_holdoff_min_fw_version
):
return False
# we want to check if the 26h bit (zero indexed) is high or not
output = np.uint32(self._read_register(58))
# the two first two chars in the bit string is the sign and a 'b'
# remove those to only get the bit pattern
bitmask = bin(output)[2:]
# all prefixed zeros are ignored in the bit conversion so the
# bit mask may be shorter than what we expect. in that case
# the bit we care about is zero so we return False
if len(bitmask) < 27:
return False
return bool(bin(output)[-27])
def _set_trigger_holdoff(self, value: bool) -> None:
fwversion = self.get_idn()["firmware"]
if not isinstance(fwversion, str) or version.parse(fwversion) < version.parse(
self._trigger_holdoff_min_fw_version
):
raise RuntimeError(
f"Alazar 9360 requires at least firmware "
f"version {self._trigger_holdoff_min_fw_version}"
f" for trigger holdoff support. "
f"You have version {fwversion}"
)
current_value = self._read_register(58)
if value is True:
# to enable trigger hold off we want to flip the
# 26th bit to 1. We do that by making a bitwise or
# with a number that has a 1 on the 26th place and zero
# otherwise. We use numpy.unit32 instead of python numbers
# to have unsigned ints of the right size
enable_mask = np.uint32(1 << 26)
new_value = current_value | enable_mask
else:
# to disable trigger hold off we want to flip the
# 26th bit to 0. We do that by making a bitwise and
# with a number that has a 0 on the 26th place and 1
# otherwise
disable_mask = ~np.uint32(1 << 26)
new_value = current_value & disable_mask
self._write_register(58, int(new_value))
class AlazarTech_ATS9360(AlazarTechATS9360):
"""
Alias for backwards compatibility. Will eventually be deprecated and removed
"""
pass