Sharing Measurement Results with LINQ-based Feedback#

In this tutorial, we demonstrate LINQ-based feedback of data from the demodulation path of a readout sequencer, which allows sequencers to exchange acquisition data with low latency.

We cover two data types in this tutorial:

I/Q Data — The (weighted) integrated result triggered by the acquire or acquire_weighted Q1ASM instruction.
Thresholded Bits (TB) — a single bit indicating whether the I/Q value exceeded a threshold line in the I/Q plane.

More information can be found in the LINQ-based feedback documentation.

Key Commands:

Command	Purpose
`fb_acq_tb_id <ID>, <duration>`	Share thresholded bits under `<ID>` after every acquisition
`fb_acq_iq_id <ID>, <duration>`	Share I/Q data under `<ID>` after every acquisition
`fb_pop_data <ID>, <dest>`	Pop the next payload matching `<ID>` into register `<dest>`
`fb_pull_data <id_dest>, <dest>`	Pop the top FIFO entry; store its ID and payload separately

ID ranges:

0: disable sending
1–15: self-cast (same sequencer)
16–255: intra-cast / multi-cast (other sequencers on same or different modules)

Hardware Requirements:

A Qblox Cluster with one QRM connected in loopback (Output 1 → Input 1).

Setup#

First, we import the required packages and connect to the instrument.

[1]:

import numpy as np  # noqa: I001
from IPython.display import Markdown, display
from __future__ import annotations

from qcodes.instrument import find_or_create_instrument

from qblox_instruments import Cluster, ClusterType

Scan For Clusters#

We scan for the available devices connected via ethernet using the Plug & Play functionality of the Qblox Instruments package (see Plug & Play for more info).

!qblox-pnp list

[2]:

cluster_ip = "10.10.200.42"
cluster_name = "cluster0"

Connect to Cluster#

We now make a connection with the Cluster.

[3]:

cluster: Cluster = find_or_create_instrument(
    Cluster,
    recreate=True,
    name=cluster_name,
    identifier=cluster_ip,
    dummy_cfg=(
        {
            2: ClusterType.CLUSTER_QCM,
            4: ClusterType.CLUSTER_QRM,
            6: ClusterType.CLUSTER_QCM_RF,
            8: ClusterType.CLUSTER_QRM_RF,
            10: ClusterType.CLUSTER_QTM,
            12: ClusterType.CLUSTER_QRC,
            16: ClusterType.CLUSTER_QSM,
        }
        if cluster_ip is None
        else None
    ),
)

cluster.reset()
print(cluster.get_system_status())

Status: OKAY, Flags: NONE, Slot flags: NONE

Get connected modules#

[4]:

# QRM baseband modules
modules = cluster.get_connected_modules(lambda mod: mod.is_qrm_type and not mod.is_rf_type)
# This uses the module of the correct type with the lowest slot index
module = list(modules.values())[0]

[5]:

module.disconnect_outputs()
module.disconnect_inputs()
module.sequencer0.nco_prop_delay_comp_en(True)

module.sequencer0.mod_en_awg(True)
module.sequencer0.demod_en_acq(True)

module.sequencer0.connect_sequencer("io0_1")

Calibrating time of flight#

The time of flight (TOF) is the delay between a play command being executed and the pulse arriving at its input.

We measure it by playing a pulse and capturing the input with the scope mode. The index of the first scope sample that exceeds half the peak amplitude gives the arrival time.

[6]:

module.sequencer0.sequence(
    {
        "waveforms": {},
        "program": """
            set_awg_offs 15000, 0    # start pulse
            acquire      0, 0, 16384 # non-blocking: scope runs while pulse is on
            set_awg_offs 0, 0
            upd_param    4           # mandatory 4 ns update cycle
            stop
        """,
        "acquisitions": {"single": {"index": 0, "num_bins": 1}},
        "weights": {},
    }
)
module.sequencer0.arm_sequencer()
module.start_sequencer()

module.store_scope_acquisition(0, "single")

if cluster_ip is None:
    TIME_OF_FLIGHT = 300
else:
    scope_data = np.array(
        module.get_acquisitions(0)["single"]["acquisition"]["scope"]["path0"]["data"]
    )
    peak = np.max(scope_data)
    TIME_OF_FLIGHT = int(np.where(np.abs(scope_data) > peak / 2)[0][0])
    print(f"TOF: {TIME_OF_FLIGHT} ns")

TOF: 152 ns

Calibrating the threshold#

Cable length, LO frequency, and NCO frequency rotate the integrated IQ result away from the real axis, shifting the classifier boundary. Without correcting for this rotation the hardware cannot threshold reliably.

The calibration plays a pulse of PULSE_LENGTH nanoseconds, waits TIME_OF_FLIGHT for the pulse to arrive at the input, then integrates for PULSE_LENGTH nanoseconds. The angle of the resulting IQ vector gives the rotation; the threshold is placed at half the aligned amplitude, midway between the no-pulse and full-pulse responses.

[7]:

PULSE_LENGTH = 20

module.sequencer0.sequence(
    {
        "waveforms": {},
        "program": f"""
            set_awg_offs 15000, 0
            upd_param    {PULSE_LENGTH}                      # hold pulse for integration window
            set_awg_offs 0, 0
            upd_param    {TIME_OF_FLIGHT - PULSE_LENGTH - 4} # wait for signal arrival; -4 for preceding upd_param
            acquire      0, 0, {PULSE_LENGTH}                # integrate over pulse duration
            stop
        """,
        "acquisitions": {"single": {"index": 0, "num_bins": 1}},
        "weights": {},
    }
)
module.sequencer0.integration_length_acq(PULSE_LENGTH)
module.sequencer0.arm_sequencer()
module.start_sequencer()

if cluster_ip is not None:
    acq = module.sequencer0.get_acquisitions()["single"]["acquisition"]["bins"]["integration"]
    iq = acq["path0"][0] + 1j * acq["path1"][0]
    rotation = np.mod(-np.angle(iq), 2 * np.pi)  # counter-rotation to align IQ to real axis
    threshold = (
        np.exp(1j * rotation) * iq
    ).real / 2  # midpoint between 0-response and full-pulse response
    module.sequencer0.thresholded_acq_threshold(threshold)
    module.sequencer0.thresholded_acq_rotation(np.degrees(rotation))  # API expects degrees
    print(
        f"{module.sequencer0.name}: rotation={np.degrees(rotation):.2f}°, threshold={threshold:.4f}"
    )

cluster0_module4_sequencer0: rotation=352.73°, threshold=1.7865

Experiment parameters#

[8]:

ID = 16

What do these values mean?#

The LINQ I/Q payload is a 32-bit signed integer encoding the same measurement as the hardware integration path. For an integration-path value \(v\) returned by get_acquisitions, the LINQ register value satisfies:

\[v_\text{LINQ} = \left\lfloor v \cdot 2^{22} \right\rfloor\]

To recover the integration-path value from a LINQ register, apply the inverse:

\[v \approx \frac{v_\text{LINQ}}{2^{22}}\]

The table below applies both directions using the register values from the I/Q run above. The \(\div 2^{22}\) column converts the raw LINQ integer to an integration-path float; the \(\times 2^{22}\) column converts the get_acquisitions float back to a LINQ integer. All four columns should be consistent.

[22]:

_acq = module.sequencer0.get_acquisitions()["single"]["acquisition"]["bins"]["integration"]
intg_i, intg_q = _acq["path0"][0], _acq["path1"][0]


def to_norm(v: int) -> float:
    """Convert raw LINQ integer to integration-path float."""
    return v / 2**22


def to_linq(v: float) -> int:
    """Convert integration-path float to raw LINQ integer."""
    return int(v * 2**22) if not np.isnan(v) else 0


rows = [("I", linq_val_i, intg_i), ("Q", linq_val_q, intg_q)]
table = "| | raw LINQ | $\\div 2^{22}$ | get\\_acq | $\\times 2^{22}$ |\n"
table += "|---|---:|---:|---:|---:|\n"
for name, linq, intg in rows:
    table += f"| {name} | {linq} | {to_norm(linq):.5f} | {intg:.5f} | {to_linq(intg)} |\n"
display(Markdown(table))

print(
    "PASS"
    if to_linq(intg_i) == linq_val_i and to_linq(intg_q) == linq_val_q
    else "FAIL - check acquisition and LINQ configuration"
)

	raw LINQ	\(\div 2^{22}\)	get_acq	\(\times 2^{22}\)
I	9236064	2.20205	2.20205	9236064
Q	1901663	0.45339	0.45339	1901663

PASS

Stop#

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 closing the connection by uncommenting the corresponding lines.

[23]:

# Stop all sequencers.
module.stop_sequencer()

# Print status of sequencers 0 and 1 (should now say it is stopped).
print(module.get_sequencer_status(0))
print(module.get_sequencer_status(1))
print()

Status: OKAY, State: STOPPED, Exit Code: 0, Info Flags: FORCED_STOP, ACQ_SCOPE_DONE_PATH_0, ACQ_SCOPE_DONE_PATH_1, ACQ_BINNING_DONE, Warning Flags: NONE, Error Flags: NONE, Log: []
Status: OKAY, State: STOPPED, Exit Code: 0, Info Flags: FORCED_STOP, Warning Flags: NONE, Error Flags: NONE, Log: []

Sharing Measurement Results with LINQ-based Feedback#

Setup#

Scan For Clusters#

Connect to Cluster#

Get connected modules#

Calibrating time of flight#

Calibrating the threshold#

Experiment parameters#

Sharing thresholded bits (TB) with intra-cast#

Configure module#

Experiment parameters#

Define sender Q1ASM program#

Define receiver Q1ASM program#

Upload sequences#

Run the experiment#

Verify result#

Sharing raw I/Q values with intra-cast#

Experiment parameters#

Define Q1ASM programs#

Define receiver Q1ASM program#

Upload sequences#

Run the experiment#

Verify result#

What do these values mean?#

Stop#