qmi.instruments.quantum_composers.pulse_generator9530

Instrument driver for the Quantum Composers 9530 pulse generator.

Classes

`OutputDriver`(value)	Output driver type.
`PulseMode`(value)	Pulse generator modes.
`QuantumComposers_PulseGenerator9530`(context, ...)	Instrument driver for the Quantum Composers 9530 pulse generator.
`RefClkSource`(value)	Reference clock sources.
`TriggerEdge`(value)	Trigger on rising or falling edge.
`TriggerMode`(value)	Trigger modes.

class qmi.instruments.quantum_composers.pulse_generator9530.RefClkSource(value)

Reference clock sources.

INTERNAL: Internal clock source.

EXTERNAL: External clock input.

EXTPLL: External clock signal with PLL.

class qmi.instruments.quantum_composers.pulse_generator9530.PulseMode(value)

Pulse generator modes.

NORMAL: Generate continuous pulse sequence (every input event causes an output pulse).

SINGLE: Generate just one pulse after the output is enabled.

BURST: Generate a fixed number of pulses after the output is enabled; then suppress further pulses.

DUTYCYCLE: Keep alternating between generating a fixed number of pulses and suppressing a fixed number of pulses.

class qmi.instruments.quantum_composers.pulse_generator9530.TriggerMode(value): Trigger modes.

class qmi.instruments.quantum_composers.pulse_generator9530.TriggerEdge(value): Trigger on rising or falling edge.

class qmi.instruments.quantum_composers.pulse_generator9530.OutputDriver(value)

Output driver type.

TTL: Fast driver with fixed 4 Volt output level (into 1 kOhm).

ADJUSTABLE: Slower driver with programmable output level.

class qmi.instruments.quantum_composers.pulse_generator9530.QuantumComposers_PulseGenerator9530(context: QMI_Context, name: str, scpi_transport: str)

Instrument driver for the Quantum Composers 9530 pulse generator.

This driver can be used to communicate with the instrument via USB or Ethernet (TCP), depending on the specified transport descriptor.

open() → None

Connect to the instrument hardware.

When this method returns, the instrument must be ready for interaction via calls to instrument-specific methods.

Subclasses can extend this method to implement instrument-specific initialization. If they do, they should call super().open() as a last statement.

close() → None

Close the connection to the instrument hardware and release associated resources.

When this method returns, the instrument must not be used again unless it is first re-opened by calling the open() method.

Subclasses can extend this method if they have specific resources to close. If they do, they should call super().close() as a last statement.

get_idn() → QMI_InstrumentIdentification: Read instrument type and version and return QMI_InstrumentIdentification instance.

reset() → None: Reset the instrument, returning most settings to defaults.

get_num_channels() → int: Return the number of output channels of the instrument.

get_refclk_source() → RefClkSource: Return the current reference clock source.

is_refclk_pll_locked() → bool: Return True if the reference clock PLL is locked to the external input signal.

set_refclk_source(source: RefClkSource) → None

Change the reference clock source.

Parameters:: source – New reference clock source (one of the RefClkSource constants).

get_refclk_rate() → int: Return the expected frequency of the external reference clock in MHz.

set_refclk_rate(rate: int) → None

Change the expected frequency of the external reference clock.

This parameter is only applicable when an external reference clock source is selected.

Parameters:: rate – Expected frequency of the input signal in MHz as an integer (valid range 10 to 100 MHz).

get_refclk_level() → float: Return the threshold level for the external clock input in Volt.

set_refclk_level(level: float) → None

Change the threshold level for the external clock input.

The threshold should be set to 50% of the input signal amplitude. This level is only applicable when an external reference clock source is selected.

Parameters:: level – Threshold level in Volt (valid range 0.02 to 2.5 Volt).

set_refclk_external(rate: int, level: float, use_pll: bool) → None

Configure the instrument to use an external reference clock input.

Parameters:

rate – External clock frequency in MHz (valid range 10 to 100).
level – Input threshold level in Volt; should be set to 50% of the signal amplitude (valid range 0.02 to 2.5).
use_pll – True to use a PLL to lock to the external input signal.

get_output_enabled() → bool: Return the global output enable state that applies to all channels.

set_output_enabled(enable: bool) → None

Enable or disable pulse generation.

This controls a global on/off switch that starts or stops pulse generation on all enabled channels. Each channel also has a separate on/off switch which only affects that specific channel.

Parameters:: enable – True to enable pulse generation (equivalent to pressing the RUN button). False to disable pulse generation (equivalent to pressing the STOP button).

get_t0_period() → float: Return the T0 pulse interval in seconds.

set_t0_period(period: float) → None

Change the T0 pulse interval.

Parameters:: period – New pulse interval in seconds (valid range 50.0e-9 to 5000.0).

get_t0_mode() → PulseMode: Return the T0 pulse generation mode.

set_t0_mode(mode: PulseMode) → None

Change the T0 pulse generation mode.

Parameters:: mode – New pulse generation mode (one of the PulseMode constants).

get_t0_burst_count() → int: Return the number of T0 pulses when operating in burst mode.

set_t0_burst_count(count: int) → None

Set the number of T0 pulses to generate when operating in burst mode.

Parameters:: count – Number of T0 pulses to generate after the output is enabled. Valid range is 1 to 10**6.

get_t0_duty_cycle() → Tuple[int, int]

Return the parameters for T0 duty cycle mode.

Returns:: Tuple (num_pulse, num_skip).

set_t0_duty_cycle(num_pulse: int, num_skip: int) → None

Change the parameters for T0 duty cycle mode.

Parameters:

num_pulse – Number of pulses to generate (valid range 1 to 10**6).
num_skip – Number of pulses to skip (valid range 1 to 10**6).

get_trigger_mode() → TriggerMode: Return the T0 trigger mode.

set_trigger_mode(mode: TriggerMode) → None

Change the T0 trigger mode.

Parameters:: mode – New trigger mode (one of the TriggerMode constants).

get_trigger_edge() → TriggerEdge: Return the active edge for the T0 trigger.

set_trigger_edge(edge: TriggerEdge) → None

Change the active edge for the T0 trigger.

Parameters:: mode – New active trigger edge (one of the TriggerEdge constants).

get_trigger_level() → float: Return the T0 trigger level in Volt.

set_trigger_level(level: float) → None

Change the T0 trigger level.

Parameters:: level – New trigger level in Volt (valid range 0.2 .. 15).

get_channel_enabled(channel: int) → bool

Return the output enable state for the specified channel.

Parameters:: channel – Channel index in range 1 .. num_channels.

set_channel_enabled(channel: int, enable: bool) → None

Enable or disable output for the specified channel.

Parameters:

channel – Channel index in range 1 .. num_channels.
enable – True to enable the channel, False to disable.

get_channel_width(channel: int) → float

Return the configured pulse width for the specified channel.

Parameters:: channel – Channel index in range 1 .. num_channels.
Returns:: Configured pulse width in seconds.

set_channel_width(channel: int, width: float) → None

Configure pulse width for the specified channel.

Parameters:

channel – Channel index in range 1 .. num_channels.
width – New pulse width in seconds (valid range 10e-9 .. 999.9).

get_channel_delay(channel: int) → float

Return the configured delay for the specified channel.

Parameters:: channel – Channel index in range 1 .. num_channels.
Returns:: Configured delay in seconds.

set_channel_delay(channel: int, delay: float) → None

Configure delay for the specified channel.

Parameters:

channel – Channel index in range 1 .. num_channels.
delay – New delay in seconds (valid range -99.9 .. 999.9).

get_channel_mode(channel: int) → PulseMode: Return the pulse generation mode of the specified channel.

set_channel_mode(channel: int, mode: PulseMode) → None

Change the pulse generation mode of the specified channel.

Parameters:

channel – Channel index in range 1 .. num_channels.
mode – New pulse mode (one of the PulseMode constants).

get_channel_burst_count(channel: int) → int: Return the number of pulses to output when operating in burst mode.

set_channel_burst_count(channel: int, count: int) → None

Set the number of T0 pulses to generate when operating in burst mode.

These parameters only has effect when the channel is operating in PulseMode.BURST mode.

Parameters:

channel – Channel index in range 1 .. num_channels.
count – Number of pulses to generate after the output is enabled. Valid range is 1 to 10**6.

get_channel_duty_cycle(channel: int) → Tuple[int, int]

Return the duty cycel parameters for the specified channel.

Returns:: Tuple (num_pulse, num_skip).

set_channel_duty_cycle(channel: int, num_pulse: int, num_skip: int) → None

Change the duty cycle parameters for the specified channel.

These parameters only have effect when the channel is operating in PulseMode.DUTYCYCLE mode.

Parameters:

channel – Channel index in range 1 .. num_channels.
num_pulse – Number of pulses to generate (valid range 1 to 10**6).
num_skip – Number of pulses to skip (valid range 1 to 10**6).

get_output_driver(channel: int) → OutputDriver: Return the current output mode for the specified channel.

set_output_driver(channel: int, mode: OutputDriver) → None

Change the output mode for the specified channel.

Parameters:

channel – Channel index in range 1 .. num_channels.
mode – New output mode (one of the OutputDriver constants).

get_output_amplitude(channel: int) → float

Return the current output amplitude in Volt.

The returned value only applies when the output mode is OutputMode.ADJUSTABLE.

set_output_amplitude(channel: int, amplitude: float) → None

Change the output amplitude of the specified channel..

The specified amplitude represents the open-circuit voltage of the output. The output channels have 50 Ohm output impedance. As a result, the voltage levels will drop to 50% of the specified amplitude when a 50 Ohm load is connected to the output port.

This setting only applies when the output mode is OutputMode.ADJUSTABLE.

Parameters:

channel – Channel index in range 1 .. num_channels.
amplitude – New output-high level in Volt (valid range 2.0 to 20.0).

get_output_inverted(channel: int) → bool: Return True if the specified channel is active low.

set_output_inverted(channel: int, invert: bool) → None

Change the output polarity of the specified channel.

Parameters:

channel – Channel index in range 1 .. num_channels.
invert – True to select active low output, False to select active high.

set_display_enabled(enable: bool) → None

Enable or disable the display on the front panel of the instrument.

Disabling the display also blocks the front panel keys, except for the power button which always works.

Parameters:: enable – True to enable display and keypad, False to disable.

force_unlock() → None

Forcefully unlock the remote object.

This unlocks the object, regardless of who owns the lock. This allows you to unlock an object if the locking proxy has been destroyed without unlocking.

Use this with care.

Do not override this stub method in subclasses. It has already been implemented in QMI_RpcProxy.

classmethod get_category() → str | None

Return the optional name of the category this object belongs to.

A category name is a free-form string that has no special significance. Its purpose is to distinguish between groups of RPC objects that fulfill similar roles.

get_name() → str

Return the name of this object.

Returns:: name attribute.

get_signals() → list[SignalDescription]

Return a list of signals that can be published by this object.

Returns:: List consisting of qmi_signals attributes.

is_locked() → bool

Query if the remote object is locked.

Do not override this stub method in subclasses. It has already been implemented in QMI_RpcProxy.

is_open() → bool: Return True if the instrument is open (ready for interaction).

lock(timeout: float = 0.0, lock_token: str | None = None) → bool

Lock the remote object. If timeout is given, try every 0.1s within the given timeout value. The remote object can be locked with an optional custom lock token by giving a string into lock_token keyword argument.

If successful, this proxy is the only proxy that can invoke RPC methods on the remote object; other proxies will receive an “object is locked” response. The return value indicates if the lock was granted; a denied lock means the object was already locked by another proxy.

Do not override this stub method in subclasses. It has already been implemented in QMI_RpcProxy.

release_rpc_object() → None: Give a warning if the instrument is removed while still open.

unlock(lock_token: str | None = None) → bool

Unlock the remote object.

Without optional parameters, this is only allowed by the proxy that initially locked the object. By giving the lock token as an input parameter, the specific object locked by this token can be unlocked. The return value indicates if the unlocking was successful.

Do not override this stub method in subclasses. It has already been implemented in QMI_RpcProxy.