E1450A()

NAME

E1450A − Quick Reference

DESCRIPTION

The following is a quick reference for the HP E1450 HP 75000 D20 Digital Functional Test System. See the instrument’s VXI User Manual for information on the SCPI Commands.

OVERLAPPING COMMANDS

When overlapping is disabled (this is the default state) all commands complete before control is returned to the user’s program. However, when overlapping is enabled, certain commands are overlapped, that is, the function they control completes at some time after they have been executed. This allows other commands to be executed while the overlapped function is still in progress. The following D20 commands are overlapped: RUN, STEP, and CONTinue.

Because overlapped commands use interrupts to determine when their function has completed, they present some difficulties in the HP-UX context. Specifically, if an interrupt occurs while a using program is waiting on a UNIX system call (e.g. a printf call) that call will terminate immediately without completing its task. This problem can best be avoided by refraining from the use of UNIX system calls while a overlapped function is pending.

The status of the D20’s overlapped commands can be determined in two ways. Either by use of the IEEE 488.2 common commands *OPC, *OPC?, and *WAI, or by the use of the STATus:OPERation commands. If both the STOPped bit (bit 7) and the PAUSEd bit (bit 8) of the OPERation register are false then the D20 is in its running state and interrupts are pending.

Please note that the common commands, *OPC? and *WAI, are always non-overlapping commands, their execution will not complete until the D20 is no longer in its running state.

The following program fragment (written in C) indicates how to deal with the D20’s overlapped commands:

{
    INST_DECL( d20, "D20", REGISTER );
    .
    .
    .
    /* Select overlapped command execution mode */
    cscpi_overlap( 1 );
    .
    .
    .
    INST_SEND( d20, "RUN" );
    /* Do not use system calls in this section */
    .
    .
    .
    /* Wait for interrupts to occur */
    INST_SEND( d20, "*WAI" );
    /* It is now safe to do system calls */
    .
    . }

QUERY COMMAND RESPONSE TYPES

The following is a list of the response types for every D20 query. Where appropriate, the size of the response is given in parentheses. When response size varies depending on query parameters or system configuration, the maximum possible size is indicated. Explanations of the various response types are given below the list.

*ESE?int16
*ESR?int16
*IDN?string (73)
*OPC?int16
*SRE?int16
*STB?int16
*TST?int16
DIAG:OSC:STAT?int16
DIAG:REG:VAL?int32
DIAG:SEQ:LOOP:BOUN?int32, int32
DIAG:SEQ:MEM:ATTR?int8 array (65535 max)
DIAG:SEQ:MEM:COMB?int16 array (65535 max)
DIAG:SEQ:MEM:DATA?int8 array (65535 max)
DIAG:SYST:HEAL:CHEC? int16
DIAG:SYST:HEAL:STAT?quoted string list (25xN, Nmax=33)
DIAG:TIM:MEM:COG?int16 array (1024 max)
DIAG:TIM:MEM:RTG?int16 array (1024 max)
DIAG:TIM:MEM:STG?int16 array (1024 max)
DIAG:TIM:MEM:TTAB?int16 array (1024 max)
DIG:GRO:CAT?quoted string list (24xN, Nmax=120)
DIG:GRO:DEF?string (28)
DIG:GRO:MOD?string (5)
DIG:GRO:SEL?string (13)
DIG:RESP:CLOC:EXT:SLOP?string (5)
DIG:RESP:CLOC:SOUR?string (5)
DIG:RESP:COMP:ENAB:SEQ:FULL?int8 array (65534 max)
DIG:RESP:COMP:ENAB:SEQ:PART?int8 array (65534 max)
DIG:RESP:COMP:ENAB:STAT?int16
DIG:RESP:COMP:ERR?null-valid string (40)
DIG:RESP:COMP:MASK:VAL?int32
DIG:RESP:PATT:SEQ:FULL?int8 array (262136 max) [see notes]
DIG:RESP:PATT:SEQ:PART?int8 array (262136 max) [see notes]
DIG:RESP:PATT:VAL?int32
DIG:SEQ:BRE<n>:POS?int32
DIG:SEQ:BRE<n>:STAT?int16
DIG:SEQ:CAT?quoted string list (27xN, Nmax=509)
DIG:SEQ:DEF?int32
DIG:SEQ:POS?int32
DIG:SEQ:SEL?string (13)
DIG:SEQ:WIND:BOUN?int32, int32
DIG:SEQ:WIND:STAT?int16
DIG:STIM:CLOC:EXT:SLOP?string(5)
DIG:STIM:CLOC:SOUR?string (5)
DIG:STIM:ENAB:SEQ:FULL?int8 array (65534 max)
DIG:STIM:ENAB:SEQ:PART?int8 array (65534 max)
DIG:STIM:ENAB:VAL?int16
DIG:STIM:PATT:SEQ:FULL?int8 array (262136 max) [see notes]
DIG:STIM:PATT:SEQ:PART?int8 array (262136 max) [see notes]
DIG:STIM:PATT:VAL?int32
DIG:TIM:ARM:SEQ:FULL?int8 array (65534 max)
DIG:TIM:ARM:SEQ:PART?int8 array (65534 max)
DIG:TIM:COND<n>:DEF?string (256 max)
DIG:TIM:COND<n>:VAL?int16
DIG:TIM:CONT:PATT?int32
DIG:TIM:CONT:STAT?int16
DIG:TIM:CYCL:AWA:COND<n>?int16
DIG:TIM:CYCL:CAT?quoted string list (24xN, Nmax=256)
DIG:TIM:CYCL:CONT<n>:WAV?int16 array (1024 max)
DIG:TIM:CYCL:DEF?int32, int32
DIG:TIM:CYCL:EIR?int16
DIG:TIM:CYCL:RPCL<n>:DEL?int32
DIG:TIM:CYCL:SEL?string (13)
DIG:TIM:CYCL:SEQ:FULL?int8 array (65534 max)
DIG:TIM:CYCL:SEQ:PART?string list (13xN, Nmax=65534)
DIG:TIM:CYCL:SPCL<n>:DEL?int32
DIG:TIM:MARK:SEQ:FULL?int8 array (65534 max)
DIG:TIM:MARK:SEQ:PART?int8 array (65534 max)
DIG:TIM:RDEL?float64
DIG:TIM:READ:POL?string (5)
DIG:TIM:RES?float64
DIG:TIM:TRIG:DEL?float64
DIG:TIM:TRIG:QUAL?int16
DIG:TIM:TRIG:SLOP?string (5)
DIG:TIM:TRIG:SOUR?string (5)
FORM:DATA?string (5)
OUTP:ECLT<n>:STAT?int16
OUTP:TTLT<n>:STAT?int16
STAT:OPER:COND?int16
STAT:OPER:ENAB?int16
STAT:OPER:EVEN?int16
STAT:OPER:NTR?int16
STAT:OPER:PTR?int16
STAT:QUES:COND?int16
STAT:QUES:ENAB?int16
STAT:QUES:EVEN?int16
STAT:QUES:NTR?int16
STAT:QUES:PTR?int16
SYST:ERR?int16, string (256)
SYST:VERS?string
TEST:ALL?int16
TEST:MOD?int16, int16, int16, int16

int8, int16, and int32

These response types are all integers. The number appearing in the name indicates the number of significant bits in the integer. The number of bits is important when declaring the variable that is to receive the response, i.e. in deciding whether long int, short int, or char, is appropriate.

int8 array

This response type should generally be received by an array of 8-bit integers. In most C compilers this translates to a character array (char[]). The size in parentheses that follows the type name indicates the maximum possible size required for the array. The actual size required depends the state of the D20 (for instance, the defined size of a sequence) or on parameters provided with the query.

A special case exists for the four varieties of PATT:SEQ queries. The width of the array elements in the response depends on the defined width of the pin group being queried. If the pin group being queried is 8 bits wide, then the receiving array elements should also be 8 bits wide, and so on. If the appropriate C type is used for the array element, then the pattern values will pack correctly in the array, one to an element. (Note that 24-bit pin groups may not be evenly packable depending on the compiler used.) The maximum size in this case was based on the maximum pin group size, 32 bits, and the maximum sequence length, 65534 vectors, being received by an array of elements only 8 bits wide.

int16 array

This response type should be received by an array of 16-bit integers (short int[] in some C compilers).

int32 array

This response type should be received by an array of 32-bit integers (int[] in some C compilers).

float64

This type is a 64-bit floating point response. For most C compilers, this means that the receiving variable should be declared as a double, but compilers vary so you should check the compiler you are using for the correct type.

string and null-valid string

Both of these types indicate that the response should be received by an array of characters (char[]). The size in parentheses that follows the type name indicates the suggested size of the array (including the standard termination for strings in C). For example, the declaration for a variable to receive the response from the FORM:DATA? query might look like:

char form_resp[5];

The "null-valid" designation indicates that a null string (a string consisting of a single character) is a valid response for the query. The null string is used to indicate that no data is currently available.

string list and quoted string list

These two types are very similar to the string types described above. They, too, should be received by an array of characters (char[]). The difference is that the list types consist of multiple data items separated by comma characters. Quoted string lists use double-quote characters to demarcate each data item. The size information given for string lists indicates both the maximum size of each data item (including the comma character) and the maximum number of data items that might be in a list. Of course, the actual size of a particular list will depend on the state of the D20 and any parameters provided to the query command.

DIFFERENCES BETWEEN COMPILED SCPI AND E1405 SCPI

There are two primary differences in the operation of D20 commands between the Compiled SCPI environment and the E1405 environment. The first, and most obvious, difference is that the RUN, STEP, and CONTinue commands, which are always overlapped in the E1405, are normally not overlapped in Compiled SCPI. The second, and more subtle, difference lies in the way that certain status information is reported.

In the E1405, there are four bits in the OPERation status register that indicate when the D20 has been waiting for some event for an unusually long time (greater than 2 seconds). The four bits are named: Awaiting Condition 0, Awaiting Condition 1, Awaiting Condition 2, and Awaiting Trigger. These bits are set by an autonomous polling process that reads the status of the E1450 Timing Module approximately once every second.

The Compiled SCPI environment does not allow an autonomous polling process, therefore the state of the four bits will only be updated when a STAT:OPER:COND? query is executed. In other words, polling of the D20’s state, for these four specific conditions, must now be undertaken by the user. Note, too, that the meaning of these bits is also somewhat different in Compiled SCPI: they indicate that the "await status" of the D20 has not changed for two consecutive polls of the status.