Skip to content

AWG Tab

The AWG tab is available on UHFAWG Arbitrary Waveform Generator instruments and on UHFLI Lock-in Amplifier instruments with installed UHF-AWG Arbitrary Waveform Generator option (see Information section in the Device tab).

Features

  • Dual-channel arbitrary waveform generator
  • 128 MSa waveform memory per channel
  • Sequence branching
  • Digital modulation
  • Multi-instrument synchronization
  • Sequence program distribution over multiple instruments
  • Cross-domain trigger engine
  • Sequence Editor with code highlighting and auto completion
  • High-level programming language with waveform generation and editing toolset
  • Waveform viewer

Description

The AWG tab gives access to the arbitrary waveform generator functionality. Whenever the tab is closed or an additional one of the same type is needed, clicking the following icon will open a new instance of the tab.

Table 1: App icon and short description
Control/Tool Option/Range Description
AWG Generate arbitrary signals using sequencing and sample-by-sample definition of waveforms.

The AWG tab (see Figure 1) consists of a settings section on the right side and the Sequence and Waveform Viewer sub-tabs on the left side. The settings section is further divided into Control, Waveform, Trigger, and Advanced sub-tabs. The Sequence sub-tab is used for displaying, editing and compiling a LabOne sequence program. The sequence program defines which waveforms are played and in which order. The Sequence Editor is the main tool for operating the AWG.

Figure 1: LabOne UI: AWG tab

A number of sequence programming examples are available through a drop-down menu at the top of the Sequence Editor, and additional ones can be found in Arbitrary Waveform Generator . The LabOne sequence programming language is specified in detail in LabOne Sequence Programming. The language comes with a number of predefined waveforms, such as Gaussian, Blackman, sine, or square functions. By combining those predefined waveforms using the waveform editing tools (add, multiply, cut, concatenate, etc), signals with a high level of complexity can be generated directly from the Sequence Editor window. Sample-by-sample definition of the output signal is possible by using comma-separated value (CSV) files specified by the user , see Waveform Generation and Playbackfor an example.

The AWG features a compiler which translates the high-level sequence program into machine instructions and waveform data to be stored in the instrument memory as shown in Figure 2. The sequence program is written using high-level control structures and syntax that are inspired by human language, whereas machine instructions reflect exactly what happens on the hardware level. Writing the sequence program using a high-level language represents a more natural and efficient way of working in comparison to writing lists of machine instructions, which is the traditional way of programming AWGs. Concretely, the improvements rely on features such as:

  • combination of waveform generation, editing, and playback sequence in a single script
  • easily readable syntax and naming for run-time variables and constants
  • optimized waveform memory management, reduced transfers upon waveform changes
  • definition of user functions and procedures for advanced structuring
  • syntax validation

By design, there is no one-to-one link between the list of statements in the high-level language and the list of instructions executed by the Sequencer. There are cases in which a more detailed understanding of the Sequencer instruction list, and in particular its execution timing, is needed. Typically this is the case when observing delays or other signal timing properties that are unexpected from looking at the high-level script. Often such problems can be solved with a few adjustments to the program. Please see Debugging Sequencer Programs for practical advice.

Figure 2: AWG sequence program compilation process

The Sequence Editor provides the editing, compilation, and transfer functionality for sequence programs. A program typed into the Editor is compiled upon clicking . If the compilation is successful and Automatic Upload is enabled, the program including all necessary waveform data is transferred to the device. If the compilation fails, the Status field will display debug messages. Clicking on allows you to choose a new name for the program. The name of the program that is currently edited is displayed at the top of the editor. External program files as well as waveform data files can be transferred to the right location easily using the file drag-and-drop zone in the Config Tab so they become accessible from the user interface. The files can be managed in the File Manager Tab and their location in the directory structure is shown in Table 2. The program name is displayed in a drop-down box. The box allows quick access to all programs in the standard sequence program location. It is possible to quickly switch between programs using the box. Changes made in one program will be preserved when switching to a different program. The file name of a program will be postfixed by an asterisk in case there are unsaved changes in the source file. Note that switching programs in the editor is not sufficient to also update the program in the instrument. In order to send a newly selected program to the instrument, the button must be clicked.

Table 2: Sequence program and waveform file location
File type Location
Waveform files (Windows) C:\Users\<user name>\Documents\Zurich Instruments\LabOne\WebServer\awg\waves
Sequence programs (Windows) C:\Users\<user name>\Documents\Zurich Instruments\LabOne\WebServer\awg\src
Waveform files (Linux) ~/Zurich Instruments/LabOne/WebServer/awg/waves
Sequence programs (Linux) ~/Zurich Instruments/LabOne/WebServer/awg/src

In the Control sub-tab the user configures signal parameters and controls the execution of the AWG. The AWG can be started in by clicking on . When enabling the Rerun button, the Sequencer will be restarted automatically when its program completes. The continuous mode is a simple way to create an infinite loop, but it results in a considerable timing jitter. To avoid this jitter, it is recommended to specify infinite loops directly in the sequence program.

The Sampling Rate field is used to control the default playback sampling rate of the AWG. The sampling rate is dynamic, i.e., can be specified for each waveform by using an optional argument in the waveform playback instructions in the sequence program. This allows for considerably reducing waveform upload time for signals that contain both fast and slow components. The two Output sections are used to configure the AWG output mode and signal amplitude. The AWG output channels are not the same as the physical Signal Outputs of the instrument. The AWG output channels are routed to the Signal Outputs of the device. The Amplitude value is a gain parameter, 1.0 by default, that is applied to waveforms on the way from the AWG output channel to the Signal Output. The Amplitude value gives a means to rescale the signal independently of the programmed waveforms. The Mode control is used to enable or disable the modulation mode , or to enable advanced modulation mode . With enabled modulation, the signal of an AWG Output is multiplied with an oscillator signal prior to being sent to the Signal Output. This is useful for the case where the desired signal can be described as a sinusoidal carrier with a shaped envelope. The advanced modulation mode allows you to modulate multiple carriers (up to 4) with individual envelope waveforms. Please read more about use cases, advantages, and practical examples in Modulation Mode.

The Waveform sub-tab displays information about the waveforms that are used by the current sequence program, such as their length and channel number. Together with the Waveform viewer sub-tab, it is a useful tool to visualize the waveforms used in the sequence program.

On the Trigger sub-tab you can configure the trigger inputs of the AWG and control the Cross-Domain Trigger functionality of the instrument. The AWG has four trigger input channels which can be configured to probe a variety of signals coming both from internal (e.g. demodulator output data) or external (e.g. Ref/Trigger input) sources . This means that the AWG trigger input channels are not the same as physical device inputs. Two of the trigger input channels are called analog (meaning they can accept signals of continuous, analog-like character), and two are called digital (meaning they can accept binary signals). Trigger Level and Hysteresis may be configured for the Analog Triggers, and the user can select between rising and falling edge trigger functionality. The primary use of the triggers is to control the timing of the AWG signal relative to an external device. Another use of triggers is to implement sequence branching. See Triggering and Synchronization and Branching and Feed-Forward for practical examples on how to use the AWG trigger in- and outputs.

The Advanced sub-tab displays the compiled list of sequencer instructions and the current state of the sequencer on the instrument. This can help an advanced user in debugging a sequence program and understanding its execution.

Sequence Editor Keyboard Shortcuts

The tables below list a number of helpful keyboard shortcuts that are applicable in the LabOne Sequence Editor.

Table 3: Line Operations
Shortcut Action
Ctrl+D Remove line
Alt+Shift+Down Copy lines down
Alt+Shift+Up Copy lines up
Alt+Down Move lines down
Alt+Up Move lines up
Alt+Del Remove to line end
Alt+Backspace Remove to line start
Ctrl+Backspace Remove word left
Ctrl+Del Remove word right
Table 4: Selection
Shortcut Action
Ctrl+A Select all
Shift+Left Select left
Shift+Right Select right
Ctrl+Shift+Left Select word left
Ctrl+Shift+Right Select word right
Shift+Home Select line start
Shift+End Select line end
Alt+Shift+Right Select to line end
Alt+Shift+Left Select to line start
Shift+Up Select up
Shift+Down Select down
Shift+Page Up Select page up
Shift+Page Down Select page down
Ctrl+Shift+Home Select to start
Ctrl+Shift+End Select to end
Ctrl+Shift+D Duplicate selection
Ctrl+Shift+P Select to matching bracket
Table 5: Go to
Shortcut Action
Left Go to left
Right Go to right
Ctrl+Left Go to word left
Ctrl+Right Go to word right
Up Go line up
Down Go line down
Alt+Left, Home Go to line start
Alt+Right, End Go to line end
Page Up Go to page up
Page Down Go to page down
Ctrl+Home Go to start
Ctrl+End Go to end
Ctrl+L Go to line
Ctrl+Down Scroll line down
Ctrl+Up Scroll line up
Ctrl+P Go to matching bracket
Table 6: Find/Replace
Shortcut Action
Ctrl+F Find
Ctrl+H Replace
Ctrl+K Find next
Ctrl+Shift+K Find previous
Table 7: Folding
Shortcut Action
Alt+L Fold selection
Alt+Shift+L Unfold
Table 8: Other
Shortcut Action
Tab Indent
Shift+Tab Outdent
Ctrl+Z Undo
Ctrl+Shift+Z, Ctrl+Y Redo
Ctrl+/ Toggle comment
Ctrl+Shift+U Change to lower case
Ctrl+U Change to upper case
Ins Overwrite
Ctrl+Shift+E Macros replay
Ctrl+Alt+E Macros recording
Del Delete

LabOne Sequence Programming

A Simple Example

The syntax of the LabOne AWG Sequencer programming language is based on C, but with a few simplifications. Each statement is concluded with a semicolon, several statements can be grouped with curly brackets, and comment lines are identified with a double slash. The following example shows some of the fundamental functionalities: waveform generation, repeated playback, triggering, and single/dual-channel waveform playback. See Arbitrary Waveform Generator for a step-by-step introduction with more examples.

// Define an integer constant
const N = 4096;
// Create two Gaussian pulses with length N points,
// amplitude +1.0 (-1.0), center at N/2, and a width of N/8
wave gauss_pos = 1.0*gauss(N, N/2, N/8);
wave gauss_neg = -1.0*gauss(N, N/2, N/8);
// execute playback sequence 100 times
repeat (100) {
  // Play pulse on AWG channel 1
  playWave(gauss_pos);
  // Play pulses simultaneously on both AWG channels
  playWave(gauss_pos, gauss_neg);
  // Wait 8000 samples
  playZero(8000);
}

Multi-Instrument Support

The UHFLI supports multi-instrument operation by two important features

  1. Automatic synchronization

  2. Multi-instrument sequence program compilation

The first feature ensures that signals of multiple AWGs are precisely aligned in time and the user does not have to worry about cable delays, or about varying trigger delays after power cycles. The second feature greatly simplifies writing sequence program, as it allows to treat a setup with multiple AWGs conceptually like a single instrument.

Automatic synchronization can be set up using the Multi-Device Sync tab and is explained in detail in Multi Device Sync Tab. We assume that two UHFLI have been successfully synchronized according to the instructions in this section. Here we show an example of a sequence program to generate synchronized signals on two instruments

As part of the synchronization procedure using MDS, the LabOne Data Server running on the host PC is connected to both instruments. In the AWG tab, enable the Multi-Device button. The LabOne AWG Compiler is then able to distribute the high-level, multi-channel program the user enters in the AWG tab across all instruments. The Signal Output on which a given wave w is played is controlled by the integer argument sig_out in the instruction playWave(sig_out, w). The numbering of the Signal Outputs is as follows:

Channel number in sequence program Instrument number (according to order in MDS tab) Signal Output number
1 Leader 1
2 Leader 2
3 Follower 1 1
4 Follower 1 2
5 Follower 2 1
...​ ...​ ...​

The sequence program below contains three playWave instructions: the first instruction generates a pulse on instrument no. 1, the second one on instrument no. 2, and the third playWave instruction generates pulses simultaneously on both instruments.

wave w_gauss = gauss(8000, 4000, 1000);

while (true) {
  setTrigger(1);
  // Pulse on AWG 1 (Signal Output 1):
  playWave(1, w_gauss);
  // Pulse on AWG 2 (Signal Output 1):
  playWave(3, w_gauss);
  // Pulse on AWG 1 (Signal Outputs 1 & 2)
  //   and on AWG 2 (Signal Outputs 1 & 2):
  playWave(1, w_gauss, 2, w_gauss,
           3, w_gauss, 4, w_gauss);
  setTrigger(0);
  wait(100);
}

Keywords and Comments

The following table lists the keywords used in the LabOne AWG Sequencer language.

Table 9: Programming keywords
Keyword Description
const Constant declaration
var Integer variable declaration
cvar Compile-time variable declaration
string Constant string declaration
true Boolean true constant
false Boolean false constant
for For-loop declaration
while While-loop declaration
repeat Repeat-loop declaration
if If-statement
else Else-part of an if-statement
switch Switch-statement
case Case-statement within a switch
default Default-statement within a switch
return Return from function or procedure, optionally with a return value

The following code example shows how to use comments.

const a = 10; // This is a line comment. Everything between the double
              // slash and the end of the line will be ignored.

/* This is a block comment. Everything between the start-of-block-comment
and end-of-block-comment markers is ignored.

For example, the following statement will be ignored by the compiler.
const b = 100;
*/

Constants and Variables

Constants may be used to make the program more readable. They may be of integer or floating-point type. It must be possible for the compiler to compute the value of a constant at compile time, i.e., on the host computer. Constants are declared using the const keyword.

Compile-time variables may be used in computations and loop iterations during compile time, e.g. to create large numbers of waveforms in a loop. They may be of integer or floating-point type. They are used in a similar way as constants, except that they can change their value during compile time operations. Compile-time variables are declared using the cvar keyword.

Variables may be used for making simple computations during run time, i.e., on the instrument. The Sequencer supports integer variables, addition, and subtraction. Not supported are floating-point variables, multiplication, and division. Typical uses of variables are to step waiting times , to output DIO values, or to tag digital measurement data with a numerical identifier. Variables are declared using the var keyword.

The following code example shows how to use variables.

var b = 100; // Create and initialize a variable

// Repeat the following block of statements 100 times
repeat (100) {
  b = b + 1; // Increment b
  wait(b);   // Wait 'b' cycles
}

The following table shows the predefined constants. These constants are intended to be used as arguments in certain run-time evaluated functions that encode device parameters with integer numbers. For example, the AWG Sampling Rate is specified as an integer exponent n in the expression (1.8 GSa/s)/2n.

Table 10: Predefined Constants
Name Value Description
commandTableEntries {4096}
AWG_RATE_1800MHZ 0 Constant to set Sampling Rate to 1.8 GHz.
AWG_RATE_900MHZ 1 Constant to set Sampling Rate to 900 MHz.
AWG_RATE_450MHZ 2 Constant to set Sampling Rate to 450 MHz.
AWG_RATE_225MHZ 3 Constant to set Sampling Rate to 225 MHz.
AWG_RATE_112MHZ 4 Constant to set Sampling Rate to 112 MHz.
AWG_RATE_56MHZ 5 Constant to set Sampling Rate to 56 MHz.
AWG_RATE_28MHZ 6 Constant to set Sampling Rate to 28 MHz.
AWG_RATE_14MHZ 7 Constant to set Sampling Rate to 14 MHz.
AWG_RATE_7MHZ 8 Constant to set Sampling Rate to 7 MHz.
AWG_RATE_3P5MHZ 9 Constant to set Sampling Rate to 3.5 MHz.
AWG_RATE_1P8MHZ 10 Constant to set Sampling Rate to 1.8 MHz.
AWG_RATE_880KHZ 11 Constant to set Sampling Rate to 880 kHz.
AWG_RATE_440KHZ 12 Constant to set Sampling Rate to 440 kHz.
AWG_RATE_220KHZ 13 Constant to set Sampling Rate to 220 kHz.
AWG_MONITOR_TRIGGER 0x0000020 Constant to activate the trigger of the Monitor unit.
AWG_INTEGRATION_TRIGGER 0x0000010 Constant to activate the trigger of the Integration units.
AWG_INTEGRATION_ARM 0x3ff0000 Constant to arm the Integration units.
DEVICE_SAMPLE_RATE <actual device sample rate>
ZSYNC_DATA_RAW 0 Constant to use as argument to getZSyncData.
QA_INT_0 0b0000000001 << 16
Constant to enable Integration unit 0 in the Integration unit enable mask of the function startQA(). To construct more elaborate masks that enable multiple units, combine these predefined constants using the operator
QA_INT_1 0b0000000010 << 16
Constant to enable Integration unit 1 in the Integration unit enable mask of the function startQA(). To construct more elaborate masks that enable multiple units, combine these predefined constants using the operator
QA_INT_2 0b0000000100 << 16
Constant to enable Integration unit 2 in the Integration unit enable mask of the function startQA(). To construct more elaborate masks that enable multiple units, combine these predefined constants using the operator
QA_INT_3 0b0000001000 << 16
Constant to enable Integration unit 3 in the Integration unit enable mask of the function startQA(). To construct more elaborate masks that enable multiple units, combine these predefined constants using the operator
QA_INT_4 0b0000010000 << 16
Constant to enable Integration unit 4 in the Integration unit enable mask of the function startQA(). To construct more elaborate masks that enable multiple units, combine these predefined constants using the operator
QA_INT_5 0b0000100000 << 16
Constant to enable Integration unit 5 in the Integration unit enable mask of the function startQA(). To construct more elaborate masks that enable multiple units, combine these predefined constants using the operator
QA_INT_6 0b0001000000 << 16
Constant to enable Integration unit 6 in the Integration unit enable mask of the function startQA(). To construct more elaborate masks that enable multiple units, combine these predefined constants using the operator
QA_INT_7 0b0010000000 << 16
Constant to enable Integration unit 7 in the Integration unit enable mask of the function startQA(). To construct more elaborate masks that enable multiple units, combine these predefined constants using the operator
QA_INT_8 0b0100000000 << 16
Constant to enable Integration unit 8 in the Integration unit enable mask of the function startQA(). To construct more elaborate masks that enable multiple units, combine these predefined constants using the operator
QA_INT_9 0b1000000000 << 16
Constant to enable Integration unit 9 in the Integration unit enable mask of the function startQA(). To construct more elaborate masks that enable multiple units, combine these predefined constants using the operator
QA_INT_ALL 0b1111111111 << 16
Constant to enable all Integration units in the Integration unit enable mask of the function startQA().
AWG_CHAN1 1 Constant to select channel 1.
AWG_CHAN2 2 Constant to select channel 2.
AWG_MARKER1 1 Constant to select marker 1.
AWG_MARKER2 2 Constant to select marker 2.
AWG_OSC_PHASE_START 1 Constant to trigger the oscillator phase on the positive edge.
AWG_OSC_PHASE_MIDDLE 0 Constant to trigger the oscillator phase on the negative edge.
AWG_USERREG_SWEEP_COUNT0 35 Constant for the sweep count register 0.
AWG_USERREG_SWEEP_COUNT1 36 Constant for the sweep count register 1.

Numbers can be expressed using either of the following formatting.

const a = 10;            // Integer notation
const b = -10;           // Negative number
const h = 0xdeadbeef;    // Hexadecimal integer
const bin = 0b10101;     // Binary integer
const f = 0.1e-3;        // Floating point number.
const not_float = 10e3;  // Not a floating point number

Booleans are specified with the keywords true and false. Furthermore, all numbers that evaluate to a nonzero value are considered true. All numbers that evaluate to zero are considered false.

Strings are delimited using "" and are interpreted as constants. Strings may be concatenated using the + operator.

string AWG_PATH = "awgs/0/";
string AWG_GAIN_PATH = AWG_PATH + "gains/0";

Waveform Generation and Editing

The following table contains the definition of functions for waveform generation.

wave zeros(const samples)

Constant amplitude of 0 over the defined number of samples.

\[ \[ h(x) = 0 \] \]

Args:

  • samples: Number of samples in the waveform

Returns:

resulting waveform

wave ones(const samples)

Constant amplitude of 1 over the defined number of samples.

\[ \[ h(x) = 1 \] \]

Args:

  • samples: Number of samples in the waveform

Returns:

resulting waveform

wave sine(const samples, const amplitude=1.0, const phaseOffset, const nrOfPeriods)

Sine function with arbitrary amplitude (a), phase offset in radians (p), number of periods (f) and number of samples (N).

\[ \[ h(x) = a\cdot\sin(2\pi f \frac{x}{N}+p) \] \]

Args:

  • amplitude: Amplitude of the signal (optional)

  • nrOfPeriods: Number of Periods within the defined number of samples

  • phaseOffset: Phase offset of the signal in radians

  • samples: Number of samples in the waveform

Returns:

resulting waveform

wave cosine(const samples, const amplitude=1.0, const phaseOffset, const nrOfPeriods)

Cosine function with arbitrary amplitude (a), phase offset in radians (p), number of periods (f) and number of samples (N).

\[ \[ h(x) = a\cdot\cos(2\pi f \frac{x}{N}+p) \] \]

Args:

  • amplitude: Amplitude of the signal (optional)

  • nrOfPeriods: Number of Periods within the defined number of samples

  • phaseOffset: Phase offset of the signal in radians

  • samples: Number of samples in the waveform

Returns:

resulting waveform

wave sinc(const samples, const amplitude=1.0, const position, const beta)

Normalized sinc function with control of peak position (p), amplitude (a), width (\beta) and number of samples (N).

\[ \[ h(x) = \begin{cases} a & \quad \text{if } x = p \\ a \cdot \frac{\sin(2\pi\cdot beta\cdot \frac{x-p}{N})}{2\pi\cdot beta\cdot \frac{x-p}{N}} & \quad \text{else} \\ \end{cases} \] \]

Args:

  • amplitude: Amplitude of the signal (optional)

  • beta: Width of the function

  • position: Peak position of the function

  • samples: Number of samples in the waveform

Returns:

resulting waveform

wave ramp(const samples, const startLevel, const endLevel)

Linear ramp from the start (s) to the end level (e) over the number of samples (N).

\[ \[ h(x) = s + \frac{x(e-s)}{N-1} \] \]

Args:

  • endLevel: level at the last sample of the waveform

  • samples: Number of samples in the waveform

  • startLevel: level at the first sample of the waveform

Returns:

resulting waveform

wave sawtooth(const samples, const amplitude=1.0, const phaseOffset, const nrOfPeriods)

Sawtooth function with arbitrary amplitude, phase in radians and number of periods.

Args:

  • amplitude: Amplitude of the signal

  • nrOfPeriods: Number of Periods within the defined number of samples

  • phaseOffset: Phase offset of the signal in radians

  • samples: Number of samples in the waveform

Returns:

resulting waveform

wave triangle(const samples, const amplitude=1.0, const phaseOffset, const nrOfPeriods)

Triangle function with arbitrary amplitude, phase in radians and number of periods.

Args:

  • amplitude: Amplitude of the signal

  • nrOfPeriods: Number of Periods within the defined number of samples

  • phaseOffset: Phase offset of the signal in radians

  • samples: Number of samples in the waveform

Returns:

resulting waveform

wave gauss(const samples, const amplitude=1.0, const position, const width)

Gaussian pulse with arbitrary amplitude (a), position (p), width (w) and number of samples (N).

\[ \[ h(x) = a \cdot e^{-\frac{(x-p)^2}{2 \cdot w^2}} \] \]

Args:

  • amplitude: Amplitude of the signal (optional)

  • position: Peak position of the pulse

  • samples: Number of samples in the waveform

  • width: Width of the pulse

Returns:

resulting waveform

wave drag(const samples, const amplitude=1.0, const position, const width)

Derivative of Gaussian pulse with arbitrary amplitude (a), position (p), width (w) and number of samples (N) normalized to a maximum amplitude of 1.

\[ \[ h(x) = a \cdot \frac{\sqrt{e}(p-x)}{w} \cdot e^{-\frac{(x-p)^2}{2 \cdot w^2}} \] \]

Args:

  • amplitude: Amplitude of the signal (optional)

  • position: Center point position of the pulse

  • samples: Number of samples in the waveform

  • width: Width of the pulse

Returns:

resulting waveform

wave blackman(const samples, const amplitude=1.0, const alpha)

Blackman window function with arbitrary amplitude (a), alpha parameter and number of samples (N).

\[ \begin{align} h(x) =& a \cdot (\alpha_0 - \alpha_1 \cos(\frac{2\pi x}{N-1}) \\ &+ \alpha_2\cos(\frac{4\pi x}{N-1})) \\ \alpha_0 =& \frac{1-\alpha}{2}; \quad \alpha_1 = \frac{1}{2}; \quad \alpha_2 = \frac{\alpha}{2}; \end{align} \]

Args:

  • alpha: Width of the function

  • amplitude: Amplitude of the signal (optional)

  • samples: Number of samples in the waveform

Returns:

resulting waveform

wave hamming(const samples, const amplitude=1.0)

Hamming window function with arbitrary amplitude (a) and number of samples (N).

\[ \begin{align} h(x) = a \cdot (\alpha - \beta \cos(\frac{2\pi x}{N-1})) \\ \text{with }\alpha = 0.54 \text{ and } \beta = 0.46 \end{align} \]

Args:

  • amplitude: Amplitude of the signal (optional)

  • samples: Number of samples in the waveform

Returns:

resulting waveform

wave hann(const samples, const amplitude=1.0)

Hann window function with arbitrary amplitude (a) and number of samples (N).

\[ \[ h(x) = a \cdot 0.5 \cdot (1 - \cos(\frac{2\pi x}{N-1})) \] \]

Args:

  • amplitude: Amplitude of the signal

  • samples: Number of samples in the waveform

Returns:

resulting waveform

wave rect(const samples, const amplitude)

Rectangle function, constants amplitude (a) over the defined number of samples.

\[ \[ h(x) = \text{a} \] \]

Args:

  • amplitude: Amplitude of the signal

  • samples: Number of samples in the waveform

Returns:

resulting waveform

wave marker(const samples, const markerValue)

Generate a waveform with marker bits set to the specified value. The analog part of the waveform is zero.

Args:

  • markerValue: Value of the marker bits

  • samples: Number of samples in the waveform

Returns:

resulting waveform

wave rand(const samples, const amplitude=1.0, const mean, const stdDev)

White noise with arbitrary amplitude, power and standard deviation.

Args:

  • amplitude: Amplitude of the signal

  • mean: Average signal level

  • samples: Number of samples in the waveform

  • stdDev: Standard deviation of the noise signal

Returns:

resulting waveform

wave randomGauss(const samples, const amplitude=1.0, const mean, const stdDev)

White noise with arbitrary amplitude, power and standard deviation.

Args:

  • amplitude: Amplitude of the signal

  • mean: Average signal level

  • samples: Number of samples in the waveform

  • stdDev: Standard deviation of the noise signal

Returns:

resulting waveform

wave randomUniform(const samples, const amplitude=1.0)

Random waveform with uniform distribution.

Args:

  • amplitude: Amplitude of the signal

  • samples: Number of samples in the waveform

Returns:

resulting waveform

wave lfsrGaloisMarker(const samples, const markerBit, const polynomial, const initial)

Generate a waveform with specified marker bit set to the Galois LFSR (linear-feedback shift register) generated sequence. The analog part of the waveform is zero. The LFSR characteristic polynomial is a member of the Galois Field of two elements and represented in binary form. See wikipedia entries for "Finite field arithmetic" and "Linear-feedback shift register (Galois LFSR)".

Args:

  • initial: LFSR initial state, any nonzero value will work, usually 0x1

  • markerBit: Marker bit to set (1 or 2)

  • polynomial: LFSR characteristic polynomial in binary representation (max shift length 32), use 0x90000 for QRSS / PRBS-20

  • samples: Number of samples in the waveform

Returns:

resulting waveform

wave chirp(const samples, const amplitude=1.0, const startFreq, const stopFreq, const phase=0)

Frequency chirp function with arbitrary amplitude, start and stop frequency, initial phase in radians and number of samples. Start and stop frequency are expressed in units of the AWG Sampling Rate. The amplitude can only be defined if the initial phase is defined as well.

Args:

  • amplitude: Amplitude of the signal (optional)

  • phase: Initial phase of the signal (optional)

  • samples: Number of samples in the waveform

  • startFreq: Start frequency of the signal

  • stopFreq: Stop Frequency of the signal

Returns:

resulting waveform

wave rrc(const samples, const amplitude=1.0, const position, const beta, const width)

Root raised cosine function with arbitrary amplitude (a), position (p), roll-off factor (\beta) and width (w) and number of samples (N).

\[ \begin{align} h(y) = a \frac{\sin(y \pi(1-\beta)) + 4 y \beta\cos(y \pi(1+\beta))}{y \pi(1-(4 y \beta)^2)} \\ \text{with } y(x) = 2 w \frac{x - p}{N} \end{align} \]

Args:

  • amplitude: Amplitude of the signal

  • beta: Roll-off factor

  • position: Center point position of the pulse

  • samples: Number of samples in the waveform

  • width: Width of the pulse

Returns:

Resulting waveform

wave vect(const value,...)

Specify a waveform sample by sample. Each sample is defined by one of an arbitrary number of input arguments. Only recommended for short waveforms that consist of less than 100 samples. Larger waveforms may be defined in a CSV file.

Args:

  • value: Waveform amplitude at the respective sample

Returns:

resulting waveform

wave placeholder(const samples, const marker0=false, const marker1=false)

Creates space for a single-channel waveform, optionally with markers, without actually generating any waveform data when compiling the sequence program. Actual waveform data needs to be uploaded separately via the "<dev>/AWGS/<n>/WAVEFORM/WAVES/<index>" API nodes after the sequence compilation and upload. The waveform index can be explicitly assigned to the generated placeholder wave using the assignWaveIndex instruction.

Args:

  • marker0: true if marker bit 0 must be used (default false)

  • marker1: true if marker bit 1 must be used (default false)

  • samples: Number of samples in the waveform

Returns:

waveform object

The following table contains the definition of functions for waveform editing.

wave join(wave wave1, wave wave2, const interpolLength=0)

Connect two or more waveforms with optional linear interpolation between the waveforms.

Args:

  • interpolLength: Number of samples to interpolate between waveforms (optional, default 0)

  • wave1: Input waveform

  • wave2: Input waveform

Returns:

joined waveform

wave join(wave wave1, wave wave2,...)

Connect two or more waveforms.

Args:

  • wave1: Input waveform

  • wave2: Input waveform

Returns:

joined waveform

wave interleave(wave wave1, wave wave2,...)

Interleave two or more waveforms sample by sample.

Args:

  • wave1: Input waveform

  • wave2: Input waveform

Returns:

interleaved waveform

wave add(wave wave1, wave wave2,...)

Add two or more waveforms sample by sample. Alternatively, the "+" operator may be used for waveform addition.

Args:

  • wave1: Input waveform

  • wave2: Input waveform

Returns:

sum waveform

wave multiply(wave wave1, wave wave2,...)

Multiply two or more waveforms sample by sample. Alternatively, the "*" operator may be used for waveform multiplication.

Args:

  • wave1: Input waveform

  • wave2: Input waveform

Returns:

product waveform

wave scale(wave waveform, const factor)

Scale the input waveform with the factor and return the scaled waveform. The input waveform remains unchanged.

Args:

  • factor: Scaling factor

  • waveform: Input waveform

Returns:

scaled waveform

wave flip(wave waveform)

Flip the input waveform back to front and return the flipped waveform. The input waveform remains unchanged.

Args:

  • waveform: Input waveform

Returns:

flipped waveform

wave cut(wave waveform, const from, const to)

Cuts a segment out of the input waveform and returns it. The input waveform remains unchanged. The segment is flipped in case that "from" is larger than "to".

Args:

  • from: First sample of the cut waveform

  • to: Last sample of the cut waveform

  • waveform: Input waveform

Returns:

cut waveform

wave filter(wave b, wave a, wave x)

Filter generates a rational transfer function with the waveforms a and b as numerator and denominator coefficients. The transfer function is normalized by the first element of a, which has to be non-zero. The filter is applied to the input waveform x and returns the filtered waveform.

\[ \begin{align} y(n) = \frac{1}{a_0}\left(\!\sum_{i=0}^{M}b_i x_{n-i} - \sum_{i=1}^{N}a_i y_{n-i}\!\right) \\ \text{with } M = \text{length}(b)-1 \\ \text{ and } N = \text{length}(a)-1 \end{align} \]

Args:

  • a: Denominator coefficients

  • b: Numerator coefficients

  • x: Input waveform

Returns:

filtered waveform

wave circshift(wave a, const n)

Circularly shifts a 1D waveform and returns it.

Args:

  • n: Number of elements to shift

  • waveform: Input waveform

Returns:

circularly shifted waveform

Waveform Playback and Predefined Functions

The following table contains the definition of functions for waveform playback and other purposes.

void setDIO(var value)

Writes the value as a 32-bit value to the DIO bus.

The value can be either a const or a var value. Configure the Mode setting in the DIO tab when using this command. The DIO interface speed of 50 MHz limits the rate at which the DIO output value is updated.

Args:

  • value: The value to write to the DIO (const or var)
var getDIO()

Reads a 32-bit value from the DIO bus.

Returns:

var containing the read value

var getDIOTriggered()

Reads a 32-bit value from the DIO bus as recorded at the last DIO trigger position.

Returns:

var containing the read value

void setTrigger(var value)

Sets the AWG Trigger output signals.

The state of all four AWG Trigger output signals is represented by the bits in the binary representation of the integer value. Binary notation of the form 0b0000 is recommended for readability.

Args:

  • value: to be written to the trigger output lines
void wait(var cycles)

Waits for the given number of Sequencer clock cycles (4.44 ns per cycle).

Args:

  • cycles: number of cycles to wait
void waitTrigger(const mask, const value)

Waits until the masked trigger input is equal to the given value.

Args:

  • mask: mask to be applied to the input signal

  • value: value to be compared with the trigger input

void waitDIOTrigger()

Waits until the DIO interface trigger is active. The trigger is specified by the Strobe Index and Strobe Slope settings in the AWG Sequencer tab.

var getDigTrigger(const index)

Gets the state of the indexed Digital Trigger input (1 or 2 on UHF, 1-8 on HDAWG).

The physical signal connected to the AWG Digital Trigger input is to be configured in the Trigger sub-tab of the AWG tab.

Args:

  • index: index of the Digital Trigger input to be read; can be either 1 or 2 on UHF, or 1-8 on HDAWG

Returns:

trigger state, either 0 or 1

void error(string msg,...)

Throws the given error message when reached.

Args:

  • msg: Message to be displayed
void info(string msg,...)

Returns the specified message when reached.

Args:

  • msg: Message to be displayed
void setInt(string path, var value)

Writes an integer value to one of the nodes in the device.

If the path does not start with a device identifier, then the current device is assumed.

Args:

  • path: The node path to be written to

  • value: The integer value to be written

void setDouble(string path, var value)

Writes a floating point value to one of the nodes in the device.

If the path does not start with a device identifier, then the current device is assumed.

Args:

  • path: The node path to be written to

  • value: The integer or floating point value to be written

void setDouble(string path, var value, const scale)

Writes a floating point value to one of the nodes in the device.

If the path does not start with a device identifier, then the current device is assumed.

Args:

  • path: The node path to be written to

  • scale: Scaling value to be applied to the value before writing to the node

  • value: The integer or floating point value to be written

void setID(var id)

Sets the ID value that is attached to data streamed from the device to the host PC. The ID value is useful for synchronizing the data acquisition process in combination with the Sweeper or the Software Trigger. The ID value is denoted AWG Seq Index in the tree of tools like the plotter.

Args:

  • id: The new ID to be attached to streaming data of the device
void setSeqIndex(var id)

Sets the ID value that is attached to data streamed from the device to the host PC. The ID value is useful for synchronizing the data acquisition process in combination with the Sweeper or the Software Trigger. The ID value is denoted AWG Seq Index in the tree of tools like the plotter. The setSeqIndex function is identical to the setID function.

Args:

  • id: The new ID to be attached to streaming data of the device
void sync()

Perform Multi-Device synchronization command for all devices at this point. Leader/Follower assignment is automatic.

Only for programs running on multiply synchronized instruments.

void waitWave()

Waits until the AWG is done playing the current waveform.

void setRate(const rate)

Overwrites the default Sampling Rate for the following playWave commands.

Args:

  • rate: New default sampling rate
void randomSeed()

Generate a new seed for the subsequent random vector commands.

void assignWaveIndex(const output, wave waveform, const index)
void assignWaveIndex(wave waveform, const index)
void playWave(const output, wave waveform, const rate=AWG_RATE_DEFAULT)

Starts to play the given waveforms on the defined output channels. The playback begins as soon as the previous waveform playback is finished.

Args:

  • output: defines on which output the following waveform is played

  • rate: sample rate with which the AWG plays the waveforms (default set in the user interface).

  • waveform: waveform to be played

void playWave(const output, wave waveform,...)

Starts to play the given waveforms on the defined output channels. It can contain multiple waveforms with an output definition. The playback begins as soon as the previous waveform playback is finished.

Args:

  • output: defines on which output the following waveform is played

  • waveform: waveform to be played

void playWave(wave waveform, const rate=AWG_RATE_DEFAULT)

Starts to play the given waveforms, output channels are assigned automatically depending on the number of input waveforms. The playback begins as soon as the previous waveform playback is finished.

Args:

  • rate: sample rate with which the AWG plays the waveforms (default set in the user interface).

  • waveform: waveform to be played

void playWave(wave waveform,...)

Starts to play the given waveforms, output channels are assigned automatically depending on the number of input waveforms. The playback begins as soon as the previous waveform playback is finished.

Args:

  • waveform: waveform to be played
void setUserReg(const register, var value)

Writes a value to one of the User Registers (indexed 0 to 15).

The User Registers may be used for communicating information to the LabOne User Interface or a running API program.

Args:

  • register: The register index (0 to 15) to be written to

  • value: The integer value to be written

var getUserReg(const register)

Reads the value from one of the User Registers (indexed 0 to 15). The User Registers may be used for communicating information to the LabOne User Interface or a running API program.

Args:

  • register: The register to be read (0 to 15)

Returns:

current register value

void playZero(const samples)
void playZero(const samples, const rate)
void playWaveNow(const output, wave waveform, const rate=AWG_RATE_DEFAULT)

Starts to play the given waveforms on the defined output channels. It starts immediately even if the previous waveform playback is still in progress.

Args:

  • output: defines on which output the following waveform is played

  • rate: sample rate with which the AWG plays the waveforms (default set in the user interface).

  • waveform: waveform to be played

void playWaveNow(const output, wave waveform,...)

Starts to play the given waveforms on the defined output channels. It can contain multiple waveforms with an output definition. It starts immediately even if the previous waveform playback is still in progress.

Args:

  • output: defines on which output the following waveform is played

  • waveform: waveform to be played

void playWaveNow(wave waveform, const rate=AWG_RATE_DEFAULT)

Starts to play the given waveforms, channels are assigned automatically depending on the number of input waveforms. It starts immediately even if the previous waveform playback is still in progress.

Args:

  • rate: sample rate with which the AWG plays the waveforms (default set in the user interface).

  • waveform: waveform to be played

void playWaveNow(wave waveform,...)

Starts to play the given waveforms, channels are assigned automatically depending on the number of input waveforms. It starts immediately even if the previous waveform playback is still in progress.

Args:

  • waveform: waveform to be played
void playWaveIndexed(const output, wave waveform, var offset, const length, const rate=AWG_RATE_DEFAULT)

Starts to play the specified part of the given waveforms on the defined output channels. It can contain multiple waveforms with an output definition. The playback begins as soon as the previous waveform playback is finished.

Args:

  • length: number of samples to be played from this waveform

  • offset: offset in samples from the start of the waveform

  • output: defines on which output the following waveform is played

  • rate: sample rate with which the AWG plays the waveforms (default set in the user interface).

  • waveform: waveform to be played

void playWaveIndexed(wave waveform, var offset, const length, const rate=AWG_RATE_DEFAULT)

Starts to play the specified part of the given waveforms, channels are assigned automatically depending on the number of input waveforms. The playback begins as soon as the previous waveform playback is finished.

Args:

  • length: number of samples to be played from this waveform

  • offset: offset in samples from the start of the waveform

  • rate: sample rate with which the AWG plays the waveforms (default set in the user interface).

  • waveform: waveform to be played

void playWaveIndexedNow(const output, wave waveform, var offset, const length, const rate=AWG_RATE_DEFAULT)

Starts to play the specified part of the given waveforms on the defined output channels. It can contain multiple waveforms with an output definition. It starts immediately even if the previous waveform playback is still in progress.

Args:

  • length: number of samples to be played from this waveform

  • offset: offset in samples from the start of the waveform

  • output: defines on which output the following waveform is played

  • rate: sample rate with which the AWG plays the waveforms (default set in the user interface).

  • waveform: waveform to be played

void playWaveIndexedNow(wave waveform, var offset, const length, const rate=AWG_RATE_DEFAULT)

Starts to play the specified part of the given waveforms, channels are assigned automatically depending on the number of input waveforms. It starts immediately even if the previous waveform playback is still in progress.

Args:

  • length: number of samples to be played from this waveform

  • offset: offset in samples from the start of the waveform

  • rate: sample rate with which the AWG plays the waveforms (default set in the user interface).

  • waveform: waveform to be played

void playDIOWave(wave waveform, const rate=AWG_RATE_DEFAULT)

Starts to play the given waveforms, channels are assigned automatically depending on the number of input waveforms, with enabled 4-channel-mode. Configure the Signal and Channel settings in the Aux tab in combination with this function. The playback begins as soon as the previous waveform playback is finished.

Args:

  • rate: sample rate with which the AWG plays the waveforms (default set in the user interface).

  • waveform: waveform to be played

void playDIOWave(wave waveform,...)

Starts to play the given waveforms, channels are assigned automatically depending on the number of input waveforms, with enabled 4-channel-mode. Configure the Signal and Channel settings in the Aux tab in combination with this function. The playback begins as soon as the previous waveform playback is finished.

Args:

  • waveform: waveform to be played
void playAuxWave(const output, wave waveform, const rate=AWG_RATE_DEFAULT)

Starts to play the given waveforms on the defined output channels with enabled 4-channel-mode. Configure the Signal and Channel settings in the Aux tab in combination with this function. The playback begins as soon as the previous waveform playback is finished.

Args:

  • output: defines on which output the following waveform is played

  • rate: sample rate with which the AWG plays the waveforms (default set in the user interface).

  • waveform: waveform to be played

void playAuxWave(const output, wave waveform,...)

Starts to play the given waveforms on the defined output channels with enabled 4-channel-mode. It can contain multiple waveforms with an output definition. Configure the Signal and Channel settings in the Aux tab in combination with this function. The playback begins as soon as the previous waveform playback is finished.

Args:

  • output: defines on which output the following waveform is played

  • waveform: waveform to be played

void playAuxWave(wave waveform, const rate=AWG_RATE_DEFAULT)

Starts to play the given waveforms, channels are assigned automatically depending on the number of input waveforms, with enabled 4-channel-mode. Configure the Signal and Channel settings in the Aux tab in combination with this function. The playback begins as soon as the previous waveform playback is finished.

Args:

  • rate: sample rate with which the AWG plays the waveforms (default set in the user interface).

  • waveform: waveform to be played

void playAuxWave(wave waveform,...)

Starts to play the given waveforms, channels are assigned automatically depending on the number of input waveforms, with enabled 4-channel-mode. Configure the Signal and Channel settings in the Aux tab in combination with this function. The playback begins as soon as the previous waveform playback is finished.

Args:

  • waveform: waveform to be played
void playAuxWaveIndexed(const output, wave waveform, var offset, const length, const rate=AWG_RATE_DEFAULT)

Starts to play the specified part of the given waveforms on the defined output channels with enabled 4-channel-mode. Configure the Signal and Channel settings in the Aux tab in combination with this function. The playback begins as soon as the previous waveform playback is finished.

Args:

  • length: number of samples to be played from this waveform

  • offset: offset in samples from the start of the waveform

  • output: defines on which output the following waveform is played

  • rate: sample rate with which the AWG plays the waveforms (default set in the user interface).

  • waveform: waveform to be played

void playAuxWaveIndexed(wave waveform, var offset, const length, const rate=AWG_RATE_DEFAULT)

Starts to play the specified part of the given waveforms, channels are assigned automatically depending on the number of input waveforms, with enabled 4-channel-mode. Configure the Signal and Channel settings in the Aux tab in combination with this function. The playback begins as soon as the previous waveform playback is finished.

Args:

  • length: number of samples to be played from this waveform

  • offset: offset in samples from the start of the waveform

  • rate: sample rate with which the AWG plays the waveforms (default set in the user interface).

  • waveform: waveform to be played

void waitAnaTrigger(const index, const value)

Waits until the indexed Analog Trigger input (1 or 2) is equal to the given value (0 or 1). The physical signal connected to the AWG Analog Trigger inputs as well as the trigger level is to be configured in the Trigger sub-tab of the AWG tab.

Args:

  • index: index of the analog trigger input to be waited on; can be either 1 or 2 on UHF, or 1 to 8 on HDAWG

  • value: value to be compared with the Analog Trigger input, can be either 0 or 1

var getAnaTrigger(const index)

Gets the state of the indexed Analog Trigger input (1 or 2 on UHF, 1-8 on HDAWG).

The physical signal connected to the AWG Analog Trigger inputs as well as the trigger level is to be configured in the Trigger sub-tab of the AWG tab.

Args:

  • index: index of the Analog Trigger input to be read; an be either 1 or 2 on UHF, or 1-8 on HDAWG

Returns:

trigger state, either 0 or 1

var getSweeperLength(const index)

Reads the sweep Length as configured in the Sweeper tab. The length is only valid when AWG Control is enabled in the Sweeper tab.

Args:

  • index: The index of the Sweeper parameter. Currently only the value of 1 is accepted.

Returns:

length configured by the Sweeper

void now()

Resets the local timer.

void at(var time)

Waits until the local timer reaches the given value.

Args:

  • time: value to wait for
void lock(wave waveform)

Ensures that the waveform is kept in the cache memory until the unlock command is used.

Args:

  • waveform: The waveform to lock
void unlock(wave waveform)

Allow the compiler to use this memory block again to cache other waveforms.

Only valid after the waveform was previously locked using the lock command.

Args:

  • waveform: The waveform to unlock
void waitDigTrigger(const index, const value)

Waits until the indexed Digital Trigger (1 or 2) is equal to the given value (0 or 1). The physical signals connected to the two AWG Digital Triggers are to be configured in the Trigger sub-tab of the AWG tab.

Args:

  • index: index of the digital trigger input to be waited on; can be either 1 or 2

  • value: value to be compared with the digital trigger input, can be either 0 or 1

void startQA(const weighted_integrator_mask, const monitor, const result_address, const trigger)

Starts the Quantum Analysis Result and Input units by setting and clearing appropriate AWG trigger output signals. The choice of whether to start one or the other or both units can be controlled using the command argument. An bitmask may be used to select explicitly which of the ten possible qubit results should be read. If no qubit results are enabled, then the Quantum Analysis Result unit will not be triggered. An optional value may be used to set the normal trigger outputs of the AWG together with starting the Quantum Analysis Result and input units. If the value is not used, then the trigger signals will be cleared.

Args:

  • monitor: Enable for QA monitor, default: false

  • result_address: Set address associated with result, default: 0x0

  • trigger: Trigger value, default: 0x0

  • weighted_integrator_mask: Integration unit enable mask, default: QA_INT_ALL

var startQAResult(const mask, const trigger)

Starts the Quantum Analysis Result unit by setting and clearing appropriate AWG trigger output signals. An optional bitmask may be used to select explicitly which of the ten possible qubit results should be read. An optional value may be used to set the normal trigger outputs of the AWG together with starting the Quantum Analysis Result unit. If the value is not used, then the trigger signals will be cleared.

Args:

  • mask: bitmask defining which of the ten qubit results should be read

  • trigger: bitmask to apply to the normal trigger outputs, similar in use to the setTrigger command

var startQAMonitor(const trigger)

Starts the Quantum Analysis Monitor unit by setting and clearing appropriate AWG trigger output signals. An optional value may be used to set the normal trigger outputs of the AWG together with starting the Quantum Analysis Monitor unit. If the value is not used, then the trigger signals will be cleared.

Args:

  • trigger: bitmask to apply to the normal trigger outputs, similar in use to the setTrigger command
void setReadoutRegisterAddress(var results_address)
var getQAResult()

Reads the value from Quantum Analysis Result unit.

Returns:

current state of all measured qubits

void waitQAResultTrigger()

Waits until the Quantum Analysis Result unit has produced a new qubit measurement result.

void resetOscPhase()

Reset the phase of the oscillator controllable by the AWG core.

var getFeedback(const data_type)

Read the last feedback message. The argument specify which data the function should return.

Args:

  • data_type: Specifies which data the function should return: ZSYNC_DATA_RAW: Return the data received on the ZSync as-is without parsing. The structure of the message can change across different LabOne releases.

Returns:

var containing the read value

var getFeedback(const data_type, var wait_cycles)
void waitZSyncTrigger()

Waits for a trigger over ZSync.

void resetRTLoggerTimestamp()

Reset the timestamp counter of the Real-Time Logger.

Accessing Instrument Settings

Using the sequencer instructions setInt and setDouble, a large number of instrument settings may be accessed directly from the sequencer with a much shorter latency than when accessed via the LabOne API. The nodes accessible with setInt setDouble are a subset of the full list of device nodes accessible via the LabOne API (see Device Node Tree ) and are listed in the table below together with their data type, latency class, and timing determinicity characteristics.

There are 3 levels of latency performance depending on how the node settings are processed on the instrument. Nodes that are classified with latency "medium" are processed with the instrument firmware by a non-realtime processor. These nodes are set typically within 100 microseconds, however not with deterministic timing. For some of the nodes, additional time is needed to take effect due to the time scale of the related hardware settings, e.g. changing the settings of the analog signal path. This needs to be taken into account by including sufficient waiting time by a wait sequencer instruction after setting the node.

Nodes classified with latency "low" are processed with deterministic timing on a dedicated bus inside the FPGA. The latency is of the order of 100 nanoseconds. Nodes classified with latency "ultra-low", such as timing-critical phase changes, are accessed via their dedicated signal path on the FPGA, and offer similarly low and deterministic latency as e.g. playWave instructions.

Providing the node as a character string is less flexible from the AWG sequencer than from the API: wildcards (*) are not supported, the node cannot start with a dash (/), and the device ID cannot be specified since it is excluded that the sequencer accesses other devices. This code example illustrates these restrictions:

setDouble("oscs/1/freq", 1e6); // permitted
setDouble("oscs/*/freq", 1e6); // not permitted
setDouble("dev8000/oscs/1/freq", 1e6); // not permitted
setDouble("/dev8000/oscs/1/freq", 1e6); // not permitted
setDouble("/oscs/1/freq", 1e6); // not permitted

In the table, the sequence [i-j] indicate a numeric range of valid indices from i to j

Node Data type Latency Deterministic timing
demods/[0-7]/adcselect Integer medium no
demods/[0-7]/order Integer medium no
demods/[0-7]/rate Float medium no
demods/[0-7]/oscselect Integer medium no
demods/[0-7]/harmonic Integer medium no
demods/[0-7]/phaseshift Float medium no
demods/[0-7]/sinc Integer medium no
demods/[0-7]/bypass Integer medium no
demods/[0-7]/timeconstant Float medium no
demods/[0-7]/enable Integer medium no
scopes/0/enable Integer medium no
scopes/0/time Integer medium no
scopes/0/trigenable Integer medium no
scopes/0/trigrising Integer medium no
scopes/0/trigfalling Integer medium no
scopes/0/triglevel Float medium no
scopes/0/length Integer medium no
scopes/0/trigholdoff Float medium no
scopes/0/trigchannel Integer medium no
scopes/0/channels/[0-1]/inputselect Integer medium no
scopes/0/channels/[0-1]/bwlimit Integer medium no
scopes/0/segments/count Integer medium no
scopes/0/channel Integer medium no
scopes/0/single Integer medium no
scopes/0/trighysteresis/absolute Float medium no
scopes/0/cont Integer medium no
scopes/0/trighysteresis/relative Float medium no
scopes/0/trighysteresis/mode Integer medium no
scopes/0/trigforce Integer medium no
scopes/0/segments/counts/enable Integer medium no
scopes/0/trigstate Integer medium no
scopes/0/triggate/enable Integer medium no
scopes/0/triggate/inputselect Integer medium no
scopes/0/trigreference Float medium no
scopes/0/trigdelay Float medium no
scopes/0/trigholdofftriggerenable Integer medium no
scopes/0/trigholdofftrigger Integer medium no
scopes/0/channels/[0-1]/limitlower Float medium no
scopes/0/channels/[0-1]/limitupper Float medium no
sigins/[0-1]/ac Integer medium no
sigins/[0-1]/imp50 Integer medium no
sigins/[0-1]/bw Integer medium no
sigins/[0-1]/on Integer medium no
sigins/[0-1]/range Integer medium no
sigins/[0-1]/diff Integer medium no
sigins/[0-1]/autorange Integer medium no
sigins/[0-1]/scaling Float medium no
sigouts/0/on Integer medium no
sigouts/0/range Float medium no
sigouts/0/imp50 Integer medium no
sigouts/0/autorange Integer medium no
sigouts/[0-1]/on Integer medium no
sigouts/[0-1]/range Float medium no
sigouts/[0-1]/imp50 Integer medium no
sigouts/[0-1]/autorange Integer medium no
sigouts/[0-1]/offset Float medium no
sigouts/[0-1]/enables/[0-7] Integer medium no
sigouts/[0-1]/amplitudes/[0-7] Float medium no
mods/[0-1]/enable Integer medium no
mods/[0-1]/output Integer medium no
mods/[0-1]0/mode Integer medium no
mods/[0-1]/sidebands/[0-1]/mode Integer medium no
mods/[0-1]/freqdevenable Integer medium no
mods/[0-1]/freqdev Float medium no
mods/[0-1]/index Float medium no
mods/[0-1]/sampleenable Integer medium no
mods/[0-1]/operation Integer medium no
mods/[0-1]/rate Float medium no
mods/[0-1]/trigger Integer medium no
mods/[0-1]/carrier/inputselect Integer medium no
mods/[0-1]/sidebands/[0-1]/inputselect Integer medium no
mods/[0-1]/carrier/order Integer medium no
mods/[0-1]/sidebands/[0-1]/order Integer medium no
mods/[0-1]/carrier/timeconstant Float medium no
mods/[0-1]/sidebands/[0-1]/timeconstant Float medium no
mods/[0-1]/carrier/oscselect Integer medium no
mods/[0-1]/sidebands/[0-1]/oscselect Integer medium no
mods/[0-1]/carrier/harmonic Integer medium no
mods/[0-1]/sidebands/[0-1]/harmonic Integer medium no
mods/[0-1]/carrier/phaseshift Float medium no
mods/[0-1]/sidebands/[0-1]/phaseshift Float medium no
mods/[0-1]/carrier_enable Integer medium no
mods/[0-1]/sidebands/[0-1]/enable Integer medium no
mods/[0-1]/carrier_gain Float medium no
mods/[0-1]/sideband[0-1]_gain Float medium no
boxcars/[0-1]/enable Integer medium no
boxcars/[0-1]/periods Integer medium no
boxcars/[0-1]/windowstart Float medium no
boxcars/[0-1]/insel Integer medium no
boxcars/[0-1]/oscsel Integer medium no
boxcars/[0-1]/limitrate Float medium no
boxcars/[0-1]/baseline/enable Integer medium no
boxcars/[0-1]/baseline/windowstart Float medium no
boxcars/[0-1]/windowsize Float medium no
outputpwas/[0-1]/enable Integer medium no
outputpwas/[0-1]/single Integer medium no
outputpwas/[0-1]/oscselect Integer medium no
outputpwas/[0-1]/insel Integer medium no
outputpwas/[0-1]/mode Integer medium no
outputpwas/[0-1]/harmonic Integer medium no
outputpwas/[0-1]/shift Float medium no
outputpwas/[0-1]/termination Integer medium no
outputpwas/[0-1]/samplecount Long medium no
outputpwas/[0-1]/holdoff Float medium no
outputpwas/[0-1]/progress Float medium no
outputpwas/[0-1]/status Integer medium no
inputpwas/[0-1]/enable Integer medium no
inputpwas/[0-1]/single Integer medium no
inputpwas/[0-1]/oscselect Integer medium no
inputpwas/[0-1]/insel Integer medium no
inputpwas/[0-1]/mode Integer medium no
inputpwas/[0-1]/harmonic Integer medium no
inputpwas/[0-1]/shift Float medium no
inputpwas/[0-1]/termination Integer medium no
inputpwas/[0-1]/samplecount Long medium no
inputpwas/[0-1]/holdoff Float medium no
pids/[0-3]/enable Integer medium no
pids/[0-3]/demod/adcselect Integer medium no
pids/[0-3]/demod/order Integer medium no
pids/[0-3]/demod/timeconstant Float medium no
pids/[0-3]/setpoint Float medium no
pids/[0-3]/dlimittimeconstant Float medium no
pids/[0-3]/limitupper Float medium no
pids/[0-3]/limitlower Float medium no
pids/[0-3]/p Float medium no
pids/[0-3]/i Float medium no
pids/[0-3]/d Float medium no
pids/[0-3]/demod/harmonic Integer medium no
pids/[0-3]/outputchannel Integer medium no
pids/[0-3]/output Integer medium no
pids/[0-3]/phaseunwrap Integer medium no
pids/[0-3]/stream/rate Float medium no
pids/[0-3]/rate Float medium no
pids/[0-3]/mode Integer medium no
pids/[0-3]/inputsource Integer medium no
pids/[0-3]/inputchannel Integer medium no
pids/[0-3]/center Double medium no
pids/[0-3]/pll/automode Integer medium no
awgs/0/enable Integer medium no
awgs/0/single Integer medium no
awgs/0/time Integer medium no
awgs/0/userregs/[0-15]] Integer medium no
awgs/0/triggers/[0-1]/level Float medium no
awgs/0/triggers/[0-1]/hysteresis/absolute Float medium no
awgs/0/triggers/[0-1]/hysteresis/relative Float medium no
awgs/0/triggers/[0-1]/hysteresis/mode Integer medium no
awgs/0/triggers/[0-1]/rising Integer medium no
awgs/0/triggers/[0-1]/falling Integer medium no
awgs/0/triggers/[0-1]/channel Integer medium no
awgs/0/triggers/[0-1]/force Integer medium no
awgs/0/triggers/[0-1]/state Integer medium no
awgs/0/triggers/[0-1]/gate/enable Integer medium no
awgs/0/triggers/[0-1]/gate/inputselect Integer medium no
awgs/0/auxtriggers/[0-1]/channel Integer medium no
awgs/0/auxtriggers/[0-1]/rising Integer medium no
awgs/0/auxtriggers/[0-1]/falling Integer medium no
awgs/0/auxtriggers/[0-1]/state Integer medium no
awgs/0/outputs/[0-1]/amplitude Float medium no
awgs/0/outputs/[0-1]/mode Integer medium no
auxouts/[0-3]/preoffset Double medium no
auxouts/[0-3]/offset Float medium no
auxouts/[0-3]/scale Float medium no
auxouts/[0-3]/limitlower Float medium no
auxouts/[0-3]/limitupper Float medium no
auxouts/[0-3]/offset Integer medium no
auxouts/[0-3]/outputselect Integer medium no
auxouts/[0-3]/demodselect Integer medium no
triggers/in/[0-3]/imp50 Integer medium no
triggers/in/[0-3]/level Integer medium no
triggers/in/[0-3]/dcc_fedge Integer medium no
triggers/out/[0-3]/srcsel Integer medium no
triggers/out/[0-3]/dir Integer medium no
triggers/out/[0-3]/static_value Integer medium no
triggers/out/[0-3]/hold Integer medium no
triggers/out/[0-3]/delay Float medium no
aucarts/[0-1]/mode Integer medium no
aucarts/[0-1]/enable Integer medium no
aucarts/[0-1]/rate Float medium no
aucarts/[0-1]/ops/[0-1]/demodselect Integer medium no
aucarts/[0-1]/ops/[0-1]/value Integer medium no
aucarts/[0-1]/ops/[0-1]/coeff Integer medium no
aucarts/[0-1]/ops/[0-1]/scale Float medium no
aupolars/[0-1]/mode Integer medium no
aupolars/[0-1]/enable Integer medium no
aupolars/[0-1]/rate Float medium no
aupolars/[0-1]/reserved1 Integer medium no
aupolars/[0-1]/ops/[0-1]/demodselect Integer medium no
aupolars/[0-1]/ops/[0-1]/value Integer medium no
aupolars/[0-1]/ops/[0-1]/coeff Integer medium no
aupolars/[0-1]/ops/[0-1]/scale Float medium no
aupolars/[0-1]/flags Integer medium no
scopes/0/stream/enables/[0-1] Integer medium no
scopes/0/stream/rate Integer medium no
oscs/[0-7]/freq Frequency low yes
demods/[0-7]/oscselect Integer ultra-low yes
demods/[0-7]/phaseshift Integer ultra-low yes

Nodes accessible with setInt and setDouble

Expressions

Expressions may be used for making computations based on mathematical functions and operators. There are two kinds of expressions: those evaluated at compile time (the moment of clicking "Save" or "Save as...​" in the user interface), and those evaluated at run time (after clicking "Run/Stop" or "Start"). Compile-time evaluated expressions only involve constants (const) or compile-time variables (cvar) and can be computed at compile time by the host computer. Such expressions can make use of standard mathematical functions and floating point arithmetic. Run-time evaluated expressions involve variables (var) and are evaluated by the Sequencer on the instrument. Due to the limited computational capabilities of the Sequencer, these expressions may only operate on integer numbers and there are less operators available than at compile time.

The following table contains the list of mathematical functions supported at compile time.

Table 11: Mathematical Functions
Function Description
const abs(const c) absolute value
const acos(const c) inverse cosine
const acosh(const c) hyperbolic inverse cosine
const asin(const c) inverse sine
const asinh(const c) hyperbolic inverse sine
const atan(const c) inverse tangent
const atanh(const c) hyperbolic inverse tangent
const cos(const c) cosine
const cosh(const c) hyperbolic cosine
const exp(const c) exponential function
const ln(const c) logarithm to base e (2.71828...)
const log(const c) logarithm to the base 10
const log2(const c) logarithm to the base 2
const log10(const c) logarithm to the base 10
const sign(const c) sign function -1 if x<0; 1 if x>0
const sin(const c) sine
const sinh(const c) hyperbolic sine
const sqrt(const c) square root
const tan(const c) tangent
const tanh(const c) hyperbolic tangent
const ceil(const c) smallest integer value not less than the argument
const round(const c) round to nearest integer
const floor(const c) largest integer value not greater than the argument
const avg(const c1, const c2,...) mean value of all arguments
const max(const c1, const c2,...) maximum of all arguments
const min(const c1, const c2,...) minimum of all arguments
const pow(const base, const exp) first argument raised to the power of second argument
const sum(const c1, const c2,...) sum of all arguments

The following table contains the list of predefined mathematical constants. These can be used for convenience in compile-time evaluated expressions.

Table 12: Predefined Constants
Name Value Description
M_E 2.71828182845904523536028747135266250 e
M_LOG2E 1.44269504088896340735992468100189214 log2(e)
M_LOG10E 0.434294481903251827651128918916605082 log10(e)
M_LN2 0.693147180559945309417232121458176568 loge(2)
M_LN10 2.30258509299404568401799145468436421 loge(10)
M_PI 3.14159265358979323846264338327950288 pi
M_PI_2 1.57079632679489661923132169163975144 pi/2
M_PI_4 0.785398163397448309615660845819875721 pi/4
M_1_PI 0.318309886183790671537767526745028724 1/pi
M_2_PI 0.636619772367581343075535053490057448 2/pi
M_2_SQRTPI 1.12837916709551257389615890312154517 2/sqrt(pi)
M_SQRT2 1.41421356237309504880168872420969808 sqrt(2)
M_SQRT1_2 0.707106781186547524400844362104849039 1/sqrt(2)
Table 13: Operators supported at compile time
Operator Description Priority
= assignment -1
+=, -=, *=, /=, %=, &=, |=, <<=, >>= assignment by sum, difference, product, quotient, remainder, AND, OR, left shift, and right shift -1
|| logical OR 1
&& logical AND 2
| bit-wise logical OR 3
& bit-wise logical AND 4
!= not equal 5
== equal 5
<= less or equal 6
>= greater or equal 6
> greater than 6
< less than 6
<< arithmetic left bit shift 7
>> arithmetic right bit shift 7
+ addition 8
- subtraction 8
* multiplication 9
/ division 9
~ bit-wise logical negation 10
Table 14: Operators supported at run time
Operator Description Priority
= assignment -1
+=, -=, *=, /=, %=, &=, |=, <<=, >>= assignment by sum, difference, product, quotient, remainder, AND, OR, left shift, and right shift -1
|| logical OR 1
&& logical AND 2
| bit-wise logical OR 3
& bit-wise logical AND 4
== equal 5
!= not equal 5
<= less or equal 6
>= greater or equal 6
> greater than 6
< less than 6
<< left bit shift 7
>> right bit shift 7
+ addition 8
- subtraction 8
~ bit-wise logical negation 9

Control Structures

Functions may be declared using the var keyword. Procedures may be declared using the void keyword. Functions must return a value, which should be specified using the return keyword. Procedures can not return values. Functions and procedures may be declared with an arbitrary number of arguments. The return keyword may also be used without arguments to return from an arbitrary point within the function or procedure. Functions and procedures may contain variable and constant declarations. These declarations are local to the scope of the function or procedure.

var function_name(argument1, argument2, ...) {
  // Statements to be executed as part of the function.
  return constant-or-variable;
}

void procedure_name(argument1, argument2, ...) {
  // Statements to be executed as part of the procedure.
  // Optional return statement
  return;
}

An if-then-else structure is used to create a conditional branching point in a sequencer program.

// If-then-else statement syntax
if (expression) {
  // Statements to execute if 'expression' evaluates to 'true'.
} else {
  // Statements to execute if 'expression' evaluates to 'false'.
}

// If-then-else statement short syntax
(expression)?(statement if true):(statement if false)
// If-then-else statement example
const REQUEST_BIT     = 0x0001;
const ACKNOWLEDGE_BIT = 0x0002;
const IDLE_BIT        = 0x8000;
var dio = getDIO();
if (dio & REQUEST_BIT) {
  dio = dio | ACKNOWLEDGE_BIT;
  setDIO(dio);
} else {
  dio = dio | IDLE_BIT;
  setDIO(dio);
}

A switch-case structure serves to define a conditional branching point similarly to the if-then-else statement, but is used to split the sequencer thread into more than two branches. Unlike the if-then-else structure, the switch statement is synchronous, which means that the execution time is the same for all branches and determined by the execution time of the longest branch. If no default case is provided and no case matches the condition, all cases will be skipped. The case arguments need to be of type const.

// Switch-case statement syntax
switch (expression) {
  case const-expression:
    expression;
  ...
  default:
    expression;
}
// Switch-case statement example
switch (getDIO()) {
  case 0:
    playWave(gauss(1024,1.0,512,64));
  case 1:
    playWave(gauss(1024,1.0,512,128));
  case 2:
    playWave(drag(1024,1.0,512,64));
  default:
    playWave(drag(1024,1.0,512,128));
}

The for loop is used to iterate through a code block several times. The initialization statement is executed before the loop starts. The end-expression is evaluated at the start of each iteration and determines when the loop should stop. The loop is executed as long as this expression is true. The iteration-expression is executed at the end of each loop iteration.

Depending on how the for loop is set up, it can be either evaluated at compile time or at run time. Run-time evaluation is typically used to play series of waveforms. Compile-time evaluation is typically used for advanced waveform generation, e.g. to generate a series of waveforms with varying amplitude. For a run-time evaluated for loop, use the var data type as a loop index. To ensure that a loop is evaluated at compile time, use the cvar data type as a loop index. Furthermore, the compile-time for loop should only contain waveform generation/editing operations and it can’t contain any variables of type var. The following code example shows both versions of the loop.

// For loop syntax
for (initialization; end-expression; iteration-expression) {
  // Statements to execute while end-expression evaluates to true
}
// FOR loop example to assemble a train of pulses into
// a single waveform (compile-time execution)
cvar gain_factor; // CVAR: integer or float values allowed
wave w_pulse_series;
for (gain_factor = 0; gain_factor < 1.0; gain_factor = gain_factor + 0.1) {
  w_pulse_series = join(w_pulse_series, gain_factor*gauss(1008, 504, 100));
}

// Playback of waveform defined using compile-time FOR loop
playWave(w_pulse_series);

// FOR loop example to vary waiting time between
// waveform playbacks (run-time execution)
var i; // VAR: integer values allowed
for (i = 0; i < 1000; i = i + 100) {
  playWave(gauss(1008, 504, 100));
  waitWave();
  wait(i);
}

The while loop is a simplified version of the for loop. The end-expression is evaluated at the start of each loop iteration. The contents of the loop are executed as long as this expression is true. Like the for loop, this loop comes in a compile-time version (if the end-expression involves only cvar and const) and in a run-time version (if the end-expression involves also var data types).

// While loop syntax
while (end-expression) {
 // Statements to execute while end-expression evaluates to true
}
// While loop example
const STOP_BIT = 0x8000;
var run = 1;
var i = 0;
var dio = 0;
while (run) {
  dio = getDIO();
  run = dio & STOP_BIT;

  dio = dio | (i & 0xff);
  setDIO(dio);
  i = i + 1;
}

The repeat loop is a simplified version of the for loop. It repeats the contents of the loop a fixed number of times. In contrast to the for loop, the repetition number of the repeat loop must be known at compile time, i.e., const-expression can only depend on constants and not on variables. Unlike the for and the while loop, this loop comes only in a run-time version. Thus, no cvar data types may be modified in the loop body.

// Repeat loop syntax
repeat (constant-expression) {
  // Statements to execute
}
// Repeat loop example
repeat (100) {
  setDIO(0x1);
  wait(10);
  setDIO(0x0);
  wait(10);
}

Functional Elements

Table 15: AWG tab: Control sub-tab
Control/Tool Option/Range Description
Start Runs the AWG.
Sampling Rate 220 kSa/s to 1.8 GSa/s AWG sampling rate. This value is used by default and can be overridden in the Sequence program. The numeric values are rounded for display purposes. The exact values are equal to the base sampling rate divided by 2^n, where n is an integer between 0 and 13.
Round oscillator frequencies. Round oscillator frequencies to nearest commensurable with 225 MHz.
Amplitude (FS) 0.0 to 1.0 Amplitude in units of full scale of the given AWG Output. The full scale corresponds to the Range voltage setting of the Signal Outputs.
Mode Select between plain mode, amplitude modulation, and advanced mode.
Plain AWG Output goes directly to Signal Output.
Modulation AWG Output is multiplied with a sinusoid carrier signal. On UHFLI instruments, AWG Output 1 (2) is multiplied with oscillator signal of demodulator 4 (8). On UHFQA instruments, AWG Output 1 (2) is multiplied with the in-phase (quadrature) signal of the internal oscillator represented in the In/Out tab.
Advanced Output of AWG channel 1 (2) modulates demodulators 1-4 (5-8) with independent envelopes. Option not supported on UHFQA instruments.
Status Display compiler errors and warnings.
Compile Status grey/green/yellow/red Sequence program compilation status. Grey: No compilation started yet. Green: Compilation successful. Yellow: Compiler warnings (see status field). Red: Compilation failed (see status field).
Upload Progress 0% to 100% The percentage of the sequencer program already uploaded to the device.
Upload Status grey/yellow/green Indicates the upload status of the compiled AWG sequence. Grey: Nothing has been uploaded. Yellow: Upload in progress. Green: Compiled sequence has been uploaded.
Register selector Select the number of the user register value to be edited.
Register 0 to 2^32 Integer user register value. The sequencer has reading and writing access to the user register values during run time.
Input File External source code file to be compiled.
Example File Load pre-installed example sequence program.
New Create a new sequence program.
Revert Undo the changes made to the current program and go back to the contents of the original file.
Save (Ctrl+S) Compile and save the current program displayed in the Sequence Editor. Overwrites the original file.
Save as... (Ctrl+Shift+S) Compile and save the current program displayed in the Sequence Editor under a new name.
Automatic upload ON / OFF If enabled, the sequence program is automatically uploaded to the device after clicking Save and if the compilation was successful.
To Device Sequence program will be compiled and, if the compilation was successful, uploaded to the device.
Multi-Device ON / OFF Compile the program for use with multiple devices. If enabled, the program will be compiled for and uploaded to the devices currently synchronized in the Multi-Device Sync tab.
Sync Status grey/green/yellow Sequence program synchronization status. Grey: No program loaded on device. Green: Program in sync with device. Yellow: Sequence program in editor differs from the one running on the device.
Table 16: AWG tab: Waveform sub-tab
Control/Tool Option/Range Description
Wave Selection Select wave for display in the waveform viewer. If greyed out, the corresponding wave is too long for display.
Waveforms Lists all waveforms used by the current sequence program.
Mem Usage (%) 0 to 100 Amount of the used waveform data relative to the device cache memory. The cache memory provides space for 32 kSa of waveform data. Mem Usage > 100% means that waveforms must be loaded from the main memory (128 MSa per channel) during playback, which can lead to delays.
Table 17: AWG tab: Trigger sub-tab
Control/Tool Option/Range Description
Force Enforce a trigger event.
Trigger State grey/green State of the Trigger. Grey: No trigger detected. Green: Trigger detected.
Signal Selects the analog trigger source signal. Navigate through the tree view that appears and click on the required signal.
Slope Select the signal edge that should activate the trigger. The trigger will be level sensitive when the Level option is selected.
Level Level sensitive trigger.
Rise Rising edge trigger.
Fall Falling edge trigger.
Both Rising or falling edge trigger.
Level (V) numeric value Defines the analog trigger level.
Hysteresis Mode Selects the mode to define the hysteresis size. The relative mode will work best over the full input range as long as the analog input signal does not suffer from excessive noise.
Hysteresis (V) Selects absolute hysteresis.
Hysteresis (%) Selects a hysteresis relative to the adjusted full scale signal input range.
Hysteresis (V) trigger signal range (positive values only) Defines the voltage the source signal must deviate from the trigger level before the trigger is rearmed again. Set to 0 to turn it off. The sign is defined by the Edge setting.
Hysteresis (%) numeric percentage value (positive values only) Hysteresis relative to the adjusted full scale signal input range. A hysteresis value larger than 100% is allowed.
Gating Trigger In 4 Select the signal source used for trigger gating if gating is enabled.
Trigger In 3
Gating enable ON / OFF If enabled the trigger will be gated by the trigger gating input signal.
Auxiliary Trigger State grey/green State of the Auxiliary Trigger. Grey: No trigger detected. Green: Trigger detected.
Signal Selects the digital trigger source signal.
DIO/Zsync Trigger state grey/green Indicates that triggers are generated from the DIO or ZSync interface to the AWG.
Strobe Index 16 to 31 Selects the index n of the DIO interface bit (notation DIO[n] in the Specification chapter of the User Manual) to be used as a STROBE signal input in connection with the waitDIOTrigger sequencer instruction.
Strobe Slope Select the signal edge that activates the STROBE trigger in connection with the waitDIOTrigger sequencer instruction.
None Off
Rise Rising edge trigger
Fall Falling edge trigger
Both Rising or falling edge trigger
Valid Index 16 to 31 Selects the index n of the DIO interface bit (notation DIO[n] in the Specification chapter of the User Manual) to be used as a VALID signal input, i.e. a qualifier indicating that a valid codeword is available on the DIO interface.
Valid Polarity Polarity of the VALID bit that indicates that a codeword is available on the DIO interface.
None VALID bit is ignored.
Low VALID bit must be logical low.
High VALID bit must be logical high.
Both VALID bit may be logical high or logical low.
Table 18: AWG tab: Advanced sub-tab
Control/Tool Option/Range Description
Sequence Editor Display and edit the sequence program.
Assembly Text display Displays the current sequence program in compiled form. Every line corresponds to one hardware instruction.
AWG Core Display assembly information.
Counter Current position in the list of sequence instructions during execution.
Status Running, Idle, Waiting Displays the status of the sequencer on the instrument. Off: Ready, not running. Green: Running, not waiting for any trigger event. Yellow: Running, waiting for a trigger event. Red: Not ready (e.g., pending elf download, no elf downloaded)
Rerun ON / OFF Reruns the Sequencer program continuously. This way of looping a program results in timing jitter. For a jitter free signal implement a loop directly in the sequence program.
Mem Usage (%) 0 to 100 Size of the current sequence program relative to the device cache memory. The cache memory provides space for a maximum of 1024 instructions.
Status grey/green/red Displays the status of the command table of the selected AWG Core. Grey: no table description uploaded, Green: table description successfully uploaded, Red: Error occurred during uploading of the table description.