{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "87904199",
   "metadata": {},
   "source": [
    "Binned acquisition\n",
    "==================\n",
    "\n",
    "In this tutorial, we will demonstrate the sequencer-based acquisition binning procedure. The binning process is applied on the input path after real-time demodulation, (weighed) integration, IQ rotation and discretization. It allows storing both the integration and discretization\n",
    "results on the fly without intervention of the host PC in up to 131072 bins. It also allows the averaging of those bins on the fly\n",
    "(see section [Sequencer Acquisition](https://docs.qblox.com/en/main/cluster/q1_sequence_processor.html#acquisitions)).\n",
    "We will then use the module sequencers to sequence waveforms on the outputs and, simultaneously, acquire the resulting waveforms on the inputs."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a5324e73",
   "metadata": {
    "tags": [
     "connectivity"
    ]
   },
   "source": [
    "We will show this by using a QRM-RF and directly connecting output $\\text{O}^{1}$ to input $\\text{I}^{1}$."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ad59b6a",
   "metadata": {
    "tags": []
   },
   "source": [
    "Setup\n",
    "-----\n",
    "\n",
    "First, we are going to import the required packages."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "28060ace",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:54:04.817276Z",
     "iopub.status.busy": "2025-05-07T16:54:04.817088Z",
     "iopub.status.idle": "2025-05-07T16:54:05.680297Z",
     "shell.execute_reply": "2025-05-07T16:54:05.678975Z"
    },
    "tags": [
     "imports"
    ]
   },
   "outputs": [],
   "source": [
    "from __future__ import annotations\n",
    "\n",
    "import json\n",
    "import math\n",
    "from typing import TYPE_CHECKING, Callable\n",
    "\n",
    "import matplotlib.pyplot as plt\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 Module"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c9efe075",
   "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://docs.qblox.com/en/main/api_reference/tools.html#api-pnp) for more info)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e76ee26",
   "metadata": {},
   "source": [
    "`!qblox-pnp list`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "631bc124",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:54:05.683573Z",
     "iopub.status.busy": "2025-05-07T16:54:05.683374Z",
     "iopub.status.idle": "2025-05-07T16:54:05.687008Z",
     "shell.execute_reply": "2025-05-07T16:54:05.686350Z"
    }
   },
   "outputs": [],
   "source": [
    "cluster_ip = \"10.10.200.42\"\n",
    "cluster_name = \"cluster0\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bdb82f49",
   "metadata": {},
   "source": [
    "### Connect to Cluster\n",
    "\n",
    "We now make a connection with the Cluster."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "8ee95bb7",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:54:05.688871Z",
     "iopub.status.busy": "2025-05-07T16:54:05.688553Z",
     "iopub.status.idle": "2025-05-07T16:54:06.601139Z",
     "shell.execute_reply": "2025-05-07T16:54:06.598760Z"
    },
    "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",
    "            10: ClusterType.CLUSTER_QTM,\n",
    "        }\n",
    "        if cluster_ip is None\n",
    "        else None\n",
    "    ),\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "491d0547",
   "metadata": {
    "lines_to_next_cell": 2
   },
   "source": [
    "#### Get connected modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "d563a592",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:54:06.606511Z",
     "iopub.status.busy": "2025-05-07T16:54:06.606247Z",
     "iopub.status.idle": "2025-05-07T16:54:06.612833Z",
     "shell.execute_reply": "2025-05-07T16:54:06.611925Z"
    }
   },
   "outputs": [],
   "source": [
    "def get_connected_modules(cluster: Cluster, filter_fn: Callable | None = None) -> dict[int, Module]:\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": 5,
   "id": "3e3637ef",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:54:06.615860Z",
     "iopub.status.busy": "2025-05-07T16:54:06.615697Z",
     "iopub.status.idle": "2025-05-07T16:54:06.635907Z",
     "shell.execute_reply": "2025-05-07T16:54:06.634949Z"
    },
    "tags": [
     "module_select"
    ]
   },
   "outputs": [],
   "source": [
    "# QRM-RF modules\n",
    "modules = get_connected_modules(cluster, lambda mod: mod.is_qrm_type and mod.is_rf_type)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "51aa2d99",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:54:06.639297Z",
     "iopub.status.busy": "2025-05-07T16:54:06.638720Z",
     "iopub.status.idle": "2025-05-07T16:54:06.642493Z",
     "shell.execute_reply": "2025-05-07T16:54:06.641555Z"
    }
   },
   "outputs": [],
   "source": [
    "# This uses the module of the correct type with the lowest slot index\n",
    "module = list(modules.values())[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b2227dbe",
   "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": 7,
   "id": "321064b3",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:54:06.646307Z",
     "iopub.status.busy": "2025-05-07T16:54:06.645539Z",
     "iopub.status.idle": "2025-05-07T16:54:09.211735Z",
     "shell.execute_reply": "2025-05-07T16:54:09.210005Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Status: OKAY, Flags: NONE, Slot flags: NONE\n"
     ]
    }
   ],
   "source": [
    "cluster.reset()\n",
    "print(cluster.get_system_status())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "24b6a457",
   "metadata": {},
   "source": [
    "Generate waveforms and weights<a id='gen_wf'></a>\n",
    "------------------------------\n",
    "\n",
    "Next, we need to create the waveforms used by the sequence for playback on the outputs as well as weights used by the sequence for weighed\n",
    "integrations. To keep it straightforward, we use the DC offset from the sequencers as our waveform and define waveform weights in the cell\n",
    "below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "07876ea2",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:54:09.216069Z",
     "iopub.status.busy": "2025-05-07T16:54:09.215664Z",
     "iopub.status.idle": "2025-05-07T16:54:09.226824Z",
     "shell.execute_reply": "2025-05-07T16:54:09.225519Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Waveform and weight parameters\n",
    "waveform_weight_length = 600  # nanoseconds\n",
    "\n",
    "# These will be used as weights in the \"Weighed acquisition\" section\n",
    "waveforms_weights = {\n",
    "    \"gaussian\": {\n",
    "        \"data\": scipy.signal.windows.gaussian(\n",
    "            waveform_weight_length, std=0.12 * waveform_weight_length\n",
    "        ).tolist(),\n",
    "        \"index\": 0,\n",
    "    },\n",
    "    \"sine\": {\n",
    "        \"data\": [\n",
    "            math.sin((2 * math.pi / waveform_weight_length) * i)\n",
    "            for i in range(0, waveform_weight_length)\n",
    "        ],\n",
    "        \"index\": 1,\n",
    "    },\n",
    "    \"block\": {\"data\": [1.0 for _ in range(0, waveform_weight_length)], \"index\": 2},\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc92d15a",
   "metadata": {},
   "source": [
    "Specify acquisitions\n",
    "--------------------\n",
    "\n",
    "We also need to specify the acquisitions so that the instrument can allocate the required memory for its acquisition list. In this case we will create 4 acquisition specifications that each create multiple bins."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "3a621fe3",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:54:09.230748Z",
     "iopub.status.busy": "2025-05-07T16:54:09.230327Z",
     "iopub.status.idle": "2025-05-07T16:54:09.237445Z",
     "shell.execute_reply": "2025-05-07T16:54:09.236159Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Acquisitions\n",
    "acquisitions = {\n",
    "    \"non_weighed\": {\"num_bins\": 10, \"index\": 0},\n",
    "    \"weighed\": {\"num_bins\": 10, \"index\": 1},\n",
    "    \"large\": {\"num_bins\": 131072, \"index\": 2},\n",
    "    \"avg\": {\"num_bins\": 10, \"index\": 3},\n",
    "    \"single\": {\"num_bins\": 1, \"index\": 4},\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "427f9c3e",
   "metadata": {},
   "source": [
    "Create Q1ASM program\n",
    "--------------------\n",
    "\n",
    "Now that we have the waveform and acquisition specifications for the sequence, we need a simple Q1ASM program that sequences the waveforms and triggers the acquisitions.\n",
    "In this case we will simply trigger 10 non-weighed acquisitions and store each acquisition in a separate bin."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "d598be21",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:54:09.241330Z",
     "iopub.status.busy": "2025-05-07T16:54:09.240933Z",
     "iopub.status.idle": "2025-05-07T16:54:09.247543Z",
     "shell.execute_reply": "2025-05-07T16:54:09.246243Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Sequence program.\n",
    "seq_prog = \"\"\"\n",
    "      move    0,R0        #Loop iterator.\n",
    "      nop\n",
    "\n",
    "loop: acquire 0,R0,1200   #Acquire bins and store them in \"non_weighed\" acquisition.\n",
    "      add     R0,1,R0     #Increment iterator\n",
    "      nop                 #Wait a cycle for R0 to be available.\n",
    "      jlt     R0,10,@loop #Run until number of iterations is done.\n",
    "\n",
    "      stop                #Stop.\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ca2582c",
   "metadata": {},
   "source": [
    "Upload sequence\n",
    "---------------\n",
    "\n",
    "Now that we have the waveform, weights and acquisition specifications and Q1ASM program, we can combine them in a sequence stored in a JSON file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "677cf193",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:54:09.251279Z",
     "iopub.status.busy": "2025-05-07T16:54:09.250886Z",
     "iopub.status.idle": "2025-05-07T16:54:09.267199Z",
     "shell.execute_reply": "2025-05-07T16:54:09.265960Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Add sequence program, waveforms, weights and acquisitions to single dictionary and write to JSON file.\n",
    "sequence = {\n",
    "    \"waveforms\": waveforms_weights,\n",
    "    \"weights\": waveforms_weights,\n",
    "    \"acquisitions\": 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": "9ceadaed",
   "metadata": {},
   "source": [
    "Let's write the JSON file to the instruments. We will use sequencer 0, which will drive outputs $\\text{O}^{[1-2]}$ and acquire on inputs $\\text{I}^{[1-2]}$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "64d59511",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:54:09.270917Z",
     "iopub.status.busy": "2025-05-07T16:54:09.270509Z",
     "iopub.status.idle": "2025-05-07T16:54:09.377019Z",
     "shell.execute_reply": "2025-05-07T16:54:09.375560Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Upload sequence.\n",
    "module.sequencer0.sequence(\"sequence.json\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d9f07514",
   "metadata": {},
   "source": [
    "Play sequence\n",
    "-------------\n",
    "\n",
    "The sequence has been uploaded to the instrument. Now we need to configure the sequencers. To keep it simple we will set a DC signal on the outputs of the instrument by enabling the sequencer offsets and disabling the modulation. These DC signals will then be acquired through the inputs. As such, we will also disable the demodulation on the input path. Furthermore, since we are running non-weighed integrations, we need to specify the integration length. This integration length will be used for every non-weighed integration moving forward. We will also put the integration result acquisition rotation to 0 degrees and acquisition threshold to 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "55dfc9ad",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:54:09.380973Z",
     "iopub.status.busy": "2025-05-07T16:54:09.380560Z",
     "iopub.status.idle": "2025-05-07T16:54:09.416541Z",
     "shell.execute_reply": "2025-05-07T16:54:09.415049Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Map sequencer to specific outputs (but first disable all sequencer connections)\n",
    "module.disconnect_outputs()\n",
    "module.disconnect_inputs()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "d2173b5f",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:54:09.420249Z",
     "iopub.status.busy": "2025-05-07T16:54:09.419850Z",
     "iopub.status.idle": "2025-05-07T16:54:09.436758Z",
     "shell.execute_reply": "2025-05-07T16:54:09.435459Z"
    },
    "tags": [
     "connect"
    ]
   },
   "outputs": [],
   "source": [
    "module.sequencer0.connect_sequencer(\"io0\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "6526d41e",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:54:09.440473Z",
     "iopub.status.busy": "2025-05-07T16:54:09.440062Z",
     "iopub.status.idle": "2025-05-07T16:54:09.507240Z",
     "shell.execute_reply": "2025-05-07T16:54:09.505817Z"
    }
   },
   "outputs": [],
   "source": [
    "# Configure scope mode\n",
    "module.scope_acq_sequencer_select(0)\n",
    "module.scope_acq_trigger_mode_path0(\"sequencer\")\n",
    "module.scope_acq_trigger_mode_path1(\"sequencer\")\n",
    "\n",
    "# Set AWG offsets\n",
    "module.sequencer0.offset_awg_path0(0.5)\n",
    "module.sequencer0.offset_awg_path1(0.5)\n",
    "\n",
    "# Configure integration\n",
    "module.sequencer0.integration_length_acq(1000)\n",
    "module.sequencer0.thresholded_acq_rotation(0)\n",
    "module.sequencer0.thresholded_acq_threshold(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "8f0efa70",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:54:09.511287Z",
     "iopub.status.busy": "2025-05-07T16:54:09.510890Z",
     "iopub.status.idle": "2025-05-07T16:54:09.534499Z",
     "shell.execute_reply": "2025-05-07T16:54:09.533216Z"
    },
    "tags": [
     "configure"
    ]
   },
   "outputs": [],
   "source": [
    "# Configure the sequencer\n",
    "module.sequencer0.mod_en_awg(True)\n",
    "module.sequencer0.demod_en_acq(True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "38e8edf7",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:54:09.538156Z",
     "iopub.status.busy": "2025-05-07T16:54:09.537762Z",
     "iopub.status.idle": "2025-05-07T16:54:09.560806Z",
     "shell.execute_reply": "2025-05-07T16:54:09.559508Z"
    },
    "tags": [
     "configure"
    ]
   },
   "outputs": [],
   "source": [
    "# Enable marker switches to toggle the RF switch before output port\n",
    "module.sequencer0.marker_ovr_en(True)\n",
    "module.sequencer0.marker_ovr_value(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "cf35172e",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:54:09.564665Z",
     "iopub.status.busy": "2025-05-07T16:54:09.564241Z",
     "iopub.status.idle": "2025-05-07T16:54:09.578307Z",
     "shell.execute_reply": "2025-05-07T16:54:09.577030Z"
    },
    "tags": [
     "configure"
    ]
   },
   "outputs": [],
   "source": [
    "# Set the NCO frequency\n",
    "module.sequencer0.nco_freq(50e6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "b2c4646a",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:54:09.581812Z",
     "iopub.status.busy": "2025-05-07T16:54:09.581416Z",
     "iopub.status.idle": "2025-05-07T16:54:09.602427Z",
     "shell.execute_reply": "2025-05-07T16:54:09.601135Z"
    },
    "tags": [
     "configure"
    ]
   },
   "outputs": [],
   "source": [
    "# Set the LO frequency. If this is commented out, the value is set to the default value\n",
    "module.out0_in0_lo_freq(3e9)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06cf1ab5",
   "metadata": {},
   "source": [
    "Now let's start the sequence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "32824a45",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:54:09.606065Z",
     "iopub.status.busy": "2025-05-07T16:54:09.605673Z",
     "iopub.status.idle": "2025-05-07T16:54:09.620738Z",
     "shell.execute_reply": "2025-05-07T16:54:09.619367Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Status: OKAY, State: STOPPED, Info Flags: ACQ_SCOPE_DONE_PATH_0, ACQ_SCOPE_DONE_PATH_1, ACQ_BINNING_DONE, Warning Flags: NONE, Error Flags: NONE, Log: []\n"
     ]
    }
   ],
   "source": [
    "# Arm and start sequencer.\n",
    "module.arm_sequencer(0)\n",
    "module.start_sequencer()\n",
    "\n",
    "# Print status of sequencer.\n",
    "print(module.get_sequencer_status(0))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3efc60f0",
   "metadata": {},
   "source": [
    "Retrieve acquisition\n",
    "--------------------\n",
    "\n",
    "Next, we will have a quick look at the input signal so that we can compare it to the integration results. Since we are integrating over a DC signal we are expecting the integration results to be roughly equal to the average DC value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "406c6427",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:54:09.624449Z",
     "iopub.status.busy": "2025-05-07T16:54:09.624025Z",
     "iopub.status.idle": "2025-05-07T16:54:10.603606Z",
     "shell.execute_reply": "2025-05-07T16:54:10.602607Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x621 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Wait for the sequencer to stop with a timeout period of one minute.\n",
    "module.get_acquisition_status(0)\n",
    "\n",
    "# Move acquisition data from temporary memory to acquisition list.\n",
    "module.store_scope_acquisition(0, \"non_weighed\")\n",
    "\n",
    "# Get acquisition list from instrument.\n",
    "non_weighed_acq = module.get_acquisitions(0)[\"non_weighed\"]\n",
    "\n",
    "# Plot acquired signal on both inputs.\n",
    "fig, ax = plt.subplots(1, 1)\n",
    "ax.plot(non_weighed_acq[\"acquisition\"][\"scope\"][\"path0\"][\"data\"][0:1000])\n",
    "ax.plot(non_weighed_acq[\"acquisition\"][\"scope\"][\"path1\"][\"data\"][0:1000])\n",
    "ax.set_xlabel(\"Time (ns)\")\n",
    "ax.set_ylabel(\"Relative amplitude\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a0ad5290",
   "metadata": {},
   "source": [
    "To check if the integration results match what we expect, we need to divide the integration results by the integration length which was set through the\n",
    "corresponding QCoDeS parameter. Note that the 'valid' key of the dictionary indicates if the bin was actually set during the sequence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "b32b15c8",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:54:10.607885Z",
     "iopub.status.busy": "2025-05-07T16:54:10.607614Z",
     "iopub.status.idle": "2025-05-07T16:54:10.618414Z",
     "shell.execute_reply": "2025-05-07T16:54:10.617593Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'integration': {'path0': [-0.23303468490473864,\n",
       "   -0.2292496336101612,\n",
       "   -0.22956912554958475,\n",
       "   -0.23086907669760626,\n",
       "   -0.23257547630679043,\n",
       "   -0.23472056668295066,\n",
       "   -0.23812310698583292,\n",
       "   -0.24270346849047386,\n",
       "   -0.24432877381533952,\n",
       "   -0.24323546653639472],\n",
       "  'path1': [-0.6740981924767954,\n",
       "   -0.6753913043478261,\n",
       "   -0.6753180263800684,\n",
       "   -0.6748627259404005,\n",
       "   -0.6744049829018075,\n",
       "   -0.6735466536394724,\n",
       "   -0.6725437225207621,\n",
       "   -0.6709755740107475,\n",
       "   -0.6705559355153884,\n",
       "   -0.6708143624816805]},\n",
       " 'threshold': [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],\n",
       " 'avg_cnt': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]}"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int_len = module.sequencer0.integration_length_acq()\n",
    "bins = non_weighed_acq[\"acquisition\"][\"bins\"]\n",
    "bins[\"integration\"][\"path0\"] = [(val / int_len) for val in bins[\"integration\"][\"path0\"]]\n",
    "bins[\"integration\"][\"path1\"] = [(val / int_len) for val in bins[\"integration\"][\"path1\"]]\n",
    "bins"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bfd3c7a6",
   "metadata": {},
   "source": [
    "Weighed acquisition\n",
    "-------------------\n",
    "\n",
    "In the following, we look into weighed integrations. This refers to integration with a weighting given by a particular weight that we specified earlier. This is equivalent to multiplying the acquired trace with a function (which specifies the weighting) and integrating the result.\n",
    "\n",
    "To do this, we will need to modify the sequence program slightly and reupload it. We will be using a gaussian weight to integrate over input path 0 and a sine weight to integrate over input path 1. The integration length of a weighed integration is determined by the weight length."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "354691df",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:54:10.621461Z",
     "iopub.status.busy": "2025-05-07T16:54:10.621173Z",
     "iopub.status.idle": "2025-05-07T16:54:10.624602Z",
     "shell.execute_reply": "2025-05-07T16:54:10.623770Z"
    }
   },
   "outputs": [],
   "source": [
    "# Sequence program.\n",
    "seq_prog = \"\"\"\n",
    "      move            0,R0            #Loop iterator.\n",
    "      move            0,R1            #Weight for path 0.\n",
    "      move            1,R2            #Weight for path 1.\n",
    "      nop\n",
    "\n",
    "loop: acquire_weighed 1,R0,R1,R2,1200 #Acquire bins and store them in \"weighed\" acquisition.\n",
    "      add             R0,1,R0         #Increment iterator\n",
    "      nop                             #Wait a cycle for R0 to be available.\n",
    "      jlt             R0,10,@loop     #Run until number of iterations is done.\n",
    "\n",
    "      stop                            #Stop.\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "4ae2a672",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:54:10.627511Z",
     "iopub.status.busy": "2025-05-07T16:54:10.627203Z",
     "iopub.status.idle": "2025-05-07T16:54:10.648650Z",
     "shell.execute_reply": "2025-05-07T16:54:10.647666Z"
    }
   },
   "outputs": [],
   "source": [
    "# Add sequence program, waveforms, weights and acquisitions to single dictionary and write to JSON file.\n",
    "sequence = {\n",
    "    \"waveforms\": waveforms_weights,\n",
    "    \"weights\": waveforms_weights,\n",
    "    \"acquisitions\": 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": "code",
   "execution_count": 25,
   "id": "c07d4a2e",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:54:10.652066Z",
     "iopub.status.busy": "2025-05-07T16:54:10.651435Z",
     "iopub.status.idle": "2025-05-07T16:54:10.751590Z",
     "shell.execute_reply": "2025-05-07T16:54:10.750334Z"
    }
   },
   "outputs": [],
   "source": [
    "# Upload sequence.\n",
    "module.sequencer0.sequence(\"sequence.json\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "232341ec",
   "metadata": {},
   "source": [
    "Let's start the sequence and retrieve the results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "8caa7f24",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:54:10.755290Z",
     "iopub.status.busy": "2025-05-07T16:54:10.754893Z",
     "iopub.status.idle": "2025-05-07T16:54:10.769344Z",
     "shell.execute_reply": "2025-05-07T16:54:10.768068Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Status: OKAY, State: STOPPED, Info Flags: ACQ_SCOPE_DONE_PATH_0, ACQ_SCOPE_DONE_PATH_1, ACQ_BINNING_DONE, Warning Flags: NONE, Error Flags: NONE, Log: []\n"
     ]
    }
   ],
   "source": [
    "# Arm and start sequencer.\n",
    "module.arm_sequencer(0)  # Arm sequencer 0\n",
    "module.start_sequencer()  # Start all armed sequencers\n",
    "\n",
    "# Print status of sequencer.\n",
    "print(module.get_sequencer_status(0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "c9b5570f",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:54:10.772806Z",
     "iopub.status.busy": "2025-05-07T16:54:10.772385Z",
     "iopub.status.idle": "2025-05-07T16:54:11.424023Z",
     "shell.execute_reply": "2025-05-07T16:54:11.422469Z"
    }
   },
   "outputs": [],
   "source": [
    "# Wait for the sequencer to stop with a timeout period of one minute.\n",
    "module.get_acquisition_status(0)\n",
    "\n",
    "# Get acquisition list from instrument.\n",
    "weighed_acq = module.get_acquisitions(0)[\"weighed\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f634a33c",
   "metadata": {},
   "source": [
    "To check if the integration results match what we expect we need to divide the integration results by the integration length again. In this case the integration\n",
    "length is determined by the length of the weights."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "e4b92ab0",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:54:11.428254Z",
     "iopub.status.busy": "2025-05-07T16:54:11.427940Z",
     "iopub.status.idle": "2025-05-07T16:54:11.437499Z",
     "shell.execute_reply": "2025-05-07T16:54:11.436357Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'integration': {'path0': [-0.07078796904879923,\n",
       "   -0.06890235467172799,\n",
       "   -0.0685163894370583,\n",
       "   -0.06884903990866963,\n",
       "   -0.06925130067100074,\n",
       "   -0.06987118979824952,\n",
       "   -0.07068035150513972,\n",
       "   -0.07185035758359547,\n",
       "   -0.07307910019126333,\n",
       "   -0.07313106816390305],\n",
       "  'path1': [0.0002176092727912458,\n",
       "   0.00023122752747337105,\n",
       "   0.00018951441324287167,\n",
       "   0.00011634145218054755,\n",
       "   0.00011595245010451745,\n",
       "   6.778937916143722e-05,\n",
       "   4.744313867558078e-05,\n",
       "   8.0509906148675e-05,\n",
       "   3.318410450011761e-05,\n",
       "   9.886499694883954e-05]},\n",
       " 'threshold': [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],\n",
       " 'avg_cnt': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]}"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int_len = waveform_weight_length\n",
    "bins = weighed_acq[\"acquisition\"][\"bins\"]\n",
    "bins[\"integration\"][\"path0\"] = [(val / int_len) for val in bins[\"integration\"][\"path0\"]]\n",
    "bins[\"integration\"][\"path1\"] = [(val / int_len) for val in bins[\"integration\"][\"path1\"]]\n",
    "bins"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "79630ff4",
   "metadata": {
    "lines_to_next_cell": 2
   },
   "source": [
    "Large number of bins\n",
    "--------------------\n",
    "The QRM supports up to 131072 bins. To show that, we need to change the program slightly. We will use the non-weighed acquisition program,\n",
    "however, we will now loop over the maximum number of acquisitions while storing each result in a separate bin."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "12b791be",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:54:11.441017Z",
     "iopub.status.busy": "2025-05-07T16:54:11.440721Z",
     "iopub.status.idle": "2025-05-07T16:54:11.445727Z",
     "shell.execute_reply": "2025-05-07T16:54:11.444459Z"
    }
   },
   "outputs": [],
   "source": [
    "# Sequence program.\n",
    "seq_prog = \"\"\"\n",
    "      move    0,R0            #Loop iterator.\n",
    "      nop\n",
    "\n",
    "loop: acquire 2,R0,1200       #Acquire bins and store them in \"large\" acquisition.\n",
    "      add     R0,1,R0         #Increment iterator\n",
    "      nop                     #Wait a cycle for R0 to be available.\n",
    "      jlt     R0,131072,@loop #Run until number of iterations is done.\n",
    "\n",
    "      stop                    #Stop.\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "3fee988c",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:54:11.449545Z",
     "iopub.status.busy": "2025-05-07T16:54:11.449124Z",
     "iopub.status.idle": "2025-05-07T16:54:11.465433Z",
     "shell.execute_reply": "2025-05-07T16:54:11.464143Z"
    }
   },
   "outputs": [],
   "source": [
    "# Add sequence program, waveforms, weights and acquisitions to single dictionary and write to JSON file.\n",
    "sequence = {\n",
    "    \"waveforms\": waveforms_weights,\n",
    "    \"weights\": waveforms_weights,\n",
    "    \"acquisitions\": 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": "code",
   "execution_count": 31,
   "id": "b822611e",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:54:11.469019Z",
     "iopub.status.busy": "2025-05-07T16:54:11.468617Z",
     "iopub.status.idle": "2025-05-07T16:54:11.573406Z",
     "shell.execute_reply": "2025-05-07T16:54:11.571965Z"
    }
   },
   "outputs": [],
   "source": [
    "# Upload sequence.\n",
    "module.sequencer0.sequence(\"sequence.json\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7755537e",
   "metadata": {},
   "source": [
    "Let's start the sequence and retrieve the results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "0b3a5de1",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:54:11.577276Z",
     "iopub.status.busy": "2025-05-07T16:54:11.576875Z",
     "iopub.status.idle": "2025-05-07T16:54:11.591349Z",
     "shell.execute_reply": "2025-05-07T16:54:11.590011Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Status: OKAY, State: RUNNING, Info Flags: NONE, Warning Flags: NONE, Error Flags: NONE, Log: []\n"
     ]
    }
   ],
   "source": [
    "# Arm and start sequencer.\n",
    "module.arm_sequencer(0)\n",
    "module.start_sequencer()\n",
    "\n",
    "# Print status of sequencer.\n",
    "print(module.get_sequencer_status(0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "181cba84",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:54:11.595213Z",
     "iopub.status.busy": "2025-05-07T16:54:11.594808Z",
     "iopub.status.idle": "2025-05-07T16:54:12.406907Z",
     "shell.execute_reply": "2025-05-07T16:54:12.405522Z"
    }
   },
   "outputs": [],
   "source": [
    "# Wait for the sequencer to stop with a timeout period of one minute.\n",
    "module.get_acquisition_status(0, timeout=1)\n",
    "\n",
    "# Get acquisition list from instrument.\n",
    "large_acq = module.get_acquisitions(0)[\"large\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b460b75d",
   "metadata": {},
   "source": [
    "Since the number of bins is now too large to simply print, we will check the number of bins and we will check the bins for NaN values which indicate that a bin is not written."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "9a0bf396",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:54:12.410744Z",
     "iopub.status.busy": "2025-05-07T16:54:12.410356Z",
     "iopub.status.idle": "2025-05-07T16:54:12.436029Z",
     "shell.execute_reply": "2025-05-07T16:54:12.434961Z"
    },
    "lines_to_next_cell": 0
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of bins: 131072\n"
     ]
    }
   ],
   "source": [
    "int_len = module.sequencer0.integration_length_acq()\n",
    "bins = large_acq[\"acquisition\"][\"bins\"]\n",
    "bins[\"integration\"][\"path0\"] = [(val / int_len) for val in bins[\"integration\"][\"path0\"]]\n",
    "bins[\"integration\"][\"path1\"] = [(val / int_len) for val in bins[\"integration\"][\"path1\"]]\n",
    "\n",
    "print(\"Number of bins: {}\".format(len(bins[\"avg_cnt\"])))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a380d4cb",
   "metadata": {},
   "source": [
    "We will also plot the integration results in every bin to visualize the contents."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "8c2e4eeb",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:54:12.439319Z",
     "iopub.status.busy": "2025-05-07T16:54:12.439151Z",
     "iopub.status.idle": "2025-05-07T16:54:12.590205Z",
     "shell.execute_reply": "2025-05-07T16:54:12.588926Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x621 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot bins\n",
    "fig, ax = plt.subplots(1, 1)\n",
    "ax.plot(bins[\"integration\"][\"path0\"])\n",
    "ax.plot(bins[\"integration\"][\"path1\"])\n",
    "ax.set_xlabel(\"Bin index\")\n",
    "ax.set_ylabel(\"Relative amplitude\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "11817f13",
   "metadata": {},
   "source": [
    "Averaging\n",
    "--------------------\n",
    "\n",
    "As you may have noticed, the acquisition results also contain an average counter. This average counter reflects the number of times a bin has been averaged during the sequence.\n",
    "Each time the sequencer writes to the same bin the results are automatically accumulated and the average counter is increased. Upon retrieval of the acquisition results, each\n",
    "result is divided by the average counter and therefore automatically averaged. To show this we will change the sequence one last time. This time we will average 10 bins a 1000\n",
    "times each."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "857755fa",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:54:12.594035Z",
     "iopub.status.busy": "2025-05-07T16:54:12.593751Z",
     "iopub.status.idle": "2025-05-07T16:54:12.598107Z",
     "shell.execute_reply": "2025-05-07T16:54:12.597176Z"
    }
   },
   "outputs": [],
   "source": [
    "# Sequence program.\n",
    "seq_prog = \"\"\"\n",
    "      move    0,R1         #Average iterator.\n",
    "\n",
    "avg:  move    0,R0         #Bin iterator.\n",
    "      nop\n",
    "\n",
    "loop: acquire 3,R0,1200    #Acquire bins and store them in \"avg\" acquisition.\n",
    "      add     R0,1,R0      #Increment bin iterator\n",
    "      nop                  #Wait a cycle for R0 to be available.\n",
    "      jlt     R0,10,@loop  #Run until number of avg iterations is done.\n",
    "      add     R1,1,R1      #Increment avg iterator\n",
    "      nop                  #Wait a cycle for R1 to be available.\n",
    "      jlt     R1,1000,@avg #Run until number of average iterations is done.\n",
    "\n",
    "      stop                 #Stop.\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "347513c4",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:54:12.601092Z",
     "iopub.status.busy": "2025-05-07T16:54:12.600927Z",
     "iopub.status.idle": "2025-05-07T16:54:12.608998Z",
     "shell.execute_reply": "2025-05-07T16:54:12.608020Z"
    }
   },
   "outputs": [],
   "source": [
    "# Add sequence program, waveforms, weights and acquisitions to single dictionary and write to JSON file.\n",
    "sequence = {\n",
    "    \"waveforms\": waveforms_weights,\n",
    "    \"weights\": waveforms_weights,\n",
    "    \"acquisitions\": 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": "code",
   "execution_count": 38,
   "id": "6a3e7ee7",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:54:12.611918Z",
     "iopub.status.busy": "2025-05-07T16:54:12.611748Z",
     "iopub.status.idle": "2025-05-07T16:54:12.714758Z",
     "shell.execute_reply": "2025-05-07T16:54:12.713278Z"
    }
   },
   "outputs": [],
   "source": [
    "# Upload sequence.\n",
    "module.sequencer0.sequence(\"sequence.json\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e4837d8",
   "metadata": {},
   "source": [
    "Let's start the sequence and retrieve the results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "3b0b37a1",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:54:12.718959Z",
     "iopub.status.busy": "2025-05-07T16:54:12.718547Z",
     "iopub.status.idle": "2025-05-07T16:54:12.733103Z",
     "shell.execute_reply": "2025-05-07T16:54:12.731751Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Status: OKAY, State: RUNNING, Info Flags: NONE, Warning Flags: NONE, Error Flags: NONE, Log: []\n"
     ]
    }
   ],
   "source": [
    "# Arm and start sequencer.\n",
    "module.arm_sequencer(0)\n",
    "module.start_sequencer()\n",
    "\n",
    "# Print status of sequencer.\n",
    "print(module.get_sequencer_status(0))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7335f9b3",
   "metadata": {},
   "source": [
    "Note that the average count of each bin is now set to a 1000."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "eb518b43",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:54:12.736970Z",
     "iopub.status.busy": "2025-05-07T16:54:12.736569Z",
     "iopub.status.idle": "2025-05-07T16:54:13.376179Z",
     "shell.execute_reply": "2025-05-07T16:54:13.374783Z"
    }
   },
   "outputs": [],
   "source": [
    "# Wait for the sequencer to stop with a timeout period of one minute.\n",
    "module.get_acquisition_status(0)\n",
    "\n",
    "# Get acquisition list from instrument.\n",
    "avg_acq = module.get_acquisitions(0)[\"avg\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "57963b3f",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:54:13.379765Z",
     "iopub.status.busy": "2025-05-07T16:54:13.379583Z",
     "iopub.status.idle": "2025-05-07T16:54:13.390416Z",
     "shell.execute_reply": "2025-05-07T16:54:13.389490Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'integration': {'path0': [-0.23539754274548122,\n",
       "   -0.2354085828041036,\n",
       "   -0.23541402051783097,\n",
       "   -0.23541453395212505,\n",
       "   -0.23540825744992674,\n",
       "   -0.23539694235466538,\n",
       "   -0.23538743966780654,\n",
       "   -0.23537577479237912,\n",
       "   -0.2353713014167074,\n",
       "   -0.23537441035661946],\n",
       "  'path1': [-0.6721376062530533,\n",
       "   -0.672133670737665,\n",
       "   -0.6721302686858818,\n",
       "   -0.6721297435271129,\n",
       "   -0.6721308368343919,\n",
       "   -0.6721340830483634,\n",
       "   -0.6721392589154861,\n",
       "   -0.6721426370297997,\n",
       "   -0.672143713727406,\n",
       "   -0.6721383009281876]},\n",
       " 'threshold': [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],\n",
       " 'avg_cnt': [1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000]}"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int_len = module.sequencer0.integration_length_acq()\n",
    "bins = avg_acq[\"acquisition\"][\"bins\"]\n",
    "bins[\"integration\"][\"path0\"] = [(val / int_len) for val in bins[\"integration\"][\"path0\"]]\n",
    "bins[\"integration\"][\"path1\"] = [(val / int_len) for val in bins[\"integration\"][\"path1\"]]\n",
    "bins"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dbe9cee6",
   "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": 42,
   "id": "0ed29b5e",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:54:13.393443Z",
     "iopub.status.busy": "2025-05-07T16:54:13.393265Z",
     "iopub.status.idle": "2025-05-07T16:54:19.271129Z",
     "shell.execute_reply": "2025-05-07T16:54:19.269049Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Status: OKAY, State: STOPPED, Info Flags: FORCED_STOP, ACQ_SCOPE_DONE_PATH_0, ACQ_SCOPE_DONE_PATH_1, ACQ_BINNING_DONE, Warning Flags: NONE, Error Flags: NONE, Log: []\n",
      "Status: OKAY, State: STOPPED, Info Flags: FORCED_STOP, Warning Flags: NONE, Error Flags: NONE, Log: []\n",
      "\n",
      "Snapshot:\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cluster0_module8:\n",
      "\tparameter                        value\n",
      "--------------------------------------------------------------------------------\n",
      "connected                         :\tTrue \n",
      "in0_att                           :\t0 (dB)\n",
      "in0_offset_path0                  :\t0 (V)\n",
      "in0_offset_path1                  :\t0 (V)\n",
      "marker0_exp0_config               :\tbypassed \n",
      "marker0_exp1_config               :\tbypassed \n",
      "marker0_exp2_config               :\tbypassed \n",
      "marker0_exp3_config               :\tbypassed \n",
      "marker0_fir_config                :\tbypassed \n",
      "marker0_inv_en                    :\tFalse \n",
      "marker1_exp0_config               :\tbypassed \n",
      "marker1_exp1_config               :\tbypassed \n",
      "marker1_exp2_config               :\tbypassed \n",
      "marker1_exp3_config               :\tbypassed \n",
      "marker1_fir_config                :\tbypassed \n",
      "marker1_inv_en                    :\tFalse \n",
      "marker2_exp0_config               :\tbypassed \n",
      "marker2_exp1_config               :\tbypassed \n",
      "marker2_exp2_config               :\tbypassed \n",
      "marker2_exp3_config               :\tbypassed \n",
      "marker2_fir_config                :\tbypassed \n",
      "marker3_exp0_config               :\tbypassed \n",
      "marker3_exp1_config               :\tbypassed \n",
      "marker3_exp2_config               :\tbypassed \n",
      "marker3_exp3_config               :\tbypassed \n",
      "marker3_fir_config                :\tbypassed \n",
      "out0_att                          :\t0 (dB)\n",
      "out0_exp0_config                  :\tbypassed \n",
      "out0_exp1_config                  :\tbypassed \n",
      "out0_exp2_config                  :\tbypassed \n",
      "out0_exp3_config                  :\tbypassed \n",
      "out0_fir_config                   :\tbypassed \n",
      "out0_in0_lo_en                    :\tTrue \n",
      "out0_in0_lo_freq                  :\t3000000000 (Hz)\n",
      "out0_in0_lo_freq_cal_type_default :\toff (Hz)\n",
      "out0_latency                      :\t0 (s)\n",
      "out0_offset_path0                 :\t7.625 (mV)\n",
      "out0_offset_path1                 :\t7.625 (mV)\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_module8_sequencer0:\n",
      "\tparameter                       value\n",
      "--------------------------------------------------------------------------------\n",
      "connect_acq                      :\tin0 \n",
      "connect_out0                     :\tIQ \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                     :\tTrue \n",
      "gain_awg_path0                   :\t1 \n",
      "gain_awg_path1                   :\t1 \n",
      "integration_length_acq           :\t1000 \n",
      "marker_ovr_en                    :\tTrue \n",
      "marker_ovr_value                 :\t3 \n",
      "mixer_corr_gain_ratio            :\t1 \n",
      "mixer_corr_phase_offset_degree   :\t-0 \n",
      "mod_en_awg                       :\tTrue \n",
      "nco_freq                         :\t5e+07 (Hz)\n",
      "nco_freq_cal_type_default        :\toff (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.49998 \n",
      "offset_awg_path1                 :\t0.49998 \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",
      "upsample_rate_awg_path0          :\t0 \n",
      "upsample_rate_awg_path1          :\t0 \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cluster0_module8_sequencer1:\n",
      "\tparameter                       value\n",
      "--------------------------------------------------------------------------------\n",
      "connect_acq                      :\toff \n",
      "connect_out0                     :\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_freq_cal_type_default        :\toff (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",
      "upsample_rate_awg_path0          :\t0 \n",
      "upsample_rate_awg_path1          :\t0 \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cluster0_module8_sequencer2:\n",
      "\tparameter                       value\n",
      "--------------------------------------------------------------------------------\n",
      "connect_acq                      :\toff \n",
      "connect_out0                     :\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_freq_cal_type_default        :\toff (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",
      "upsample_rate_awg_path0          :\t0 \n",
      "upsample_rate_awg_path1          :\t0 \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cluster0_module8_sequencer3:\n",
      "\tparameter                       value\n",
      "--------------------------------------------------------------------------------\n",
      "connect_acq                      :\toff \n",
      "connect_out0                     :\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_freq_cal_type_default        :\toff (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",
      "upsample_rate_awg_path0          :\t0 \n",
      "upsample_rate_awg_path1          :\t0 \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cluster0_module8_sequencer4:\n",
      "\tparameter                       value\n",
      "--------------------------------------------------------------------------------\n",
      "connect_acq                      :\toff \n",
      "connect_out0                     :\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_freq_cal_type_default        :\toff (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",
      "upsample_rate_awg_path0          :\t0 \n",
      "upsample_rate_awg_path1          :\t0 \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cluster0_module8_sequencer5:\n",
      "\tparameter                       value\n",
      "--------------------------------------------------------------------------------\n",
      "connect_acq                      :\toff \n",
      "connect_out0                     :\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_freq_cal_type_default        :\toff (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",
      "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_status(0))\n",
    "print(module.get_sequencer_status(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_status())"
   ]
  }
 ],
 "metadata": {
  "jupytext": {
   "cell_metadata_filter": "all",
   "notebook_metadata_filter": "files_to_bundle_in_zip_file,is_demo,execute"
  },
  "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.9.20"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}