# LeCroy T3DSO1204 Oscilloscope

class pymeasure.instruments.lecroy.LeCroyT3DSO1204(adapter, name='LeCroy T3DSO1204 Oscilloscope', **kwargs)

  Bases: `TeledyneOscilloscope`

  Represents the LeCroy T3DSO1204 Oscilloscope interface for interacting with the instrument.

  Refer to the LeCroy T3DSO1204 Oscilloscope Programmer’s Guide for further details about using the lower-level methods to interact directly with the scope.

  This implementation is based on the shared base class `TeledyneOscilloscope`.

  Attributes:

  > WRITE_INTERVAL_S: minimum time between two commands. If a command is received less than WRITE_INTERVAL_S after the previous one, the code blocks until at least WRITE_INTERVAL_S seconds have passed. Because the oscilloscope takes a non-negligible time to perform some operations, it might be needed for the user to tweak the sleep time between commands. The WRITE_INTERVAL_S is set to 10ms as default however its optimal value heavily depends on the actual commands and on the connection type, so it is impossible to give a unique value to fit all cases. An interval between 10ms and 500ms second proved to be good, depending on the commands and connection latency.

      scope = LeCroyT3DSO1204(resource)
      scope.autoscale()
      ch1_data_array, ch1_preamble = scope.download_waveform(source="C1", points=2000)
      # ...
      scope.shutdown()

  ch_1
    Channel:

      `LeCroyT3DSO1204Channel`

  ch_2
    Channel:

      `LeCroyT3DSO1204Channel`

  ch_3
    Channel:

      `LeCroyT3DSO1204Channel`

  ch_4
    Channel:

      `LeCroyT3DSO1204Channel`

  class BaseChannelCreator(cls, **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 – Channel class for channel interface

      - id – The id of the channel on the instrument, integer or string.

      - **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 – Class for all children or tuple/list of classes, one for each child.

      - id – tuple/list of ids of the channels on the instrument.

      - prefix – 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.

      - **kwargs – Keyword arguments for all children.

  property acquisition_average

    Control the averaging times of average acquisition.

  acquisition_sample_size(source)

    Get acquisition sample size for a certain channel. Used mainly for waveform acquisition. If the source is MATH, the SANU? MATH query does not seem to work, so I return the memory size instead.

    Parameters:

      source – channel number of channel name.

    Returns:

      acquisition sample size of that channel.

  property acquisition_sample_size_c1

    Get the number of data points that the hardware will acquire from the input signal of channel 1. Note. Channel 2 and channel 1 share the same ADC, so the sample is the same too.

  property acquisition_sample_size_c2

    Get the number of data points that the hardware will acquire from the input signal of channel 2. Note. Channel 2 and channel 1 share the same ADC, so the sample is the same too.

  property acquisition_sample_size_c3

    Get the number of data points that the hardware will acquire from the input signal of channel 3. Note. Channel 3 and channel 4 share the same ADC, so the sample is the same too.

  property acquisition_sample_size_c4

    Get the number of data points that the hardware will acquire from the input signal of channel 4. Note. Channel 3 and channel 4 share the same ADC, so the sample is the same too.

  property acquisition_sampling_rate

    Get the sample rate of the scope.

  property acquisition_status

    Get the acquisition status of the scope.

  property acquisition_type

    Control the type of data acquisition.

    Can be ‘normal’, ‘peak’, ‘average’, ‘highres’.

  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 – Class of the channel.

      - id – Child id how it is used in communication, e.g. “A”.

      - collection – Name of the collection of children, used for dictionary access to the channel interfaces.

      - prefix – 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.

      - attr_name – For creating a single channel interface, the attr_name argument is used when setting the attribute name of the channel interface.

      - **kwargs – Keyword arguments for the channel creator.

    Returns:

      Instance of the created child.

  ask(command, query_delay=None)

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

    Parameters:

      - command – Command string to be sent to the instrument.

      - query_delay – Delay between writing and reading in seconds.

    Returns:

      String returned by the device without read_termination.

  autoscale()

    Autoscale displayed channels.

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

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

    Parameters:

      - command – Command to be sent to the instrument.

      - query_delay – Delay between writing and reading in seconds.

      - kwargs – Arguments for `read_binary_values()`.

    Returns:

      NumPy array of values.

  property bwlimit

    Set the internal low-pass filter for all channels.(dynamic)

  center_trigger()

    Set the trigger levels to center of the trigger source waveform.

  ch(source)

    Get channel object from its index or its name. Or if source is “math”, just return the scope object.

    Parameters:

      source – can be 1, 2, 3, 4 or C1, C2, C3, C4, MATH

    Returns:

      handle to the selected source.

  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 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 of error entries.

  clear()

    Clear the instrument status byte.

  property complete

    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>>, 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 – A string command that asks for the value, set to None if get is not supported (see also `setting()`).

      - set_command – A string command that writes the value, set to None if set is not supported (see also `measurement()`).

      - docs – A docstring that will be included in the documentation

      - validator – A function that takes both a value and a group of valid values and returns a valid value, while it otherwise raises an exception

      - values – A list, tuple, range, or dictionary of valid values, that can be used as to map values if `map_values` is True.

      - map_values – A boolean flag that determines if the values should be interpreted as a map

      - get_process – A function that take a value and allows processing before value mapping, returning the processed value

      - set_process – A function that takes a value and allows processing before value mapping, returning the processed value

      - command_process –

        A function that takes a command and allows processing before executing the command

        Deprecated since version 0.12: Use a dynamic property instead.

      - check_set_errors – Toggles checking errors after setting

      - check_get_errors – Toggles checking errors after getting

      - dynamic – Specify whether the property parameters are meant to be changed in instances or subclasses.

      - preprocess_reply – Optional callable used to preprocess the string received from the instrument, before splitting it. The callable returns the processed string.

      - separator – A separator character to split the string returned by the device into a list.

      - maxsplit – The string returned by the device is splitted at most maxsplit times. -1 (default) indicates no limit.

      - cast – A type to cast each element of the splitted string.

      - values_kwargs (dict) – Further keyword arguments for `values()`.

      - **kwargs –

        Keyword arguments for `values()`.

        Deprecated since version 0.12: Use values_kwargs dictionary parameter instead.

    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.

  default_setup()

    Set up the oscilloscope for remote operation.

    The COMM_HEADER command controls the way the oscilloscope formats response to queries. This command does not affect the interpretation of messages sent to the oscilloscope. Headers can be sent in their long or short form regardless of the CHDR setting. By setting the COMM_HEADER to OFF, the instrument is going to reply with minimal information, and this makes the response message much easier to parse. The user should not be fiddling with the COMM_HEADER during operation, because if the communication header is anything other than OFF, the whole driver breaks down.

  display_parameter(parameter, channel)

    Same as the display_parameter method in the Channel subclass.

  download_image()

    Get a BMP image of oscilloscope screen in bytearray of specified file format.

  download_waveform(source, requested_points=None, sparsing=None)

    Get data points from the specified source of the oscilloscope.

    The returned objects are two np.ndarray of data and time points and a dict with the waveform preamble, that contains metadata about the waveform.

    Parameters:

      - source – measurement source. It can be “C1”, “C2”, “C3”, “C4”, “MATH”.

      - requested_points – number of points to acquire. If None the number of points requested in the previous call will be assumed, i.e. the value of the number of points stored in the oscilloscope memory. If 0 the maximum number of points will be returned.

      - sparsing – interval between data points. For example if sparsing = 4, only one point every 4 points is read. If 0 or None the sparsing of the previous call is assumed, i.e. the value of the sparsing stored in the oscilloscope memory.

    Returns:

      data_ndarray, time_ndarray, waveform_preamble_dict: see waveform_preamble property for dict format.

  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

  property grid_display

    Control the type of the grid which is used to display (FULL, HALF, OFF).

  property id

    Get the identification of the instrument.

  property intensity

    Set the intensity level of the grid or the trace in percent

  property math_define

    Control the desired waveform math operation between two channels.

    Three parameters must be passed as a tuple:

    1. source1 : source channel on the left

    2. operation : operator must be “*”, “/”, “+”, “-”

    3. source2 : source channel on the right

  property math_vdiv

    Control the vertical scale of the selected math operation.

    This command is only valid in add, subtract, multiply and divide operation. Note: legal values for the scale depend on the selected operation.

  property math_vpos

    Control the vertical position of the math waveform with specified source.

    Note: the point represents the screen pixels and is related to the screen center. For example, if the point is 50. The math waveform will be displayed 1 grid above the vertical center of the screen. Namely one grid is 50.

  property measure_delay

    Control measurement delay.

    The MEASURE_DELY command places the instrument in the continuous measurement mode and starts a type of delay measurement. The MEASURE_DELY? query returns the measured value of delay type. The command accepts three arguments with the following syntax:

    > measure_delay = (<type>,<sourceA>,<sourceB>)

    > <type> := {PHA,FRR,FRF,FFR,FFF,LRR,LRF,LFR,LFF,SKEW}

    > <sourceA>,<sourceB> := {C1,C2,C3,C4} where if sourceA=CX and sourceB=CY, then X < Y

    Type | Description
    --- | ---
    PHA | The phase difference between two channels. (rising edge - rising edge)
    FRR | Delay between two channels. (first rising edge - first rising edge)
    FRF | Delay between two channels. (first rising edge - first falling edge)
    FFR | Delay between two channels. (first falling edge - first rising edge)
    FFF | Delay between two channels. (first falling edge - first falling edge)
    LRR | Delay between two channels. (first rising edge - last rising edge)
    LRF | Delay between two channels. (first rising edge - last falling edge)
    LFR | Delay between two channels. (first falling edge - last rising edge)
    LFF | Delay between two channels. (first falling edge - last falling edge)
    Skew | Delay between two channels. (edge – edge of the same type)

  measure_parameter(parameter, channel)

    Same as the measure_parameter method in the Channel subclass

  static measurement(get_command, docs, values=(), map_values=None, get_process=<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 – A string command that asks for the value

      - docs – A docstring that will be included in the documentation

      - values – A list, tuple, range, or dictionary of valid values, that can be used as to map values if `map_values` is True.

      - map_values – A boolean flag that determines if the values should be interpreted as a map

      - get_process – A function that take a value and allows processing before value mapping, returning the processed value

      - command_process –

        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.

      - check_get_errors – Toggles checking errors after getting

      - dynamic – Specify whether the property parameters are meant to be changed in instances or subclasses. See `control()` for an usage example.

      - preprocess_reply – Optional callable used to preprocess the string received from the instrument, before splitting it. The callable returns the processed string.

      - separator – A separator character to split the string returned by the device into a list.

      - maxsplit – The string returned by the device is splitted at most maxsplit times. -1 (default) indicates no limit.

      - cast – A type to cast each element of the splitted string.

      - values_kwargs (dict) – Further keyword arguments for `values()`.

      - **kwargs –

        Keyword arguments for `values()`.

        Deprecated since version 0.12: Use values_kwargs dictionary parameter instead.

  property memory_size

    Control the maximum depth of memory.

    <size>:={7K,70K,700K,7M} for non-interleaved mode. Non-interleaved means a single channel is active per A/D converter. Most oscilloscopes feature two channels per A/D converter.

    <size>:={14K,140K,1.4M,14M} for interleave mode. Interleave mode means multiple active channels per A/D converter.

  property menu

    Control the bottom menu enabled state (strict bool).

  property next_error

    Get the next error in the queue. If you want to read and log all errors, use `check_errors()` instead.

  property options

    Get the device options installed.

  read(**kwargs)

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

  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).

  remove_child(child)

    Remove the child from the instrument and the corresponding collection.

    Parameters:

      child – Instance of the child to delete.

  reset()

    Reset the instrument.

  run()

    Starts repetitive acquisitions.

    This is the same as pressing the Run key on the front panel.

  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 – A string command that writes the value

      - docs – A docstring that will be included in the documentation

      - validator – A function that takes both a value and a group of valid values and returns a valid value, while it otherwise raises an exception

      - values – A list, tuple, range, or dictionary of valid values, that can be used as to map values if `map_values` is True.

      - map_values – A boolean flag that determines if the values should be interpreted as a map

      - set_process – A function that takes a value and allows processing before value mapping, returning the processed value

      - check_set_errors – Toggles checking errors after setting

      - dynamic – Specify whether the property parameters are meant to be changed in instances or subclasses. See `control()` for an usage example.

  shutdown()

    Brings the instrument to a safe and stable state

  single()

    Causes the instrument to acquire a single trigger of data.

    This is the same as pressing the Single key on the front panel.

  property status

    Get the status byte and Master Summary Status bit.

  stop()

    Stops the acquisition. This is the same as pressing the Stop key on the front panel.

  property timebase

    Get timebase setup as a dict containing the following keys:

    - “timebase_scale”: horizontal scale in seconds/div (float)

    - “timebase_offset”: interval in seconds between the trigger and the reference position (float)

    - “timebase_hor_magnify”: horizontal scale in the zoomed window in seconds/div (float)

    - “timebase_hor_position”: horizontal position in the zoomed window in seconds (float)

  property timebase_hor_magnify

    Control the zoomed (delayed) window horizontal scale (seconds/div).

    The main sweep scale determines the range for this command.

  property timebase_hor_position

    Control the horizontal position in the zoomed (delayed) view of the main sweep.

    The main sweep range and the main sweep horizontal position determine the range for this command. The value for this command must keep the zoomed view window within the main sweep range.

  property timebase_offset

    Control the time interval in seconds between the trigger event and the reference position (at center of screen by default).

  property timebase_scale

    Control the horizontal scale (units per division) in seconds for the main window (float).

  timebase_setup(scale=None, offset=None, hor_magnify=None, hor_position=None)

    Set up timebase. Unspecified parameters are not modified. Modifying a single parameter might impact other parameters. Refer to oscilloscope documentation and make multiple consecutive calls to timebase_setup if needed.

    Parameters:

      - scale – interval in seconds between the trigger event and the reference position.

      - offset – horizontal scale per division in seconds/div.

      - hor_magnify – horizontal scale in the zoomed window in seconds/div.

      - hor_position – horizontal position in the zoomed window in seconds.

  property trigger

    Get trigger setup as a dict containing the following keys:

    - “mode”: trigger sweep mode [auto, normal, single, stop]

    - “trigger_type”: condition that will trigger the acquisition of waveforms [edge, slew,glit,intv,runt,drop]

    - “source”: trigger source [c1,c2,c3,c4]

    - “hold_type”: hold type (refer to page 172 of programing guide)

    - “hold_value1”: hold value1 (refer to page 172 of programing guide)

    - “hold_value2”: hold value2 (refer to page 172 of programing guide)

    - “coupling”: input coupling for the selected trigger sources

    - “level”: trigger level voltage for the active trigger source

    - “level2”: trigger lower level voltage for the active trigger source (only slew/runt trigger)

    - “slope”: trigger slope of the specified trigger source

  property trigger_mode

    Control the trigger sweep mode (string).

    <mode>:= {AUTO,NORM,SINGLE,STOP}

    - auto : When AUTO sweep mode is selected, the oscilloscope begins to search for the trigger signal that meets the conditions. If the trigger signal is satisfied, the running state on the top left corner of the user interface shows Trig’d, and the interface shows stable waveform. Otherwise, the running state always shows Auto, and the interface shows unstable waveform.

    - normal : When NORMAL sweep mode is selected, the oscilloscope enters the wait trigger state and begins to search for trigger signals that meet the conditions. If the trigger signal is satisfied, the running state shows Trig’d, and the interface shows stable waveform. Otherwise, the running state shows Ready, and the interface displays the last triggered waveform (previous trigger) or does not display the waveform (no previous trigger).

    - single : When SINGLE sweep mode is selected, the backlight of SINGLE key lights up, the oscilloscope enters the waiting trigger state and begins to search for the trigger signal that meets the conditions. If the trigger signal is satisfied, the running state shows Trig’d, and the interface shows stable waveform. Then, the oscilloscope stops scanning, the RUN/STOP key is red light, and the running status shows Stop. Otherwise, the running state shows Ready, and the interface does not display the waveform.

    - stopped : STOP is a part of the option of this command, but not a trigger mode of the oscilloscope.

  property trigger_select

    Control the condition that will trigger the acquisition of waveforms (string).

    Depending on the trigger type, additional parameters must be specified. These additional parameters are grouped in pairs. The first in the pair names the variable to be modified, while the second gives the new value to be assigned. Pairs may be given in any order and restricted to those variables to be changed.

    There are five parameters that can be specified. Parameters 1. 2. 3. are always mandatory. Parameters 4. 5. are required only for certain combinations of the previous parameters.

    1. <trig_type>:={edge, slew, glit, intv, runt, drop}

    2. <source>:={c1, c2, c3, c4, line}

    3. <hold_type>:=

       - {ti, off} for edge trigger.

       - {ti} for drop trigger.

       - {ps, pl, p2, p1} for glit/runt trigger.

       - {is, il, i2, i1} for slew/intv trigger.

    4. <hold_value1>:= a time value with unit.

    5. <hold_value2>:= a time value with unit.

    Note:

    - “line” can only be selected when the trigger type is “edge”.

    - All time arguments should be given in multiples of seconds. Use the scientific notation if necessary.

    - The range of hold_values varies from trigger types. [80nS, 1.5S] for “edge” trigger, and [2nS, 4.2S] for others.

    - The trigger_select command is switched automatically between the short, normal and extended version depending on the number of expected parameters.

  trigger_setup(mode=None, source=None, trigger_type=None, hold_type=None, hold_value1=None, hold_value2=None, coupling=None, level=None, level2=None, slope=None)

    Set up trigger.

    Unspecified parameters are not modified. Modifying a single parameter might impact other parameters. Refer to oscilloscope documentation and make multiple consecutive calls to trigger_setup and channel_setup if needed.

    Parameters:

      - mode – trigger sweep mode [auto, normal, single, stop]

      - source – trigger source [c1, c2, c3, c4, line]

      - trigger_type – condition that will trigger the acquisition of waveforms [edge,slew,glit,intv,runt,drop]

      - hold_type – hold type (refer to page 172 of programing guide)

      - hold_value1 – hold value1 (refer to page 172 of programing guide)

      - hold_value2 – hold value2 (refer to page 172 of programing guide)

      - coupling – input coupling for the selected trigger sources

      - level – trigger level voltage for the active trigger source

      - level2 – trigger lower level voltage for the active trigger source (only slew/runt trigger)

      - slope – trigger slope of the specified trigger source

  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 – SCPI command to be sent to the instrument.

      - preprocess_reply – Optional callable used to preprocess the string received from the instrument, before splitting it. The callable returns the processed string.

      - separator – A separator character to split the string returned by the device into a list.

      - maxsplit – The string returned by the device is splitted at most maxsplit times. -1 (default) indicates no limit.

      - cast – A type to cast each element of the splitted string.

      - **kwargs – Keyword arguments to be passed to the `ask()` method.

    Returns:

      A list of the desired type, or strings where the casting fails.

  wait_for(query_delay=None)

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

    Parameters:

      query_delay – Delay between writing and reading in seconds. None is default delay.

  property waveform_first_point

    Control the address of the first data point to be sent (int). For waveforms acquired in sequence mode, this refers to the relative address in the given segment. The first data point starts at zero and is strictly positive.

  property waveform_points

    Control the number of waveform points to be transferred with the digitize method (int). NP = 0 sends all data points.

    Note that the oscilloscope may provide less than the specified nb of points.

  property waveform_preamble

    Get preamble information for the selected waveform source as a dict with the following keys:

    - “type”: normal, peak detect, average, high resolution (str)

    - “requested_points”: number of data points requested by the user (int)

    - “sampled_points”: number of data points sampled by the oscilloscope (int)

    - “transmitted_points”: number of data points actually transmitted (optional) (int)

    - “memory_size”: size of the oscilloscope internal memory in bytes (int)

    - “sparsing”: sparse point. It defines the interval between data points. (int)

    - “first_point”: address of the first data point to be sent (int)

    - “source”: source of the data : “C1”, “C2”, “C3”, “C4”, “MATH”.

    - “unit”: Physical units of the Y-axis

    - “type”: type of data acquisition. Can be “normal”, “peak”, “average”, “highres”

    - “average”: average times of average acquisition

    - “sampling_rate”: sampling rate (it is a read-only property)

    - “grid_number”: number of horizontal grids (it is a read-only property)

    - “status”: acquisition status of the scope. Can be “stopped”, “triggered”, “ready”, “auto”, “armed”

    - “xdiv”: horizontal scale (units per division) in seconds

    - “xoffset”: time interval in seconds between the trigger event and the reference position

    - “ydiv”: vertical scale (units per division) in Volts

    - “yoffset”: value that is represented at center of screen in Volts

  property waveform_sparsing

    Control the interval between data points (integer). For example:

    SP = 0 sends all data points. SP = 4 sends 1 point every 4 data points.

  write(command, **kwargs)

    Write the command to the instrument through the adapter.

    Note: if the last command was sent less than WRITE_INTERVAL_S before, this method blocks for the remaining time so that commands are never sent with rate more than 1/WRITE_INTERVAL_S Hz.

    Parameters:

      command – command string to be sent to the instrument

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

    Write binary values to the device.

    Parameters:

      - command – Command to send.

      - values – The values to transmit.

      - **kwargs (*args,) – Further arguments to hand to the Adapter.

  write_bytes(content, **kwargs)

    Write the bytes content to the instrument.

class pymeasure.instruments.lecroy.lecroyT3DSO1204.LeCroyT3DSO1204Channel(parent, id)

  Bases: `TeledyneOscilloscopeChannel`

  Implementation of a LeCroy T3DSO1204 Oscilloscope channel.

  Implementation modeled on Channel object of Keysight DSOX1102G instrument.

  property bwlimit

    Control the 20 MHz internal low-pass filter (strict bool).

    This oscilloscope only has one frequency available for this filter.

  property invert

    Control the inversion of the input signal (strict bool).

  property skew_factor

    Control the channel-to-channel skew factor for the specified channel. Each analog channel can be adjusted + or -100 ns for a total of 200 ns difference between channels. You can use the oscilloscope’s skew control to remove cable-delay errors between channels.

  property trigger_level2

    Control the lower trigger level voltage for the specified source (float). Higher and lower trigger levels are used with runt/slope triggers. When setting the trigger level it must be divided by the probe attenuation. This is not documented in the datasheet and it is probably a bug of the scope firmware. An out-of-range value will be adjusted to the closest legal value.

  property unit

    Control the unit of the specified trace. Measurement results, channel sensitivity, and trigger level will reflect the measurement units you select. (“A” for Amperes, “V” for Volts).