{ "cells": [ { "cell_type": "markdown", "id": "0403ec49", "metadata": { "lines_to_next_cell": 2 }, "source": [ "Basic sequencing\n", "================\n", "\n", ".. Note::\n", " A version of this tutorial suitable for RF modules can be found [here](https://qblox-qblox-instruments.readthedocs-hosted.com/en/main/tutorials/q1asm_tutorials/basic/rf/basic_sequencing.html).\n", "\n", "In this tutorial we will demonstrate basic sequencer based operations (see [Sequencer Operation](https://qblox-qblox-instruments.readthedocs-hosted.com/en/main/cluster/q1_sequence_processor.html#operation)) for programming a qblox instrument.\n", "This includes creating a sequence consisting of waveforms and a simple Q1ASM program,\n", "and executing this sequence synchronously on multiple sequencers.\n", "\n", "The general process for setting up and executing a program on a Q1 sequencer is as follows:\n", "\n", "1. Connect to instrument\n", "2. Prepare a sequence (JSON formatted file) which consists of\n", " - Waveforms for playback\n", " - Weights for weighted integration\n", " - Acquisitions for capture\n", " - Q1ASM program to be executed by the sequencer\n", "3. This sequence is then loaded onto a sequencer on the connected instrument using the method `instrument_variable.sequencerX.sequence(\"SequenceFile.json\")`\n", "4. The sequencer is then setup over its API as necessary\n", "5. Sequencer is then armed and started to commence the experiment\n", "6. Stop the sequencer and close down all instruments\n", "\n", "This tutorial will give a basic introduction on how to work with the waveforms and Q1ASM segments of a sequence.\n", "\n", "In the Tutorial the sequence is going to consecutively play two waveforms, a gaussian and block with a duration of 20ns each, with an increasing wait period\n", "in between them. We will increase the wait period by 20ns repeated 100 times, after which the sequence is stopped. The sequence will also trigger marker\n", "output 1 at every interval, so that the sequence can be easily monitored on an oscilloscope.\n", "\n", "We can perform this tutorial with either a Cluster QCM/QRM . We use the term 'QxM' encompassing both QCM and QRM modules." ] }, { "cell_type": "markdown", "id": "a0ebeca0", "metadata": { "tags": [] }, "source": [ "Setup\n", "-----\n", "\n", "First, we are going to import the required packages." ] }, { "cell_type": "code", "execution_count": 1, "id": "d8cf3da3", "metadata": { "execution": { "iopub.execute_input": "2024-03-28T14:29:48.889441Z", "iopub.status.busy": "2024-03-28T14:29:48.887666Z", "iopub.status.idle": "2024-03-28T14:29:51.015176Z", "shell.execute_reply": "2024-03-28T14:29:51.014136Z" } }, "outputs": [], "source": [ "from __future__ import annotations\n", "\n", "import json\n", "from typing import TYPE_CHECKING, Callable\n", "\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "import scipy.signal\n", "from qcodes.instrument import find_or_create_instrument\n", "\n", "from qblox_instruments import Cluster, ClusterType\n", "\n", "if TYPE_CHECKING:\n", " from qblox_instruments.qcodes_drivers.module import QcmQrm" ] }, { "cell_type": "markdown", "id": "a981e430", "metadata": {}, "source": [ "### Scan For Clusters\n", "\n", "We scan for the available devices connected via ethernet using the Plug & Play functionality of the Qblox Instruments package (see [Plug & Play](https://qblox-qblox-instruments.readthedocs-hosted.com/en/main/api_reference/tools.html#api-pnp) for more info)." ] }, { "cell_type": "code", "execution_count": 2, "id": "ee9eb444", "metadata": { "execution": { "iopub.execute_input": "2024-03-28T14:29:51.021098Z", "iopub.status.busy": "2024-03-28T14:29:51.019826Z", "iopub.status.idle": "2024-03-28T14:29:53.163767Z", "shell.execute_reply": "2024-03-28T14:29:53.162726Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Devices:\n", " - 10.10.200.13 via 192.168.207.146/24 (reconfiguration needed!): cluster_mm 0.6.2 with name \"QSE_1\" and serial number 00015_2321_005\n", " - 10.10.200.42 via 192.168.207.146/24 (reconfiguration needed!): cluster_mm 0.7.0 with name \"QAE-I\" and serial number 00015_2321_004\n", " - 10.10.200.43 via 192.168.207.146/24 (reconfiguration needed!): cluster_mm 0.6.2 with name \"QAE-2\" and serial number 00015_2206_003\n", " - 10.10.200.50 via 192.168.207.146/24 (reconfiguration needed!): cluster_mm 0.7.0 with name \"cluster-mm\" and serial number 00015_2219_003\n", " - 10.10.200.53 via 192.168.207.146/24 (reconfiguration needed!): cluster_mm 0.7.0 with name \"cluster-mm\" and serial number 00015_2320_004\n", " - 10.10.200.70 via 192.168.207.146/24 (reconfiguration needed!): cluster_mm 0.6.1 with name \"cluster-mm\" and serial number 123-456-789\n", " - 10.10.200.80 via 192.168.207.146/24 (reconfiguration needed!): cluster_mm 0.6.1 with name \"cluster-mm\" and serial number not_valid\n" ] } ], "source": [ "!qblox-pnp list" ] }, { "cell_type": "code", "execution_count": 3, "id": "cb940ea9", "metadata": { "execution": { "iopub.execute_input": "2024-03-28T14:29:53.169125Z", "iopub.status.busy": "2024-03-28T14:29:53.169125Z", "iopub.status.idle": "2024-03-28T14:29:53.179710Z", "shell.execute_reply": "2024-03-28T14:29:53.178203Z" } }, "outputs": [], "source": [ "cluster_ip = \"10.10.200.42\"\n", "cluster_name = \"cluster0\"" ] }, { "cell_type": "markdown", "id": "5e8e0571", "metadata": {}, "source": [ "### Connect to Cluster\n", "\n", "We now make a connection with the Cluster." ] }, { "cell_type": "code", "execution_count": 4, "id": "f3b62f17", "metadata": { "execution": { "iopub.execute_input": "2024-03-28T14:29:53.186590Z", "iopub.status.busy": "2024-03-28T14:29:53.184601Z", "iopub.status.idle": "2024-03-28T14:29:54.161318Z", "shell.execute_reply": "2024-03-28T14:29:54.159729Z" }, "lines_to_next_cell": 2 }, "outputs": [], "source": [ "cluster = find_or_create_instrument(\n", " Cluster,\n", " recreate=True,\n", " name=cluster_name,\n", " identifier=cluster_ip,\n", " dummy_cfg=(\n", " {\n", " 2: ClusterType.CLUSTER_QCM,\n", " 4: ClusterType.CLUSTER_QRM,\n", " 6: ClusterType.CLUSTER_QCM_RF,\n", " 8: ClusterType.CLUSTER_QRM_RF,\n", " }\n", " if cluster_ip is None\n", " else None\n", " ),\n", ")" ] }, { "cell_type": "markdown", "id": "a3967138", "metadata": { "lines_to_next_cell": 2 }, "source": [ "#### Get connected modules" ] }, { "cell_type": "code", "execution_count": 5, "id": "7bec9c31", "metadata": { "execution": { "iopub.execute_input": "2024-03-28T14:29:54.165336Z", "iopub.status.busy": "2024-03-28T14:29:54.165336Z", "iopub.status.idle": "2024-03-28T14:29:54.177287Z", "shell.execute_reply": "2024-03-28T14:29:54.175288Z" } }, "outputs": [], "source": [ "def get_connected_modules(cluster: Cluster, filter_fn: Callable | None = None) -> dict[int, QcmQrm]:\n", " def checked_filter_fn(mod: ClusterType) -> bool:\n", " if filter_fn is not None:\n", " return filter_fn(mod)\n", " return True\n", "\n", " return {\n", " mod.slot_idx: mod for mod in cluster.modules if mod.present() and checked_filter_fn(mod)\n", " }" ] }, { "cell_type": "code", "execution_count": 6, "id": "5e3049b8", "metadata": { "execution": { "iopub.execute_input": "2024-03-28T14:29:54.181510Z", "iopub.status.busy": "2024-03-28T14:29:54.181510Z", "iopub.status.idle": "2024-03-28T14:29:54.299525Z", "shell.execute_reply": "2024-03-28T14:29:54.297852Z" } }, "outputs": [ { "data": { "text/plain": [ "{4: }" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# QRM baseband modules\n", "modules = get_connected_modules(cluster, lambda mod: mod.is_qrm_type and not mod.is_rf_type)\n", "modules" ] }, { "cell_type": "code", "execution_count": 7, "id": "22893eb8", "metadata": { "execution": { "iopub.execute_input": "2024-03-28T14:29:54.304574Z", "iopub.status.busy": "2024-03-28T14:29:54.303574Z", "iopub.status.idle": "2024-03-28T14:29:54.315039Z", "shell.execute_reply": "2024-03-28T14:29:54.313760Z" } }, "outputs": [], "source": [ "module = modules[4]" ] }, { "cell_type": "markdown", "id": "50a2336f", "metadata": {}, "source": [ "### Reset the Cluster\n", "\n", "We reset the Cluster to enter a well-defined state. Note that resetting will clear all stored parameters, so resetting between experiments is usually not desirable." ] }, { "cell_type": "code", "execution_count": 8, "id": "469859b0", "metadata": { "execution": { "iopub.execute_input": "2024-03-28T14:29:54.319818Z", "iopub.status.busy": "2024-03-28T14:29:54.318799Z", "iopub.status.idle": "2024-03-28T14:29:57.738407Z", "shell.execute_reply": "2024-03-28T14:29:57.737097Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Status: OKAY, Flags: NONE, Slot flags: NONE\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "c:\\work\\code\\qblox_instruments_install\\qblox_instruments\\native\\generic_func.py:1033: FutureWarning: \n", " After June 2024, this feature is subject to removal in future releases.\n", " Transition to an alternative is advised.\n", " See https://qblox-qblox-instruments.readthedocs-hosted.com/en/main/getting_started/deprecated.html\n", " \n", " warnings.warn(\n", "c:\\work\\code\\qblox_instruments_install\\qblox_instruments\\native\\generic_func.py:77: FutureWarning: \n", " After June 2024, this feature is subject to removal in future releases.\n", " Transition to an alternative is advised.\n", " See https://qblox-qblox-instruments.readthedocs-hosted.com/en/main/getting_started/deprecated.html\n", " \n", " self._deprecation_warning()\n", "c:\\work\\code\\qblox_instruments_install\\qblox_instruments\\native\\generic_func.py:129: FutureWarning: \n", " After June 2024, this feature is subject to removal in future releases.\n", " Transition to an alternative is advised.\n", " See https://qblox-qblox-instruments.readthedocs-hosted.com/en/main/getting_started/deprecated.html\n", " \n", " self._deprecation_warning()\n" ] } ], "source": [ "cluster.reset()\n", "print(cluster.get_system_state())" ] }, { "cell_type": "markdown", "id": "5d8bc54b", "metadata": {}, "source": [ "Generate waveforms \n", "------------------\n", "\n", "Next, we need to create the gaussian and block waveforms for the sequence. The waveforms constructed here will be referenced by the Q1ASM program for playback. See section [Sequencer](https://qblox-qblox-instruments.readthedocs-hosted.com/en/main/cluster/q1_sequence_processor.html#sequences) for details on how waveform dictionary is structured." ] }, { "cell_type": "markdown", "id": "3c982206", "metadata": {}, "source": [ "Waveform resolution notes" ] }, { "cell_type": "code", "execution_count": 9, "id": "598457d8", "metadata": { "execution": { "iopub.execute_input": "2024-03-28T14:29:57.743467Z", "iopub.status.busy": "2024-03-28T14:29:57.743467Z", "iopub.status.idle": "2024-03-28T14:29:57.753946Z", "shell.execute_reply": "2024-03-28T14:29:57.752947Z" } }, "outputs": [], "source": [ "# Waveform parameters\n", "waveform_length = 22 # nanoseconds\n", "\n", "# Waveform dictionary (data will hold the samples and index will be used to select the waveforms in the instrument).\n", "waveforms = {\n", " \"gaussian\": {\n", " \"data\": scipy.signal.windows.gaussian(waveform_length, std=0.12 * waveform_length).tolist(),\n", " \"index\": 0,\n", " },\n", " \"block\": {\"data\": [1.0 for i in range(0, waveform_length)], \"index\": 1},\n", "}" ] }, { "cell_type": "markdown", "id": "5bc6442a", "metadata": {}, "source": [ "Let's plot the waveforms to see what we have created." ] }, { "cell_type": "code", "execution_count": 10, "id": "2ada5e17", "metadata": { "execution": { "iopub.execute_input": "2024-03-28T14:29:57.760075Z", "iopub.status.busy": "2024-03-28T14:29:57.760075Z", "iopub.status.idle": "2024-03-28T14:29:57.942418Z", "shell.execute_reply": "2024-03-28T14:29:57.941418Z" } }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "time = np.arange(0, max(map(lambda d: len(d[\"data\"]), waveforms.values())), 1)\n", "fig, ax = plt.subplots(1, 1, figsize=(10, 10 / 1.61))\n", "\n", "for wf, d in waveforms.items():\n", " ax.plot(time[: len(d[\"data\"])], d[\"data\"], \".-\", linewidth=0.5, label=wf)\n", "\n", "ax.legend(loc=4)\n", "ax.grid(alpha=1 / 10)\n", "ax.set_ylabel(\"Waveform primitive amplitude\")\n", "ax.set_xlabel(\"Time (ns)\")\n", "\n", "plt.draw()\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "bdbd4159", "metadata": {}, "source": [ "Create Q1ASM program\n", "--------------------\n", "\n", "Now that we have the waveforms for the sequence, we need a Q1ASM program that sequences the waveforms as previously described. The Q1ASM program can address the memory in the sequences waveforms and acquisitions to construct a program for playback. View [Q1 Programming](https://qblox-qblox-instruments.readthedocs-hosted.com/en/main/cluster/q1_sequence_processor.html#instructions) for a break down of available instructions in the Q1ASM language." ] }, { "cell_type": "code", "execution_count": 11, "id": "e9343de0", "metadata": { "execution": { "iopub.execute_input": "2024-03-28T14:29:57.946419Z", "iopub.status.busy": "2024-03-28T14:29:57.946419Z", "iopub.status.idle": "2024-03-28T14:29:57.956982Z", "shell.execute_reply": "2024-03-28T14:29:57.956478Z" } }, "outputs": [], "source": [ "# Sequence program.\n", "seq_prog = \"\"\"\n", " move 100,R0 #Loop iterator.\n", " move 20,R1 #Initial wait period in ns.\n", " wait_sync 4 #Wait for sequencers to synchronize and then wait another 4 ns.\n", "\n", "loop: set_mrk 1 #Set marker output 1.\n", " play 0,1,4 #Play a gaussian and a block on output path 0 and 1 respectively and wait 4 ns.\n", " set_mrk 0 #Reset marker output 1.\n", " upd_param 18 #Update parameters and wait the remaining 18 ns of the waveforms.\n", "\n", " wait R1 #Wait period.\n", "\n", " play 1,0,22 #Play a block and a gaussian on output path 0 and 1 respectively and wait 22 ns.\n", " wait 1000 #Wait a 1us in between iterations.\n", " add R1,20,R1 #Increase wait period by 20 ns.\n", " loop R0,@loop #Subtract one from loop iterator.\n", "\n", " stop #Stop the sequence after the last iteration.\n", "\"\"\"" ] }, { "cell_type": "markdown", "id": "d7a53f4d", "metadata": {}, "source": [ "Prepare and Upload sequence\n", "---------------------------\n", "\n", "Now that we have the waveforms and Q1ASM program, we can combine them in a sequence stored in a JSON file." ] }, { "cell_type": "code", "execution_count": 12, "id": "fba47c0b", "metadata": { "execution": { "iopub.execute_input": "2024-03-28T14:29:57.962137Z", "iopub.status.busy": "2024-03-28T14:29:57.961135Z", "iopub.status.idle": "2024-03-28T14:29:57.973166Z", "shell.execute_reply": "2024-03-28T14:29:57.972160Z" } }, "outputs": [], "source": [ "# Add sequence to single dictionary and write to JSON file.\n", "sequence = {\n", " \"waveforms\": waveforms,\n", " \"weights\": {},\n", " \"acquisitions\": {},\n", " \"program\": seq_prog,\n", "}\n", "with open(\"sequence.json\", \"w\", encoding=\"utf-8\") as file:\n", " json.dump(sequence, file, indent=4)\n", " file.close()" ] }, { "cell_type": "markdown", "id": "b452b16a", "metadata": {}, "source": [ "Let's write the JSON file to the instruments. We will use sequencer 0 and 1, which will drive outputs $\\text{O}^{[1-2]}$ and $\\text{O}^{[3-4]}$ respectively." ] }, { "cell_type": "code", "execution_count": 13, "id": "7914daa0", "metadata": { "execution": { "iopub.execute_input": "2024-03-28T14:29:57.977169Z", "iopub.status.busy": "2024-03-28T14:29:57.977169Z", "iopub.status.idle": "2024-03-28T14:29:58.079911Z", "shell.execute_reply": "2024-03-28T14:29:58.077789Z" } }, "outputs": [], "source": [ "# Upload sequence.\n", "module.sequencer0.sequence(\"sequence.json\")\n", "module.sequencer1.sequence(\"sequence.json\")" ] }, { "cell_type": "markdown", "id": "2b119d35", "metadata": {}, "source": [ "Play sequence\n", "-------------\n", "\n", "The sequence has been uploaded to the instrument. Now we need to configure the sequencers in the instrument to use the `wait_sync` instruction\n", "at the start of the Q1ASM program to synchronize." ] }, { "cell_type": "code", "execution_count": 14, "id": "d60772bb", "metadata": { "execution": { "iopub.execute_input": "2024-03-28T14:29:58.084736Z", "iopub.status.busy": "2024-03-28T14:29:58.083709Z", "iopub.status.idle": "2024-03-28T14:29:58.154053Z", "shell.execute_reply": "2024-03-28T14:29:58.152956Z" } }, "outputs": [], "source": [ "# Configure the sequencers to synchronize.\n", "module.sequencer0.sync_en(True)\n", "module.sequencer1.sync_en(True)\n", "\n", "# Map sequencers to specific outputs (but first disable all sequencer connections).\n", "module.disconnect_outputs()\n", "\n", "# If it is a QRM, we only map sequencer 0 to the outputs.\n", "module.sequencer0.connect_sequencer(\"out0_1\")\n", "if module.is_qcm_type:\n", " module.sequencer1.connect_sequencer(\"out2_3\")" ] }, { "cell_type": "markdown", "id": "01acebd4", "metadata": {}, "source": [ "Now let's start the sequence. If you want to observe the sequence, this is the time to connect an oscilloscope to marker output 1 and one or more\n", "of the four outputs. Configure the oscilloscope to trigger on the marker output 1." ] }, { "cell_type": "code", "execution_count": 15, "id": "9edd4784", "metadata": { "execution": { "iopub.execute_input": "2024-03-28T14:29:58.159258Z", "iopub.status.busy": "2024-03-28T14:29:58.158095Z", "iopub.status.idle": "2024-03-28T14:29:58.200681Z", "shell.execute_reply": "2024-03-28T14:29:58.199647Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Status: STOPPED, Flags: NONE\n", "Status: STOPPED, Flags: NONE\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "c:\\work\\code\\qblox_instruments_install\\qblox_instruments\\native\\generic_func.py:2414: FutureWarning: \n", " After June 2024, this feature is subject to removal in future releases.\n", " Transition to an alternative is advised.\n", " See https://qblox-qblox-instruments.readthedocs-hosted.com/en/main/getting_started/deprecated.html\n", " \n", " warnings.warn(\n", "c:\\work\\code\\qblox_instruments_install\\qblox_instruments\\native\\generic_func.py:85: FutureWarning: \n", " After June 2024, this feature is subject to removal in future releases.\n", " Transition to an alternative is advised.\n", " See https://qblox-qblox-instruments.readthedocs-hosted.com/en/main/getting_started/deprecated.html\n", " \n", " self._deprecation_warning()\n" ] } ], "source": [ "# Arm and start both sequencers.\n", "module.arm_sequencer(0)\n", "module.arm_sequencer(1)\n", "module.start_sequencer()\n", "\n", "# Print status of both sequencers.\n", "print(module.get_sequencer_state(0))\n", "print(module.get_sequencer_state(1))" ] }, { "cell_type": "markdown", "id": "be2fd19c", "metadata": {}, "source": [ "Stop\n", "----\n", "\n", "Finally, let's stop the sequencers if they haven't already and close the instrument connection. One can also display a detailed snapshot containing the instrument parameters before\n", "closing the connection by uncommenting the corresponding lines." ] }, { "cell_type": "code", "execution_count": 16, "id": "4e77e23f", "metadata": { "execution": { "iopub.execute_input": "2024-03-28T14:29:58.205152Z", "iopub.status.busy": "2024-03-28T14:29:58.203751Z", "iopub.status.idle": "2024-03-28T14:30:08.128158Z", "shell.execute_reply": "2024-03-28T14:30:08.126820Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Status: STOPPED, Flags: FORCED_STOP\n", "Status: STOPPED, Flags: FORCED_STOP\n", "\n", "Snapshot:\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "cluster0_module4:\n", "\tparameter value\n", "--------------------------------------------------------------------------------\n", "in0_gain :\t-6 (dB)\n", "in0_offset :\t0 (V)\n", "in1_gain :\t-6 (dB)\n", "in1_offset :\t0 (V)\n", "marker0_inv_en :\tFalse \n", "marker1_inv_en :\tFalse \n", "marker2_inv_en :\tFalse \n", "marker3_inv_en :\tFalse \n", "out0_offset :\t0 (V)\n", "out1_offset :\t0 (V)\n", "present :\tTrue \n", "scope_acq_avg_mode_en_path0 :\tFalse \n", "scope_acq_avg_mode_en_path1 :\tFalse \n", "scope_acq_sequencer_select :\t0 \n", "scope_acq_trigger_level_path0 :\t0 \n", "scope_acq_trigger_level_path1 :\t0 \n", "scope_acq_trigger_mode_path0 :\tsequencer \n", "scope_acq_trigger_mode_path1 :\tsequencer \n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "cluster0_module4_sequencer0:\n", "\tparameter value\n", "--------------------------------------------------------------------------------\n", "connect_acq_I :\tin0 \n", "connect_acq_Q :\tin1 \n", "connect_out0 :\tI \n", "connect_out1 :\tQ \n", "cont_mode_en_awg_path0 :\tFalse \n", "cont_mode_en_awg_path1 :\tFalse \n", "cont_mode_waveform_idx_awg_path0 :\t0 \n", "cont_mode_waveform_idx_awg_path1 :\t0 \n", "demod_en_acq :\tFalse \n", "gain_awg_path0 :\t1 \n", "gain_awg_path1 :\t1 \n", "integration_length_acq :\t1024 \n", "marker_ovr_en :\tFalse \n", "marker_ovr_value :\t0 \n", "mixer_corr_gain_ratio :\t1 \n", "mixer_corr_phase_offset_degree :\t-0 \n", "mod_en_awg :\tFalse \n", "nco_freq :\t0 (Hz)\n", "nco_phase_offs :\t0 (Degrees)\n", "nco_prop_delay_comp :\t0 (ns)\n", "nco_prop_delay_comp_en :\tFalse (ns)\n", "offset_awg_path0 :\t0 \n", "offset_awg_path1 :\t0 \n", "sync_en :\tTrue \n", "thresholded_acq_marker_address :\t1 \n", "thresholded_acq_marker_en :\tFalse \n", "thresholded_acq_marker_invert :\tFalse \n", "thresholded_acq_rotation :\t0 (Degrees)\n", "thresholded_acq_threshold :\t0 \n", "thresholded_acq_trigger_address :\t1 \n", "thresholded_acq_trigger_en :\tFalse \n", "thresholded_acq_trigger_invert :\tFalse \n", "trigger10_count_threshold :\t1 \n", "trigger10_threshold_invert :\tFalse \n", "trigger11_count_threshold :\t1 \n", "trigger11_threshold_invert :\tFalse \n", "trigger12_count_threshold :\t1 \n", "trigger12_threshold_invert :\tFalse \n", "trigger13_count_threshold :\t1 \n", "trigger13_threshold_invert :\tFalse \n", "trigger14_count_threshold :\t1 \n", "trigger14_threshold_invert :\tFalse \n", "trigger15_count_threshold :\t1 \n", "trigger15_threshold_invert :\tFalse \n", "trigger1_count_threshold :\t1 \n", "trigger1_threshold_invert :\tFalse \n", "trigger2_count_threshold :\t1 \n", "trigger2_threshold_invert :\tFalse \n", "trigger3_count_threshold :\t1 \n", "trigger3_threshold_invert :\tFalse \n", "trigger4_count_threshold :\t1 \n", "trigger4_threshold_invert :\tFalse \n", "trigger5_count_threshold :\t1 \n", "trigger5_threshold_invert :\tFalse \n", "trigger6_count_threshold :\t1 \n", "trigger6_threshold_invert :\tFalse \n", "trigger7_count_threshold :\t1 \n", "trigger7_threshold_invert :\tFalse \n", "trigger8_count_threshold :\t1 \n", "trigger8_threshold_invert :\tFalse \n", "trigger9_count_threshold :\t1 \n", "trigger9_threshold_invert :\tFalse \n", "ttl_acq_auto_bin_incr_en :\tFalse \n", "ttl_acq_input_select :\t0 \n", "ttl_acq_threshold :\t0 \n", "upsample_rate_awg_path0 :\t0 \n", "upsample_rate_awg_path1 :\t0 \n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "cluster0_module4_sequencer1:\n", "\tparameter value\n", "--------------------------------------------------------------------------------\n", "connect_acq_I :\tin0 \n", "connect_acq_Q :\tin1 \n", "connect_out0 :\toff \n", "connect_out1 :\toff \n", "cont_mode_en_awg_path0 :\tFalse \n", "cont_mode_en_awg_path1 :\tFalse \n", "cont_mode_waveform_idx_awg_path0 :\t0 \n", "cont_mode_waveform_idx_awg_path1 :\t0 \n", "demod_en_acq :\tFalse \n", "gain_awg_path0 :\t1 \n", "gain_awg_path1 :\t1 \n", "integration_length_acq :\t1024 \n", "marker_ovr_en :\tFalse \n", "marker_ovr_value :\t0 \n", "mixer_corr_gain_ratio :\t1 \n", "mixer_corr_phase_offset_degree :\t-0 \n", "mod_en_awg :\tFalse \n", "nco_freq :\t0 (Hz)\n", "nco_phase_offs :\t0 (Degrees)\n", "nco_prop_delay_comp :\t0 (ns)\n", "nco_prop_delay_comp_en :\tFalse (ns)\n", "offset_awg_path0 :\t0 \n", "offset_awg_path1 :\t0 \n", "sync_en :\tTrue \n", "thresholded_acq_marker_address :\t1 \n", "thresholded_acq_marker_en :\tFalse \n", "thresholded_acq_marker_invert :\tFalse \n", "thresholded_acq_rotation :\t0 (Degrees)\n", "thresholded_acq_threshold :\t0 \n", "thresholded_acq_trigger_address :\t1 \n", "thresholded_acq_trigger_en :\tFalse \n", "thresholded_acq_trigger_invert :\tFalse \n", "trigger10_count_threshold :\t1 \n", "trigger10_threshold_invert :\tFalse \n", "trigger11_count_threshold :\t1 \n", "trigger11_threshold_invert :\tFalse \n", "trigger12_count_threshold :\t1 \n", "trigger12_threshold_invert :\tFalse \n", "trigger13_count_threshold :\t1 \n", "trigger13_threshold_invert :\tFalse \n", "trigger14_count_threshold :\t1 \n", "trigger14_threshold_invert :\tFalse \n", "trigger15_count_threshold :\t1 \n", "trigger15_threshold_invert :\tFalse \n", "trigger1_count_threshold :\t1 \n", "trigger1_threshold_invert :\tFalse \n", "trigger2_count_threshold :\t1 \n", "trigger2_threshold_invert :\tFalse \n", "trigger3_count_threshold :\t1 \n", "trigger3_threshold_invert :\tFalse \n", "trigger4_count_threshold :\t1 \n", "trigger4_threshold_invert :\tFalse \n", "trigger5_count_threshold :\t1 \n", "trigger5_threshold_invert :\tFalse \n", "trigger6_count_threshold :\t1 \n", "trigger6_threshold_invert :\tFalse \n", "trigger7_count_threshold :\t1 \n", "trigger7_threshold_invert :\tFalse \n", "trigger8_count_threshold :\t1 \n", "trigger8_threshold_invert :\tFalse \n", "trigger9_count_threshold :\t1 \n", "trigger9_threshold_invert :\tFalse \n", "ttl_acq_auto_bin_incr_en :\tFalse \n", "ttl_acq_input_select :\t0 \n", "ttl_acq_threshold :\t0 \n", "upsample_rate_awg_path0 :\t0 \n", "upsample_rate_awg_path1 :\t0 \n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "cluster0_module4_sequencer2:\n", "\tparameter value\n", "--------------------------------------------------------------------------------\n", "connect_acq_I :\tin0 \n", "connect_acq_Q :\tin1 \n", "connect_out0 :\toff \n", "connect_out1 :\toff \n", "cont_mode_en_awg_path0 :\tFalse \n", "cont_mode_en_awg_path1 :\tFalse \n", "cont_mode_waveform_idx_awg_path0 :\t0 \n", "cont_mode_waveform_idx_awg_path1 :\t0 \n", "demod_en_acq :\tFalse \n", "gain_awg_path0 :\t1 \n", "gain_awg_path1 :\t1 \n", "integration_length_acq :\t1024 \n", "marker_ovr_en :\tFalse \n", "marker_ovr_value :\t0 \n", "mixer_corr_gain_ratio :\t1 \n", "mixer_corr_phase_offset_degree :\t-0 \n", "mod_en_awg :\tFalse \n", "nco_freq :\t0 (Hz)\n", "nco_phase_offs :\t0 (Degrees)\n", "nco_prop_delay_comp :\t0 (ns)\n", "nco_prop_delay_comp_en :\tFalse (ns)\n", "offset_awg_path0 :\t0 \n", "offset_awg_path1 :\t0 \n", "sync_en :\tFalse \n", "thresholded_acq_marker_address :\t1 \n", "thresholded_acq_marker_en :\tFalse \n", "thresholded_acq_marker_invert :\tFalse \n", "thresholded_acq_rotation :\t0 (Degrees)\n", "thresholded_acq_threshold :\t0 \n", "thresholded_acq_trigger_address :\t1 \n", "thresholded_acq_trigger_en :\tFalse \n", "thresholded_acq_trigger_invert :\tFalse \n", "trigger10_count_threshold :\t1 \n", "trigger10_threshold_invert :\tFalse \n", "trigger11_count_threshold :\t1 \n", "trigger11_threshold_invert :\tFalse \n", "trigger12_count_threshold :\t1 \n", "trigger12_threshold_invert :\tFalse \n", "trigger13_count_threshold :\t1 \n", "trigger13_threshold_invert :\tFalse \n", "trigger14_count_threshold :\t1 \n", "trigger14_threshold_invert :\tFalse \n", "trigger15_count_threshold :\t1 \n", "trigger15_threshold_invert :\tFalse \n", "trigger1_count_threshold :\t1 \n", "trigger1_threshold_invert :\tFalse \n", "trigger2_count_threshold :\t1 \n", "trigger2_threshold_invert :\tFalse \n", "trigger3_count_threshold :\t1 \n", "trigger3_threshold_invert :\tFalse \n", "trigger4_count_threshold :\t1 \n", "trigger4_threshold_invert :\tFalse \n", "trigger5_count_threshold :\t1 \n", "trigger5_threshold_invert :\tFalse \n", "trigger6_count_threshold :\t1 \n", "trigger6_threshold_invert :\tFalse \n", "trigger7_count_threshold :\t1 \n", "trigger7_threshold_invert :\tFalse \n", "trigger8_count_threshold :\t1 \n", "trigger8_threshold_invert :\tFalse \n", "trigger9_count_threshold :\t1 \n", "trigger9_threshold_invert :\tFalse \n", "ttl_acq_auto_bin_incr_en :\tFalse \n", "ttl_acq_input_select :\t0 \n", "ttl_acq_threshold :\t0 \n", "upsample_rate_awg_path0 :\t0 \n", "upsample_rate_awg_path1 :\t0 \n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "cluster0_module4_sequencer3:\n", "\tparameter value\n", "--------------------------------------------------------------------------------\n", "connect_acq_I :\tin0 \n", "connect_acq_Q :\tin1 \n", "connect_out0 :\toff \n", "connect_out1 :\toff \n", "cont_mode_en_awg_path0 :\tFalse \n", "cont_mode_en_awg_path1 :\tFalse \n", "cont_mode_waveform_idx_awg_path0 :\t0 \n", "cont_mode_waveform_idx_awg_path1 :\t0 \n", "demod_en_acq :\tFalse \n", "gain_awg_path0 :\t1 \n", "gain_awg_path1 :\t1 \n", "integration_length_acq :\t1024 \n", "marker_ovr_en :\tFalse \n", "marker_ovr_value :\t0 \n", "mixer_corr_gain_ratio :\t1 \n", "mixer_corr_phase_offset_degree :\t-0 \n", "mod_en_awg :\tFalse \n", "nco_freq :\t0 (Hz)\n", "nco_phase_offs :\t0 (Degrees)\n", "nco_prop_delay_comp :\t0 (ns)\n", "nco_prop_delay_comp_en :\tFalse (ns)\n", "offset_awg_path0 :\t0 \n", "offset_awg_path1 :\t0 \n", "sync_en :\tFalse \n", "thresholded_acq_marker_address :\t1 \n", "thresholded_acq_marker_en :\tFalse \n", "thresholded_acq_marker_invert :\tFalse \n", "thresholded_acq_rotation :\t0 (Degrees)\n", "thresholded_acq_threshold :\t0 \n", "thresholded_acq_trigger_address :\t1 \n", "thresholded_acq_trigger_en :\tFalse \n", "thresholded_acq_trigger_invert :\tFalse \n", "trigger10_count_threshold :\t1 \n", "trigger10_threshold_invert :\tFalse \n", "trigger11_count_threshold :\t1 \n", "trigger11_threshold_invert :\tFalse \n", "trigger12_count_threshold :\t1 \n", "trigger12_threshold_invert :\tFalse \n", "trigger13_count_threshold :\t1 \n", "trigger13_threshold_invert :\tFalse \n", "trigger14_count_threshold :\t1 \n", "trigger14_threshold_invert :\tFalse \n", "trigger15_count_threshold :\t1 \n", "trigger15_threshold_invert :\tFalse \n", "trigger1_count_threshold :\t1 \n", "trigger1_threshold_invert :\tFalse \n", "trigger2_count_threshold :\t1 \n", "trigger2_threshold_invert :\tFalse \n", "trigger3_count_threshold :\t1 \n", "trigger3_threshold_invert :\tFalse \n", "trigger4_count_threshold :\t1 \n", "trigger4_threshold_invert :\tFalse \n", "trigger5_count_threshold :\t1 \n", "trigger5_threshold_invert :\tFalse \n", "trigger6_count_threshold :\t1 \n", "trigger6_threshold_invert :\tFalse \n", "trigger7_count_threshold :\t1 \n", "trigger7_threshold_invert :\tFalse \n", "trigger8_count_threshold :\t1 \n", "trigger8_threshold_invert :\tFalse \n", "trigger9_count_threshold :\t1 \n", "trigger9_threshold_invert :\tFalse \n", "ttl_acq_auto_bin_incr_en :\tFalse \n", "ttl_acq_input_select :\t0 \n", "ttl_acq_threshold :\t0 \n", "upsample_rate_awg_path0 :\t0 \n", "upsample_rate_awg_path1 :\t0 \n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "cluster0_module4_sequencer4:\n", "\tparameter value\n", "--------------------------------------------------------------------------------\n", "connect_acq_I :\tin0 \n", "connect_acq_Q :\tin1 \n", "connect_out0 :\toff \n", "connect_out1 :\toff \n", "cont_mode_en_awg_path0 :\tFalse \n", "cont_mode_en_awg_path1 :\tFalse \n", "cont_mode_waveform_idx_awg_path0 :\t0 \n", "cont_mode_waveform_idx_awg_path1 :\t0 \n", "demod_en_acq :\tFalse \n", "gain_awg_path0 :\t1 \n", "gain_awg_path1 :\t1 \n", "integration_length_acq :\t1024 \n", "marker_ovr_en :\tFalse \n", "marker_ovr_value :\t0 \n", "mixer_corr_gain_ratio :\t1 \n", "mixer_corr_phase_offset_degree :\t-0 \n", "mod_en_awg :\tFalse \n", "nco_freq :\t0 (Hz)\n", "nco_phase_offs :\t0 (Degrees)\n", "nco_prop_delay_comp :\t0 (ns)\n", "nco_prop_delay_comp_en :\tFalse (ns)\n", "offset_awg_path0 :\t0 \n", "offset_awg_path1 :\t0 \n", "sync_en :\tFalse \n", "thresholded_acq_marker_address :\t1 \n", "thresholded_acq_marker_en :\tFalse \n", "thresholded_acq_marker_invert :\tFalse \n", "thresholded_acq_rotation :\t0 (Degrees)\n", "thresholded_acq_threshold :\t0 \n", "thresholded_acq_trigger_address :\t1 \n", "thresholded_acq_trigger_en :\tFalse \n", "thresholded_acq_trigger_invert :\tFalse \n", "trigger10_count_threshold :\t1 \n", "trigger10_threshold_invert :\tFalse \n", "trigger11_count_threshold :\t1 \n", "trigger11_threshold_invert :\tFalse \n", "trigger12_count_threshold :\t1 \n", "trigger12_threshold_invert :\tFalse \n", "trigger13_count_threshold :\t1 \n", "trigger13_threshold_invert :\tFalse \n", "trigger14_count_threshold :\t1 \n", "trigger14_threshold_invert :\tFalse \n", "trigger15_count_threshold :\t1 \n", "trigger15_threshold_invert :\tFalse \n", "trigger1_count_threshold :\t1 \n", "trigger1_threshold_invert :\tFalse \n", "trigger2_count_threshold :\t1 \n", "trigger2_threshold_invert :\tFalse \n", "trigger3_count_threshold :\t1 \n", "trigger3_threshold_invert :\tFalse \n", "trigger4_count_threshold :\t1 \n", "trigger4_threshold_invert :\tFalse \n", "trigger5_count_threshold :\t1 \n", "trigger5_threshold_invert :\tFalse \n", "trigger6_count_threshold :\t1 \n", "trigger6_threshold_invert :\tFalse \n", "trigger7_count_threshold :\t1 \n", "trigger7_threshold_invert :\tFalse \n", "trigger8_count_threshold :\t1 \n", "trigger8_threshold_invert :\tFalse \n", "trigger9_count_threshold :\t1 \n", "trigger9_threshold_invert :\tFalse \n", "ttl_acq_auto_bin_incr_en :\tFalse \n", "ttl_acq_input_select :\t0 \n", "ttl_acq_threshold :\t0 \n", "upsample_rate_awg_path0 :\t0 \n", "upsample_rate_awg_path1 :\t0 \n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "cluster0_module4_sequencer5:\n", "\tparameter value\n", "--------------------------------------------------------------------------------\n", "connect_acq_I :\tin0 \n", "connect_acq_Q :\tin1 \n", "connect_out0 :\toff \n", "connect_out1 :\toff \n", "cont_mode_en_awg_path0 :\tFalse \n", "cont_mode_en_awg_path1 :\tFalse \n", "cont_mode_waveform_idx_awg_path0 :\t0 \n", "cont_mode_waveform_idx_awg_path1 :\t0 \n", "demod_en_acq :\tFalse \n", "gain_awg_path0 :\t1 \n", "gain_awg_path1 :\t1 \n", "integration_length_acq :\t1024 \n", "marker_ovr_en :\tFalse \n", "marker_ovr_value :\t0 \n", "mixer_corr_gain_ratio :\t1 \n", "mixer_corr_phase_offset_degree :\t-0 \n", "mod_en_awg :\tFalse \n", "nco_freq :\t0 (Hz)\n", "nco_phase_offs :\t0 (Degrees)\n", "nco_prop_delay_comp :\t0 (ns)\n", "nco_prop_delay_comp_en :\tFalse (ns)\n", "offset_awg_path0 :\t0 \n", "offset_awg_path1 :\t0 \n", "sync_en :\tFalse \n", "thresholded_acq_marker_address :\t1 \n", "thresholded_acq_marker_en :\tFalse \n", "thresholded_acq_marker_invert :\tFalse \n", "thresholded_acq_rotation :\t0 (Degrees)\n", "thresholded_acq_threshold :\t0 \n", "thresholded_acq_trigger_address :\t1 \n", "thresholded_acq_trigger_en :\tFalse \n", "thresholded_acq_trigger_invert :\tFalse \n", "trigger10_count_threshold :\t1 \n", "trigger10_threshold_invert :\tFalse \n", "trigger11_count_threshold :\t1 \n", "trigger11_threshold_invert :\tFalse \n", "trigger12_count_threshold :\t1 \n", "trigger12_threshold_invert :\tFalse \n", "trigger13_count_threshold :\t1 \n", "trigger13_threshold_invert :\tFalse \n", "trigger14_count_threshold :\t1 \n", "trigger14_threshold_invert :\tFalse \n", "trigger15_count_threshold :\t1 \n", "trigger15_threshold_invert :\tFalse \n", "trigger1_count_threshold :\t1 \n", "trigger1_threshold_invert :\tFalse \n", "trigger2_count_threshold :\t1 \n", "trigger2_threshold_invert :\tFalse \n", "trigger3_count_threshold :\t1 \n", "trigger3_threshold_invert :\tFalse \n", "trigger4_count_threshold :\t1 \n", "trigger4_threshold_invert :\tFalse \n", "trigger5_count_threshold :\t1 \n", "trigger5_threshold_invert :\tFalse \n", "trigger6_count_threshold :\t1 \n", "trigger6_threshold_invert :\tFalse \n", "trigger7_count_threshold :\t1 \n", "trigger7_threshold_invert :\tFalse \n", "trigger8_count_threshold :\t1 \n", "trigger8_threshold_invert :\tFalse \n", "trigger9_count_threshold :\t1 \n", "trigger9_threshold_invert :\tFalse \n", "ttl_acq_auto_bin_incr_en :\tFalse \n", "ttl_acq_input_select :\t0 \n", "ttl_acq_threshold :\t0 \n", "upsample_rate_awg_path0 :\t0 \n", "upsample_rate_awg_path1 :\t0 \n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Status: OKAY, Flags: NONE, Slot flags: NONE\n" ] } ], "source": [ "# Stop both sequencers.\n", "module.stop_sequencer()\n", "\n", "# Print status of both sequencers (should now say it is stopped).\n", "print(module.get_sequencer_state(0))\n", "print(module.get_sequencer_state(1))\n", "print()\n", "\n", "# Print an overview of the instrument parameters.\n", "print(\"Snapshot:\")\n", "module.print_readable_snapshot(update=True)\n", "\n", "# Reset the cluster\n", "cluster.reset()\n", "print(cluster.get_system_state())" ] } ], "metadata": { "jupytext": { "formats": "ipynb,py:percent" }, "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.8.18" } }, "nbformat": 4, "nbformat_minor": 5 }