FLUKE AUTORANGING COMBISCOPE PM3382A (01) PDF MANUAL

To program your CombiScope instrument using SCPI, you need the following setup:

• The CombiScope instrument must contain a factory-installed IEEE option.

• A PC is used as the controller.

• An IEEE-488.2 interface (GPIB) board must be installed in the PC to turn it into a GPIB controller.

• The GPIB controller must be connected to the CombiScope instrument via an IEEE cable.

• MS-QuickBASIC is used as the programming language in the examples provided in the PDF.

• Standard IEEE-488.2 drivers are used to control the CombiScope instrument via GPIB. These drivers must be included in the application program. For QuickBASIC, the first statement should typically be: REM $INCLUDE: 'QBDECL.BAS'

• The examples in the PDF used IEEE-488.2 drivers and the device handler GPIB.COM from the product PM2201/03 (equivalent to National Instruments PCIIA).

The following drivers and parameters are commonly used:

• Send Driver: Used to send a command or query.

CALL Send (,

Send the *RST command to reset the instrument to a fixed setup optimized for remote operation.

Example: CALL Send(0, 8, "*RST", 1)

To clear the status and error data, send the *CLS command.

Example: CALL Send(0, 8, "*CLS", 1)

1. Send the *IDN? query to request the instrument’s identity.

Example: CALL Send (0, 8, "*IDN?", 1)

2. Read the response message.

Example: CALL Receive (0, 8, response$, 256)

3. To query the instrument options, send the *OPT? query.

Example: CALL Send (0, 8, "*OPT?", 1)

4. Read the response message for the options.

Example: CALL Receive (0, 8, response$, 256)

Use the INSTrument subsystem commands. After a *RST, the instrument is in digital mode.

To switch to analog mode, send:

INSTrument ANALog or INSTrument:NSELect 2

Example: CALL Send (0, 8, "INSTrument ANALog", 1)

To switch back to digital mode, send:

INSTrument DIGital or INSTrument:NSELect 1

Example: CALL Send (0, 8, "INSTrument:NSELect 1", 1)

Instrument errors (programming or setting errors) are reported during command execution. To check for errors, use one of the following approaches:

1. Query after functional groups: Send the SYSTem:ERRor? or STATus:QUEue? query after every group of functionally related commands and read the response.

2. Error-reporting routine: Program a subroutine that sends SYSTem:ERRor? or STATus:QUEue? and reads the response. Call this routine after each command or group of commands.

3. SRQ mechanism: Program an error-reporting routine and use the Service Request (SRQ) Generation mechanism to interrupt the program and execute the routine when an error occurs (see section 3.14.4.2 in the PDF).

Example for method 1 or 2 (reading error):

er$ = SPACE$(60)

CALL Send(0, 8, "SYSTem:ERRor?", 1)

CALL Receive(0, 8, er$, 256)

PRINT "Response to error query = "; LEFT$(er$, IBCNT%-1) ' Assumes IBCNT% holds byte count

Trace acquisitions are started using the INITiate commands.

• For a single acquisition: Send a single INITiate command (or INITiate:IMMediate).

• For continuous acquisitions: Send the INITiate:CONTinuous ON command.

To read the acquired trace data from a source (e.g., input channel CH2 or memory register M2_3), use the TRACe? query.

Example: TRACe? CH2

You can specify the number of trace samples (acquisition length) using TRACe:POINts. Available points depend on standard or extended memory (e.g., 512, 2048, 4096, 8192, 16384, 32768).

Example: TRACe:POINts CH1, 8192

You can specify the data format (8 or 16 bits) using the FORMat command.

Example: FORMat INTeger, 16 ‘ Sets 16-bit integer format

The trace response data follows the IEEE 488.2 definite-length arbitrary block data format:

#nx..xfb.....bs

Where:

• #: Block data introducer.

• n: Single digit representing the number of subsequent digits (x..x).

• x..x: Digits specifying the number of data bytes (fbb…bbs) that follow.

• f: Trace data format byte (8 for 8-bit samples, 16 for 16-bit samples).

• b.....b: Trace sample data bytes.

– If f=8, each sample is one byte.

– If f=16, each sample is two bytes (most significant byte first, then least significant byte).

• s: Checksum byte calculated over all trace data bytes (fbb…bbs).

• : NewLine character (ASCII 10 decimal) marking the end of the data block.

Example: #41026<16>...<10>

This represents:

• #4: Introducer, followed by 4 digits for byte count.

• 1026: Number of data bytes (N) = 1026 (512 samples * 2 bytes/sample + 1 format byte + 1 checksum byte).

• <16>: Format byte (decimal 16) indicating 16-bit samples.

• : First 16-bit sample.

• ...

• : 512th 16-bit sample.

• : Checksum byte.

• <10>: NewLine terminator.

Preparations:

• Connect a probe to the desired input channel (e.g., channel 1).

• Be ready to trigger the acquisition (e.g., by touching the probe tip or striking the probe).

Procedure (Conceptual Steps based on Example):

1. Set the data format (e.g., 8-bit): FORMat INTeger, 8

2. Set the number of points: TRACe:POINts CH1, 8192

3. Set the trigger source: TRIGger:SOURce INTernal1

4. Set the trigger level: TRIGger:LEVel 0.1

5. Initiate the single acquisition: INITiate

6. Prompt the user or provide means to apply the trigger signal.

7. Wait for the acquisition to complete. You can use the *WAI command to pause the program until the instrument finishes pending operations like the acquisition initiated by INITiate.

Example: CALL Send(0, 8, "*WAI", 1)

8. Query the trace data: TRACe? CH1

Example: CALL Send(0, 8, "TRACe? CH1", 1)

9. Receive the trace data block.

Example: CALL Receive(0, 8, tracebuf$, 256)

10. Parse the received data block according to its format (see “What is the format of the trace response data?”).

Preparations:

• Connect a probe from a repetitive signal source (like the Probe Adjust signal) to the desired channel (e.g., channel 2).

Procedure (Conceptual Steps based on Example for 5 traces):

1. Reset the instrument (optional, sets defaults): *RST

2. Configure the channel (e.g., for AC coupling on CH2): CONFigure:AC (@2)

3. Ensure the channel is active (this might be done by CONFigure or explicitly): SENSe:FUNCtion 'XTIME:VOLTage2' (Switches CH2 on)

4. Prepare storage (e.g., open a file: OPEN "O", #1, "TRACE5.DAT")

5. Loop for the desired number of traces (e.g., FOR i=1 TO 5):

a. Initiate a single acquisition: INITiate

b. Wait for completion and query the trace: *WAI;TRACe? CH2 (The *WAI ensures INITiate finishes before TRACe? is processed)

Example: CALL Send(0, 8, "*WAI;TRACE? CH2", 1)

c. Receive the trace data block.

Example: CALL Receive(0, 8, tracebuf$, 256)

d. Store the received data (e.g., write to file: PRINT #1, LEFT$(tracebuf$, IBCNT%))

6. End loop (e.g., NEXT i)

7. Finalize storage (e.g., close file: CLOSE)

Measurement instructions allow making complete measurements at different levels:

• Highest level (MEASure?): Easiest to use. Configures the instrument, initiates the trigger, fetches data, and returns the result in one step. Less flexible.

• Middle level (CONFigure + READ?): Offers more programming flexibility. CONFigure sets up the instrument for a specific measurement type. READ? initiates the trigger, fetches data, and returns the result. Equivalent to MEASure?.

• Lowest level (INITiate + FETCh?): Provides the most control, especially for acquiring multiple characteristics from one acquisition. INITiate starts the acquisition process. FETCh? retrieves a specific calculated characteristic from the acquired data. Equivalent to READ?.

The following table summarizes the tasks performed by each instruction:

Use the MEASure? query for the simplest single-shot measurement. It performs configuration, acquisition, and result fetching.

Example: Measure AC-RMS on channel 1.

CALL Send (0, 8, "MEASure:AC? (@1)", 1)

CALL Receive (0, 8, response$, 256)

PRINT "AC-RMS value: "; LEFT$(response$, IBCNT% - 1)

To get other characteristics from the *same* acquisition triggered by MEASure?, you can use FETCh? queries immediately after.

Example: Fetch Peak-to-Peak after the AC measurement above.

CALL Send (0, 8, "FETCh:PTPeak?", 1)

CALL Receive (0, 8, response$, 256)

PRINT "Peak-To-Peak value: "; LEFT$(response$, IBCNT% - 1)

To make repeated measurements efficiently, use the CONFigure command once, followed by multiple READ? queries.

Procedure (Conceptual Steps based on Example for 5 AC measurements):

1. Configure the measurement type once: CONFigure:AC (@1)

Example: CALL Send (0, 8, "CONFigure:AC (@1)", 1)

2. Loop for the desired number of measurements (e.g., FOR i = 1 TO 5):

a. Initiate measurement and get the primary result using READ?:

Example: CALL Send (0, 8, "READ:AC?", 1)

Example: CALL Receive (0, 8, response$, 256)

Example: PRINT "AC-RMS: "; LEFT$(response$, IBCNT%-1);

b. (Optional) Fetch additional characteristics from the *same* acquisition using FETCh?:

Example: CALL Send (0, 8, "FETCh:PTPeak?", 1)

Example: CALL Receive (0, 8, response$, 256)

Example: PRINT " / Peak-To-Peak: "; LEFT$(response$, IBCNT%-1);

Example: CALL Send (0, 8, "FETCh:AMPLitude?", 1)

Example: CALL Receive (0, 8, response$, 256)

Example: PRINT " / Amplitude: "; LEFT$(response$, IBCNT%-1)

3. End loop (e.g., NEXT i)

You can access the remote operation using four main concepts:

1. Using measurement instructions (MEASure?, CONFigure, READ?, FETCh?):

– Advantage: Easy to program, no deep instrument knowledge needed for basic measurements.

– Trade-off: Slower for single measurements as the instrument optimizes settings automatically.

– Example: MEASure:FREQuency?

2. Single function programming using the instrument model (INPut, SENSe, TRACe, CALCulate, TRIGger, DISPlay subsystems):

– Advantage: Fine control over individual instrument functions.

– Trade-off: Requires understanding the instrument’s remote operation and functions.

– Example: TRACe? CH1

3. Programming the complete instrument setup (*SAV, *RCL, SYSTem:SET?, SYSTem:SET):

– Advantage: Simple way to save/recall entire states, including non-programmable settings.

– Trade-off: Processes complete setups; individual settings must be programmed separately if needed.

– Example: *SAV 3, *RCL 3

4. Programming through front panel simulation (SYSTem:KEY, DISPlay:MENU):

– Advantage: Can access settings not directly available via other remote commands; matches front panel operation.

– Trade-off: Cumbersome, state-dependent, lacks feedback from the display, generally not recommended.

– Example: SYSTem:KEY 4

The instrument model groups related functions into subsystems:

• INPut: Handles signal conditioning functions (coupling, impedance, etc.).

• SENSe: Contains the data acquisition functions where the analog signal is converted to digital values (averaging, sweep time, etc.).

• TRACe: Manages the memory where acquisition results (traces) are stored.

• CALCulate: Provides post-processing functions on acquired data (math, FFT, etc.).

• TRIGger: Controls the acquisition triggering process (source, level, slope, type, etc.).

• DISPlay: Handles the front panel display functions (brightness, menus, text, etc.).

Commands controlling functions within a subsystem start with the subsystem name (e.g., INPut:COUPling DC, TRIGger:LEVel 0.5).

You can save and recall complete instrument setups using internal memory or transfer them via the GPIB controller.

Using Internal Memory:

• To save the current setup to an internal memory location (e.g., location 3):

*SAV 3

• To recall a setup from an internal memory location (e.g., location 3):

*RCL 3

Using GPIB Controller (Transferring Setup Data):

• To query the instrument for its complete setup data (or a specific part/node):

SYSTem:SET? (for complete setup)

SYSTem:SET? 32 (for cursor settings, node 32)

• Read the response, which will be in a compact block data format ().

• To restore a previously read setup back to the instrument:

SYSTem:SET (where is the data read earlier)

Use the SYSTem:KEY command followed by a numeric code representing the key. This method allows remote operation to precisely match a front panel setup, especially for functions not directly programmable otherwise.

Caution: This method is generally not recommended as its effect depends entirely on the instrument’s state at the moment the command is received, and remote programming lacks the visual feedback of the front panel display.

Example: Simulate pressing softkey 4 (which might toggle noise rejection in the TRIGGER menu):

SYSTem:KEY 4

To activate a specific softkey menu first, use the DISPlay:MENU command.

Example: Activate the TRIGGER softkey menu:

DISPlay:MENU TRIGger

Use the CONFigure and READ? command sequence. This allows you to insert commands between CONFigure and READ? to modify specific settings vital to your application.

1. Use CONFigure to set up the basic measurement type.

Example: CONFigure:AC (Configures for AC RMS measurement on default channel)

2. Send commands to customize specific settings. These settings will be used by the subsequent READ?.

Example: SENSe:AVERage ON (Turn averaging on)

Example: SENSe:AVERage:COUNt 4 (Set averaging count to 4)

3. Use READ? to start the acquisition with the customized settings and return the result.

Example: READ:AC? (Reads the averaged AC RMS value)

Note: The READ? query should generally match the measurement type set by CONFigure. While requesting a different characteristic with READ? might be possible, the instrument configuration might not be optimal or valid for that request.

To avoid re-acquiring the waveform for each characteristic, use the INITiate and FETCh? command sequence.

1. Configure the instrument if necessary (e.g., using CONFigure or individual setting commands).

2. Start a single acquisition using INITiate[:IMMediate].

Example: INITiate

3. Wait for the acquisition to complete (e.g., using *WAI or by checking status bits).

4. Use multiple FETCh? queries to retrieve different characteristics calculated from the waveform acquired in step 2.

Example: FETCh:AC? (Fetch AC RMS value)

Example: FETCh:FREQuency? (Fetch frequency)

Example: FETCh:RISE:TIME? (Fetch rise time)

Example: FETCh:PTPeak? (Fetch peak-to-peak value)

Important: Always explicitly specify the measurement function in the FETCh? query header (e.g., FETCh:AC?, not just FETCh?) when fetching multiple different characteristics.

To synchronize a measurement start with other instruments via GPIB, use the INITiate and FETCh? concept combined with a GPIB trigger command (*TRG or GET – Group Execute Trigger).

1. Configure the measurement type.

Example: CONFigure:AC

2. Set the trigger source to BUS.

Example: TRIGger:SOURce BUS

3. Initiate the measurement process. The instrument will now wait for the GPIB trigger.

Example: INITiate

4. Send the GPIB trigger command when ready.

Example: Send *TRG command or issue a GET message.

5. Fetch the result after the triggered acquisition is complete.

Example: FETCh:AC?

Note: You cannot use MEASure? or READ? with TRIGger:SOURce BUS as these commands attempt immediate execution and would conflict with waiting for the bus trigger, likely causing a query error.

Use the FETCh? query, specifying the memory trace element as the source in the channel list parameter.

Ensure valid waveform data is stored in the specified memory location before sending the FETCh? query.

Example: Fetch the rise time from the waveform stored in memory register 3, trace 4.

FETCh:RISE:TIME? (@M3_4)

Example: Fetch the period from the waveform stored in memory register 4, trace 1.

FETCh:PERiod? (@M4_1)

The acquisition process involves several states and commands:

• IDLE state: The instrument is waiting to start an acquisition. Reached after power-on, *RST, ABORt, or completion of a single-shot acquisition.

• Initiation: Sending INITiate[:IMMediate] or setting INITiate:CONTinuous ON moves the instrument from IDLE to start the acquisition process.

• Waiting for Trigger: After initiation (unless trigger source is IMMediate or BUS), the instrument waits for the configured trigger conditions (level, slope, etc.) to be met.

• Acquiring: Once triggered (or immediately if IMMediate), the instrument acquires the waveform data.

• Completion:

– If INITiate:CONTinuous is OFF (single shot), the instrument returns to the IDLE state after acquisition.

– If INITiate:CONTinuous is ON, the instrument immediately starts another acquisition cycle without returning to IDLE.

• Aborting: Sending ABORt or *RST immediately stops any ongoing acquisition and returns the instrument to the IDLE state. *RST also resets settings, while ABORt does not.

• Trigger Conditions: Programmed using the TRIGger subsystem (SOURce, LEVel, SLOPe, TYPE, etc.).

• Operation Complete: The *OPC command or query can be used to check if the instrument has finished an acquisition and returned to the IDLE state (only applicable when INITiate:CONTinuous is OFF).

Use the commands within the TRIGger subsystem:

• Trigger Type: Selects the trigger mode.

– TRIGger:TYPE EDGE (Normal edge triggering, default after *RST)

– TRIGger:TYPE VIDeo (Video triggering)

– (Logic and Glitch types are mentioned but programming details are not provided for SCPI)

• Trigger Source: Selects the signal used for triggering.

– TRIGger:SOURce IMMediate (Triggers immediately, default after *RST)

– TRIGger:SOURce INTernal (Uses input channel n, e.g., INTernal1 for CH1)

– TRIGger:SOURce EXTernal (Uses external trigger input – CH4 on PM33x0A)

– TRIGger:SOURce LINE (Uses AC line voltage)

– TRIGger:SOURce BUS (Waits for GPIB *TRG or GET)

• Trigger Level: Sets the voltage level for edge triggering (only when source is INTernal).

– TRIGger:LEVel (e.g., TRIGger:LEVel 0.2). Programming the level automatically turns off level peak-peak auto-finding.

– TRIGger:LEVel:AUTO ON|OFF (Turns level peak-peak auto-finding on/off. Default is OFF after *RST, with level set to max).

• Trigger Slope: Defines the edge polarity for edge triggering.

– TRIGger:SLOPe POSitive (Triggers on rising edge, default after *RST)

– TRIGger:SLOPe NEGative (Triggers on falling edge)

– TRIGger:SLOPe EITHer (Triggers on either edge)

Trigger coupling for the Main Time Base (MTB) is controlled using the Low-Pass (LPASs) and High-Pass (HPASs) filter commands within the TRIGger:FILTer subsystem. These are mutually exclusive with standard input coupling set via INPut:COUPling.

• DC Coupling (0 Hz cutoff): Allows all frequencies, including DC, to pass to the trigger circuit.

– Command: TRIGger:FILTer:LPASs:STATe ON (Enables the low-pass filter path)

– Command: TRIGger:FILTer:LPASs:FREQuency 0 (Effectively sets cutoff to 0 Hz for DC coupling)

*After *RST, the default setting is AC coupling (10 Hz High-Pass).*

• AC Coupling (10 Hz cutoff, default): Blocks DC and low frequencies below approximately 10 Hz.

– Command: TRIGger:FILTer:LPASs:STATe ON

– Command: TRIGger:FILTer:LPASs:FREQuency 10 (This is the state after *RST)

• Low Frequency Reject (LF Reject, 30 kHz High-Pass): Blocks frequencies below approximately 30 kHz.

– Command: TRIGger:FILTer:LPASs:STATe ON

– Command: TRIGger:FILTer:LPASs:FREQuency 3E+4 (Sets 30 kHz cutoff)

• High Frequency Reject (HF Reject, 30 kHz Low-Pass): Blocks frequencies above approximately 30 kHz.

– Command: TRIGger:FILTer:HPASs:STATe ON (Enables the high-pass filter path, which acts as HF reject)

– (The cutoff for HPASs is implicitly 30kHz when enabled for HF reject)

Note: Activating LPASs deactivates HPASs, and vice versa. The INPut:COUPling command (AC, DC, GND) sets the coupling for the signal path to the acquisition system, which is separate from the trigger coupling, although often set identically.

1. Select Video Trigger Type:

TRIGger:TYPE VIDeo

2. Select Video Standard (Format):

– Using standard name: TRIGger:VIDeo:FORMat:TYPE (e.g., NTSC, PAL, SECAM)

Example: TRIGger:VIDeo:FORMat:TYPE PAL

– Using lines per frame (for HDTV): TRIGger:VIDeo:FORMat:LPFRame (e.g., 1050, 1125, 1250)

Example: TRIGger:VIDeo:FORMat:LPFRame 1125

3. Select Trigger Mode (Field or Line):

– Trigger on specific field: TRIGger:VIDeo:FIELd:SELect NUMBer

– Trigger on any line: TRIGger:VIDeo:FIELd:SELect ALL

4. Specify Field or Line Number:

– If triggering on field (FIELd:SELect NUMBer): TRIGger:VIDeo:FIELd:NUMBer <1|2>

Example: TRIGger:VIDeo:FIELd:NUMBer 2 (Selects field 2)

– Set trigger line number: TRIGger:VIDeo:LINE

Example: TRIGger:VIDeo:LINE 512

*Note: If field selection is NUMBer, setting a LINE number automatically switches to the corresponding field (e.g., for PAL 625 lines, line 123 selects field 1, line 325 selects field 2). If field selection is ALL, setting LINE just selects the line.*

5. Select Signal Polarity (Optional):

TRIGger:VIDeo:SSIGnal POSitive|NEGative

The trigger mode depends on the combination of INITiate:CONTinuous and TRIGger:SOURce settings:

When using single-shot or multiple-shot modes (INITiate:CONTinuous OFF), you can check the OPERation status register bits and the standard Event Status Register (ESR) Operation Complete (OPC) bit.

Single-Shot Mode (TB MODE – single):

Multiple-Shot Mode (TB MODE – multi):

Query these registers using STATus:OPERation:CONDition? and *ESR? respectively.

Use the SENSe:SWEep:OFFSet:TIME command to specify the time delay between the trigger event and the center of the acquisition window.

• Post-triggering: A positive time value shifts the acquisition window *after* the trigger event.

Example: SENSe:SWEep:OFFSet:TIME 0.001 (Sets a 1 ms post-trigger delay, trigger event appears near the left of the screen)

• Pre-triggering: A negative time value shifts the acquisition window to capture data *before* the trigger event.

Example: SENSe:SWEep:OFFSet:TIME -1E-3 (Sets a 1 ms pre-trigger delay, trigger event appears near the right of the screen)

• Zero Offset (Trigger at Center): SENSe:SWEep:OFFSet:TIME 0 (Places the trigger event at the center of the screen)

After a *RST, the offset time defaults to -0.005 (-5 ms). Since the default total acquisition time (SENS:SWEep:TIME) after reset is 10 ms, this places the trigger point exactly in the middle of the trace.

External triggering is only possible for PM33x0A CombiScope instruments, using Channel 4 as the input.

Requirements/Possibilities:

• Select external trigger source: TRIGger:SOURce EXTernal.

• Attenuator positions 0.1 and 1 V/div are available (can be set via front panel AMP key simulation if needed).

• Trigger slope can be set to POSitive or NEGative (TRIGger:SLOPe).

• Trigger coupling can be set to AC or DC (TRIGger:FILTer... commands or front panel AC/DC key simulation).

Viewing External Trigger Signal:

• The view facility for the external trigger channel (CH4) can be switched on only if:

– EXTernal or INTernal4 is programmed as the trigger source.

– Peak detection acquisition mode is OFF.

• Use the command: SENSe:FUNCtion:ON "XTIMe:VOLTage4" or simulate the TRIG VIEW key (SYSTem:KEY 812).

Limitation:

• The amplitude of the external trigger signal must be high enough for the selected sensitivity (0.1 or 1 V/div).

• Autoset scans CH1, CH2, and the external trigger input. If a signal is present on the external input, Autoset selects it as the trigger source and activates the view facility.

After an acquisition completes, the resulting trace data is placed in the corresponding channel’s memory buffer within the TRACe subsystem (e.g., CH1 data goes to TRACe memory element CH1, CH2 data to CH2, etc.).

To read this data, use the TRACe[:DATA]? query, specifying the channel whose data you want to retrieve.

Example: Read the trace data last acquired on input channel 2.

TRACe? CH2

The instrument will respond with the trace data in the currently selected block data format (set by FORMat command, see “What is the format of the trace response data?”).

Important: New acquisitions overwrite the previous data in the CHx buffers. If you need to save a trace before the next acquisition, you must copy it to a memory register (e.g., M1_1, M2_3) using the TRACe:COPY command (refer to section 3.10.2 in the PDF).

The trace data is sent as a block of binary codes. Trace samples can be formatted to consist of 8 bits (1 byte) or 16 bits (2 bytes) codes, which can be selected by the FORMat command. After *RST (reset), the samples are sent as 2-byte codes by default.

When samples are formatted as two bytes (16 bits), the most significant byte (msb) is sent first, followed by the least significant byte (lsb).

The sample values sent in the block are coded according to the two’s complement notation.

The value of the trace points relates to the vertical position of the corresponding sample on the screen. The relationship is as follows (values in parentheses apply to single-byte format):

For example, a 16-bit sample with value 25600 corresponds to the top position of the screen. Samples with values -25600 and 0 correspond to the bottom and mid-position respectively.

The Analog-to-Digital Converter (ADC) allows trace acquisitions somewhat outside the vertical screen boundaries, using the full dynamic range of the ADC. This results in a dynamic trace range of 65535 points (from -32768 to +32767), whereas the screen range is limited to 51200 points (from -25600 to +25600).

The format is as follows:

#3514 <8> <byte 1> … <byte 512> <checksum> <NL>

Where:

#3514: Header indicating 3 digits for the number of bytes (514).

<8>: Byte with decimal value 8, indicating 8-bit sample length.

<byte 1> … <byte 512>: The 512 trace sample bytes.

<checksum>: Checksum byte.

<NL>: Newline character (terminating LF, decimal 10).

Total number of trace bytes = 512 samples * 1 byte/sample = 512 bytes.

Total number of bytes in block = 512 (data) + 1 (length byte) + 1 (checksum) = 514 bytes.

The conversion from a single byte value (representing an 8-bit sample in two’s complement) to an integer is done as follows:

If byte ≥ 128 then integer = byte – 256.

If byte < 128 then integer = byte.

Example: byte = 255 → integer = 255 – 256 = -1.

Example: byte = 100 → integer = 100.

The format is as follows:

#41026 <16> <msb 1> <lsb 1> … <msb 512> <lsb 512> <checksum> <NL>

Where:

#41026: Header indicating 4 digits for the number of bytes (1026).

<16>: Byte with decimal value 16, indicating 16-bit sample length.

<msb 1> <lsb 1>: Most significant byte and least significant byte for trace sample 1.

…

<msb 512> <lsb 512>: Most significant byte and least significant byte for trace sample 512.

<checksum>: Checksum byte.

<NL>: Newline character (terminating LF, decimal 10).

Total number of trace bytes = 512 samples * 2 bytes/sample = 1024 bytes.

Total number of bytes in block = 1024 (data) + 1 (length byte) + 1 (checksum) = 1026 bytes.

The conversion from a double byte value (byte1 = msb, byte2 = lsb, representing a 16-bit sample in two’s complement) to an integer is done as follows:

If byte1 < 128 then integer = byte1 * 256 + byte2.

If byte1 ≥ 128 then integer = (byte1 – 256) * 256 + byte2.

Example: byte1 = 255 & byte2 = 32 → integer = (255 – 256) * 256 + 32 = -1 * 256 + 32 = -224.

Example: byte1 = 100 & byte2 = 0 → integer = 100 * 256 + 0 = 25600.

Screen positions (Ps) correspond to voltage values (Vs). This relation is determined by the settings programmed by the SENSE:VOLTage:RANGE:PTPeak and SENSE:VOLTage:RANGE:OFFSet commands.

The relationship is expressed by the equations:

For 8-bit sample traces: Vs = (Ps * PTPeak) / 200 – OFFSet

For 16-bit sample traces: Vs = (Ps * PTPeak) / 51200 – OFFSet

Where:

Vs = Corresponding voltage amplitude

Ps = Screen position (e.g., -100% to +100% or equivalent scaling)

PTPeak = Programmed peak-to-peak voltage range for the screen

OFFSet = Programmed voltage offset

There is a direct relation between the screen position (Ps) and the value (Ts) of a trace sample. This relation is expressed by the equations:

For 8-bit sample traces: Ps = Ts (where Ts ranges from -100 to +100 for screen range)

For 16-bit sample traces: Ps = (Ts / 25600) * 100 = Ts / 256 (where Ts ranges from -25600 to +25600 for screen range, and Ps is scaled to -100% to +100%)

By eliminating the screen position (Ps) from the equations relating Vs to Ps and Ps to Ts, a direct relation between the voltage value (Vs) and the trace sample value (Ts) can be derived:

For 8-bit sample traces: Vs = (Ts / 200) * PTPeak – OFFSet

For 16-bit sample traces: Vs = (Ts / 51200) * PTPeak – OFFSet

Where:

Vs = Corresponding voltage amplitude

Ts = Value of the trace sample

PTPeak = Programmed peak-to-peak voltage range for the screen

OFFSet = Programmed voltage offset

A trace of samples (received as a data block) can be converted to an array of voltages using the following steps, as demonstrated in the program example EXCNVTRC.BAS:

1. Read the trace data block from the instrument (e.g., using TRACE? CH1).

2. Parse the response to determine the number of bytes, sample length (8 or 16 bits), and number of samples.

3. Query the instrument for the current Peak-to-Peak voltage range (SENSE:VOLTage:RANGE:PTPeak?) and store the value (ptpeak).

4. Query the instrument for the current Offset voltage (SENSE:VOLTage:RANGE:OFFSet?) and store the value (offset).

5. Iterate through each sample in the received data block:

a. Extract the byte(s) corresponding to the current sample.

b. Convert the byte(s) to an integer trace sample value (trace%) using the appropriate 8-bit or 16-bit conversion logic (two’s complement).

c. Calculate the voltage value (sample(i)) using the formula corresponding to the sample length:

– For 8-bit: sample(i) = trace% / 200 * ptpeak – offset

– For 16-bit: sample(i) = trace% / 51200 * ptpeak – offset

d. Store the calculated voltage value in an array.

6. The resulting array contains the voltage values corresponding to the trace samples.

Averaging can be enabled using the SENSE:AVERage[:STATe] ON command. When enabled, the instrument performs averaging according to the following formula:

AVG_n = (X_1 + … + X_n) / n

Where ‘n’ is the number of acquisitions to be averaged, and ‘X’ represents the acquisition result (trace or measurement).

1. Set the number of acquisitions to average using the SENSE:AVERage:COUNt <n> command. For example, SENSE:AVERage:COUNt 16 sets the average count to 16.

2. Enable the averaging function using the SENSE:AVERage[:STATe] ON command.

When SENSE:AVERage is ON and an acquisition is initiated (e.g., with INITiate), the CombiScope instrument takes ‘n’ (the number set by SENSE:AVERage:COUNt) successive acquisitions. Only after sufficient acquisitions are taken is the final averaged result returned. Intermediate results cannot be queried.

The acquisition process with averaging involves the following states:

1. IDLE state: The initial state after power-on, *RST, or ABORt.

2. INITiated state: Entered after an INITiate or INIT:CONT ON command. The instrument is waiting for the first trigger.

3. Wait for AVERage state: After the first acquisition completes, the instrument enters this state. It performs subsequent acquisitions (up to the SENSE:AVERage:COUNt value). In this state, it cycles between ‘Wait for trigger’ and ‘Wait for complete’ for each acquisition contributing to the average.

4. Return to INITiated state (if INIT:CONT ON) or IDLE state (if INIT) after the required number of acquisitions are averaged.

Input channels are switched on or off using the SENSE:FUNCtion[:ON] or SENSE:FUNCtion:OFF commands, specifying the channel using the “XTIME:VOLTage<n>” parameter, where <n> is the channel number (1, 2, 3, or 4).

Example ON: SENSE:FUNCtion:ON “XTIME:VOLTage2”

Example OFF: SENSE:FUNCtion:OFF “XTIME:VOLTage1”

After a *RST command, channel 1 is turned on, and the other channels are off.

The addition of two channels can be selected by specifying the “XTIME:VOLTage:SUM” parameter with the SENSE:FUNCtion[:ON] command:

Addition of CH1 and CH2: SENSE:FUNCtion “XTIME:VOLTage:SUM 1,2”

Addition of CH3 and CH4: SENSE:FUNCtion “XTIME:VOLTage:SUM 3,4”

Enabling the addition of input channels (e.g., CH3+CH4) automatically switches channel 3 and channel 4 on.

Disabling the addition of two channels (e.g., CH3+CH4) automatically switches channel 3 and channel 4 off, provided at least one channel remains on.

If CH1+CH2 is on and CH3/CH4 are off, you cannot program CH1+CH2 off directly using SENSE:FUNCtion:OFF “XTIME:VOLTage:SUM 1,2”. Instead, you must first turn on one of the individual channels (CH1 or CH2) to ensure at least one channel remains active. For example, send the command:

SENSE:FUNCtion:ON “XTIME:VOLTage2”

This sets CH2 on, which automatically turns CH1+CH2 off, while CH1 remains off (unless it was individually turned on previously).

The INPut<n>:COUPling command allows you to set the vertical input coupling for each input channel <n> separately. The options are AC, DC, or GROund.

Example (Channel 1 AC coupled): INPut:COUPling AC

Example (Channel 2 Ground coupled): INPut2:COUPling GROund

After a *RST command, all input channels are DC coupled.

The common low-pass filter (bandwidth limiter, fixed at 20 MHz cutoff) for all input channels can be turned on or off using the INPut:FILTer command.

To turn ON: INPut:FILTer ON

To turn OFF: INPut:FILTer OFF (Default after *RST)

The filter frequency can be queried using: INPut:FILTer:FREQuency?

The input impedance for each input channel <n> can be specified separately using the INPut<n>:IMPedance command. Options are 50 (for 50 Ω) or 1E6 (or HIGH, for 1 MΩ).

Example (Channel 4, 50 Ω): INPut4:IMPedance 50

The default impedance after a *RST command is 1 MΩ.

The polarity of the signal on input channels 2 and 4 can be set using the INPut<n>:POLarity command. The options are NORMal (default) or INVerted.

Example (Channel 2 Normal): INPut2:POLarity NORMal

Example (Channel 4 Inverted): INPut4:POLarity INVerted

The peak-to-peak range of the signal acquisition over all 8 divisions of the display screen for each input channel <n> is specified using the SENSE:VOLTage<n>:RANGe:PTPeak command.

Example (Channel 2, 800 mV peak-to-peak): SENSE:VOLTage2:RANGe:PTPeak 0.8

After a *RST command, the peak-to-peak value for channel 1 is set at 1.6V.

The vertical sensitivity per division is calculated from the specified peak-to-peak value as follows:

<vertical_sensitivity> = <peak-to-peak> / 8

For example, if the peak-to-peak range is set to 800 mV, the vertical sensitivity is 800 mV / 8 = 100 mV/div.

The vertical offset for each input channel <n> can be specified using the SENSE:VOLTage<n>:RANGe:OFFSet command.

Example (Channel 2, +100 mV offset): SENSE:VOLTage2:RANGe:OFFSet 0.1

After a *RST command, the vertical offset for each input channel is zero.

The AUTO RANGE function, enabled by the SENSE:VOLTage<n>:RANGe:AUTO ON command for a specific channel <n>, automatically selects the vertical input sensitivity (attenuation) to keep the signal amplitude displayed between 2 and 6.4 divisions on the screen. Autoranging attenuators work independently on the available input channels (1-4 for PM33x4A, 1-2 for PM33x2A).

When auto attenuation is switched on for an input channel <n>, the input signal for that channel is automatically forced to AC coupling. It is still possible to switch back to DC coupling using the INPut<n>:COUPling DC command, but proper operation of auto attenuation cannot be guaranteed in that case.

Auto attenuation is limited to a minimum sensitivity of 50 mV per division. This minimum value is used as the noise level to prevent auto attenuation from trying to adjust noise on an open input channel.

The number of sample points, which is the total acquisition length for all traces, is set using the TRACE:POINts command, specifying a channel (e.g., CH1) and the desired number of points. The number of samples is limited to discrete values (refer to the command reference for details).

Example (Set acquisition length to 8192 points): TRACE:POINts CH1, 8192

After a *RST command, the number of samples is 512.

If the number of samples (acquisition length) is changed, the contents of all trace memories (acquisition and register traces) are cleared. All previously stored traces are lost.

The time base speed, which is the time duration of one complete trace acquisition, is specified using the SENSE:SWEep:TIME command. In digital mode, the specified value is limited to permitted Main Time Base (MTB) values.

Example: SENSE:SWEep:TIME <time_value>

The command reference provides details on permitted values.

The Main Time Base (MTB), expressed in seconds per division, is determined by the sweep time (SENSE:SWEep:TIME) and the number of trace points (TRACE:POINts). Since there are 50 points per division, the MTB can be calculated using the following equation:

MTB = 50 * SENSE:SWEep:TIME / (TRACE:POINts – 1)

The time value (Ts) associated with a trace sample point can be calculated from its index within the trace, the total sweep time, and the number of points in the trace using the following expression:

Ts = <sample_index> * SENSE:SWEep:TIME / (TRACE:POINts – 1)

where <sample_index> is the point number of the sample in the trace (starting from 0 or 1 depending on convention, usually 0 for the first point).

To guarantee real-time acquisition (sampling within one acquisition period, not using random sampling techniques), the command SENSE:SWEep:REALtime[:STATe] must be set to ON.

Example: SENSE:SWEep:REALtime ON

After *RST, the :REALtime command is set to OFF.

When real-time acquisition is enabled (SENSE:SWEep:REALtime ON), the random sampling techniques are disabled. The trade-off is that the SENSE:SWEep:TIME range is limited to 200 ns or slower. Faster time base settings are not available in guaranteed real-time mode.

The “peak detection” function allows the Analog-to-Digital Converters (ADC) to operate at their highest speed, even when a lower time base speed is selected. This results in the detection of maximum and minimum peaks of the signal (oversampling) that might occur between the slower sample points dictated by the selected time base. This function can be switched on or off using the SENSE:SWEep:PDETection[:STATe] command.

Example ON: SENSE:SWEep:PDETection ON

The AUTO RANGE function for the Main Time Base (MTB), enabled by SENSE:SWEep:TIME:AUTO ON, automatically adjusts the time base so that two to six waveform periods are displayed on the screen. If the waveform doesn’t contain enough information to calculate its period, the time base is adjusted to acquire a minimum of two periods.

One period of a signal is determined by three successive crossings (X1, X2, X3) of the hysteresis band with the input signal. The period length is the time between the first (X1) and third (X3) crossings. The level of the hysteresis band can be set using the TRIGger:LEVel command.

When operating with an acquisition length of 512 points, the maximum input frequency for reliable autoranging is 25 MHz. For all other acquisition lengths, the maximum input frequency is 50 MHz. If the input frequency is greater than the maximum alias detection frequency, it is no longer possible to detect aliasing, which might affect autoranging accuracy.

The CALCulate functions (which comply with front panel MATH1 and MATH2) are used as follows:

1. Select the source trace for the post-processing function using CALCulate<n>:FEED.

2. Specify the settings of the post-processing function (e.g., filter type, window width, mathematical operation).

3. Enable the post-processing function using the :STATe ON command for the specific function (e.g., CALCulate2:INTegral:STATe ON).

4. Check the result of the post-processing function, which is stored in specific trace memory locations (e.g., M1_n or M2_n) and can be read using TRACe?.

These functions work only in the digital mode.

The trace that is to be sourced (used as input) into the CALCulate function is selected by sending the CALCulate<n>:FEED command with the desired trace name.

Examples:

CALCulate2:FEED “CH3” (Channel 3 = source for CALC2)

CALCulate:FEED “M2_1” (Memory trace M2_1 = source for CALC1)

After a *RST command, CH1 becomes the input trace for both CALCulate functions.

Empty traces may not be selected as input traces.

A memory register 1 location (M1_j) may not be specified as the source (feed) for CALCulate1.

A memory register 2 location (M2_j) may not be the source (feed) for CALCulate2.

For PM33x0A CombiScope instruments, CH3 and CH4 cannot be selected as a source.

The following settings can be programmed:

– The filter type of the FFT function: RECTanguler | HAMMing | HANNing (e.g., CALCulate2:TRANsform:FREQuency:WINDow HAMMing)

– The width of the low-pass filter window: 3, 5, 7, …, 39, 41 points (e.g., CALCulate:FILTer:FREQuency:POINts 35)

– The width of the differential window: 3, 5, 7, …, 127, 129 points (e.g., CALCulate2:DERivative:POINts 35)

A desired post-processing function is enabled by using the :STATe ON command of the specific function within the concerned calculate block (CALCulate1 or CALCulate2).

Example: CALCulate2:TRANsform:FREQuency:STATe ON (Enables FFT for CALCulate2)

The standard available post-processing functions are:

– Mathematical calculations: :MATH

– Frequency filtering: :FILTer:FREQuency

– Frequency domain transformations (FFT): :TRANsform:FREQuency

The optional post-processing functions are:

– Histogram transformation: :TRANsform:HISTogram

– Integrating traces: :INTegral

– Differentiating traces: :DERivative (alias :DIFFerential)

Post-processing is automatically executed when a trace that is fed into the CALCulate function is changed. If a mathematical function is switched on, the other functions (Filter, FFT, etc.) are automatically switched off.

The results of the :MATH, :TRANsform:FREQuency (FFT), and :TRANsform:HISTogram functions are stored in M1_1 for CALCulate1 and in M2_1 for CALCulate2, regardless of the input (feed) trace.

The results of the :FILTer:FREQuency, :INTegral, and :DERivative (or :DIFFerential) functions are stored in M1_n or M2_n, depending on the input source. If CHn or Mi_n is the input trace for CALCulate1, the result is placed in M1_n (where n = 1, 2, 3, 4). If CHn or Mi_n is the input trace for CALCulate2, the result is placed in M2_n (n = 1, 2, 3, 4).

Example: If CALCulate2:FEED “CH3” and CALCulate2:INTegral:STATE ON are executed, the integral of the channel 3 trace is placed in M2_3.

When the result of a calculation is saved in a trace memory location (e.g., M1_2), the other trace locations of the same memory register (M1_1, M1_3, M1_4) are used by the calculate process. Data stored in these locations may be destroyed.

The result of a CALCulate function that is stored in a trace memory location (e.g., M2_1) can be read into the controller by using the TRACe? query with the specific memory location.

Example: Send TRACe? M2_1, then read the response.

Yes, the result of a CALCulate block (e.g., M1_1 from CALCulate1) can be used as a source (feed) for the other CALCulate block (e.g., CALCulate2:FEED “M1_1”). However, the result cannot be used as a source for the same CALCulate block.

Mathematical calculations are performed using the CALCulate1:MATH and CALCulate2:MATH functions. These functions take an expression defining the operation and the two operand traces.

Example: CALCulate:MATH “(CH1+CH2)” performs CH1 + CH2.

Example: CALCulate2:MATH “(M1_1 – CH2)” performs M1_1 – CH2.

After defining the calculation, it must be enabled using CALCulate<n>:MATH:STATe ON.

The result is stored according to the rules described for post-processing results (e.g., result of CALCulate1:MATH is stored in M1_1).

The attenuation of the resulting trace from a mathematical calculation is automatically set higher than the sum of the attenuations of the individual traces involved in the calculation.

The first argument can be specified implicitly by using the keyword IMPLied in the expression. When IMPLied is used, the trace that is currently programmed as the input source via the CALCulate<n>:FEED command is used as the first argument. The second argument must always be specified explicitly by its trace name.

Example:

1. CALCulate:FEED “CH3” (Sets CH3 as the implicit source for CALC1)

2. CALCulate:MATH “(IMPLied+CH2)” (Defines the calculation as CH3 + CH2)

3. CALCulate:MATH:STATe ON (Enables the function)

The result (CH3 + CH2) will be stored in M1_1.

The INTegral function performs a point-to-point integration on the input trace (selected via :FEED). The result is a trace where each point represents the integral (accumulation) up to the corresponding point in the original input trace. The function is enabled using CALCulate<n>:INTegral:STATe ON. Scaling can be adjusted via the MATHPLUS – PARAM menu option using front panel controls.

The DERivative (or DIFFerential) function calculates the differential quotient (derivative) of the input trace points (selected via :FEED). Each point in the resulting trace is the derivative of the corresponding point in the original input trace, calculated over a specified window. The function is enabled using CALCulate<n>:DERivative:STATe ON. Scaling can be adjusted via the MATHPLUS – PARAM menu option using front panel controls.

The width of the differential window for the DERivative function can be programmed from 3 to 129 points in increments of 2 points using the CALCulate<n>:DERivative:POINts command.

Example: CALCulate2:DERivative:POINts 35

After a *RST command, the number of points is 5.

The result of an FFT (Fast Fourier Transformation) calculation is displayed as a trace of amplitude values (vertically) versus frequency values (horizontally).

The vertical result type for the FFT calculation can be selected using the CALCulate<n>:TRANsform:FREQuency:TYPE command. The options are RELative or ABSolute.

The calculated amplitude and frequency values, typically associated with cursors placed on the FFT display, can be read using the DISPlay:WINDow:TEXT<n>:DATA? query, specifically with <n> = 60 (frequency) and <n> = 61 (amplitude).

A relative FFT calculation results in a display consisting of frequency (Hz) and amplitude in decibels (dB), relative to the frequency component with the largest amplitude (which is assigned 0 dB).

An absolute FFT calculation results in a display consisting of frequency (Hz) and an absolute amplitude value. The amplitude units can be dBm (dB relative to 1 milliwatt), dBµV (dB relative to 1 microvolt), or Vrms (Volts RMS), as selected via the front panel CURSORS – READOUT softkey menu.

The following FFT window functions can be selected using the CALCulate<n>:TRANsform:FREQuency:WINDow command:

– RECTangular: Transforms a repetitive time amplitude trace into its power spectrum without applying any specific window. Best for signals perfectly periodic within the acquisition window.

– HAMMing / HANNing: Reduce side lobes in the frequency spectrum by applying a Hamming or Hanning window to the input time-domain signal. This improves the visibility of minor frequency components, especially if the signal is not perfectly periodic within the window or if there is significant spectral leakage.

The resulting FFT trace is a MIN/MAX (envelope) trace, meaning each horizontal point represents both the minimum and maximum amplitude calculated for that frequency bin. The FFT trace points are scaled vertically between +4 and -4 divisions on the screen. However, the sample values returned by a TRACe? query are shifted 4 divisions upwards. The amplitude values typically range from -0 dB (top, corresponding to the strongest component or reference) to -80 dB (bottom).

The relationship between the trace sample value (Ts) reported via TRACE:DATA? and the displayed FFT trace point value (in dB) is:

Note: These Ts values reflect the shifted values returned by TRACE:DATA? for an FFT trace.

FFT trace sample values (Ts), as returned by the TRACE:DATA? query, can be converted to the actual FFT point value (Ps) in dB using the following steps:

1. Subtract the offset value for 4 divisions:

– For 8-bit samples: Subtract 100 (since 4 divisions * 25 units/division = 100)

– For 16-bit samples: Subtract 25600 (since 4 divisions * 6400 units/division = 25600)

2. Multiply the result by the correction factor:

– For 8-bit samples: Multiply by 0.4 (-10 dB / -25 units = 0.4 dB/unit)

– For 16-bit samples: Multiply by 0.0015625 (-10 dB / -6400 units = 0.0015625 dB/unit)

The equations are:

For 8-bit samples: Ps (dB) = (Ts – 100) * 0.4

For 16-bit samples: Ps (dB) = (Ts – 25600) * 0.0015625

(Note: Ts here refers to the raw sample value from TRACE:DATA?, not the general trace sample value definition from section 3.4.3).

In a relative FFT calculation, the component with the highest amplitude is taken as the reference level, referred to as the 0 dB level. All other amplitude trace point values represent the strength of their frequency components relative to this reference.

In an absolute FFT calculation, the amplitude trace point values depend on the absolute reference level selected via the CURSORS – READOUT front panel menu.

The possible absolute reference levels that can be selected via the CURSORS – READOUT front panel menu are:

– dBm (reference = 1 mW) with REFerence IMPedance of 50Ω

– dBm (reference = 1 mW) with REFerence IMPedance of 600Ω

– dBµV (reference = 1 µV)

– Vrms (reference = RMS signal amplitude)

The reference level for absolute FFT, corresponding to the top of the screen (0 dB relative level), is calculated based on the RMS value of a sine wave occupying 6.34 divisions peak-to-peak. This RMS value is 6.34 / (2 * sqrt(2)) ≈ 2.24 times the vertical sensitivity setting (mV/div). For any attenuator setting, the reference level can be calculated as:

Reference Level = 2.24 * <number of millivolts per division>

Examples:

At 20mV/div: Reference Level ≈ 2.24 * 20 = 44.8 mVrms

At 100mV/div: Reference Level ≈ 2.24 * 100 = 224 mVrms

This calculated level corresponds to the absolute value (e.g., Vrms, dBm, dBµV) displayed at the top of the FFT screen.

A signal of 1 mW at 50Ω impedance is used as a voltage reference, corresponding to the 100 mV/div setting. The RMS voltage for this signal is:

Urms = sqrt(P * R) = sqrt(1E-3 W * 50 Ω) ≈ 0.2236068 V

For a full screen display (assumed to be 10 divisions for this calculation, although FFT uses 8), this reference corresponds to Urms = 2.236068 V. The Vrms offset voltage for any attenuator setting is then calculated as:

Vrms offset = attenuation * Urms_reference (where Urms_reference = 0.2236068 V if attenuation is V/div, or 2.236068 V if attenuation is related to full screen)

Using the provided example for 0.5 V/div (which seems to relate attenuation to the 100mV/div reference implicitly):

Attenuation factor = 0.5 V/div / 0.1 V/div = 5 (relative to 100mV/div reference)

Vrms offset = 5 * 0.2236068 V ≈ 1.118034 V

Alternatively, using the 2.236068 V reference directly with the V/div setting:

Vrms offset = (Attenuator_setting_V_per_div / 0.1_V_per_div) * 0.2236068 V

Example for 0.5 V/div: Vrms offset = (0.5 / 0.1) * 0.2236068 = 5 * 0.2236068 ≈ 1.118034 V

This Vrms offset represents the absolute RMS voltage corresponding to the top of the screen at that specific attenuator setting.

The dBm-50Ω offset value (absolute dBm value corresponding to the top of the screen) is calculated from the Vrms offset value using the reference voltage for 0 dBm at 50Ω (which is sqrt(1E-3 * 50) ≈ 0.2236068 V):

dBm-50Ω offset = 20 * log10 (Vrms offset / 0.2236068)

Example for attenuator setting 0.5 V/div (Vrms offset ≈ 1.118034 V):

dBm-50Ω offset = 20 * log10 (1.118034 / 0.2236068) = 20 * log10(5) ≈ 13.9794 dBm

The dBm-600Ω offset value is calculated from the Vrms offset value using the reference voltage for 0 dBm at 600Ω (which is sqrt(1E-3 * 600) ≈ 0.7745967 V):

dBm-600Ω offset = 20 * log10 (Vrms offset / 0.7745967)

Example for attenuator setting 0.5 V/div (Vrms offset ≈ 1.118034 V):

dBm-600Ω offset = 20 * log10 (1.118034 / 0.7745967) ≈ 20 * log10(1.44338) ≈ 3.187587 dBm

The dBμV offset value is calculated from the Vrms offset value using the reference voltage of 1 μV (1.0E-6 V):

dBμV offset = 20 * log10 (Vrms offset / 1.0E-6)

Example for attenuator setting 0.5 V/div (Vrms offset ≈ 1.118034 V):

dBμV offset = 20 * log10 (1.118034 / 1E-6) ≈ 20 * log10(1118034) ≈ 120.9691 dBμV

The calculated offset values (corresponding to the top of the screen / 0 dB relative level) are summarized below:

The horizontal frequency value (Fs) in Hz for each point in the FFT trace is calculated based on the sample index, the acquisition length (number of points), and the Main Time Base (MTB) using the following equation:

Fs = (<sample_index> * 1250) / (TRACE:POINts * MTB * 50)

Where:

<sample_index>: Point number of the sample in the trace (e.g., 0 to N-1).

TRACE:POINts: Acquisition length (total number of samples).

MTB: Main Time Base in seconds per division (calculated from SENSE:SWEep:TIME).

The constants 1250 and 50 likely relate to the FFT calculation span and the number of points per division.

Only trace sample data can be queried from trace memories (M1_n, M2_n) where FFT results are stored. No trace administration data, such as the acquisition length (TRACE:POINts) or MTB value (derived from SENSE:SWEep:TIME) used for the calculation, is stored with the FFT trace. This means that these values must be queried from the actual input channel signal (which was the source for the FFT process) *before* reading the FFT trace memory. Care must be taken not to change the acquisition length or MTB between activating the FFT post-processing function and reading the resulting trace memory, otherwise the frequency calculation will be incorrect.

To convert and print the frequency and amplitude values of an FFT trace (e.g., 512 samples, 1 or 2 bytes, result stored in M1_1 via MATH1):

1. **Set up FFT:** Use the front panel (or corresponding commands) to:

– Enable MATH1 and select “fft”.

– Select the desired FFT filter (“hamming”, “hanning”, “rectang”) via MATH – PARAM – FILTER.

– Select relative (“rel”) or absolute (“abs”) FFT via MATH – PARAM – READOUT.

– If absolute, select the desired units (“dBm + 50Ω”, “dBm + 600Ω”, “dBµV”, “Vrms”) via CURSORS – READOUT.

– Ensure the source channel (e.g., CH1) has the signal of interest.

2. **Query Necessary Values:**

– Get acquisition length: `TRACE:POINts? CH1`

– Get sweep time: `SENSE:SWEep:TIME?`

– Calculate MTB: `MTB = (sweep_time * 50) / (acquisition_length – 1)`

– Calculate frequency factor: `calc = 1250 / (acquisition_length * MTB * 50)`

– If absolute FFT, get peak-to-peak voltage for attenuation: `SENSE:VOLTage:RANGE:PTPeak? CH1` (Calculate Attenuation = peak-to-peak / 8)

– Get FFT type (Absolute/Relative): `CALCulate:TRANsform:FREQuency:TYPE?`

3. **Read FFT Trace:**

– `TRACe? M1_1` (Read the FFT result stored in M1_1)

4. **Convert and Print:**

– Parse the received trace data block (handle header, checksum).

– Loop through each sample point (index `i` from 0 to N-1):

– Calculate Frequency: `Fs = i * calc`

– Extract amplitude sample value (Ts) (handle 1 or 2 bytes).

– Convert Ts to Amplitude (Ps) in dB using the formulas from section 3.19:

– `Ps = (Ts – offset) * factor` (offset/factor depend on 8/16 bits)

– If absolute FFT, add the appropriate calculated offset (dBm, dBµV, or convert Vrms) based on the queried attenuation and selected units.

– Print the calculated Frequency (Fs) and Amplitude (Ps) for each point.

Note: The program example EXFFTTRC.BAS implements this process.

The HISTogram function (CALCulate<n>:TRANsform:HISTogram) calculates an amplitude distribution of the incoming trace (selected via :FEED). The result is a histogram trace with 512 points. Each point in the histogram specifies the number of times that a data point from the input trace falls within one of 512 specific amplitude belts. The function is enabled using :STATE ON.

The total range covered by the 512 amplitude belts is determined by the selected peak-to-peak range (SENSE:VOLTage<n>:RANGe:PTPeak) of the input channel. The width of each amplitude belt is calculated as:

amplitude belt = peak-to-peak range / 512

The histogram is displayed on the screen in the area between +3 and -2 divisions vertically, and between the third and the seventh division horizontally. The horizontal axis represents the amplitude in volts (corresponding to the amplitude belts). The vertical axis represents the number of occurrences of an amplitude within each belt, displayed in percent.

The FILTer function (CALCulate<n>:FILTer:FREQuency) performs digital low-pass filtering on the input trace (selected via :FEED) to suppress undesired frequency noise. The filtering is based on a window averaging technique. The function is enabled using :STATE ON.

The width of the filter window for the FILTer function can be programmed from 3 to 41 points in increments of 2 points using the CALCulate<n>:FILTer:FREQuency:POINts command.

Example: CALCulate:FILTer:FREQuency:POINts 35

After a *RST command, the number of points is 19.

The trace memory stores:

– Channel acquisition traces: CH1 to CH4 (capturing live input signals).

– Memory register traces: M1 to M8 (standard memory) or M1 to M50 (extended memory). These can store copies of acquisition traces, results of post-processing, or user-defined constant traces.

The amount of memory register space depends on whether the CombiScope instrument is equipped with standard or extended memory:

– Standard memory: 8 memory registers available (M1 to M8).

– Extended memory: 50 memory registers available (M1 to M50).

The available registers also depend on the selected acquisition length (TRACE:POINts).

The following trace acquisition lengths can be programmed using TRACE:POINts:

– 512

– 2024 (2K)

– 4096 (4K)

– 8192 (8K)

– 16384 (16K)

– 32768 (32K)

If a different acquisition length is programmed using TRACE:POINts, the contents of all acquisition and register trace space are cleared. All previously stored traces are lost.

The resulting traces of the post-processing functions are always stored in specific memory registers:

– CALCulate1 function results are stored in memory register 1 locations (e.g., M1_1, M1_n).

– CALCulate2 function results are stored in memory register 2 locations (e.g., M2_1, M2_n).

No, for the PM33x0A CombiScope instruments, CH3 and CH4 cannot be selected as the source for post-processing or copying. Instead, the external channel (e.g., M1_E representing the external input) can be selected where applicable.

The following table shows the relationship (PM33x0A channels shown in parentheses):

Delayed Time Base (DTB) acquisition traces are only saved in the CH1 to CH4 memory (acquisition space), and only when the acquisition length is 512 samples. DTB acquisitions can only be defined via front panel operations, not directly via SCPI commands covered here.

The resolution of trace sample values for all trace acquisitions can be formatted using the FORMat command, specifically with the INTeger parameter.

To format as 16 bits (2 bytes): FORMat INTeger, 16 (This is the default after *RST)

To format as 8 bits (1 byte): FORMat INTeger, 8

No, the contents of the acquisition and register space are not cleared when a different trace format (8 or 16 bits) is programmed using the FORMat command.

Use the TRACE:COPY command, specifying the destination memory register trace and the source channel.

Example: TRACE:COPY M1_2, CH2 (Copies acquisition trace from CH2 to memory register trace M1_2)

When copying from an input channel (e.g., CH2 to M1_2), the acquisition traces of any other currently active channels (CHn that are ON) are also copied into the corresponding locations in the destination register (e.g., CH1 to M1_1, CH3 to M1_3, if they are ON). All previously stored traces in the entire destination memory register (e.g., M1) are lost.

Use the TRACE:COPY command, specifying the destination memory register trace and the source memory register trace.

Example: TRACE:COPY M2_2, M1_2 (Copies the trace stored in M1_2 to M2_2)

When copying from one memory register trace to another (e.g., M1_2 to M2_2), all other stored traces within the source memory register (M1_n) are also copied to the corresponding locations in the destination memory register (M2_n), provided a trace was previously stored in that M1_n location. All previously stored traces in the entire destination memory register (e.g., M2) are lost.

To write a previously read trace block (obtained using TRACE? query) back into a memory register (Mi_n), use the TRACe command:

1. Read the trace block: Send TRACE? CH3, then Read <trace block>

2. Write the trace block: Send TRACe M2_3,<trace block>

Programming Note: The fixed command part (TRACe M2_3,) and the variable <trace block> must be sent separately without any EOI (End Or Identify) detection in between. The <trace block> must also be sent without EOI detection and without detection of the EOL (End Of Line) code, as the block itself might contain the EOL character code.

Use the TRACe command specifying the target memory register trace (Mi_n) and the desired constant value. The constant value should be within the range -32767 to 32767.

Example: TRACe M2_4, 1028

This command fills all locations of memory register trace M2_4 with the constant value 1028 (which is 0404 hexadecimal). If the trace format is 16-bit, it uses 0404h; if 8-bit, it uses 04h.

No, a trace can only be written to memory register space (Mi_n) and not to acquisition space (CHn).

The contents of trace memory registers can be read using the TRACe? query, specifying the desired trace location.

The TRACe? query allows you to read the contents from:

– An acquisition trace from one of the input channels (CH1 to CH4).

– Previously stored trace data from one of the memory registers (M1 to M8 or M1 to M50). This can be a copied acquisition trace or a trace of constant values.

– The result of a post-processing function stored in M1 (for CALCulate1) or M2 (for CALCulate2).

Example: TRACe? CH1 (Reads acquisition trace CH1)

Example: TRACe? M5_2 (Reads trace stored in M5_2)

Example: TRACe? M1_1 (Reads result of CALCulate1 function)

The brightness of the trace(s) displayed on the screen is controlled using the DISPlay:BRIGhtness command. The brightness is set on a scale from 0.0 (low) to 1.0 (high).

Example: DISPlay:BRIGhtness 0.3 (Sets brightness to 0.3)

After a *RST command, the brightness intensity is 0.18.

The display screen is divided into areas controlled by specific commands:

– WINDow[1]: The main upper area used by front panel functions like MEAS1/MEAS2, CURSORS, and MATH-FFT to display measurement data readout. Data can be queried using DISPlay:WINDow[1]:TEXT:DATA?.

– WINDow2: An area below WINDow1 used for writing user-defined text using DISPlay:WINDow2:TEXT commands.

– MENU: The area typically at the right or bottom used to display softkey menus, controlled by DISPlay:MENU commands.

Measured data displayed on the upper line(s) of the screen (WINDow[1]) can be acquired using the DISPlay:WINDow[1]:TEXT<n>:DATA? query. The number <n> specifies which measured data value to retrieve. The corresponding front panel functions (MEAS1, MEAS2, CURSORS, MATH-FFT) must be enabled and selected for data to be available.

The following measured data values can be selected by specifying <n>:

– 1, 2: MEAS1, MEAS2 data

– 10, 11, 12, 13, 20, 21, 30, 40, 51, 52: CURSORS data

– 60, 61: MATH – FFT frequency, amplitude

The format of a response string from DISPlay:WINDow[1]:TEXT<n>:DATA? is:

<meas_type>,<meas_value>,<suffix_unit>

User-defined text can be displayed in the WINDow2 area using the following commands:

– Enable display: DISPlay:WINDow2:TEXT:STATe ON (Display is off after *RST)

– Write text (string): DISPlay:WINDow2:TEXT:DATA ‘<string>’

– Write text (block data): DISPlay:WINDow2:TEXT:DATA #<n><digits><data>

– Clear text area: DISPlay:WINDow2:TEXT:CLEar

Note: The ASCII character 25 is displayed as Ω.

A softkey menu can be selected and automatically enabled for display using the DISPlay:MENU command, followed by the menu name.

Example: DISPlay:MENU CURSors (Selects and displays the CURSORS menu)

After a *RST command, the display of softkey menus is turned off.

The display of any currently shown softkey menu can be turned off using the command:

DISPlay:MENU:STATe OFF

A hardcopy device is selected using the HCOPY:DEVice <TYPE> command, where <TYPE> is one of the supported device types.

Example: HCOPY:DEVice PM8277

After a *RST command, the selected device is “plotter; HPGL”.

A hardcopy of the picture on the screen can be requested using the HCOPY:DATA? query. The instrument will respond with the hardcopy data formatted according to the currently selected printer/plotter options (set via HCOPY:DEVice or front panel UTILITY menu).

The response data to an HCOPY:DATA? query is sent as block data of indefinite length. This means it is preceded by a preamble “#0” (two bytes: ‘#’ and ‘0’). This preamble must be removed from the beginning of the block data before sending the remaining data to the connected plotter or printer device.

1. Send the query HCOPY:DATA? to the instrument (DSO) via GPIB.

2. Read the block response data from the instrument via GPIB into a buffer in the controller.

3. Remove the first two bytes (“#0”) from the received data buffer.

4. Send the remaining part of the data buffer (the actual print/plot data) to the printer/plotter device at its GPIB address.

The current time (in 24-hour format) is set using the SYSTem:TIME command:

SYSTem:TIME <hours>,<minutes>,<seconds>

Example: SYSTem:TIME 14,25,36 (Sets time to 14:25:36)

The current date is set using the SYSTem:DATE command:

SYSTem:DATE <year>,<month>,<day>

Example: SYSTem:DATE 1993,12,15 (Sets date to 15 December 1993)

The date and time are stamped on acquired waveforms.

The instrument data is calibrated automatically by sending either the *CAL? query or the CALibration? query. Calibration is only possible when the instrument is warmed up.

The internal calibration lasts several minutes. The response to the *CAL? or CALibration? query is only returned after the calibration has completed.

– A “0” result is returned after correct calibration.

– A “1” result is returned if the calibration failed.

During the calibration process, bit 0 (“Calibrating”) is set in the operation status condition register. However, this bit cannot be read during the execution of the sequential *CAL? or CALibration? queries. It can be read after sending the overlapped CALibration command (without the query ‘?’).

Completion of the CALibration command (overlapped) is reported by setting bit 0 (OPC – Operation Complete) in the Standard Event Status Register (ESR). When the calibration is finished, bit 8 (“CALibration”) in the QUEStionable status register reports a possible calibration error (it is set to 1 if an error occurred).

Execute calibration only when it is needed, for example, when a message on the screen of the CombiScope instrument requests you to do so, or if the temperature has changed significantly since the last calibration (indicated by Questionable Status bit 4).

To use SRQ to detect calibration completion:

1. Define an SRQ handler routine (e.g., ON PEN GOSUB ServReq).

2. Enable SRQ generation (e.g., PEN ON).

3. Configure the Operation Status register to report the transition of bit 0 (Calibration) from 1 to 0 (completion): Send STATus:OPERation:NTRansition 1.

4. Enable bit 0 in the Operation Status Enable register to allow it to be reported in the Status Byte: Send STATus:OPERation:ENABle 1.

5. Enable bit 7 (OPER summary bit) in the Service Request Enable (SRE) register to allow an SRQ to be generated when the Operation Status summary bit becomes true: Send *SRE 128.

6. Reset the instrument (*RST) and clear status registers (*CLS).

7. Start the calibration using the overlapped command: Send CALibration.

8. The program can perform other tasks while waiting.

9. When calibration finishes, bit 0 goes low, triggering the NTR filter, setting the summary bit, which propagates through the enabled SRE bit to generate an SRQ, causing the SRQ handler routine to be called.

The following status data applies:

– The meaning of the bits of the OPERation status is described in section 3.15.1.1.

– The meaning of the bits of the QUEStionable status is described in section 3.15.1.2.

– The meaning of the bits of the standard Event Status Register (ESR) is described in the command reference for the *ESR? query.

– The message output queue can contain about 250 data bytes.

– The error/event queue can contain 20 error messages before it overflows.

The Operation Status register group consists of:

– CONDition register: Reflects the current state of the instrument.

– EVENt register: Latches state changes based on filters.

– ENABle register: Controls which bits contribute to the summary.

– PTRansition filter: Configures detection of 0-to-1 transitions.

– NTRansition filter: Configures detection of 1-to-0 transitions.

These can be queried using commands like STATus:OPERation:CONDition?, STATus:OPERation:EVENt?, STATus:OPERation:ENABle?, etc.

(Bits 1, 4, 6, 7, 11-15 are not defined or always 0 in the condition register)

Similar to the Operation Status, the Questionable Status register group consists of CONDition, EVENt, ENABle, PTRansition, and NTRansition registers. These can be queried using commands like STATus:QUEStionable:CONDition?, etc.

(Bits 1-3, 5-7, 10-15 are not defined or always 0 in the condition register)

The *CLS (Clear Status) command is used to clear specific status data structures.

The *CLS command clears the following:

– All event status registers (Standard Event Status Register – ESR, operation event register, questionable event register).

– The Status Byte register (STB), except for the MAV bit (bit 4).

– The Error/event queue.

Note: It does *not* clear enable registers, filters, or output queues.

The STATus:PRESet command presets the filters (PTRansition, NTRansition) and enable registers (ENABle) of the Operation and Questionable status data structures in such a way that device-dependent events (i.e., bits becoming true in the condition registers) are reported upwards towards the Status Byte register.

Note: With Enable registers set to 0000, no status bits will actually propagate to the status byte summary bits after a preset, unless the enable registers are explicitly set afterwards.

You can use the Status Byte (STB) polling method:

1. Enable the OPC (Operation Complete) bit in the Standard Event Status Enable register (*ESE 1). OPC corresponds to bit 0.

2. Send the command(s) whose completion you want to detect (e.g., CONFigure:AC, INITiate).

3. Append the *OPC command. This command forces the instrument to set the OPC bit in the ESR *after* all preceding commands have finished.

4. Repeatedly poll the Status Byte register using the *STB? query.

5. Check bit 5 (ESB – Event Status Bit) of the returned status byte. When bit 5 becomes 1, it indicates that at least one enabled bit in the ESR (in this case, the OPC bit) has become true, meaning the operation is complete.

Example logic: Read STB value; IF (STB_value AND 32) THEN OperationCompleted = True.

You can use the Service Request (SRQ) interrupt method:

1. Define an SRQ handler routine in your controller program (e.g., ON PEN GOSUB ServReq).

2. Enable SRQ generation in the controller (e.g., PEN ON).

3. Enable the OPC (Operation Complete) bit in the Standard Event Status Enable register (*ESE 1).

4. Enable the ESB (Event Status Bit, bit 5) in the Service Request Enable register (*SRE 32). This allows an SRQ to be generated when the ESB summary bit in the Status Byte becomes true.

5. Send the command(s) whose completion you want to detect (e.g., CONFigure:AC, INITiate).

6. Append the *OPC command.

7. The controller can perform other tasks.

8. When the preceding operations finish, the OPC bit is set in the ESR, causing the ESB bit (bit 5) in the Status Byte to become true. Since bit 5 is enabled in the SRE register, an SRQ is generated, interrupting the controller and executing the SRQ handler routine.

9. The SRQ handler routine should typically read the Status Byte (via serial poll) to clear the SRQ and read the ESR (*ESR?) to clear the OPC bit.

Instrument errors (usually programming or setting errors) can be reported by querying the instrument’s error queue. This is done by sending the SYSTem:ERRor? query or the STATus:QUEue? query to the instrument, followed by reading the response message. The instrument maintains a queue of errors; repeated queries will retrieve errors one by one until the queue is empty (indicated by a “0, ‘No error'” response).

Querying for errors after every single command can be impractical. Recommended approaches are:

1. Query after groups of commands: Send the SYSTem:ERRor? query and read the response after sending a group of commands that functionally belong together.

2. Use an error-reporting routine: Program a subroutine that sends SYSTem:ERRor? and reads the response. Call this subroutine after each command or group of commands.

3. Use SRQ for error reporting: Program an error-reporting routine and use the SRQ mechanism (triggered by error bits in status registers) to interrupt the program and execute the error-reporting routine when an error occurs.

Create a subroutine (e.g., `ErrorCheck`) that performs the error query and reads the response. Call this subroutine after relevant commands or command groups.

Example Subroutine (BASIC-like):

“`basic

ErrorCheck:

CALL Send(0, 8, “SYSTem:ERRor?”, 1) ‘ Queries for a system error

CALL Receive(0, 8, response$, 256) ‘ Reads the instrument error

IF LEFT$(response$, 1) <> “0” THEN ‘ Check if error code is not 0

PRINT “Error: “; response$ ‘ Prints the instrument error

‘ Add error handling logic here if needed

END IF

RETURN

“`

Then, in the main code:

“`basic

CALL Send(0, 8, “READ:AC?”, 1)

CALL Receive(0, 8, response$, 256)

PRINT “AC-RMS: “; response$

GOSUB ErrorCheck ‘ Call the error checking routine

“`

1. **Enable Error Reporting:** Configure the Standard Event Status Register (ESR) and Service Request Enable (SRE) register to generate an SRQ when an error occurs. Typically, you would enable command error, execution error, or query error bits in the *ESE register and enable the ESB bit in the *SRE register.

2. **Define SRQ Handler:** Create an SRQ handler routine (e.g., `ON PEN GOSUB ErrorCheck`) that will be executed when an SRQ occurs.

3. **Error Check Subroutine:** Implement the `ErrorCheck` subroutine to repeatedly query `SYSTem:ERRor?` until it returns “0, ‘No error'”, printing each error found. This ensures the error queue is cleared.

Example Subroutine (BASIC-like):

“`basic

SUB ErrorCheck

DIM er$ AS STRING * 60

DO

CALL Send(0, 8, “SYSTem:ERRor?”, 1) ‘ Sends error query

CALL Receive(0, 8, er$, 256) ‘ Reads error string

IF LEFT$(er$, 1) <> “0” THEN

PRINT “Error = “; er$ ‘ Displays error string

END IF

LOOP WHILE LEFT$(er$, 1) <> “0” ‘ Loop until 0, ‘No error’

END SUB

“`

4. **Enable SRQ:** Turn on SRQ handling in the controller (e.g., `PEN ON`).

When an error occurs and the status system is configured correctly, an SRQ will be generated, triggering the `ErrorCheck` routine to read and display all errors from the queue.

Send the *RST command to the instrument. This resets the instrument-specific functions to their default state and selects the digital mode.

Complete instrument setups can be stored in and recalled from internal recall memories 1 through 10 (memory 0 contains the initial settings).

– To save the current setup to memory location <n> (1-10): Send *SAV <n>

– To recall a setup from memory location <n> (0-10): Send *RCL <n>

Example (Save to memory 3): *SAV 3

Example (Recall from memory 3): *RCL 3

Complete or partial instrument setups (nodes) can be transferred between the instrument and an external controller’s memory:

– To store (query) a setup from the instrument to the controller: Send the SYSTem:SET? [<node>] query. Read the response string containing the setup data.

– To recall (send) a setup from the controller to the instrument: Send the SYSTem:SET [<node>] command, followed by the setup data string.

Example (Store complete setup):

1. Send SYSTem:SET?

2. Read settings$

Example (Recall complete setup):

1. Send SYSTem:SET <setup_data> (Send header SYSTem:SET separately if needed for EOI handling)

The pressing of a front panel key can be simulated using the SYSTem:KEY command, followed by the key’s number code according to the defined matrix.

Example: SYSTem:KEY 101 (Simulates pressing the key at row 1, column 1, often Autoset)

Example: SYSTem:KEY 2 (Simulates pressing softkey 2)

Whether a key has been pressed can be detected via bit 6 (URQ – User Request) of the Standard Event Status Register (ESR). The specific key that was last pressed can be queried using the SYSTem:KEY? query.

The front panel keys (excluding rotary knobs) are roughly numbered based on a row and column matrix. Softkeys are numbered 1 to 6.

(Note: Softkey positions 1 to 6 correspond to keys 1, 2, 3, 4, 5, 6 respectively in the SYSTem:KEY command).

Autoset can be simulated by sending the command corresponding to the Autoset key number, which is typically 101.

Example: SYSTem:KEY 101

Simulating a softkey menu operation involves:

1. Enabling the desired main menu using DISPlay:MENU <menu_name> (e.g., DISPlay:MENU UTIL for Utility menu).

2. Sending SYSTem:KEY <n> commands, where <n> is 1 to 6, to simulate pressing the corresponding softkeys required to navigate the menu and select the desired option.

3. Optionally, disable the menu display afterwards using DISPlay:MENU:STATe OFF or by enabling another menu.

Example (Set probe correction for CH1 to 10:1 via UTILITY menu):

“`basic

CALL Send(0, 8, “DISPlay:MENU UTIL”, 1) ‘ Enable UTILITY menu

CALL Send(0, 8, “SYSTem:KEY 2;KEY 5;KEY 4”, 1) ‘ Simulate pressing softkeys 2(PROBE), 5(CORR), 4(10:1)

CALL Send(0, 8, “DISPlay:MENU:STATE OFF”, 1) ‘ Disable UTILITY menu display

“`

Not all front panel functions are individually programmable with SCPI commands. However, the SYSTem:SET and *SAV/*RCL commands can be used to access the following functions:

Cursor functions: see CURSORS menu (appendix B.2.2)

Logic Triggering: see TRIGGER menu (appendix B.2.10)

Event functions: see TB MODE menu (appendix B.2.9)

DTB functions: see DTB (DEL’D TB) menu (appendix B.2.6)

X pos: see X POS button

Display menu functions: see DISPLAY menu (appendix B.2.3)

Pass/Fail functions: see MATHPLUS MATH menu (appendix A5 and B.2.4.)

Other functions and keys that are not individually programmable with SCPI commands are accessible using the SYSTem:KEY command. They are:

Roll mode: DISPlay:MENU TBMode;:SYSTem:KEY 3 toggles on/off

Trigger noise: DISPlay:MENU TRIGger;:SYSTem:KEY 4 toggles on/off

TEXT OFF key: SYSTem:KEY 801 selects next option

STATUS key: SYSTem:KEY 201 toggles on/off

MAGNIFY keys: SYSTem:KEY 210/211 selects previous/next step

ENVELOPE: DISPlay:MENU ACQuire;:SYSTem:KEY 3 toggles on/off

MULTiple-shot: DISPlay:MENU TBMode;:SYSTem:KEY 1 (up)or 2 (down) (after INITiate:CONTinuous OFF)

The following table summarizes the common commands:

Note: Notes 1, 2, and 3 refer to details described elsewhere in the PDF regarding voltage parameters, measure parameters, and channel lists.

Note: Notes 1, 2, 3, and 4 refer to details described elsewhere in the PDF regarding voltage parameters, measure parameters, channel lists and trace lists.

Note: Notes 1, 2, and 3 refer to details described elsewhere in the PDF regarding voltage parameters, measure parameters, and channel lists.

It is advised to send the commands *RST and *CLS first, before executing the programming examples in this chapter. In this way the oscilloscope is reset to default settings (*RST) and the status data cleared (*CLS).

Be aware of coupled commands during command execution. Coupling information is described in the command descriptions. Coupling means that an instrument may change other functions or values, which are not directly programmed by sending this command. Example: The vertical sensitivity is derived from the programmed peak-to-peak value (SENSE:VOLTage:RANGE:PTPeak). The programmed trigger level (TRIGger:LEVel) is adapted to the vertical sensitivity to keep the signal display on the screen.

In the remote state the front panel keys will have no effect on programmed settings. Local front panel control can be obtained by pressing the LOCAL key, provided the instrument is not programmed Locally Locked Out (LLO). After power on the oscilloscope is in its local state, i.e., controlled via the front panel.

All commands and queries are sequential commands, except the INITiate, INITiate:CONTinuous, and CALibration command (overlapped commands).

Note: Overlapped commands are commands that can be executed in overlap with other commands. Sequential commands are commands that are completed first, before a next command is executed.

Syntax: *CAL?

Response: 0 | 1 (0 = Calibration okay, 1 = Calibration not okay)

Description: This query performs an automatic internal self-calibration and reports the result. No external means or operator interface is needed. The response indicates whether the self-calibration completed without error. A possible calibration error is also reported via bit 8 in the QUEStionable status register. The *CAL? query is the equivalent of the CALibration[:ALL]? query.

Limitation: The calibration process will last a couple of minutes. During this time, bit 0 in the OPERation status is set, indicating calibration is busy (this status can only be requested if calibration was started via the front panel). Because *CAL? is a sequential command, a next command or query in the same program message is not executed until the calibration process is completed. Until then, no response to a next query is obtained.

Example:

Send → *CAL?

Read (Response is held up during calibration)

IF = 1 THEN PRINT “calibration not successful.”

Front panel compliance: The *CAL? query is the remote equivalent of the front panel CAL key.

Syntax: *CLS

Description: The *CLS command clears the following status data structures:

1. Clears all Event Status Registers, such as:

– Standard Event Status Register (*ESR?)

– Status Byte Register (*STB?)

– Operation Event Status register (STATus:OPERation:EVENT)

– Questionable Event Status Register (STATus:QUEStionable:EVENT)

2. Clears the Error/Event Queue.

3. Cancels the effect of the *OPC command and the *OPC? query; any request for the OPC flag is cancelled.

Note: When the *CLS command is entered as the first command in a new program message, it also clears the Output Queue and as a consequence, the MAV-bit in the Status Byte Register.

Example:

Send → *CLS (Clears the status data)

Syntax: *ESE

Query form: *ESE?

Response:

Description: The command sets and the query reports the contents of the standard Event Status Enable register (ESE). The range is 0 to 255 decimal. The ESE register determines which bits in the standard Event Status Register (ESR) are enabled to be summarized in the Status Byte Register (STB). The ESE register is cleared at Power on.

Example:

Send → *ESE 17 (Enables the EXE (Execution Error, bit 4) and the OPC (Operation Complete, bit 0) bits to be summarized in the Status Byte Register. Alternative commands *ESE #B10001 and *ESE #H11.)

Send → *ESE?

Read ← 17 (Indicates bits 4 and 0 are set.)

Syntax: *ESR?

Response:

Description: The *ESR? query reports the contents of the standard Event Status Register (ESR) and clears it. The range is 0 to 255 decimal.

Bit Meanings (ESR):

• Bit 7: PON = Power ON
• Bit 6: URQ = User Request
• Bit 5: CME = Command Error
• Bit 4: EXE = Execution Error
• Bit 3: DDE = Device Dependent Error
• Bit 2: QYE = Query Error
• Bit 1: RQC = Request Control (Not used, always 0)
• Bit 0: OPC = Operation Complete

Notes:

• PON indicates power cycle since last read/clear (always set true at power on).
• URQ indicates user request for attention (e.g., return to local).
• OPC indicates completion of all previously started actions.

Example:

Send → *ESR?

Read ← 28 (Binary #B11100, decimal 16+8+4). This means bits 4 (EXE), 3 (DDE), and 2 (QYE) are set, indicating an execution error, a device-dependent error, and a query error occurred since the last read.

Syntax: *IDN?

Response: ,,,

Where:

• : E.g., FLUKE
• : E.g., PM3392A
• : Always 0
• : ::
  • : Firmware ID (Type e.g., SW3394AIM, Version e.g., V1.0, Date e.g., year-month-day)
  • : Mask ID (e.g., UHM V1.0)
  • : UFO ID (e.g., UFO V2.0)

Description: Reports the identification of the instrument in Arbitrary ASCII Response Data format. This implies *IDN? must be the last query in a program message unit (terminated by New Line). It identifies firmware type/version/date, Universal Host Mask processor software version, and Universal Front processor software version.

Example:

Send → *IDN?

Read ← FLUKE,PM3384A,0,SW3394AIM V2.0 1994-09-15:UHM V1.0:UFO V2.0

Front panel compliance: Equivalent to the Maintenance option of the UTILITY menu.

Syntax: *OPC

Query form: *OPC?

Response: 1

Description:

• The *OPC command causes the instrument to set the operation complete bit (OPC, bit 0) in the standard Event Status Register (ESR) when all pending operations have finished.
• The *OPC? query places the ASCII character ‘1’ in the output queue when all pending operations are finished. The instrument holds off the GPIB handshake (if addressed as talker) as long as there are pending operations.

The OPC bit is cleared, along with other *ESR bits, when *ESR? is executed.

Note: The *RST command, the *CLS command, and power on cancel the effect of an *OPC command or an *OPC? query.

Restrictions: Be careful with GPIB controller timeouts. Ensure the timeout period is long enough to cover the operation time of the instrument, especially for operations that never complete (like INITiate:CONTinuous ON).

Example:

Send → *RST; *CLS (Resets instrument, clears status)

Send → INITiate:CONTinuous ON (Continuous initiation)

Send → *OPC; *ESR? (Request OPC notification, query ESR)

Read ← 0 (Instrument is busy sweeping, OPC bit not yet set)

Send → INITiate:CONTinuous OFF (Stop initiation)

Send → *OPC; *ESR? (Request OPC notification, query ESR)

Read ← 1 (Instrument has finished sweeping, OPC bit was set)

Syntax: *OPT?

Response: {,}

Where = ::

• : IEEE | EXT | EM | MP
• : Always 0
• : Always 0

Description: The *OPT? query reports which options are present.

• IEEE:0:0: IEEE-488.2/SCPI option installed.
• EXT:0:0: EXTernal trigger option installed.
• EM:0:0: Extended Memory available.
• MP:0:0: Math Plus option installed.

Example:

Send → *OPT?

Read ← IEEE:0:0,MP:0:0 (The IEEE and MathPlus options are available.)

Front panel compliance: Equivalent to the Maintenance option of the UTILITY menu.

Syntax: *RCL

Description: The *RCL command restores instrument settings from one of the internal memory registers 0..10.

• Register 0: Contains standard settings (recall only).
• Registers 1-10: Contain user-programmable settings (saved via *SAV command).

After power on, the settings from just before power off are restored (saved in non-volatile memory).

Example:

Send → *SAV 2 (Stores the actual instrument settings into memory register 2.)

Send → *RCL 2 (Restores the instrument settings from memory register 2.)

Front panel compliance: Equivalent to the front panel softkey operation via the SETUPS/RECALL menu. Standard settings in memory 0 can be changed via the front panel FRONT SETUPS menu.

Syntax: *RST

Description: The *RST command resets the instrument. The hardware and software are initialized without affecting any IEEE interface conditions. The instrument turns into a fixed setup optimized for remote operation. This fixed setup is different from the setup recalled via the front panel SETUPS menu (optimized for local control).

The *RST command sets the following instrument settings, independent of the past history:

The *RST command performs the following actions:

Cancels or aborts any instrument-dependent action.

Cancels the effect of the *OPC command and the *OPC? query.

Sets the TRIGger subsystem into its IDLE state.

The *RST command does not affect the following:

State of the IEEE 488.1 interface.

GPIB (IEEE 488.1) address of the instrument.

Contents of the Output Queue.

Contents of the Error/Event Queue.

Service Request Enable setting in the SRE register.

Transition filters in the status subsystem.

Event registers in the status subsystem.

Event enable registers in the status subsystem.

Calibration data that affects the device specifications.

Version number set by the SYSTem:VERSion command.

Contents of the internal memory registers (*SAV/*RCL).

Syntax: *SAV

Description: The *SAV command saves the current instrument settings into one of the internal memory registers 1..10. Settings in memory register 0 are standard settings and cannot be saved to, only recalled. Settings saved in registers 1 through 10 can be recalled using the *RCL command.

Example:

Send → *SAV 2 (Stores the actual instrument settings into memory register 2.)

Send → *RCL 2 (Restores the instrument settings from memory register 2.)

Front panel compliance: Equivalent to the front panel softkey operation via the SETUPS/RECALL menu. Standard settings in memory 0 can be changed via the front panel FRONT SETUPS menu.

Syntax: *SRE

Query form: *SRE?

Response:

Description: The command sets and the query reports the contents of the Service Request Enable (SRE) register. The range is 0 to 255 decimal, but bit 6 (value 64) is ignored and always reported as zero (real range 0-63 and 128-191). The bits in the SRE register determine:

1. Which corresponding bits in the Status Byte register (STB) cause a service request (SRQ) from the instrument.

2. Which corresponding bits in the STB are summarized in the Master Summary Status (MSS) bit within the *STB register.

A bit value of 1 enables the condition, 0 disables it. The SRQ line is activated only when a *new* enabled reason for service occurs. The Status Byte is not updated after an SRQ until a serial poll is done or the reason for service no longer exists.

Example:

Send → *SRE #B100000 (This sets bit 5 (ESB – Event Summary Bit) in the Service Request Enable Register.)

Syntax: *STB?

Response:

Description: The *STB? query reports the contents of the Status Byte register (STB). The range is 0 to 255 decimal. The STB contains the summary status of all overlaying status registers and queues.

Bit Meanings (STB):

• Bit 7 (OPER): OPERation status. Contains the summary of the OPERation status register structure.
• Bit 6 (RQS/MSS): RQS (Requested Service) / MSS (Master Summary Status).
  • RQS: Indicates the device requests service (SRQ=1 on GPIB). Cleared after a serial poll. Set true again only when a *new* event occurs that requires service. Read by Serial Poll.
  • MSS: Indicates there is an event causing the device to request service. Cleared when the event(s) in the overlaying status structure that caused the Service Request are cleared. Read by *STB?.
• Bit 5 (ESB): Event Summary Bit. Contains the summary of the Standard Event Status register structure.
• Bit 4 (MAV): Message Available. Indicates whether the Output Queue contains at least one message (bit=1) or is empty (bit=0).
• Bit 3 (QUES): QUEStionable status. Contains the summary of the QUEStionable status register structure.
• Bit 2: Error/Event queue bit. Indicates whether the Error/Event queue contains at least one message (bit=1) or is empty (bit=0).
• Bit 1: Device Dependent Status bit (not used).
• Bit 0: Device Dependent Status bit (not used).

Example:

Send → *STB?

Read ← 4 (Binary #B100). This means bit 2 is set, indicating there is an error message in the Error/Event Queue.

Syntax: *TRG

Description: The *TRG command triggers the instrument by generating a Group Execute Trigger (GET) code. This is typically used when the trigger source is set to BUS.

Example:

Send → *RST (Resets the instrument)

Send → TRIGger:SOURce BUS (GPIB becomes trigger source)

Send → INITiate (Initiates the instrument once, arming the trigger)

Send → *TRG (Triggers the instrument via GPIB)

Send → FETCh:FREQuency? (Fetches a measurement result, e.g., frequency)

Read ←

Syntax: *TST?

Response: 0 | 1

• 0: Self-test okay.
• 1: Self-test not okay.

Description: The *TST? query initiates a RAM/ROM test in the instrument and returns the result. A result of 0 indicates the test completed without detecting any error. A result of 1 indicates the self-test failed. Upon successful completion of *TST?, the instrument settings are restored to their values prior to the execution of *TST?.

Example:

Send → *TST?

Read ←

IF = 1 THEN PRINT “Self-test failed; instrument must be repaired.”

Syntax: *WAI

Description: The *WAI (Wait-to-continue) command prevents the instrument from executing any further commands until all previous commands and queries have been completed. It is used to force sequential execution of commands by the instrument. On receipt of *WAI, the instrument executes all pending commands and queries before it executes the next command or query.

Restrictions: Be careful with GPIB controller timeouts. Verify first whether the timeout period is long enough to cover the operation time of the instrument, as the controller might interrupt the program if the wait time exceeds the timeout.

Example:

Send → *RST (Resets the instrument)

Send → INITiate (First initiation of the trigger system)

Send → *WAI (Wait for the first initiation to complete)

Send → INITiate (Second initiation of the trigger system)

Notice that the second initiation is only executed when the actions of the first initiation have been completed.

Note: The *OPC? query can also be used to achieve sequential execution of the first and the second INITiation.

Syntax: ABORT

Description: The ABORt command resets the trigger system and places it in the “IDLE” state. Pending actions that were already started are finished immediately. The ABORT command is not finished until the pending actions have been terminated.

Note: The commands *RST and ABORt have the same effect on the trigger functions, except that ABORt does not affect the state of the INITiate:CONTinuous command. So, when an ABORt command is sent while the INITiate:CONTinuous is ON, the trigger system will leave the IDLE state at once.

Example:

Send → ABORT (Aborts the current acquisition)

Send → CONFigure:AC (Configures for AC-RMS value)

Send → READ:AC? (Initiates and reads the AC-RMS value)

Read ←

Commands:

• CALCulate:DERivative:POINts | MAXimum | MINimum
• CALCulate:DERivative:STATE

Where is [1] | 2.

Alias: :DERivative can be written as :DIFFerential.

Parameters:

• for POINts: 3, 5, 7, …, 127, 129 (odd number of points).
• for STATE: 0 (OFF) or 1 (ON).

Description:

• The :POINts command specifies the width (number of points) of the differentiate window.
• The :STATE command switches the differentiate function on or off.

The result is stored in M1_n (for CALCulate1) or M2_n (for CALCulate2) based on the input source (CHn or Mi_n). After *RST, the window width is 5 points and the function is off.

Example:

Send → CALCulate1:DERivative:POINts 21 (The width for MATH1 becomes 21 points)

Send → CALCulate1:DERivative:STATE ON (Switches the MATH1 differentiate function on)

Front panel compliance: Corresponds to MATH1 and MATH2 features.

Syntax: CALCulate:FEED ““

Where is [1] | 2.

Parameter:

• ““: A predefined acquisition trace (CH1|CH2|CH3|CH4) or memory trace (Mi_1|Mi_2|Mi_3|Mi_4). Note: i=1..8 (standard memory), i=9..50 (extended memory). This is string data and can use single quotes (‘ ‘) as well.

Query form: CALCulate:FEED?

Response: “CHn” | “Mi_n”

Description: This command controls the source for the specified calculate function (CALCulate1 or CALCulate2). The trace specified by is selected as the source. After a *RST command, CH1 becomes the source for both CALCulate1 and CALCulate2.

Limitations:

• A channel must be ON before it can be selected.
• An empty trace may not be used as a source.
• M1_i is not allowed as source for a CALCulate1 command.
• M2_i is not allowed as source for a CALCulate2 command.

Example:

Send → CALCulate2:FEED “CH3” (Channel 3 becomes the source for MATH2)

Send → CALCulate1:FEED ‘M8_4’ (Memory trace M8_4 becomes the source for MATH1)

Front panel compliance: Corresponds to MATH1 and MATH2 features.

Commands:

• CALCulate:FILTer[:GATE]:FREQuency:POINts | MAXimum | MINimum
• CALCulate:FILTer[:GATE]:FREQuency:STATE

Where is [1] | 2.

Parameters:

• for POINts: 3, 5, 7, …, 39, 41 (odd number of points).
• for STATE: 0 (OFF) or 1 (ON).

Description:

• The :POINts command specifies the width (number of points) of the filter window.
• The :STATE command switches the calculate function FILTer on or off.

The result is stored in M1_n (for CALCulate1) or M2_n (for CALCulate2) based on the input source (CHn or Mi_n). After *RST, the filter window width is 19 points and the function is off.

Example:

Send → CALCulate1:FILTer:FREQuency:POINts 21 (The width for MATH1 filter becomes 21 points)

Send → CALCulate1:FILTer:FREQuency:STATE ON (Switches the MATH1 filter function on)

Front panel compliance: Corresponds to MATH1 and MATH2 features.

Syntax: CALCulate:INTegral:STATE

Where is [1] | 2.

Parameter: : 0 (OFF) or 1 (ON).

Query form: CALCulate:INTegral:STATe?

Response: 0 | 1

Description: This command switches the integrate function on or off for the specified calculate block (CALCulate1 or CALCulate2). The result is stored in M1_n or M2_n depending on the input source (CHn or Mi_n). After a *RST command, the integrate function is turned off.

Example:

Send → CALCulate1:INTegral:STATE ON (Switches the MATH1 integrate function on)

Front panel compliance: Corresponds to MATH1 and MATH2 features.

Syntax: CALCulate:MATH[:EXPRession] ( )

Where is [1] | 2.

Parameters:

• : A predefined acquisition trace (CH1|CH2|CH3|CH4) or memory trace (Mi_1|Mi_2|Mi_3|Mi_4). Note: i=1..8 (standard), i=9..50 (extended).
• : + | – | * (add, subtract, or multiply).

Query form: CALCulate:MATH[:EXPRession]?

Response: ( )

Description: This command specifies the mathematical expression for the MATH function (MATH1 or MATH2). It selects the two source traces and the operation (+, -, *). This command does not switch the function on; use CALCulate:MATH:STATE for that.

Note: The first trace name can be substituted by the keyword IMPLied. In that case, the trace name defined by CALCulate:FEED is applicable.

Limitations:

• Both source traces must not be empty.
• For PM33x0A instruments, CH3, CH4, Mi_3, and Mi_4 cannot be used in an expression.

Example:

Send → CALCulate2:MATH (CH1+CH2) (Selects MATH2 channel 1 + 2)

Send → CALCulate2:MATH:STATE ON (Switches MATH2 function on)

Front panel compliance: Corresponds to MATH1 and MATH2 features.

Syntax: CALCulate:MATH:STATE

Where is [1] | 2.

Parameter: : 0 (OFF) or 1 (ON).

Query form: CALCulate:MATH:STATe?

Response: 0 | 1

Description: This command switches the specified mathematics function (MATH1 or MATH2) on or off. If switched on, the internal scale and offset are reset to initial values. The result is stored in M1_1 for CALCulate1 and in M2_1 for CALCulate2. After a *RST command, the mathematics function is turned off.

Example:

Send → CALCulate1:MATH (CH1-CH2) (Selects MATH1 channel 1 – 2)

Send → CALCulate1:MATH:STATE ON (Switches MATH1 function on)

Front panel compliance: Corresponds to MATH1 and MATH2 features.

Commands:

• CALCulate:TRANsform:FREQuency:STATE
• CALCulate:TRANsform:FREQuency:TYPE ABSolute | RELative
• CALCulate:TRANsform:FREQuency:WINDow RECTangular | HAMMing | HANNing

Where is [1] | 2.

Description:

• STATE: Switches the FFT function on (1) or off (0).
• TYPE: Selects between RELative and ABSolute FFT calculation.
• WINDow: Defines the window type used with the FFT function.
  • RECTangular: Transforms a repetitive time amplitude trace into its power spectrum (amplitude vs. frequency).
  • HAMMing / HANNing: Reduce side lobes by applying a window to the input signal, improving visibility of minor frequency components (especially if MATH1/MATH2 – FFT – PARAM “limited area” function is not accurately selected).

The result of the FFT function is stored in M1_1 (for CALCulate1) or M2_1 (for CALCulate2). After a *RST command, the FFT type is RELative, the FFT window is RECTangular, and the FFT functions are switched OFF.

Example:

Send → CALCulate2:TRANsform:FREQuency:TYPE RELative (Selects relative MATH2-FFT calculation)

Send → CALCulate2:TRANsform:FREQuency:WINDow HANNing (Selects MATH2-FFT-HANNing window)

Send → CALCulate2:TRANsform:FREQuency:STATE ON (Switches MATH2-FFT on)

Front panel compliance: Corresponds to MATH1 and MATH2 features.

Syntax: CALCulate:TRANsform:HISTogram:STATE

Where is [1] | 2.

Parameter: : 0 (OFF) or 1 (ON).

Query form: CALCulate:TRANsform:HISTogram:STATe?

Response: 0 | 1

Description: This command switches the HISTogram function on or off for the specified calculate block (CALCulate1 or CALCulate2). The result is stored in M1_1 or M2_1. After a *RST command, the histogram function is turned off.

Example:

Send → CALCulate1:TRANsform:HISTogram:STATE ON (Switches the MATH1 histogram function on)

Front panel compliance: Corresponds to MATH1 and MATH2 features.

Syntax: CALibration[:ALL]

Query form: CALibration[:ALL]?

Response (for query): 0 | 1 (0 = OK, 1 = Not OK)

Description:

• The CALibration command performs an automatic internal self-calibration. No external means or operator interface is needed. It is an overlapped command, meaning other operations can potentially run concurrently. During calibration, the “Calibrating” bit (0) in the OPERation status register can be read to check status (1 = busy, 0 = finished).
• The CALibration? query performs the self-calibration and reports the result (0 or 1). It is equivalent to the *CAL? query. A possible error is also reported via bit 8 in the QUEStionable status register (0=OK, 1=Wrong).

Limitation: The calibration process lasts a couple of minutes. During this time, bit 0 in the OPERation status is set (indicating busy). This status can only be requested if the calibration was started via the CALibration command (not the query), because the CALibration? query is a sequential command. A sequential command means the next command/query in the same program message is not executed until the calibration process is completed. Until then, no response to the next query is obtained.

Example (using overlapped command and status check):

Send → *RST (Resets the instrument)

Send → CALibration (Starts auto calibration – overlapped)

Send → STATUS:OPERation:CONDition? (Requests for oper. conditions)

Read ← (Reads condition register)

WHILE (bit 0 of = 1) (Loops while calibration busy)

Send → STATUS:OPERation:CONDition? (Requests for oper. conditions)

Read ← (Reads condition register)

LOOP WHILE

Send → STATUS:QUEStionable:CONDition? (Requests for questionable conditions)

Read ← (Reads condition register)

IF (bit 8 of = 0) THEN Calibration_Okay

ELSE (bit 8 of = 1) Calibration_Not_Okay

END_IF

Front panel compliance: The CALibration command/query is the remote equivalent of the front panel CAL key.

Syntax: CONFigure[:VOLTage] [[(),] ] [,]

Description: The CONFigure command is part of the measurement instruction set. It sets up the instrument to perform the measurement specified by , using any provided parameters (, , ) to optimize settings. If parameters are defaulted, the oscilloscope chooses its own settings based on the signal and trade-offs.

The CONFigure command only sets up the instrument; it does not start the acquisition or return a result. It must be followed by a READ? query (or INITiate and FETCh?). Executing CONFigure and READ? is equivalent to executing a MEASure? query.

The default :VOLTage node specifies the measurement relates to a voltage signal (e.g., AC component, rise time).

Restrictions:

• A CONFigure command may be executed only when the oscilloscope is in the digital mode (INStrument:SELect DIGital). Digital mode is selected after *RST.
• Executing this query in analog mode generates execution error -221, “Settings conflict; Digital mode required”.

Example 1:

Send → CONFigure:VOLTage:AC 0.6, (@2) (Configures AC-RMS on channel 2, expected voltage 600 mV)

Send → INPut2:COUPling AC (Ensure channel 2 AC coupled)

Send → READ:AC? (@2) (Initiates + fetches AC-RMS value for channel 2)

Read ←

Example 2:

Send → CONFigure:VOLTage:RISE:TIME (0.5),20,80,1E-2,(@2) (‘Configures rise time on channel 2: expected V=0.5V, LOW ref=20%, HIGH ref=80%, expected time=0.01s)

Send → INPut2:COUPling DC (Ensure channel 2 DC coupled)

Send → READ:RISE:TIME? (@2) (Initiates + fetches rise time for channel 2)

Read ←

Send → FETCh:FALL:TIME? (@2) (Fetches fall time for channel 2 from same acquisition)

Read ←

Syntax: DISPlay:BRIGhtness | MINimum | MAXimum

Parameters:

• : 0.0 .. 1.0
• MINimum: Equals 0.0 (Trace display is fully blanked)
• MAXimum: Equals 1.0 (Trace display has full intensity)

Query form: DISPlay:BRIGhtness? [MINimum | MAXimum]

Response: (e.g., 0.00E00 … 1.00E00)

Description: This command sets, and the query returns, the brightness of the trace display. The number 0.0 gives the lowest brightness, and 1.0 gives the highest. Note that the intensity of text display is not controlled with this command. After a *RST command, the brightness is set to 0.18 (1.80E-01).

Example:

Send → DISPlay:BRIGhtness 0.5 (Sets trace brightness at 0.5)

Front panel compliance: This command is the remote equivalent of the front panel TRACE INTENSITY knob.

Syntax: DISPlay:MENU[:NAME]

Parameter :

Description: The DISPlay:MENU command selects a softkey menu by specifying its predefined name. Additionally, the display of the softkey menu field is switched ON (coupled to DISPlay:MENU:STATE ON). Menus ACQuire, DISPlay, MATH, MEASure, SAVE, and RECall are available only in digital mode; specifying them in analog mode generates error -221. After a *RST command, the mode is set to TBMode without displaying the TB MODE softkey menu field.

Example:

Send → DISPlay:MENU TBMode (Selects and displays the TB MODE softkey menu)

Front panel compliance: This command is the remote equivalent of the front panel menu buttons (TB MODE, TRIGGER, DTB, SETUPS, CURSORS, ACQUIRE, DISPLAY, MATH, MEASURE, SAVE, RECALL, UTILITY, and VERT MENU).

Syntax: DISPlay:MENU:STATE

Parameter: : 0 (OFF) or 1 (ON).

Query form: DISPlay:MENU:STATE?

Response: 0 | 1

Description: This command switches the display of the softkey menu field on or off. After a *RST command, the display is turned off.

Example:

Send → *RST (Selects TB MODE menu with display off by default)

Send → DISPlay:MENU:STATE ON (Switches TB MODE menu display on)

Front panel compliance: This command remotely enables the display of one of the front panel menus (TB MODE, TRIGGER, DTB, SETUPS, CURSORS, ACQUIRE, DISPLAY, MATH, MEASURE, SAVE, RECALL, UTILITY or VERT MENU).

Syntax: DISPlay:WINDow[1]:TEXT:DATA?

Parameters:

• [1]: Indicates the measurement result field is window 1.
• : Specifies which measurement result to return:
  • 1: MEAS1 result
  • 2: MEAS2 result
  • 10: Delta-V/Delta-Y (depends on X-deflection/X vs Y state)

    TYPE:	ANALOG MODE:	DIGITAL MODE:
    Delta-V	X-deflection off	X versus Y off
    Delta-Y	X-deflection on	X versus Y on

  • 11: V1
  • 12: V2
  • 13: DC voltage (VDC)
  • 20: Delta-T (X-deflection off / X versus Y off)
  • 21: Frequency (1 / delta-T)
  • 30: Delta-X (X-deflection on / X versus Y on)
  • 40: Phase between 2 channels
  • 51: T1-trg
  • 52: T2-trg
  • 60: FFT frequency (Hz)
  • 61: FFT amplitude (dB relative, or dBm, dbµV, Vrms absolute)

Response: (A sequence of 7-bit ASCII characters representing the measurement value and units as displayed).

Description: This query returns the measured data as displayed on the upper line(s) of the CombiScope instrument screen, corresponding to the selected measurement .

Example:

Send → DISPlay:WINDow[1]:TEXT1:DATA? (Query MEAS1 result)

Read ← pkpk,6084E-04,V (Response indicates a peak-peak value of 608.4 mV for MEAS1)

The measurement data functions must be enabled first, or the error message -221 “Settings conflict” is generated. If the oscilloscope is in the analog mode, the error message -221 “Settings conflict; Digital mode required” is generated.

The following measurement data values can be selected by specifying the number `` in the query `DISPlay:WINDow[1]:TEXT:DATA?`:

Note:

MEAS1 and MEAS2 data measurement functions can only be selected and enabled via the front panel MEASURE key and softkey menu.

CURSORS data measurement functions can only be selected and enabled via the front panel CURSORS key and softkey menu.

MATH – FFT data measurement functions can be selected and enabled via the front panel MATH/CURSORS keys and softkey menus, or by programming using commands like:

CALCulate:TRANsform:FREQuency:TYPE ABSolute (Selects abs. values)

CALCulate:TRANsform:FREQuency:TYPE RELative (Selects rel. values)

CALCulate:TRANsform:FREQuency:STATE ON (Enables MATH1 – FFT)

The result of an FFT can be expressed as a relative or an absolute amplitude value. A relative FFT calculation consists of a frequency (Hz) and an amplitude in (dB). An absolute FFT calculation consists of a frequency (Hz) and an amplitude in dBm (dB with respect to 1 milliwatt), dBμV (dB with respect to 1 microvolt), or Vrms (Volt RMS) as selected via the front panel CURSORS – READOUT softkey menu.

Example: Query MEAS1 result

Send→ DISPlay:MENU MEASure ‘ Switches MEASURE menu display on.

‘ Enable and define the MEAS1 function via the front panel MEASURE menu.

Send → DISPlay:WINDOW:TEXT1:DATA? ‘ Queries MEAS1 result.

Read ←

PRINT

Front panel compliance: The DISPlay:WINDow[1]:TEXT:DATA? query is the remote equivalent of the front panel CURSORS, MATH, and MEASURE keys and softkey menus.

Use the command DISPlay:WINDow2:TEXT[1]:CLEar.

This command clears the contents of the user text field (window 2) from the screen of the oscilloscope, making it no longer displayed.

Example:

Send → DISPlay:WINDOW2:TEXT:STATE ON ‘ Enables display of text.

Send → DISPlay:WINDOW2:TEXT:CLEar ‘ Clears all user text.

Front panel compliance: This command is the remote equivalent of the “delete user text” option of the front panel DISPLAY – TEXT menu.

Use the command DISPlay:WINDow2:TEXT[1]:DATA | .

This command writes data into the user text field (window 2). The data is displayed on the two text lines of the screen. The first character/byte is positioned at the start of the first text line, and the 64th character/byte is on the last position of the second text line.

Keyboard characters (directly entered via your controller’s keyboard) can be sent as (maximum 64 characters, enclosed in quotes like “this is a string” or ‘this also’).

Non-keyboard characters must be sent as (maximum 64 data bytes). Refer to the character set table for codes.

Example 1: Displaying text

Send → DISPlay:WINDow2:TEXT:STATE ON ‘ Enables display of text.

Send → DISPlay:WINDow2:TEXT:DATA "Remote control via PC" ‘ Displays the text.

Example 2: Displaying text with special characters (1.25 kΩ (CH1))

Send → DISPlay:WINDow2:TEXT:STATE ON ‘ Enables display of text.

Send → DISPlay:WINDow2:TEXT:DATA #01.25 k ‘ Sends header + 1.25 k as text (using indefinite length block data format #0).

Send → ‘ Sends 25 decimal (= Ω symbol) as a single character byte.

Send → ' (CH1)' ‘ Sends space, followed by (CH1).

Front panel compliance: This command is the remote equivalent of the “insert user text” option of the front panel DISPLAY – TEXT menu.

The following table shows the character set:

Notes:

The left value (dec) is the decimal value of the code and the right value (sym) is the oscilloscope symbol.

The displayed symbol for the decimal values 128 to 255 is equal to the symbol display for the decimal values 0 to 127. Example: Decimal value 200 = decimal value 72 (200-128) = symbol H.

For the PM33x0A CombiScope instruments the $ symbol (dec. 36) is replaced by the ET symbol (External Trigger).

Use the command DISPlay:WINDow2:TEXT[1]:STATE .

Set to 1 or ON to turn the display on.

Set to 0 or OFF to turn the display off.

To query the current state, use DISPlay:WINDow2:TEXT[1]:STATE?. The response will be 1 (on) or 0 (off).

After a *RST command, the display of user text is turned off by default.

Example:

Send → DISPlay:WINDOW2:TEXT:STATE OFF ‘ Turns off the display of the user text.

Front panel compliance: This command is the remote equivalent of the “user text on/off” option of the front panel DISPLAY – TEXT menu.

The FETCH? queries are part of the measurement instruction set. They return the signal characteristic from the last initiated measurement, as specified by the part of the query header.

Syntax: FETCH[:VOLTage]? [[ (),] ] [, | ]

An INITiate command (or READ?, MEASure?) must precede a FETCH? query. The response becomes available only after the acquisition is completed. Execution of INITiate[:IMMediate] followed by FETCH? is equivalent to executing a READ? query.

A FETCH? query can also return a signal characteristic from a valid acquisition result stored in a TRACe memory element using the parameter (e.g., FETCH:AC? (@M2_3) fetches AC-RMS of the M2_3 trace).

Trace list format: (@)

Trace name format: |

Acquisition trace names: CH1 | CH2 | CH3 | CH4 (Note: CH3 and CH4 not available for PM33x0A).

Memory trace names: M_ (i=1-8 standard memory, 9-50 extended memory; j=1-4 channel sequence number. Note: j=3 and j=4 not for PM33x0A).