Readout Sequencers

A readout sequencer is a type of Q1 sequencer whose signal path generates two streams of output signals called path_0 and path_1 just like a control sequencer. Additionally, the signal path includes an acquisition path which acquires and processes the signal.

Note

A readout sequencer is not only an acquisition sequencer. It can both play and acquire signals, and is designed to acquire the same signal that is played from it.

The following describes the parts or blocks of the signal path of a readout sequencer along with examples to illustrate how the blocks work together. Some of the blocks perform mathematical operations to a signal. In these cases, a formula of the form \(y(t)=f(x(t))\) is presented, where \(t\) is time in discrete time steps of 1 ns corresponding to each time sample, \(y(t)\) is the output of the block, given that \(x(t)\) is the input to the block. The function \(f(x(t))\) can be manipulated using Q1ASM instructions or QCoDeS commands depending on the block.

Arbitrary waveform generator (AWG)

1. Waveform playback

A readout sequencer has a certain waveform memory from which signals can be played. The user can upload waveforms while uploading a sequence using the Sequencer.sequence() method. The method takes a dictionary as an argument, and one of the keys must be waveforms, which itself is a dictionary with a python list of floating point values in the range of 1.0 to -1.0 with a resolution of one nanosecond per sample. See below an example:

Example: waveform upload

from scipy.signal.windows import gaussian

sequencer0.sequence(
    {
        "waveforms": {
            # 4 ns ramp waveform
            "wfm1": {
                data = [0.0, 0.1, 0.2, 0.3],
                index = 0
            },

            # 100 ns gaussian waveform (100 pts -> 100 ns)
            "gaussian": {
                data = list(gaussian(100, 20)),
                index = 1
            }
        },
        ...
    }
)

Important

The data supplied to the waveform dictionary must be a python list. It cannot be a numpy array.

The waveform memory for each sequencer is 16384 samples (total of all waveforms stored in one sequencer), and the maximum number of waveforms that can be stored on a sequencer is 1024. The stored waveforms can be retrieved using Sequencer.get_waveforms().

The play RT instruction is used to start waveform playback from the waveform memory. The instruction takes two arguments before the real-time duration argument. The first two are the waveform indices for path 0 and path 1. Once the play instruction is executed by the RT core, the waveform is then completely played irrespective of further instructions, except when the RT core issues the playback of another waveform, in which case the waveform will be stopped and the new waveform will start.

Example: Play waveform

The example below assumes that the sequence dictionary in the Example: waveform upload above is uploaded to the sequencer.

play 0,1,200 # Play wfm1 on path_0 and gaussian on path_1. Then wait 200 ns.
play 1,1,100 # Play gaussian on both path_0 and path_1. Then wait 100 ns.

play 1,1,50 # Play gaussian on both path_0 and path_1. Then wait 50 ns.
# Interrupt playback of gaussian from the previous play.
play 0,0,4 # Play wfm1 on both path_0 and path_1. Then wait 4 ns.
stop

Note

If the waveform is shorter than duration, the output is zeros after waveform playback.

2. Gain

A readout sequencer has a dedicated gain step for both paths 0 and 1, which can either be configured using the ControlSequencer.gain_awg_path0() QCoDeS parameter or within a sequence using the set_awg_gain Q1ASM latched instruction of the Q1 sequencer which enables pulse parametrization. The QCoDeS and Q1ASM gain readouts are multiplied together before the gain is applied to the signal.

The set_awg_gain Q1ASM latched instruction takes two integers from -32768 to 32767 as arguments for the gain of the two paths.

Mathematically, this block is:

\[ y(t) = Ggx(t) \]

where,

• \(G\) is the gain from the ControlSequencer.gain_awg_path0() QCoDeS parameter and

• \(g\) is the gain from the set_awg_gain Q1ASM latched register.

Note

If modulated IQ signals are used for an output pair, it is good practice to set the same gain for both paths, i.e., ControlSequencer.gain_awg_path0() = ControlSequencer.gain_awg_path1()

Example: Increasing gains

The following example plays 10 gaussian pulses with increasing amplitude. The example assumes that the sequence dictionary in the Example: waveform upload above is uploaded to the sequencer.

move 10, R0     # Loop counter
move 1000, R1   # Initial gain of 1000

start:
    set_awg_gain    R1, R1          # Set gain to value in R1.
    play            1,1,100         # Play gaussian on both path_0 and path_1. Then wait 100 ns.
    add             R1, 1000, R1    # R1 = R1 + 1000
    loop            R0, @start      

stop

3. Offset

A readout sequencer has a dedicated offset step for both paths 0 and 1, which can either be configured using the ControlSequencer.offset_awg_path0() QCoDeS parameter or within a sequence using the set_awg_offs Q1ASM latched instruction of the Q1 sequencer which enables pulse parametrization. The QCoDeS and Q1ASM offset readouts are added together before the gain is applied to the signal.

The set_awg_offs Q1ASM latched instruction takes two integers from -32768 to 32767 as arguments for the offset of the two paths.

Mathematically, this block is:

\[ y(t) = x(t) + O + o \]

where,

• \(O\) is the offset from the ControlSequencer.offset_awg_path0() QCoDeS parameter and

• \(o\) is the offset from the set_awg_offs Q1ASM latched register.

Note

If modulated IQ signals are used for an output pair, it is good practice to set the same offset for both paths, i.e., ControlSequencer.offset_awg_path0() = ControlSequencer.offset_awg_path1()

Example: Increasing offsets

The following example plays 10 gaussian pulses with increasing offsets. The example assumes that the sequence dictionary in the Example: waveform upload above is uploaded to the sequencer.

move 10, R0     # Loop counter
move 1000, R1   # Initial offset of 1000

start:
    set_awg_offs    R1, R1          # Set offset to value in R1.
    play            1,1,100         # Play gaussian on both path_0 and path_1. Then wait 100 ns.
    add             R1, 1000, R1    # R1 = R1 + 1000
    loop            R0, @start      

stop

4. Numerically controlled oscillator (NCO)

A readout sequencer has a numerically controlled oscillator (NCO) whose frequency and phase parameters either be configured using the ControlSequencer.nco_freq() and ControlSequencer.nco_phase_offs() QCoDeS parameters or within a sequence using the set_freq, reset_ph, set_ph, and set_ph_delta Q1ASM latched instructions.

The NCO outputs a two signals (\(n_I\) and \(n_Q\)), which can be interpreted as a complex signal (\(\mathbf{n}(t)\)).

Real signals

\[\begin{split}\begin{align} n_I(t) &= \cos(\omega t' + \Phi + \phi)\\ n_Q(t) &= \sin(\omega t' + \Phi + \phi)\\ \end{align}\end{split}\]

Complex signals

\[\begin{align} \mathbf{n}(t) &= e^{\mathbf{i}(\omega t' + \Phi + \phi)} \end{align}\]

where,

• \(\omega = 2\pi f\) where \(f\) is the frequency of the NCO.

  \(f\) can be set using the ControlSequencer.nco_freq() QCoDeS parameter or the set_freq Q1ASM instruction.

• \(t'\) is the time internal to the NCO.

  It is set to zero with the reset_ph instruction. Note that the reset_ph instruction also sets \(\phi=0\) and \(\Phi=0\). The set_ph_delta Q1ASM instruction induces a phase kick \(t'\rightarrow t' + \delta\phi/\omega\) at the instant that the signal path is updated (when the next RT instruction is executed).

• \(\Phi\) is the phase offset.

  It is set from the ControlSequencer.nco_phase_offs() QCoDeS parameter.

• \(\phi\) is the phase offset.

  It is set from the set_ph Q1ASM latched register.

The ControlSequencer.nco_phase_offs() QCoDeS parameter and set_ph Q1ASM instruction are added together before it is applied to the NCO.

Warning

The ControlSequencer.nco_freq() QCoDeS parameter and set_freq Q1ASM instruction override each other. We highly recommend setting NCO frequencies only either using QCoDeS or Q1ASM and not both.

For further in depth details and a tutorial on how to use the Q1 sequencer NCO capabilities, please refer to the NCO tutorial.

5. Modulation (mixer)

The two output signals from the NCO (\(\mathbf{n}(t) = n_I(t) + \mathbf{i}n_Q(t)\)) and the signal from paths 0 and 1 (\(\mathbf{x}(t) = x_0(t) + \mathbf{i}x_1(t)\)) are multiplied as complex signals in this block to output a modulated signal (\(\mathbf{y}(t) = y_0(t) + \mathbf{i}y_1(t)\)).

Real signals

\[\begin{split}\begin{align} y_0(t) &= \frac{n_I(t) x_0(t) - n_Q(t) x_1(t)}{\sqrt{2}}\\ y_1(t) &= \frac{n_Q(t) x_0(t) + n_I(t) x_1(t)}{\sqrt{2}}\\ \end{align}\end{split}\]

Complex signals

\[\begin{align} \mathbf{y}(t) &= \frac{\mathbf{n}(t)\mathbf{x}(t)}{\sqrt{2}} \end{align}\]

Note

The \(1/\sqrt{2}\) factor ensures that the output is limited to \(\pm 1\).

Modulation is enabled using the ControlSequencer.mod_en_awg() parameter.

Example: Pulses of increasing frequency

The following example plays 10 square pulses with increasing frequency from 0 to 9 MHz.

move 10, R0     # Loop counter
move 0, R1      # Initial frequency of 0 Hz

start:
    set_freq     R1                # Set the frequency to R1/4 Hz. The argument is in multiples of 0.25 Hz.
    set_awg_offs 32767, 32767      # Set the path_0 and path_1 offset to maximum.
    upd_param    1000              # Apply the offset to the output and wait 1 us.
    set_awg_offs 0, 0              # Set the path_0 and path_1 offset to 0.
    upd_param    4                 # Apply the offset to the output and wait 4 ns.
    add          R1, 4000000, R1   # R1 = R1 + 4000000. Corresponding to 1 MHz.
    loop         R0, @start      

stop

5.1 Mixer Correction

If the two signals (path 0 and 1) generated by the readout sequencer are meant to be used as the I and Q signals to a physical mixer (such as in the RF modules), one may want to correct for mixer imperfections. The mixer correction block allows the user to set an amplitude ratio (\(\alpha\)) and a phase offset (\(\phi_m\)) between the I and Q signals, so that the output of the physical mixer is ideal. The output of the mixer correction block is calculated by the mixer correction block as follows:

\[\begin{split}\begin{align} y_0(t) &= x_0(t) - \tan(-\phi_m) x_1(t)\\ y_1(t) &= \frac{\alpha}{\cos(-\phi_m)} x_1(t)\\ \end{align}\end{split}\]

where,

• \(\alpha\) is the amplitude ratio between the I and Q signals set by ControlSequencer.mixer_corr_gain_ratio() QCoDeS parameter.

• \(\phi_m\) is the phase offset between the I and Q signals set by ControlSequencer.mixer_corr_phase_offset_degree() QCoDeS parameter.

Please refer to the Automatic mixer calibration tutorial and Manual mixer calibration tutorial for more details.

Acquisition path (ACQ)

Two input signals called input path 0 and input path 1 enter the acquisition signal path. These signals are configured to go through three paths: scope path, TTL path and the demodulated path.

Before acquiring signals through any of the paths, the acquisitions dictionary must be uploaded using the Sequencer.sequence() method. Below is an example of uploading acquisitions:

Example: acquisitions upload

sequencer0.sequence(
    {
        "acquisitions": {
            # Reserve 1 bin for an acquisition called "single"
            "single": {"num_bins": 1, "index": 0},
            # Reserve 1000 bins for an acquisition called "multiple"
            "multiple": {"num_bins": 1000, "index": 1},
        },
        ...
    }
)

1. Scope path

Signals can be acquired and directly stored in memory, similar to an oscilloscope. In order to use the scope path, the QRM.scope_acq_trigger_mode_path0() method must be used to select how the scope will be started. This can be set to:

• "level": the scope will acquire a signal when the signal crosses a certain level. The level is set by QRM.scope_acq_trigger_level_path0().

• "sequencer": the scope will acquire a signal when the selected sequencer executes an acquire instruction. The sequencer is selected using QRM.scope_acq_sequencer_select().

Exception:

The scope acquisition is performed per module. Sequencers may merely be configured to start the scope acquisition using the acquire instruction. Every module only has one shared scope memory, unlike the binned memory for the other two acquisition paths.

Each time the scope is started, it will capture 16384 input samples on both paths and will store the raw input samples in a temporary buffer on the FPGA. If the scope is started again, this memory is overwritten. The samples may be moved from the temporary buffer to the RAM of the module using QRM.store_scope_acquisition(), which moves the samples into the specified acquisition in the acquisition list of the sequencer, located in the RAM of the instrument. Multiple acquisitions can be stored in this list before being retrieved using Sequencer.get_acquisitions() which returns a dictionary of acquisitions. Scope mode data is located under the “scope” key as lists of floating point values in the range of 1.0 to -1.0 with a resolution of one nanosecond per sample, as well as an indication if the ADC was out-of-range during the measurement.

Note

The bins reserved in the acquisition dictionary are not used by the scope path. The scope will always acquire 16384 samples.

It is possible to accumulate data acquired by repeated scope acquisitions by setting QRM.scope_acq_avg_mode_en_path0() to True. Data retrieved will then be element-wise accumulated over all the repetitions. i.e. sample N of the next acquisition is accumulated to sample N of acquisition memory. This happens while the acquisition is still in the temporary buffer, so after the desired number of averaging acquisitions is completed, QRM.store_scope_acquisition() may be used to store the accumulated result in the acquisition list. Once retrieved from the instrument, the accumulated samples will be divided by the number of acquisitions to get the element-wise average scope trace.

Please see the scope acquisition tutorial for how to set up and use the scope path.

2. TTL trigger acquisition path

The TTL acquisition path is used to acquire and count trigger events. It can also be used to generate a histogram of trigger counts directly on the FPGA. The acquire_ttl Q1ASM instruction is used to start the TTL acquisition path.

1. Input select

In the TTL trigger path, one of the inputs is selected using the qblox_instruments ReadoutSequencer.ttl_acq_input_select() parameter. The acquire_ttl instruction enables the TTL trigger acquisition path by setting the enable argument to 1 and needs to actively disable the path again by using the same instruction with its enable argument set to 0.

Important

While the TTL trigger acquisition path is enabled, real-time integration and discretization is disabled.

Example: enabling and disabling the TTL trigger acquisition path

acquire_ttl 0,0,1,1000 # Acquire triggers and wait for 1000 ns.
acquire_ttl 0,0,0,4    # Stop acquiring triggers and wait for 4 ns.
stop                   # Stop sequencer.

2. Threshold

The thresholding unit evaluates all data above the set threshold, returning a 1 if it is above and a 0 otherwise. This result can be shared across the cluster for feedback applications.

The threshold for this acquisition can be set for each sequencer individually, e.g. qrm.sequencer0.ttl_acq_threshold(0.5)

3. Edge detect

When a TTL trigger is detected at the threshold comparator, the resulting one-bit signal is pushed through an edge detection to transform the TTL trigger of undetermined duration into a single clock cycle trigger pulse.

4. Enable

The TTL trigger path is always active, but its output results are gated based on the enable parameter in the acquire_ttl Q1ASM instruction.

5. Bin counter

The bin index is given as an argument of the instruction and can be automatically incremented by each detected trigger through the bin counter. ReadoutSequencer.ttl_acq_auto_bin_incr_en() selects if the bin index is automatically incremented when acquiring multiple triggers. Automatic bin increments allow for storing a histogram of trigger counts in the bins.

6. Averaging/Binning

The resulting trigger pulse and the associated ADC values that caused the trigger detection can be stored through the binning and averaging module. When doing this, the retrigger rate is restricted to roughly 1MHz.

The count of triggers will be saved in ‘averages’ and can be retrieved by using sequencer.get_acquisitions(0)['0']['acquisition']['bins']['averages']

For more details, please refer to the TTL acquisition tutorial.

3. Demodulation path

The demodulation path is used to demodulate a signal such that only the envelope is processed. The acquire Q1ASM instruction is used to start the TTL acquisition path.

The demodulation path allows for accumulating the demodulated signal in time (called “integration”), accumulating the demodulated signal across executions of the acquire instruction (called “averaging”) and also allows for thresholding the integrated signal to produce a 1-bit output.

Important

The NCO is shared between the AWG and ACQ paths. This allows a modulated signal that is played from the AWG to be demodulated back to the envelope by the ACQ since the frequency of modulation and demodulation is the same.

1. Demodulation (mixer)

The two output signals from the NCO (\(\mathbf{n}(t) = n_I(t) - \mathbf{i}n_Q(t)\)) and the signal from paths 0 and 1 (\(\mathbf{x}(t) = x_0(t) + \mathbf{i}x_1(t)\)) are multiplied as complex signals in this block to output a demodulated signal (\(\mathbf{y}(t) = y_0(t) + \mathbf{i}y_1(t)\)).

Note

The NCO output \(n_I(t)\) and \(n_Q(t)\) are used as is for the AWG modulation block. For the ACQ demodulation block, the sign of \(n_Q(t)\) is flipped.

Real signals

\[\begin{split}\begin{align} y_0(t) &= \sqrt{2} \Bigl\{n_I(t) x_0(t) + n_Q(t) x_1(t)\Bigr\}\\ y_1(t) &= \sqrt{2} \Bigl\{-n_Q(t) x_0(t) + n_I(t) x_1(t)\Bigr\}\\ \end{align}\end{split}\]

Complex signals

\[\begin{align} \mathbf{y}(t) &= \sqrt{2}\mathbf{n}(t)\mathbf{x}(t) \end{align}\]

Note

The \(\sqrt{2}\) factor ensures if a pulse that is modulated using the AWG of a sequencer, that the input is normalized to a range of \(\pm 1\).

Demodulation is enabled using the ReadoutSequencer.demod_en_acq() parameter.

1.1 Time of flight compensation

If you are using the sequencer to acquire the signal that is played, it is desirable to delay the NCO output by the time of flight. This ensures that the phase of the demodulated signal is constant even when the frequency is changed in a sweep for example.

Real signals

\[\begin{split}\begin{align} y_0(t) &= n_I(t - \delta t)\\ y_1(t) &= -n_Q(t - \delta t)\\ \end{align}\end{split}\]

Complex signals

\[\begin{align} \mathbf{y}(t) &= \mathbf{n}(t - \delta t) \end{align}\]

where,

• \(\delta t\) is the delay of the NCO set by the ReadoutSequencer.nco_prop_delay_comp() QCoDeS parameter.

NCO delay compensation must be enabled using the ReadoutSequencer.nco_prop_delay_comp_en() QCoDeS parameter.

4. Integrator

The acquire instruction integrates the demodulated signal. The integrator block performs a square integration, or applies the provided integration weights to the incoming data. When using the square integration, the length of the integration is restricted to 16 ms.

Let us define the samples of the demodulated signal as \(\mathbf{x}[i] = x_0[i] + x_1[i]\), where i is the index of the sample (\(i=0\) is the sample corresponding to when the acquire instruction was executed).

Real signals

\[\begin{split}\begin{align} y_0 &= \sum_{i=0}^{N} x_0[i]\\ y_1 &= \sum_{i=0}^{N} x_1[i]\\ \end{align}\end{split}\]

Complex signals

\[\begin{align} \mathbf{y} &= \sum_{i=0}^{N} \mathbf{x}[i] \end{align}\]

where,

• \(N\) is the number of samples to be integrated set by the ReadoutSequencer.integration_length_acq() QCoDeS parameter.

There is also an option to integrate the demodulated signal using a different weight for each sample acquired before integration using the acquire_weighed instruction. For weighted integration, this length of the acquisition is limited to the length of the weight memory of 16 384 ns.

Weighted integration may be used to boost the signal to noise ratio of a measurement. For example, suppose that the amount of information in the acquired signal drops exponentially in time such that the end of the acquired signal has a lot more noise than the beginning. The integration weights could also be set to drop exponentially so that the noise at the end of the acquired signal is ignored.

Real signals

\[\begin{split}\begin{align} y_0 &= \sum_{i=0}^{L} w_0[i] x_0[i]\\ y_1 &= \sum_{i=0}^{L} w_1[i] x_1[i]\\ \end{align}\end{split}\]

Complex signals

\[\begin{align} \mathbf{y} &= \sum_{i=0}^{L} \Bigl\{w_0[i] x_0[i] + \mathbf{i} w_1[i] x_1[i]\Bigr\} \end{align}\]

where,

• \(L\) is the lengths of the uploaded weights selected by the acquire_weighed instruction.

• \(w_0[i]\) and \(w_1[i]\) are the weights uploaded by the user to the weight memory.

Important

The weights \(w_0\) and \(w_1\) are not multiplied in a complex manner. See below for more details:

Complex weighted integration

In order to perform a true complex multiplication using the weights, you must acquire from two sequencers set up with the same frequency, phase, etc. parameters, and with weights of the two sequencers being \(w_0\) and \(-w_1\) for the first sequencer, and \(w_1\) and \(w_0\) for the second sequencer. This leads to:

Real signals

\[\begin{split}\begin{align} y_0^0 &= \sum_{i=0}^{L} w_0[i] x_0[i]\\ y_1^0 &= \sum_{i=0}^{L} -w_1[i] x_1[i]\\ y_0^1 &= \sum_{i=0}^{L} w_1[i] x_0[i]\\ y_1^1 &= \sum_{i=0}^{L} w_0[i] x_1[i]\\ \end{align}\end{split}\]

Complex signals

\[\begin{split}\begin{align} \mathbf{y}^0 &= \sum_{i=0}^{L} w_0[i] x_0[i] - \mathbf{i} w_1[i] x_1[i]\\ \mathbf{y}^1 &= \sum_{i=0}^{L} w_1[i] x_0[i] + \mathbf{i} w_0[i] x_1[i] \end{align}\end{split}\]

where,

• \(y_n^m\) is the output of path \(n\) from sequencer \(m\).

• \(\mathbf{y}^m\) is the complex output from sequencer \(m\).

Then performing the following sum on the host PC gives the desired result:

Real signals

\[\begin{split}\begin{align} y_0 &= y_0^0 + y_1^0\\ y_1 &= y_0^1 + y_1^1\\ \end{align}\end{split}\]

Complex signals

\[\begin{align} \mathbf{y} &= y_0 + \mathbf{i}y_1 = \sum_{i=0}^{L} \mathbf{w}[i] \mathbf{x}[i] \end{align}\]

The integration process continues irrespective of further sequence processor instructions, except when the sequence processor issues another acquisition using the acquire or acquire_weighed instructions, in which case the integration will be stopped, the result will be stored and a new integration will start.

4.1 Weight Memory

The weight memory stores the integration weights set by the user in the provided sequence. The weights are expressed as a list of floating point values in the range of 1.0 to -1.0 with a resolution of one nanosecond per sample. The maximum number of weights that can be stored is 32, with a maximum of 16384 total weight samples. See below for an example of uploading the weights:

Example: weights upload

sequencer0.sequence(
    {
        "weights": {
            "weights_I": {
                data = list(gaussian(100, 20)),
                index = 0
            },
            "weights_Q": {
                data = list(gaussian(100, 20)),
                index = 1
            }
        },
        ...
    }
)

5. Rotation and thresholding

The integrated value from the integrator is then rotated and thresholded using the ReadoutSequencer.thresholded_acq_rotation() and ReadoutSequencer.thresholded_acq_threshold() parameters. The output is 1 bit: set to 1 (0) if the real part of the rotated value is greater (less) than the threshold. This 1 bit result may be used as a trigger source.

Real signals

\[\begin{split}\begin{align} y = \Bigl\{\cos{\theta} x_0 - \sin{\theta} x_1\Bigr\} > T\\ \end{align}\end{split}\]

Complex signals

\[\begin{align} y &= \mathfrak{Re}\Bigl\{{\mathbf{i}\theta}\mathbf{x}\Bigr\} > T \end{align}\]

6. Binning and averaging

The demodulated integrated value and the thresholded bit result will be stored in memory. The acquire and acquire_weighed instructions that are used to start acquiring a signal using the demodulated path also define where in memory the results are stored by their arguments. If multiple acquisitions are acquired into the same bin the results are summed together, and divided when the results are transferred to the PC using Sequencer.get_acquisitions().

Below are two examples where:

1. consecutive acquisitions are acquired in a sequence of bins, and

Example: Acquire in different bins

The example assumes that the sequence dictionary in the Example: acquisitions upload above is uploaded to the sequencer.

move 100, R0    # Loop counter
move 0, R1      # Bin index

start:
    # Append result to acquisition "multiple" (index 1) and bin R1.
    acquire 1,R1,100    # Start acquiring. Then wait 100 ns.
    add     R1,1,R1     # R1 = R1 + 1
    loop    @start, R0  # Loop
stop

sequencer.get_acquisitions()['multiple']['acquisition']['bins'] is a list of 10 numbers each for path 0 and 1.

2. consecutive acquisitions are acquired in a single bin.

Example: Average using one bin

The example assumes that the sequence dictionary in the Example: acquisitions upload above is uploaded to the sequencer.

move 100, R0    # Loop counter

start:
    # Append result to acquisition "single" (index 0) and bin 0.
    acquire 0,0,100     # Start acquiring. Then wait 100 ns. 
    loop    @start, R0  # Loop
stop

sequencer.get_acquisitions()['single']['acquisition']['bins'] is a the average of 10 acquisitions for path 0 and 1.

Trigger sources

1. Thresholded acquisition

Any thresholded acquisition result, as discussed in the rotation and thresholding section, may be sent to the trigger network by following the next steps:

1. Enable sending triggers with ReadoutSequencer.thresholded_acq_trigger_en().

2. Choose a trigger address (from 1 to 15) using ReadoutSequencer.thresholded_acq_trigger_address(). Remember that this address needs to be used by the receiving sequencer to handle this trigger.

3. By default, a trigger is sent to the network if the thresholded result (\(y\) as defined in the rotation and thresholding section) is True. The ReadoutSequencer.thresholded_acq_trigger_invert() parameter may be used to send a trigger if the thresholded result is False.

Example: conditional playback of a waveform

In this example, sequencer 0 performs a measurement and sequencer 1 performs a conditional playback based on the measurement result.

Here are the settings required:

sequencer0.thresholded_acq_trigger_en(True)
sequencer0.thresholded_acq_trigger_address(12)
sequencer0.thresholded_acq_trigger_invert(False)

sequencer1.trigger12_count_threshold(1)
sequencer1.trigger12_threshold_invert(False)

The program for sequencer 0:

wait_sync 4       #Wait for sequencers to synchronize

play 0,0,4        #Play readout pulse
wait 148          #Wait for readout pulse to return
acquire 0,0,100   #Acquire readout pulse

stop              #Stop program

The program for sequencer 1:

wait_sync 4             #Wait for sequencers to synchronize

set_latch_en 1,4        #Latch any trigger
latch_rst 1000          #Reset the trigger network address counters, then wait on trigger address 12

set_cond 1,2048,0,4     #Play waveform if trigger is seen (condition: OR T12)
play 0,0,20             #""
set_cond 1,2048,1,4     #Play waveform if trigger is NOT seen (condition: NOR T12)
play 1,1,20             #""

stop                    #Stop program

2. TTL triggers

When acquiring using the TTL trigger acquisition path, any trigger detected during the acquisition period can be sent to the trigger network as well. Note that multiple triggers can be sent on the network during a single acquisition period. However, the trigger network can only be retriggered every 252 ns, so the rate of the TTL triggers on the input must be limited to the maximum trigger network rate.

During a TTL trigger acquisition, all detected triggers are treated like thresholded acquisition results. Mapping the TTL triggers on the trigger network is therefore identical to mapping thresholded acquisition results on the network and uses the same parameters.

Example: trigger counting

In this example, the trigger network address counters are used to count TTL triggers on the inputs. Sequencer 0 detects the triggers on the input of the device and then counts the resulting triggers on the trigger network. Finally, it plays a waveform if 5 or more triggers are detected.

Here are the settings required:

sequencer0.ttl_acq_input_select(0)
sequencer0.ttl_acq_threshold(0.2)
sequencer0.ttl_acq_auto_bin_incr_en(false)

sequencer0.thresholded_acq_trigger_en(True)
sequencer0.thresholded_acq_trigger_address(12)
sequencer0.thresholded_acq_trigger_invert(False)

sequencer0.trigger12_count_threshold(5)
sequencer0.trigger12_threshold_invert(False)

The program for sequencer 0:

wait_sync 4            #Wait for sequencers to synchronize

set_latch_en 1,4       #Latch any trigger
latch_rst 4            #Reset the trigger network address counters

acquire_ttl 0,0,1,5000 #Acquire input triggers
acquire_ttl 0,0,0,4    #Stop acquiring triggers

set_cond 1,2048,0,20   #Play if 5 triggers have been seen (condition: OR T12)
play 0,0,20            #""

stop                   #Stop program