{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "10b7f15d",
   "metadata": {},
   "source": [
    "TTL acquisition\n",
    "==================\n",
    "\n",
    "In this tutorial we will demonstrate the sequencer based TTL (Transistor-Transistor-Logic) acquisition procedure. The TTL acquisition enables us to count trigger pulses, based on a settable threshold. The acquisition protocol allows us to save the number of triggers in separate bins, or average the triggers on the fly (see section [TTL Acquisitions](https://qblox-qblox-instruments.readthedocs-hosted.com/en/main/cluster/q1_sequence_processor.html#acquisitions)). We will showcase this functionality by using a QRM of which output $\\text{O}^{[1]}$ is directly connected to input $\\text{I}^{[1]}$, to both send pulses and acquire the resulting data."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6328a3b0",
   "metadata": {
    "tags": []
   },
   "source": [
    "Setup\n",
    "-----\n",
    "\n",
    "First, we are going to import the required packages."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "9dd51fc1",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-03-28T14:33:43.338232Z",
     "iopub.status.busy": "2024-03-28T14:33:43.336971Z",
     "iopub.status.idle": "2024-03-28T14:33:44.436757Z",
     "shell.execute_reply": "2024-03-28T14:33:44.435579Z"
    }
   },
   "outputs": [],
   "source": [
    "from __future__ import annotations\n",
    "\n",
    "from typing import TYPE_CHECKING, Callable\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from numpy import random\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": "ef60a61c",
   "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": "ba3614fc",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-03-28T14:33:44.441846Z",
     "iopub.status.busy": "2024-03-28T14:33:44.441846Z",
     "iopub.status.idle": "2024-03-28T14:33:46.839953Z",
     "shell.execute_reply": "2024-03-28T14:33:46.838520Z"
    }
   },
   "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": "7904d389",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-03-28T14:33:46.844510Z",
     "iopub.status.busy": "2024-03-28T14:33:46.843491Z",
     "iopub.status.idle": "2024-03-28T14:33:46.855129Z",
     "shell.execute_reply": "2024-03-28T14:33:46.853517Z"
    }
   },
   "outputs": [],
   "source": [
    "cluster_ip = \"10.10.200.42\"\n",
    "cluster_name = \"cluster0\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6233cde1",
   "metadata": {},
   "source": [
    "### Connect to Cluster\n",
    "\n",
    "We now make a connection with the Cluster."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "1b17a3cb",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-03-28T14:33:46.859127Z",
     "iopub.status.busy": "2024-03-28T14:33:46.859127Z",
     "iopub.status.idle": "2024-03-28T14:33:47.790814Z",
     "shell.execute_reply": "2024-03-28T14:33:47.788805Z"
    },
    "lines_to_next_cell": 2
   },
   "outputs": [],
   "source": [
    "\n",
    "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": "c4427304",
   "metadata": {
    "lines_to_next_cell": 2
   },
   "source": [
    "#### Get connected modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "0d700efb",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-03-28T14:33:47.796379Z",
     "iopub.status.busy": "2024-03-28T14:33:47.795379Z",
     "iopub.status.idle": "2024-03-28T14:33:47.805703Z",
     "shell.execute_reply": "2024-03-28T14:33:47.804555Z"
    }
   },
   "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": "f4104364",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-03-28T14:33:47.810888Z",
     "iopub.status.busy": "2024-03-28T14:33:47.810888Z",
     "iopub.status.idle": "2024-03-28T14:33:47.929834Z",
     "shell.execute_reply": "2024-03-28T14:33:47.928840Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{4: <Module: cluster0_module4 of Cluster: cluster0>}"
      ]
     },
     "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": "eece827d",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-03-28T14:33:47.937782Z",
     "iopub.status.busy": "2024-03-28T14:33:47.936785Z",
     "iopub.status.idle": "2024-03-28T14:33:47.945105Z",
     "shell.execute_reply": "2024-03-28T14:33:47.943802Z"
    },
    "lines_to_next_cell": 0
   },
   "outputs": [],
   "source": [
    "readout_module = modules[4]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "931972e3",
   "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": "3549e1f2",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-03-28T14:33:47.950506Z",
     "iopub.status.busy": "2024-03-28T14:33:47.949504Z",
     "iopub.status.idle": "2024-03-28T14:33:51.380044Z",
     "shell.execute_reply": "2024-03-28T14:33:51.377744Z"
    }
   },
   "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_status())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c12056db",
   "metadata": {},
   "source": [
    "Generate waveforms<a id='gen_wf'></a>\n",
    "------------------------------\n",
    "\n",
    "Next, we need to create the waveforms used by the sequence for playback on the outputs. Here, we define a single waveform consisting of a 16 ns block pulse with an amplitude of 0.5."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "6787c997",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-03-28T14:33:51.385687Z",
     "iopub.status.busy": "2024-03-28T14:33:51.384186Z",
     "iopub.status.idle": "2024-03-28T14:33:51.395420Z",
     "shell.execute_reply": "2024-03-28T14:33:51.393353Z"
    }
   },
   "outputs": [],
   "source": [
    "# Waveform length parameter\n",
    "waveform_length = 16  # nanoseconds\n",
    "\n",
    "waveforms = {\n",
    "    \"block\": {\"data\": [0.5 for i in range(0, waveform_length)], \"index\": 0},\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e2453280",
   "metadata": {},
   "source": [
    "Specify acquisitions\n",
    "--------------------\n",
    "\n",
    "We need to specify the acquisitions so that the instrument can allocate the required memory for its acquisition list. Here, we create one acquisition that consists of 100 bins, at acquisition index 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "7aab69f0",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-03-28T14:33:51.399667Z",
     "iopub.status.busy": "2024-03-28T14:33:51.399667Z",
     "iopub.status.idle": "2024-03-28T14:33:51.409817Z",
     "shell.execute_reply": "2024-03-28T14:33:51.408810Z"
    }
   },
   "outputs": [],
   "source": [
    "# Acquisitions\n",
    "acquisitions = {\n",
    "    \"ttl\": {\"num_bins\": 100, \"index\": 0},\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f4bffe6b",
   "metadata": {},
   "source": [
    "Create Q1ASM programs\n",
    "--------------------\n",
    "\n",
    "Now that we have the waveform and acquisition specified, we define a simple Q1ASM program that sequences the waveforms and one that triggers the acquisitions.\n",
    "We will send 5 block pulses of 16 ns at 1 MHz (with 984 ns in between them). At the same time we will perform a 6000 ns TTL acquisition. Note that 1 MHz is the maximum continuous rate for a TTL acquisition.\n",
    "\n",
    "The TTL acquisition is carried out with the `acquire_ttl` command that takes four arguments. The first argument is the index of what acquisition should be done, the second specifies in what bin index it is stored, the third toggles the acquisition on or off and finally the fourth argument is the amount of ns to wait. See the section on [Q1ASM instructions](https://qblox-qblox-instruments.readthedocs-hosted.com/en/main/cluster/q1_sequence_processor.html#instructions) for a more detailed overview of the sequencer instructions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "06c1077a",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-03-28T14:33:51.414602Z",
     "iopub.status.busy": "2024-03-28T14:33:51.413186Z",
     "iopub.status.idle": "2024-03-28T14:33:51.426450Z",
     "shell.execute_reply": "2024-03-28T14:33:51.425441Z"
    }
   },
   "outputs": [],
   "source": [
    "# Sequence program for AWG.\n",
    "seq_prog_awg = \"\"\"\n",
    "        wait_sync 4           #Wait for sequencers to synchronize and then wait another 4ns.\n",
    "        move      5,R0        #Loop iterator.\n",
    "loop:\n",
    "        play      0,0,16      #Play a block on output path 0 and wait 16ns.\n",
    "        wait      984         #Wait 984ns\n",
    "        loop      R0, @loop   #Repeat loop until R0 is 0\n",
    "\n",
    "        stop                  #Stop the sequence after the last iteration.\n",
    "\"\"\"\n",
    "\n",
    "# Sequence program for acquiring\n",
    "seq_prog_acq = \"\"\"\n",
    "        wait_sync 4           #Wait for sequencers to synchronize and then wait another 4ns.\n",
    "        wait 140              #Approximate time of flight\n",
    "        acquire_ttl 0,0,1,4   #Turn on TTL acquire on input path 0 and wait 4ns.\n",
    "        wait 6000             #Wait 6000ns.\n",
    "        acquire_ttl 0,0,0,4   #Turn off TTL acquire on input path 0 and wait 4ns.\n",
    "\n",
    "        stop                   #Stop sequencer.\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "15331468",
   "metadata": {},
   "source": [
    "Upload sequence\n",
    "---------------\n",
    "\n",
    "The sequences are uploaded to the sequencers. We will use sequencer 0 to send the pulses and sequencer 1 to acquire them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "31f4aa11",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-03-28T14:33:51.433438Z",
     "iopub.status.busy": "2024-03-28T14:33:51.431049Z",
     "iopub.status.idle": "2024-03-28T14:33:51.442050Z",
     "shell.execute_reply": "2024-03-28T14:33:51.440657Z"
    }
   },
   "outputs": [],
   "source": [
    "# Add sequence program, waveform and acquisitions to single dictionary.\n",
    "sequence_awg = {\n",
    "    \"waveforms\": waveforms,\n",
    "    \"weights\": {},\n",
    "    \"acquisitions\": {},\n",
    "    \"program\": seq_prog_awg,\n",
    "}\n",
    "sequence_acq = {\n",
    "    \"waveforms\": {},\n",
    "    \"weights\": {},\n",
    "    \"acquisitions\": acquisitions,\n",
    "    \"program\": seq_prog_acq,\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "96882935",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-03-28T14:33:51.445663Z",
     "iopub.status.busy": "2024-03-28T14:33:51.444663Z",
     "iopub.status.idle": "2024-03-28T14:33:51.516354Z",
     "shell.execute_reply": "2024-03-28T14:33:51.515308Z"
    }
   },
   "outputs": [],
   "source": [
    "# Upload sequence.\n",
    "readout_module.sequencer0.sequence(sequence_awg)\n",
    "readout_module.sequencer1.sequence(sequence_acq)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c2e6925",
   "metadata": {},
   "source": [
    "Play sequence\n",
    "-------------\n",
    "\n",
    "Now we configure the sequencers, and play the sequence.\n",
    "\n",
    "We will use sequencer 0 which will drive output $\\text{O}^{1}$, and sequencer 1 which will acquire on input $\\text{I}^{1}$, enabling syncing, and prepare the (scope) acquisition.\n",
    "\n",
    "Then the TTL acquisition is configured by using `ttl_acq_input_select` to select $\\text{I}^{1}$ as input. We set `ttl_acq_auto_bin_incr_en` to False such that our TTL count will be put in one bin. We set our TTL threshold to a value of 0.5 of our input range (corresponding to 0.5 V) using `ttl_acq_threshold `, and our input gain to 0 dB using `in0_gain`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "9c10ace3",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-03-28T14:33:51.521545Z",
     "iopub.status.busy": "2024-03-28T14:33:51.519414Z",
     "iopub.status.idle": "2024-03-28T14:33:51.696524Z",
     "shell.execute_reply": "2024-03-28T14:33:51.696524Z"
    }
   },
   "outputs": [],
   "source": [
    "# Map sequencer to specific outputs (but first disable all sequencer connections)\n",
    "readout_module.disconnect_outputs()\n",
    "readout_module.disconnect_inputs()\n",
    "\n",
    "# Drive through first output\n",
    "readout_module.sequencer0.connect_out0(\"I\")\n",
    "\n",
    "# Acquire through first input\n",
    "readout_module.sequencer1.connect_acq_I(\"in0\")\n",
    "\n",
    "# Enable sync\n",
    "readout_module.sequencer0.sync_en(True)\n",
    "readout_module.sequencer1.sync_en(True)\n",
    "\n",
    "# Delete previous acquisition.\n",
    "readout_module.delete_acquisition_data(1, \"ttl\")\n",
    "\n",
    "# Configure scope mode\n",
    "readout_module.scope_acq_sequencer_select(1)\n",
    "\n",
    "# Choose threshold and input gain\n",
    "threshold = 0.5\n",
    "input_gain = 0\n",
    "\n",
    "# Configure the TTL acquisition\n",
    "readout_module.sequencer1.ttl_acq_input_select(0)\n",
    "readout_module.sequencer1.ttl_acq_auto_bin_incr_en(False)\n",
    "\n",
    "# Set input gain and threshold\n",
    "readout_module.in0_gain(input_gain)\n",
    "readout_module.sequencer1.ttl_acq_threshold(threshold)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "02847644",
   "metadata": {},
   "source": [
    "We start the sequence, and print the status flags of our sequencers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "527acede",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-03-28T14:33:51.702546Z",
     "iopub.status.busy": "2024-03-28T14:33:51.701546Z",
     "iopub.status.idle": "2024-03-28T14:33:51.743566Z",
     "shell.execute_reply": "2024-03-28T14:33:51.742290Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Status: STOPPED, Flags: NONE\n",
      "Status: STOPPED, Flags: ACQ_SCOPE_DONE_PATH_0, ACQ_SCOPE_DONE_PATH_1, ACQ_BINNING_DONE\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 sequencer.\n",
    "readout_module.arm_sequencer(0)\n",
    "readout_module.arm_sequencer(1)\n",
    "readout_module.start_sequencer()\n",
    "\n",
    "# Print status of sequencer.\n",
    "print(readout_module.get_sequencer_status(0, 1))\n",
    "print(readout_module.get_sequencer_status(1, 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf1e858f",
   "metadata": {},
   "source": [
    "Retrieve acquisition\n",
    "--------------------\n",
    "\n",
    "We retrieve the acquisition data from sequencer 1. Then, both plot the scope data for the first 6000 ns and print the number of counted pulses, that is stored in `data['acquisition'][\"bins\"][\"avg_cnt\"][0]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "2967dadc",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-03-28T14:33:51.747701Z",
     "iopub.status.busy": "2024-03-28T14:33:51.747701Z",
     "iopub.status.idle": "2024-03-28T14:33:51.976098Z",
     "shell.execute_reply": "2024-03-28T14:33:51.975098Z"
    },
    "lines_to_next_cell": 2
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\work\\code\\qblox_instruments_install\\qblox_instruments\\native\\generic_func.py:3210: 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"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pulses detected: 5\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1500x465.839 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Wait for the sequencer to stop with a timeout period of one minute.\n",
    "readout_module.get_acquisition_status(1, 1)\n",
    "\n",
    "# Move acquisition data from temporary memory to acquisition list.\n",
    "readout_module.store_scope_acquisition(1, \"ttl\")\n",
    "\n",
    "# Get acquisition list from instrument.\n",
    "data = readout_module.get_acquisitions(1)[\"ttl\"]\n",
    "\n",
    "# Plot acquired signal on both inputs.\n",
    "print(\"pulses detected: \" + str(data[\"acquisition\"][\"bins\"][\"avg_cnt\"][0]))\n",
    "\n",
    "fig, ax = plt.subplots(1, 1, figsize=(15, 15 / 2 / 1.61))\n",
    "ax.plot(data[\"acquisition\"][\"scope\"][\"path0\"][\"data\"][0:6000], label=\"Trace\")\n",
    "ax.axhline(y=threshold, color=\"r\", label=\"Threshold\")\n",
    "ax.set_xlabel(\"Time (ns)\")\n",
    "ax.set_ylabel(\"Amplitude (Volt)\")\n",
    "plt.legend(loc=\"upper right\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f339e29",
   "metadata": {},
   "source": [
    "We observe that we indeed do see five 16 ns pulses in the scope acquisition. Furthermore we observe that the amount of pulses counted matches the amount we of the scope trace. You are encouraged to change the threshold value and input gain yourself, and learn about th importance of calibrating these values."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8006daf8",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "<h1> Note </h1>\n",
    "It is important to correctly calibrate your input gain and threshold. For example in a setup with noise and/or interferences, setting the input gain too high might result in these kind of pulses:\n",
    "\n",
    "![download.png](download.png)\n",
    "\n",
    "\n",
    "Such a single pulse results in multiple counts, as the threshold is passed multiple times. We therefore strongly recommend calibrating the TTL acquisition using the scope acquisition as is shown above.\n",
    "    </div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "732a2880",
   "metadata": {
    "lines_to_next_cell": 2
   },
   "source": [
    "Short pulse bursts\n",
    "--------------------\n",
    "\n",
    "As the acquisition module in the sequencer has an internal buffer of 8 data entries, any pulse bursts of <8 will be handled correctly when exceeding the maximum continuous rate of 1 MHz. When exceeding the buffer limit, a `ACQ_BINNING_FIFO_ERROR` will be thrown.\n",
    "To illustrate this we will define a function `generate_pulse_program` that takes as input `num_pulses` (the number of pulses to generate) and `wait_time` (the time to wait between pulses in ns).\n",
    "We also define a function to upload the sequence to the AWG."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "d50dbb33",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-03-28T14:33:51.981100Z",
     "iopub.status.busy": "2024-03-28T14:33:51.981100Z",
     "iopub.status.idle": "2024-03-28T14:33:51.993185Z",
     "shell.execute_reply": "2024-03-28T14:33:51.991190Z"
    }
   },
   "outputs": [],
   "source": [
    "# Sequence program for AWG.\n",
    "def generate_pulse_program(num_pulses: int, wait_time: int) -> str:\n",
    "    seq_prog_awg = f\"\"\"\n",
    "        wait_sync 4           #Wait for sequencers to synchronize and then wait another 4ns.\n",
    "        move      {num_pulses},R0  #Loop iterator.\n",
    "loop:\n",
    "        play      0,0,16      #Play a block on output path 0 and wait 16ns.\n",
    "        wait      {wait_time} #Wait wait_time ns\n",
    "        loop      R0, @loop   #Repeat loop until R0 is 0\n",
    "\n",
    "        stop                  #Stop the sequence after the last iteration.\n",
    "    \"\"\"\n",
    "    return seq_prog_awg\n",
    "\n",
    "\n",
    "# Upload sequence to AWG\n",
    "def upload_sequence(seq_prog_awg: str) -> None:\n",
    "    sequence_awg = {\n",
    "        \"waveforms\": waveforms,\n",
    "        \"weights\": {},\n",
    "        \"acquisitions\": {},\n",
    "        \"program\": seq_prog_awg,\n",
    "    }\n",
    "\n",
    "    readout_module.sequencer0.sequence(sequence_awg)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff61a34d",
   "metadata": {},
   "source": [
    "We now generate the program, upload it and set the threshold and input gain."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "e47ff6fc",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-03-28T14:33:51.998743Z",
     "iopub.status.busy": "2024-03-28T14:33:51.998743Z",
     "iopub.status.idle": "2024-03-28T14:33:52.070656Z",
     "shell.execute_reply": "2024-03-28T14:33:52.068086Z"
    }
   },
   "outputs": [],
   "source": [
    "seq_prog_awg = generate_pulse_program(num_pulses=5, wait_time=20)\n",
    "upload_sequence(seq_prog_awg)\n",
    "\n",
    "# Choose threshold and input gain\n",
    "threshold = 0.5\n",
    "input_gain = 0\n",
    "\n",
    "# Delete previous acquisition.\n",
    "readout_module.delete_acquisition_data(1, \"ttl\")\n",
    "\n",
    "# Set input gain and threshold\n",
    "readout_module.in0_gain(input_gain)\n",
    "readout_module.sequencer1.ttl_acq_threshold(threshold)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "86013ece",
   "metadata": {},
   "source": [
    "We then arm the sequencers and play the sequence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "4686c722",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-03-28T14:33:52.074674Z",
     "iopub.status.busy": "2024-03-28T14:33:52.074674Z",
     "iopub.status.idle": "2024-03-28T14:33:52.117016Z",
     "shell.execute_reply": "2024-03-28T14:33:52.114986Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Status: STOPPED, Flags: NONE\n",
      "Status: STOPPED, Flags: ACQ_SCOPE_DONE_PATH_0, ACQ_SCOPE_DONE_PATH_1, ACQ_BINNING_DONE\n"
     ]
    }
   ],
   "source": [
    "# Arm and start sequencer.\n",
    "readout_module.arm_sequencer(0)\n",
    "readout_module.arm_sequencer(1)\n",
    "readout_module.start_sequencer()\n",
    "\n",
    "# Print status of sequencer.\n",
    "print(readout_module.get_sequencer_status(0, 1))\n",
    "print(readout_module.get_sequencer_status(1, 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "88f3bc9e",
   "metadata": {},
   "source": [
    "We retrieve the acquisition and plot it as in the previous section."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "2b8df8a7",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-03-28T14:33:52.122016Z",
     "iopub.status.busy": "2024-03-28T14:33:52.121118Z",
     "iopub.status.idle": "2024-03-28T14:33:52.335306Z",
     "shell.execute_reply": "2024-03-28T14:33:52.333334Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pulses detected: 5\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1500x465.839 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Wait for the sequencer to stop with a timeout period of one minute.\n",
    "readout_module.get_acquisition_status(1, 1)\n",
    "\n",
    "# Move acquisition data from temporary memory to acquisition list.\n",
    "readout_module.store_scope_acquisition(1, \"ttl\")\n",
    "\n",
    "# Get acquisition list from instrument.\n",
    "data = readout_module.get_acquisitions(1)[\"ttl\"]\n",
    "\n",
    "# Plot acquired signal on both inputs (first 200 ns).\n",
    "print(\"pulses detected: \" + str(data[\"acquisition\"][\"bins\"][\"avg_cnt\"][0]))\n",
    "\n",
    "fig, ax = plt.subplots(1, 1, figsize=(15, 15 / 2 / 1.61))\n",
    "ax.plot(data[\"acquisition\"][\"scope\"][\"path0\"][\"data\"][0:200], label=\"Trace\")\n",
    "ax.axhline(y=threshold, color=\"r\", label=\"Threshold\")\n",
    "ax.set_xlabel(\"Time (ns)\")\n",
    "ax.set_ylabel(\"Amplitude (Volt)\")\n",
    "plt.legend(loc=\"upper right\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9cf5c07d",
   "metadata": {},
   "source": [
    "We encourage you to play around with the `num_pulses`, `wait_time`, `input_gain` and `threshold` yourself."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "590e98bf",
   "metadata": {},
   "source": [
    "Auto bin increment\n",
    "--------------\n",
    "\n",
    "\n",
    "In the play sequence section we set the `ttl_acq_auto_bin_incr_en` to False, meaning all of our pulses get counted within one bin. When it is set to True our data will be stored in separate bins, where the bin index is incremented by one for every detected pulse. The pulse count is therefore equal to the number of valid bins. When doing multiple measurements, this allows us to acquire a cumulative probability distribution of counted triggers.\n",
    "\n",
    "To illustrate the usage we will define a function which returns a Q1ASM program that plays a `N` amount of pulses (at a 1 MHz rate), where `N` is a random number between 1 and 100 taken from a Poissonian distribution. This is meant to mock a stochastic physical process, e.g the amount of photons emitted by a laser.\n",
    "We will call the function a 1000 times and run it, without deleting the acquisition data between the runs.\n",
    "After this we will plot a histogram from our acquired data to inspect the result."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7d3a3fa9",
   "metadata": {},
   "source": [
    "We will now define new Q1ASM programs. We define a function which returns a program that generates `num_pulses` number of pulses. These pulses are 16 ns long, and are send at a rate of 1 MHz again.\n",
    "\n",
    "For the acquiring sequencer we will execute the same program as in the previous section, albeit with an acquisition window of 100.000 ns."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "8edde276",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-03-28T14:33:52.340840Z",
     "iopub.status.busy": "2024-03-28T14:33:52.340840Z",
     "iopub.status.idle": "2024-03-28T14:33:52.349386Z",
     "shell.execute_reply": "2024-03-28T14:33:52.348338Z"
    }
   },
   "outputs": [],
   "source": [
    "# Sequence program for acquiring\n",
    "seq_prog_acq = \"\"\"\n",
    "        move      10,R0       #Loop iterator.\n",
    "        wait_sync 4           #Wait for sequencers to synchronize and then wait another 4ns.\n",
    "        wait 140              #Approximate time of flight\n",
    "        acquire_ttl 0,0,1,4   #Turn on TTL acquire on input path 0 and wait 4ns.\n",
    "loop:\n",
    "        wait 10000            #Wait 10000 ns\n",
    "        loop      R0, @loop   #Repeat loop until R0 is 0\n",
    "        acquire_ttl 0,0,0,4   #Turn off TTL acquire on input path 0 and wait 4ns.\n",
    "\n",
    "        stop                   #Stop sequencer.\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f22eda1d",
   "metadata": {},
   "source": [
    "We will first configure our sequencers. Then use `random` to generate an amount of pulses, and repeat this 10000 times."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "9720c0b6",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-03-28T14:33:52.354662Z",
     "iopub.status.busy": "2024-03-28T14:33:52.353660Z",
     "iopub.status.idle": "2024-03-28T14:33:52.550024Z",
     "shell.execute_reply": "2024-03-28T14:33:52.549496Z"
    }
   },
   "outputs": [],
   "source": [
    "# Choose threshold and input gain\n",
    "threshold = 0.5\n",
    "input_gain = 0\n",
    "\n",
    "# Delete previous acquisition.\n",
    "readout_module.delete_acquisition_data(1, \"ttl\")\n",
    "\n",
    "# Configure the TTL acquisition\n",
    "readout_module.sequencer1.ttl_acq_input_select(0)\n",
    "readout_module.sequencer1.ttl_acq_auto_bin_incr_en(True)\n",
    "\n",
    "# Enable sync\n",
    "readout_module.sequencer0.sync_en(True)\n",
    "readout_module.sequencer1.sync_en(True)\n",
    "\n",
    "# Set input gain and threshold\n",
    "readout_module.in0_gain(input_gain)\n",
    "readout_module.sequencer1.ttl_acq_threshold(threshold)\n",
    "\n",
    "sequence_acq = {\n",
    "    \"waveforms\": {},\n",
    "    \"weights\": {},\n",
    "    \"acquisitions\": acquisitions,\n",
    "    \"program\": seq_prog_acq,\n",
    "}\n",
    "\n",
    "# Upload acquire sequence.\n",
    "readout_module.sequencer1.sequence(sequence_acq)\n",
    "\n",
    "# Map sequencer to specific outputs (but first disable all sequencer connections)\n",
    "readout_module.disconnect_outputs()\n",
    "readout_module.disconnect_inputs()\n",
    "\n",
    "# Drive through first output\n",
    "readout_module.sequencer0.connect_out0(\"I\")\n",
    "\n",
    "# Acquire through first input\n",
    "readout_module.sequencer1.connect_acq_I(\"in0\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "e6a9a2dd",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-03-28T14:33:52.554847Z",
     "iopub.status.busy": "2024-03-28T14:33:52.553841Z",
     "iopub.status.idle": "2024-03-28T14:34:45.824570Z",
     "shell.execute_reply": "2024-03-28T14:34:45.822549Z"
    }
   },
   "outputs": [],
   "source": [
    "num_pulses_list = random.poisson(lam=50, size=1000)\n",
    "wait_time = 1000\n",
    "\n",
    "for num_pulses in num_pulses_list:\n",
    "    seq_prog_awg = generate_pulse_program(num_pulses, wait_time)\n",
    "    upload_sequence(seq_prog_awg)\n",
    "    # Arm and start sequencer.\n",
    "    readout_module.arm_sequencer(0)\n",
    "    readout_module.arm_sequencer(1)\n",
    "    readout_module.start_sequencer()\n",
    "    readout_module.get_acquisition_status(1, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "212b951b",
   "metadata": {},
   "source": [
    "### Create histogram\n",
    "\n",
    "We retrieve the acquired data from the sequence to take a look at it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "2b0a4d84",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-03-28T14:34:45.829713Z",
     "iopub.status.busy": "2024-03-28T14:34:45.828718Z",
     "iopub.status.idle": "2024-03-28T14:34:45.883835Z",
     "shell.execute_reply": "2024-03-28T14:34:45.882817Z"
    },
    "lines_to_next_cell": 2
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "counts per bin: [1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 998, 997, 995, 994, 994, 991, 987, 978, 969, 948, 925, 904, 880, 860, 815, 769, 726, 674, 624, 567, 512, 461, 404, 348, 305, 259, 222, 185, 157, 134, 104, 74, 53, 39, 30, 24, 19, 12, 8, 6, 5, 4, 2, 2, 2, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]\n"
     ]
    }
   ],
   "source": [
    "# Wait for the sequencer to stop with a timeout period of one minute.\n",
    "readout_module.get_acquisition_status(1, 1)\n",
    "\n",
    "# Move acquisition data from temporary memory to acquisition list.\n",
    "readout_module.store_scope_acquisition(1, \"ttl\")\n",
    "\n",
    "# Get acquisition list from instrument.\n",
    "data = readout_module.get_acquisitions(1)[\"ttl\"][\"acquisition\"][\"bins\"][\"avg_cnt\"]\n",
    "\n",
    "# Plot acquired signal on both inputs.\n",
    "print(f\"counts per bin: {data}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1ac77726",
   "metadata": {
    "lines_to_next_cell": 2
   },
   "source": [
    "Every time the acquisition_ttl is ran the sequencer starts over with incrementing the bins (from bin 0). In every bin, the counts are summed up for all 1000 runs. Therefore, the data is a cumulative probability distribution of triggers counted. We now reorganize the acquired data into a probability distribution function (a histogram), and plot the result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "6566ee29",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-03-28T14:34:45.889350Z",
     "iopub.status.busy": "2024-03-28T14:34:45.887894Z",
     "iopub.status.idle": "2024-03-28T14:34:46.068296Z",
     "shell.execute_reply": "2024-03-28T14:34:46.067295Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def create_histogram(data: list) -> dict[int, float]:\n",
    "    data_diff = np.diff(data)\n",
    "    res = {\n",
    "        count + 1: -v\n",
    "        for (count, v) in enumerate(data_diff)\n",
    "        if not (np.isnan(v) or np.isclose(v, 0))\n",
    "    }\n",
    "    return res\n",
    "\n",
    "\n",
    "res = create_histogram(data)\n",
    "plt.bar(res.keys(), res.values(), 1, color=\"g\")\n",
    "plt.title(\"1000 runs with a Poissonian distribution (µ = 50) of pulses\")\n",
    "plt.xlabel(\"Trigger Count\")\n",
    "plt.ylabel(\"Occurrence\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "37cae7bd",
   "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": 26,
   "id": "6a0ff0fc",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-03-28T14:34:46.073302Z",
     "iopub.status.busy": "2024-03-28T14:34:46.073302Z",
     "iopub.status.idle": "2024-03-28T14:34:55.894773Z",
     "shell.execute_reply": "2024-03-28T14:34:55.893757Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Status: STOPPED, Flags: FORCED_STOP\n",
      "\n",
      "Snapshot:\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cluster0_module4:\n",
      "\tparameter                    value\n",
      "--------------------------------------------------------------------------------\n",
      "in0_gain                      :\t0 (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    :\t1 \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                    :\toff \n",
      "connect_acq_Q                    :\toff \n",
      "connect_out0                     :\tI \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_sequencer1:\n",
      "\tparameter                       value\n",
      "--------------------------------------------------------------------------------\n",
      "connect_acq_I                    :\tin0 \n",
      "connect_acq_Q                    :\toff \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         :\tTrue \n",
      "ttl_acq_input_select             :\t0 \n",
      "ttl_acq_threshold                :\t0.49976 \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                    :\toff \n",
      "connect_acq_Q                    :\toff \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                    :\toff \n",
      "connect_acq_Q                    :\toff \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                    :\toff \n",
      "connect_acq_Q                    :\toff \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                    :\toff \n",
      "connect_acq_Q                    :\toff \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 sequencer.\n",
    "readout_module.stop_sequencer()\n",
    "\n",
    "# Print status of sequencer.\n",
    "print(readout_module.get_sequencer_status(0))\n",
    "print()\n",
    "\n",
    "# Print an overview of the instrument parameters.\n",
    "print(\"Snapshot:\")\n",
    "readout_module.print_readable_snapshot(update=True)\n",
    "\n",
    "# Reset the cluster\n",
    "cluster.reset()\n",
    "print(cluster.get_system_status())"
   ]
  }
 ],
 "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
}