Keysight 81160A Pulse Function Arbitrary Noise Generator

class pymeasure.instruments.keysight.Keysight81160A(adapter, name='Agilent 33500 Function/Arbitrary Waveform generator family', **kwargs)

Bases: Agilent33500

Represent the Keysight 81160A and provide a high-level interface for interacting with the instrument.

generator = Keysight81160A("GPIB::1")        # Replace with your device address
generator.reset()                            # Reset the generator to default settings

generator.shape = "SIN"                      # Set default channel output shape to sine
generator.channels[1].shape = "SIN"          # Set channel 1 output signal shape to sine
generator.frequency = 1e3                    # Set default channel output frequency to 1 kHz
generator.channels[1].frequency = 1e3        # Set channel 1 output frequency to 1 kHz
generator.channels[2].amplitude = 5          # Set channel 2 output amplitude to 5 Vpp
generator.channels[2].offset = 0.5           # Set channel 2 output offset to 0.5 V
generator.channels[2].output = True          # Enable channel 2 output

# Output a square wave at 1 kHz with 5 Vpp and 0.5 V offset
generator.channels[2].apply_square(1e3, 5, 0)

ch1 = generator.channels[1]                  # Short form for channel 1
waveform = [-2.0, -1.5, 0.0, 1.5, 2.0]       # Define a user-defined waveform in Volts
ch1.waveform_volatile = waveform             # Set user-defined waveform to volatile memory
print(f"{ch1.free_memory_slots} slots free") # Get number of slots in non-volatile memory
ch1.save_waveform(waveform, "test")          # Save the waveform to non-volatile memory
ch1.shape = "USER"                           # Set channel 1 shape to user-defined
ch1.trigger_mode = "MAN"                     # Set trigger mode to manual
ch1.trigger_count = 2                        # Set number of cycles to be generated to 2
ch1.output = True                            # Enable channel 1 output
generator.trigger()                          # Trigger the generator to output the waveform
ch1.delete_waveform("test")                  # Delete the waveform from non-volatile memory

ch_1

Channel:: Keysight81160AChannel

ch_2

Channel:: Keysight81160AChannel

class BaseChannelCreator(**kwargs)

Bases: object

Base class for ChannelCreator and MultiChannelCreator.

Parameters:

cls – Class for all children or tuple/list of classes, one for each child.
**kwargs – Keyword arguments for all children.

class ChannelCreator(cls, id=None, **kwargs)

Bases: BaseChannelCreator

Add a single channel to the parent class.

The child will be added to the parent instance at instantiation with CommonBase.add_child(). The attribute name that ChannelCreator was assigned to in the Instrument class will be the name of the channel interface.

class Extreme5000(Instrument):
    # Two output channels, accessible by their property names
    # and both are accessible through the 'channels' collection
    output_A = Instrument.ChannelCreator(Extreme5000Channel, "A")
    output_B = Instrument.ChannelCreator(Extreme5000Channel, "B")
    # A channel without a channel accessible through the 'motor' collection
    motor = Instrument.ChannelCreator(MotorControl)

inst = SomeInstrument()
# Set the extreme_temp for channel A of Extreme5000 instrument
inst.output_A.extreme_temp = 42

Parameters:

cls (type[Child]) – Channel class for channel interface
id (Union[int, str, None]) – The id of the channel on the instrument, integer or string. (default: None)
**kwargs – Keyword arguments for all children.

class MultiChannelCreator(cls, id=None, prefix='ch_', **kwargs)

Bases: BaseChannelCreator

Add channels to the parent class.

The children will be added to the parent instance at instantiation with CommonBase.add_child(). The attribute name (e.g. channels) will be used as the collection of the children. You may define the attribute prefix. If there are no other pressing reasons, use channels as the attribute name and leave the prefix at the default "ch_".

class Extreme5000(Instrument):
    # Three channels of the same type: 'ch_A', 'ch_B', 'ch_C'
    # and add them to the 'channels' collection
    channels = Instrument.MultiChannelCreator(Extreme5000Channel, ["A", "B", "C"])
    # Two channel interfaces of different types: 'fn_power', 'fn_voltage'
    # and add them to the 'functions' collection
    functions = Instrument.MultiChannelCreator((PowerChannel, VoltageChannel),
                                    ["power", "voltage"], prefix="fn_")

Parameters:

cls (Union[type[Child], Sequence[type[Child]]]) – Class for all children or tuple/list of classes, one for each child.
id (Union[int, str, None]) – tuple/list of ids of the channels on the instrument. (default: None)
prefix (Optional[str]) – Collection prefix for the attributes, e.g. “ch_” creates attribute self.ch_A. If prefix evaluates False, the child will be added directly under the variable name. Required if id is tuple/list. (default: 'ch_')
**kwargs – Keyword arguments for all children.

add_child(cls, id=None, collection='channels', prefix='ch_', attr_name='', **kwargs)

Add a child to this instance and return its index in the children list.

The newly created child may be accessed either by the id in the children dictionary or by the created attribute, e.g. the fifth channel of instrument with id “F” has two access options: instrument.channels["F"] == instrument.ch_F

Note

Do not change the default collection or prefix parameter, unless you have to distinguish several collections of different children, e.g. different channel types (analog and digital).

Parameters:

cls (type[TypeVar(child, bound= Child)]) – Class of the channel.
id (Union[int, str, None]) – Child id how it is used in communication, e.g. “A”. (default: None)
collection (str) – Name of the collection of children, used for dictionary access to the channel interfaces. (default: 'channels')
prefix (Optional[str]) – For creating multiple channel interfaces, the prefix e.g. “ch_” is prepended to the attribute name of the channel interface self.ch_A. If prefix evaluates False, the child will be added directly under the collection name. (default: 'ch_')
attr_name (Optional[str]) – For creating a single channel interface, the attr_name argument is used when setting the attribute name of the channel interface. (default: '')
**kwargs – Keyword arguments for the channel creator.

Returns:

TypeVar(child, bound= Child) – Instance of the created child.

property amplitude: Any: Control the voltage amplitude in Volts (float).(dynamic)

property amplitude_unit: Any: Control the amplitude units (string, strictly ‘VPP’, ‘VRMS’, or ‘DBM’).(dynamic)

property arb_advance: Any: Control how the device advances from data point to data point (str). Can be set to ‘TRIG<GER>’ or ‘SRAT<E>’ (default).

property arb_file: Any: Control the arbitrary signal to use from the volatile memory of the device.(dynamic)

property arb_filter: Any: Control the filter setting for arbitrary signals (str). Can be set to ‘NORM<AL>’, ‘STEP’ and ‘OFF’.

property arb_srate: Any: Control the sample rate of the currently selected arbitrary signal in Sa/s (float). Valid values range from 1 µSa/s to 250 MSa/s (maximum range, device-dependent).

ask(command, query_delay=None)

Write a command to the instrument and return the read response.

Parameters:

command (str) – Command string to be sent to the instrument.
query_delay (Optional[float]) – Delay between writing and reading in seconds. (default: None)

Returns:

str – String returned by the device without read_termination.

beep(): Causes a system beep.

binary_values(command, query_delay=None, **kwargs)

Write a command to the instrument and return a numpy array of the binary data.

Parameters:

command (str) – Command to be sent to the instrument.
query_delay (Optional[float]) – Delay between writing and reading in seconds. (default: None)
kwargs – Arguments for read_binary_values().

Returns:

NumPy array of values.

property burst_mode: Any: Control the burst mode type (str, strictly ‘TRIG<GERED>’ or ‘GAT<ED>’).(dynamic)

property burst_ncycles: Any: Control the number of cycles to be output when a burst is triggered (int).(dynamic)

property burst_period: Any: Control the period of subsequent bursts in seconds (float).(dynamic)

property burst_state: Any: Control the burst mode state (bool).(dynamic)

check_errors()

Read all errors from the instrument.

Returns:: List of error entries.

check_get_errors()

Check for errors after having gotten a property and log them.

Called if check_get_errors=True is set for that property.

If you override this method, you may choose to raise an Exception for certain errors.

Returns:: list – List of error entries.

check_set_errors()

Check for errors after having set a property and log them.

Called if check_set_errors=True is set for that property.

If you override this method, you may choose to raise an Exception for certain errors.

Returns:: list – List of error entries.

clear(): Clear the instrument status byte.

clear_display(): Removes a text message from the display.

property complete: Any

Get the synchronization bit.

This property allows synchronization between a controller and a device. The Operation Complete query places an ASCII character 1 into the device’s Output Queue when all pending selected device operations have been finished.

static control(get_command, set_command, docs, validator=<function CommonBase.<lambda>>, values=(), map_values=False, get_process=<function CommonBase.<lambda>>, get_process_list=<function CommonBase.<lambda>>, set_process=<function CommonBase.<lambda>>, command_process=None, check_set_errors=False, check_get_errors=False, dynamic=False, preprocess_reply=None, separator=', ', maxsplit=-1, cast=<class 'float'>, values_kwargs=None, **kwargs)

Return a property for the class based on the supplied commands. This property may be set and read from the instrument. See also measurement() and setting().

Parameters:

get_command (Optional[str]) – A string command that asks for the value, set to None if get is not supported (see also setting()).
set_command (Optional[str]) – A string command that writes the value, set to None if set is not supported (see also measurement()).
docs (str) – A docstring that will be included in the documentation
validator (Callable[[Any, TypeVar(Vs)], TypeVar(V2)]) – A function that takes both a value and a group of valid values and returns a valid value, while it otherwise raises an exception (default: <function CommonBase.<lambda> at 0x76f219f7e3e0>)
values (TypeVar(Vs)) – A list, tuple, range, or dictionary of valid values, that can be used as to map values if map_values is True. (default: ())
map_values (bool) – A boolean flag that determines if the values should be interpreted as a map (default: False)
get_process (Callable[[Any], Any]) – A function that takes a value and allows processing before value mapping, returning the processed value (default: <function CommonBase.<lambda> at 0x76f219f7e480>)
get_process_list (Callable[[list[Any]], Any]) – A function that takes the value list and processes it. (default: <function CommonBase.<lambda> at 0x76f219f7e520>)
set_process (Callable[[TypeVar(V2)], Any]) – A function that takes a value and allows processing before value mapping, returning the processed value (default: <function CommonBase.<lambda> at 0x76f219f7e5c0>)
command_process (Optional[Callable]) –
A function that takes a command and allows processing before executing the command

Deprecated since version 0.12: Use a dynamic property instead. (default: None)
check_set_errors (bool) – Toggles checking errors after setting (default: False)
check_get_errors (bool) – Toggles checking errors after getting (default: False)
dynamic (bool) – Specify whether the property parameters are meant to be changed in instances or subclasses. (default: False)
preprocess_reply (Optional[Callable[[str], str]]) – Optional callable used to preprocess the string received from the instrument, before splitting it. The callable returns the processed string. (default: None)
separator (str) – A separator character to split the string returned by the device into a list. (default: ',')
maxsplit (int) – The string returned by the device is split at most maxsplit times. -1 (default) indicates no limit. (default: -1)
cast (Callable[[str], TypeVar(T)]) – A type to cast each element of the split string. (default: <class 'float'>)
values_kwargs (dict) – Further keyword arguments for values().
**kwargs –
Keyword arguments for values().

Deprecated since version 0.12: Use values_kwargs dictionary parameter instead.

Return type:

Union[property, DynamicProperty]

Example of usage of dynamic parameter is as follows:

class GenericInstrument(Instrument):
    center_frequency = Instrument.control(
        ":SENS:FREQ:CENT?;", ":SENS:FREQ:CENT %e GHz;",
        " A floating point property that represents the frequency ... ",
        validator=strict_range,
        # Redefine this in subclasses to reflect actual instrument value:
        values=(1, 20),
        dynamic=True  # enable changing property parameters on-the-fly
    )

class SpecificInstrument(GenericInstrument):
    # Identical to GenericInstrument, except for frequency range
    # Override the "values" parameter of the "center_frequency" property
    center_frequency_values = (1, 10) # Redefined at subclass level

instrument = SpecificInstrument()
instrument.center_frequency_values = (1, 6e9) # Redefined at instance level

Warning

Unexpected side effects when using dynamic properties

Users must pay attention when using dynamic properties, since definition of class and/or instance attributes matching specific patterns could have unwanted side effect. The attribute name pattern property_param, where property is the name of the dynamic property (e.g. center_frequency in the example) and param is any of this method parameters name except dynamic and docs (e.g. values in the example) has to be considered reserved for dynamic property control.

data_arb(arb_name, data_points, data_format='DAC')

Uploads an arbitrary trace into the volatile memory of the device.

The data_points can be given as: comma separated 16 bit DAC values (ranging from -32767 to +32767), as comma separated floating point values (ranging from -1.0 to +1.0) or as a binary data stream. Check the manual for more information. The storage depends on the device type and ranges from 8 Sa to 16 MSa (maximum).

Parameters:

arb_name – The name of the trace in the volatile memory. This is used to access the trace.
data_points – Individual points of the trace. The format depends on the format parameter. format = ‘DAC’ (default): Accepts list of integer values ranging from -32767 to +32767. Minimum of 8 a maximum of 65536 points. format = ‘float’: Accepts list of floating point values ranging from -1.0 to +1.0. Minimum of 8 a maximum of 65536 points. format = ‘binary’: Accepts a binary stream of 8 bit data.
data_format – Defines the format of data_points. Can be ‘DAC’ (default), ‘float’ or ‘binary’. See documentation on parameter data_points above. (default: 'DAC')

data_volatile_clear()

Clear all arbitrary signals from volatile memory.

This should be done if the same name is used continuously to load different arbitrary signals into the memory, since an error will occur if a trace is loaded which already exists in the memory.

property display: Any: Set text to be displayed on the front panel of the device (string).

property ext_trig_out: Any: Control whether the trigger out signal is active (bool).

property frequency: Any: Control the waveform frequency in Hz (float). Depends on the specified shape.(dynamic)

static get_channel_pairs(cls): Return a list of all the Instrument’s channel pairs

static get_channels(cls)

Return a list of all the Instrument’s ChannelCreator and MultiChannelCreator instances

Return type:: list[tuple[str, BaseChannelCreator]]

property id: Any: Get the identification of the instrument.

static measurement(get_command, docs, values=(), map_values=False, get_process=<function CommonBase.<lambda>>, get_process_list=<function CommonBase.<lambda>>, command_process=None, check_get_errors=False, dynamic=False, preprocess_reply=None, separator=', ', maxsplit=-1, cast=<class 'float'>, values_kwargs=None, **kwargs)

Return a property for the class based on the supplied commands. This is a measurement quantity that may only be read from the instrument, not set.

Parameters:

get_command (str) – A string command that asks for the value
docs (str) – A docstring that will be included in the documentation
values (Any) – A list, tuple, range, or dictionary of valid values, that can be used as to map values if map_values is True. (default: ())
map_values (bool) – A boolean flag that determines if the values should be interpreted as a map (default: False)
get_process (Callable[[Any], Any]) – A function that takes a value and allows processing before value mapping, returning the processed value (default: <function CommonBase.<lambda> at 0x76f219f7e700>)
get_process_list (Callable[[list[Any]], Any]) – A function that takes the value list and processes it. (default: <function CommonBase.<lambda> at 0x76f219f7e7a0>)
command_process (Optional[Callable]) –
A function that take a command and allows processing before executing the command, for getting

Deprecated since version 0.12: Use a dynamic property instead. (default: None)
check_get_errors (bool) – Toggles checking errors after getting (default: False)
dynamic (bool) – Specify whether the property parameters are meant to be changed in instances or subclasses. See control() for an usage example. (default: False)
preprocess_reply (Optional[Callable[[str], str]]) – Optional callable used to preprocess the string received from the instrument, before splitting it. The callable returns the processed string. (default: None)
separator (str) – A separator character to split the string returned by the device into a list. (default: ',')
maxsplit (int) – The string returned by the device is split at most maxsplit times. -1 (default) indicates no limit. (default: -1)
cast (Callable[[str], TypeVar(T)]) – A type to cast each element of the split string. (default: <class 'float'>)
values_kwargs (dict) – Further keyword arguments for values().
**kwargs –
Keyword arguments for values().

Deprecated since version 0.12: Use values_kwargs dictionary parameter instead.

Return type:

Union[property, DynamicProperty]

property next_error: Any: Get the next error in the queue. If you want to read and log all errors, use check_errors() instead.

property offset: Any: Control the voltage offset in Volts (float).(dynamic)

property options: Any: Get the device options installed.

property output: Any: Control the output state (bool).(dynamic)

property output_load: Any: Control the expected load resistance in Ohms (str or float). The output impedance is always 50 Ohm, this setting can be used to correct the displayed voltage for loads unmatched to 50 Ohm.(dynamic)

property phase: Any: Control the waveform phase in degrees (float, from -360 to 360).

phase_sync(): Synchronize the phase of all channels.

property pulse_dutycycle: Any: Control the pulse duty cycle in percent (float, from 0 to 100).(dynamic)

property pulse_hold: Any: Control whether pulse width or duty cycle is maintained when the period or frequency of the waveform is changed (str).(dynamic)

property pulse_period: Any: Control the pulse period in seconds (float). Overwrites frequency. If the period is shorter than the pulse width + the edge time, the edge time and pulse width are adjusted.(dynamic)

property pulse_transition: Any: Control the pulse edge time (both rising and falling) in seconds (float).(dynamic)

property pulse_width: Any: Control the pulse width in seconds (float).(dynamic)

property ramp_symmetry: Any: Control the ramp waveform symmetry in percent (float, from 0 to 100).(dynamic)

read(**kwargs)

Read up to (excluding) read_termination or the whole read buffer.

Return type:: str

read_binary_values(**kwargs): Read binary values from the device.

read_bytes(count, **kwargs)

Read a certain number of bytes from the instrument.

Parameters:

count (int) – Number of bytes to read. A value of -1 indicates to read the whole read buffer.
kwargs – Keyword arguments for the adapter.

Returns bytes:

Bytes response of the instrument (including termination).

Return type:

bytes

remove_child(child)

Remove the child from the instrument and the corresponding collection.

Parameters:: child (Child) – Instance of the child to delete.
Return type:: None

reset(): Reset the instrument.

static setting(set_command, docs, validator=<function CommonBase.<lambda>>, values=(), map_values=False, set_process=<function CommonBase.<lambda>>, check_set_errors=False, dynamic=False)

Return a property for the class based on the supplied commands. This property may be set, but raises an exception when being read from the instrument.

Parameters:

set_command (str) – A string command that writes the value
docs (str) – A docstring that will be included in the documentation
validator (Callable[[Any, TypeVar(Vs)], Any]) – A function that takes both a value and a group of valid values and returns a valid value, while it otherwise raises an exception (default: <function CommonBase.<lambda> at 0x76f219f7e8e0>)
values (TypeVar(Vs)) – A list, tuple, range, or dictionary of valid values, that can be used as to map values if map_values is True. (default: ())
map_values (bool) – A boolean flag that determines if the values should be interpreted as a map (default: False)
set_process (Callable[[Any], Any]) – A function that takes a value and allows processing before value mapping, returning the processed value (default: <function CommonBase.<lambda> at 0x76f219f7e980>)
check_set_errors (bool) – Toggles checking errors after setting (default: False)
dynamic (bool) – Specify whether the property parameters are meant to be changed in instances or subclasses. See control() for an usage example. (default: False)

Return type:

Union[property, DynamicProperty]

property shape: Any: Control the output waveform shape (str).(dynamic)

shutdown()

Brings the instrument to a safe and stable state

Return type:: None

property square_dutycycle: Any: Control the square wave duty cycle in percent (float).(dynamic)

property status: Any: Get the status byte and Master Summary Status bit.

trigger(): Send a trigger signal to the function generator.

property trigger_source: Any: Control the trigger source (str).

values(command, separator=', ', cast=<class 'float'>, preprocess_reply=None, maxsplit=-1, **kwargs)

Write a command to the instrument and return a list of formatted values from the result.

Parameters:

command (str) – SCPI command to be sent to the instrument.
preprocess_reply (Optional[Callable[[str], str]]) – Optional callable used to preprocess the string received from the instrument, before splitting it. The callable returns the processed string. (default: None)
separator (str) – A separator character to split the string returned by the device into a list. (default: ',')
maxsplit (int) – The string returned by the device is split at most maxsplit times. -1 (default) indicates no limit. (default: -1)
cast (Callable[[str], TypeVar(T)]) – A type to cast each element of the split string. (default: <class 'float'>)
**kwargs – Keyword arguments to be passed to the ask() method.

Returns:

list[Union[TypeVar(T), str]] – A list of the desired type, or strings where the casting fails.

property voltage_high: Any: Control the upper voltage level in Volts (float).(dynamic)

property voltage_low: Any: Control the lower voltage level in Volts (float).(dynamic)

wait_for(query_delay=None)

Wait for some time. Used by ‘ask’ to wait before reading.

Parameters:: query_delay (Optional[float]) – Delay between writing and reading in seconds. None is default delay. (default: None)
Return type:: None

wait_for_trigger(timeout=3600, should_stop=<function Agilent33500.<lambda>>)

Wait until the triggering has finished or timeout is reached.

Parameters:

timeout – The maximum time the waiting is allowed to take. If timeout is exceeded, a TimeoutError is raised. If timeout is set to zero, no timeout will be used. (default: 3600)
should_stop – Optional function (returning a bool) to allow the waiting to be stopped before its end. (default: <function Agilent33500.<lambda> at 0x76f1fd0714e0>)

write(command, **kwargs)

Write a string command to the instrument appending write_termination.

Parameters:

command (str) – command string to be sent to the instrument
kwargs – Keyword arguments for the adapter.

Return type:

None

write_binary_values(command, values, *args, **kwargs)

Write binary values to the device.

Parameters:

command (str) – Command to send.
values (Sequence[Union[int, float]]) – The values to transmit.
**kwargs (*args,) – Further arguments to hand to the Adapter.

Return type:

None

write_bytes(content, **kwargs)

Write the bytes content to the instrument.

Return type:: None

class pymeasure.instruments.keysight.keysight81160A.Keysight81160AChannel(*args, **kwargs)

Bases: Agilent33500Channel

Represent the Keysight 81160A channel and provide a high-level interface for interacting with the instrument channels.

apply_dc(voltage)

Apply a DC voltage.

Parameters:: voltage – Voltage to be applied (float).

apply_noise(amplitude, offset)

Apply noise to the output.

Parameters:

amplitude – The amplitude of the noise (float).
offset – The offset voltage (float).

apply_pulse(frequency, amplitude, offset)

Apply a pulse waveform.

Parameters:

frequency – Frequency of the pulse (float).
amplitude – Amplitude of the pulse (float).
offset – Offset voltage (float).

apply_sin(frequency, amplitude, offset)

Apply a sine waveform.

Parameters:

frequency – Frequency of the sine wave (float).
amplitude – Amplitude of the sine wave (float).
offset – Offset voltage (float).

apply_square(frequency, amplitude, offset)

Apply a square waveform.

Parameters:

frequency – Frequency of the square wave (float).
amplitude – Amplitude of the square wave (float).
offset – Offset voltage (float).

apply_user_waveform(frequency, amplitude, offset)

Apply a user-defined waveform.

Parameters:

frequency – Frequency of the user waveform (float).
amplitude – Amplitude of the user waveform (float).
offset – Offset voltage (float).

property coupling_enabled: Any: Control whether the channel coupling is enabled (bool). ‘True’ to copy values from this channel to another one.

delete_waveform(name)

Delete a waveform from the generator’s nonvolatile memory.

Parameters:: name – The name of the user-defined waveform to be deleted.

property free_memory_slots: Any: Get the number of free non-volatile memory slots to store user waveforms (int).

property limit_high: Any: Control the high-level voltage limit in Volts (float).(dynamic)

property limit_low: Any: Control the low-level voltage limit in Volts (float).(dynamic)

property limit_state_enabled: Any: Control whether the state limit is enabled (bool).

save_waveform(waveform, name)

Save a waveform to the generator’s nonvolatile memory.

Parameters:

waveform – The waveform data.
name – The name that will be used to identify the waveform in memory, up to 12 characters. The first character must be a letter (A-Z), but the remaining characters can be numbers (0-9) or the underscore character (‘_’). Blank spaces are not allowed.

property trigger_count: Any

Control the number of cycles to be output when a burst is triggered (int). Enable burst state if number > 1.

Short form of burst_ncycles and burst_state = True(dynamic)

property trigger_mode: Any: Control the triggering mode (string, strictly ‘IMM’, ‘INT2’, ‘EXT’ or ‘MAN’).(dynamic)

property waveform_volatile

Get volatile waveform data.

Warning: This property may not reflect the current device volatile waveform. It only returns the waveform previously set via this driver. If the device has been power-cycled, modified externally, or if no waveform was set, the returned value may be invalid or None.

Returns:: waveform data (array-like) or None if not set.

property waveforms: Any: Get the available user waveforms in memory (list[str]).