Contents HP E1429A/B Digitizer User’s Manual Warranty . . . . . . . . . . WARNINGS . . . . . . . . Safety Symbols . . . . . . Declaration of Conformity . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9 10 10 11 Chapter 1. Getting Started . . . . . . . . . . . . . . .
Level Arming . . . . . . . . . . . . . . . . . . . . . . . ARMLEVEL.C . . . . . . . . . . . . . . . . . . . . . Comments . . . . . . . . . . . . . . . . . . . . . . . Pre- and Post-Arm Readings . . . . . . . . . . . . . . . PREPOST.C . . . . . . . . . . . . . . . . . . . . . . Comments . . . . . . . . . . . . . . . . . . . . . . . Specifying a Sample Rate . . . . . . . . . . . . . . . . . SAMPLE.C . . . . . . . . . . . . . . . . . . . . . . . Comments . . . . . . . . . . . . . . . . . . . . . . .
Digitizer Data Formats . . . . . . . . . . Packed Reading Conversions . . . . . . Retrieving Readings . . . . . . . . . . . Retrieving Readings Using READ? . . . Retrieving Readings Using FETCh? . . . Using DIAGnostic:UPLoad:SADDress? . Memory Management . . . . . . . . . . . . The DIAGnostic Subsystem . . . . . . . VME Bus Data Transfers . . . . . . . . . . Locating the Data Register . . . . . . . . The VINStrument Subsystem . . . . . . Local Bus Data Transfers . . . . . . . . . . Local Bus Description . .
[:STARt][:IMMediate] . . . . . . . . . . . . . . [:STARt]:LEVel[]:NEGative . [:STARt]:LEVel[]:POSitive . [:STARt]:SLOPe[] . . . . . . . . . . . . . [:STARt]:SOURce[] . . . . . . . . . . . . . CALibration[] . . . . . . . . . . . . . . . . :COUNt? . . . . . . . . . . . . . . . . . . . . . :DATA . . . . . . . . . . . . . . . . . . . . . . :DELay . . . . . . . . . . . . . . . . . . . . . . :GAIN . . . . . . . . . . . . . . . . . . . . . . :SECure:CODE . . . . . . . .
:TTLTrg:FEED . . . . . . . . . . . . . . . :TTLTrg[:STATe] . . . . . . . . . . . . . READ[] . . . . . . . . . . . . . . . . . . READ? . . . . . . . . . . . . . . . . . . . . . SENSe . . . . . . . . . . . . . . . . . . . . . . . [SENSe[]]:FUNCtion . . . . . . . . . . . [SENSe[]]:FUNCtion . . . . . . . . . [SENSe[]]:ROSCillator . . . . . . . . . . :EXTernal:FREQuency . . . . . . . . . . . . . :SOURce . . . . . . . . . . . . . . . . . . . . [SENSe[]]:SWEep . . . . . . . . .
*EMC and *EMC? . . . . . . *ESE and *ESE? . . . . . . . *ESR? . . . . . . . . . . . . *GMC? . . . . . . . . . . . . *IDN? . . . . . . . . . . . . . *LMC? . . . . . . . . . . . . *LRN? . . . . . . . . . . . . *OPC . . . . . . . . . . . . . *OPC? . . . . . . . . . . . . *PMC . . . . . . . . . . . . . *PUD and *PUD? . . . . . . *RCL . . . . . . . . . . . . . *RMC . . . . . . . . . . . . . *RST . . . . . . . . . . . . . *SAV . . . . . . . . . . . . . *SRE and *SRE? . . . . . . . *STB? . . . . . . . . . . . .
The Arm Internal Bus Register . . . . . . . . . . The Arm Source Register . . . . . . . . . . . . The Arm Control Register . . . . . . . . . . . . The Trigger Source Register . . . . . . . . . . . The Reference Oscillator Register . . . . . . . . The Arm delay Register . . . . . . . . . . . . . The Arm Count Register . . . . . . . . . . . . . The Arm Count Latch Register . . . . . . . . . . The Trigger Immediate Register . . . . . . . . . The Decade Division Register . . . . . . . . . .
Appendix D. Local Bus Interleaved Transfers . . . . . . . . . . . . . . . . . . . . . . . . 405 Appendix Contents . . . . . . . . . . . Interleaved Transfers . . . . . . . . . Setting the Interleaved Transfer Mode Programming Procedure . . . . . . . Example Program . . . . . . . . . . Comments . . . . . . . . . . . . . . 8 HP E1429A/B Digitizer User’s Manual . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Certification Hewlett-Packard Company certifies that this product met its published specifications at the time of shipment from the factory. HewlettPackard further certifies that its calibration measurements are traceable to the United States National Institute of Standards and Technology (formerly National Bureau of Standards), to the extent allowed by that organization’s calibration facility, and to the calibration facilities of other International Standards Organization members.
Documentation History All Editions and Updates of this manual and their creation date are listed below. The first Edition of the manual is Edition 1. The Edition number increments by 1 whenever the manual is revised. Updates, which are issued between Editions, contain replacement pages to correct or add additional information to the current Edition of the manual. Whenever a new Edition is created, it will contain all of the Update information for the previous Edition.
Declaration of Conformity according to ISO/IEC Guide 22 and EN 45014 Manufacturer’s Name: Hewlett-Packard Company Loveland Manufacturing Center Manufacturer’s Address: 815 14th Street S.W. Loveland, Colorado 80537 declares, that the product: Product Name: 20MS a/s Digitizer Model Number: HP E1429A Product Options: All conforms to the following Product Specifications: Safety: IEC 1010-1 (1990) Incl.
Notes 12 HP E1429A/B 20 MSa/s 2-Channel Digitizer User’s Manual
Chapter 1 Getting Started Chapter Contents This chapter covers the features, configuration, and programming procedures for the HP E1429A/B 2-Channel, 20 MSa/s Digitizer. The main sections of this chapter include: • HP E1429A/B Features and VXIbus Configuration . . . . . . . 13 • Preparation for Use . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16 • Introductory Programs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20 Sending the *IDN? Command . . . . . . . . . . . . . . .
Figure 1-1.
HP E1429A/B VXIbus Configuration Table 1-1 lists the digitizer’s VXIbus device information and factory settings. Appendix A has the complete list of HP E1429A/B operating specifications. Table 1-1. HP E1429A/B VXIbus Configuration VXIbus Device Information Device type: message-based servant C-size (1 slot) Connectors: P1 and P2 Addressing modes: A16/A24 Data transfer modes: D08/D16/D32 slave A24 size: 4096 bytes Dynamically Configurable Non-interrupter/non-interrupt handler VXIbus Revision Compliance: 1.
Caution The 800 Vpk level is a product safety test specification and does not assure correct product operation if 800 Vpk transients have been applied. To maintain product functionality and performance, do not exceed ±42 Vpk on the single-ended inputs, or ±102.4 Vpk on the differential inputs. Preparation for Use This section contains configuration information specific to the HP E1429A/B digitizer.
• If your system uses an external controller and the HP E1406 Command Module, put the digitizer in the servant area of the Command Module. This enables the module to function as the HP-IB interface to the digitizer. The HP E1406 Command Module has a factory set logical address of 0 and a servant area switch setting of 255. Using the factory settings, it is not necessary to change the logical address of the digitizer (40) to place it in the servant area of the Command Module.
Note The Digitizer Bus Request Level Bus Request Level Guidelines The digitizer’s servant area switches are not used and should be left in their factory-set (0) position. The bus request level is a priority at which the HP E1429A/B digitizer can request the use of the VME (VXI Data Transfer) Bus. • There are four bus request lines (BG0 - BG3) from which one is selected (Figure 1-2). Bus request line 3 has the highest priority, bus request line 0 has the lowest priority.
Note Addressing the Digitizer over HP-IB For compliance with European EMC standards EN 55011 and EN 50082-1, backplane connector shields are included with each HP E1429A/B digitizer ordered. The shields need only be installed in the VXI mainframe if it is necessary to comply with these standards. Devices in the Series C mainframe and in the servant area of the HP E1406 Command Module are located by an HP-IB address.
Introductory Programs The introductory programs in this section include: • • • • Sending the *IDN? Command Digitizer Self-Test Resetting the digitizer and clearing the status registers Querying the digitizer configuration HP BASIC and C language versions of the introductory programs follow. C language versions of these and all programs in the manual are contained on the following disk which ships with the manual: • HP E1429A/B Example Programs: C Language 3.
/****************************************************************************/ void main(void) /* Run the program */ { char message[80]; intlength = 80; IOOUTPUTS(ADDR, "*IDN?", 5); IOENTERS(ADDR, message, &length); /* send *IDN? command */ /* enter *IDN? response */ printf("%s\n", message); /* print*IDN? response */ } Digitizer Self-Test The digitizer self-test is executed with the command: *TST? The digitizer parameters tested include: • • • • • internal interrupt lines measurement range integrity
Caution Executing the self-test erases the readings in the digitizer’s non-volatile memory. If the self-test fails, the command: DIAGnostic:TEST? can be executed to obtain additional information on the failure. Note that DIAGnostic:TEST can return a string up to 40 characters. HP BASIC 10 20 30 40 50 60 70 80 90 100 110 120 130 140 150 160 !Send the self-test command, enter and display the result.
/****************************************************************************/ void main(void) /* Run the program */ { char message[256], diagnostic[80]; intlength = 256; float tst; IOOUTPUTS(ADDR, "*TST?", 5); IOENTER(ADDR, &tst); /* send the self-test command */ /* enter the code */ printf("%d\n\n", (int) tst); /* display the code */ if (tst != 0) { IOOUTPUTS(ADDR, "SYST:ERR?", 9); IOENTERS(ADDR, message, &length); printf("Error: %s\n\n", message); /* query error register */ /* enter error message */
HP BASIC 10 !Assign an I/O path between the computer and digitizer. 20 ASSIGN @A_d TO 70905 30 COM @A_d 40 !Call the subprogram 50 Rst_cls 60 END 70 ! 80 SUB Rst_cls 90 Rst_cls: !subprogram which resets and clears the digitizer. 100 COM @A_d 110 OUTPUT @A_d;"*RST;*CLS;*OPC?" !reset and clear 120 ENTER @A_d;Complete 130 SUBEND RSTCLS.C /* RSTCLS.C - This program resets the digitizer and clears its status register */ /* Include the following header files */ #include #include
Querying the Digitizer Configuration After resetting the digitizer or cycling power, the digitizer parameters are set to their power-on values. These values are listed in Appendix B, Table B-2. You can determine the digitizer’s reset settings or its current configuration using the command: *LRN? The data returned by *LRN? is a semicolon (;) separated list of each parameter setting. HP BASIC 10 !Assign an I/O path between the computer and the A/D.
LRN.C This program uses a 2,000 element character array. To prevent stack overflow errors when compiling and running this program using Microsoft® QuickC©, change the stack size using the /F option of the “ qcl” command. An example of how this program might be compiled is: qcl /AL /F 8192 b:\lrn.c c:\qc2\lib\clhpib.lib /* LRN.C - This program queries the digitizer’s reset conditions */ /* Include the following header files */ #include #include #include
prt = strtok(lrndata,";"); printf("\n\t%s",prt); /* Print out each (*LRN? data) token */ while (prt != NULL) { prt = strtok(NULL,";"); /* Exit when data returned by *OPC? (1) is reached */ if (atoi(prt) == 1) break; /* Print one user screen’s worth of *LRN? data, have user */ /* press ’Enter’ to see the next screen of data */ if (loop >= 23) { printf("\n\nPress \’Enter\’ to continue"); scanf("%c", &ch); fflush(stdin); loop = 0; } printf("\n\t%s",prt); loop ++;/* increment counter */ } } Chapter 1 Getting
Instrument and Programming Languages The purpose of this manual is to teach you how to use the HP E1429A/B digitizer. To do this, the manual uses block diagrams, flowcharts, and example programs. In most cases, the manual’s example programs list only the digitizer’s SCPI commands. The I/O (input/output) constructs depend on the programming language you use.
Coupled commands can cause “Settings conflict” errors when the program executes. When a coupled command is executed, the command setting is evaluated by the digitizer processor. If the setting causes an illegal digitizer configuration, a "Settings conflict" error occurs. The error message lists the conflicting settings, and then reports the values set by the digitizer processor.
placing a semicolon ( ; ) following the quotation mark ( " ) which closes the command string: OUTPUT 70905;"OUTP:EXT1:STAT ON;"; OUTPUT 70905;":TRIG:SOUR EXT1;"; OUTPUT 70905;":OUTP:EXT1:STAT OFF" Since the last command is the end of the command string, the EOL terminator is not suppressed. Note C Language Programs In the C language programs contained in this manual, there is no end-of-line terminator to suppress as the commands are executed as elements of an array.
C Compilers Used The C Language programs were compiled (and tested) using the following compilers: • Microsoft® QuickC© Version 2.0 • Borland Turbo C++© Version 1.0 Compiling and Linking the Programs To run a C program, you must compile and link the program to make an executable file. To compile and link a program: • Be sure the necessary paths have been added to the AUTOEXEC.BAT file for the compilers to find the library and header files (see the appropriate C Language manual to set the proper paths).
Once compiled and linked, an executable file (.EXE) and object file (.OBJ) are created in the current directory. You execute the program by typing and entering the file name (with the .EXE extension). Compiling in the Integrated Environment You can compile, link, and run your C programs from the Microsoft® QuickC© or Turbo C++© integrated environments. To do so, add: program_name.C CLHPIB.LIB to the program list (under the "Make" menu) in the Microsoft® QuickC© environment.
Introduction to Programming The SCPI commands used to program the digitizer are separated into two groups: common commands and subsystem commands. Common commands begin with an asterisk, and include commands such as *RST, *CLS, *OPC?. Chapter 4 contains a complete listing of the digitizer’s common commands. Subsystem commands are those commands which configure the digitizer. Each subsystem is a set of commands that roughly corresponds to a functional block inside the digitizer.
Using the MEASure and CONFigure Commands Each time the digitizer takes a reading, it does so from a configuration based on parameters set by the digitizer subsystems (Figure 1-4). The easiest way to set these parameters is with the MEASure or CONFigure command.
Table 1-3.
Programming Sequence The recommended sequence for programming the digitizer is shown in Figure 1-5. Note that CONFigure sets many digitizer parameter values that usually do not have to be changed with "lower-level" subsystem commands. The lower-level commands are used when you want to set a value different from the value set by CONFigure.
Configuring the Channels How to Make Measurements Using MEASure Digitizer channels 1 and 2 share the digitizer’s arming and triggering circuitry and memory. Thus, the arming and triggering configuration and the number of readings set for one channel applies to the other channel as well. When the digitizer is armed and triggered, both channels sample and store their readings in memory simultaneously. This section explains when to use MEASure or CONFigure to configure the digitizer.
MEAS.C /* MEAS.C - This program demonstrates how to take readings using the */ /* digitizer’s MEASure command. In this program, MEASure configures the */ /* digitizer to take 10 readings on the 5V range, using the differential */ /* input port. */ /* Include the following header files */ #include #include #include #include #include
/* Use the MEASure command to configure the digitizer and to take */ /* the readings */ IOOUTPUTS(ADDR, "MEAS1:ARR:VOLT? (10),5,(@3)", 27); /* Send (27) characters */ IOENTERA(ADDR, rdgs, &readings); /* Read readings from MEASure command */ for (i = 0; i < readings; i++) { printf("\nReading %d = %f", i, *rdgs++); } free (rdgs - readings); } /****************************************************************************/ void rst_clr(void) { /* Reset and clear the A/D */ IOOUTPUTS(ADDR, "*RST;*CLS", 9); /* Se
CONF1:ARR:VOLT (20),1,(@1) SENS1:SWE:OFFS:POIN -10 Taking Readings After Using CONFigure To take readings, the digitizer must be triggered. The MEASure command automatically triggers the digitizer after setting the configuration. When CONFigure is used, the digitizer must be triggered using the READ? command or INITiate[:IMMediate] and FETCh[]? commands as shown.
CONF.C /* CONF.C - This program demonstrates how to use the CONFigure command and */ /* low-level digitizer commands to configure the digitizer. INITialize and */ /* FETCh? are used to trigger the digitizer and retrieve the readings from */ /* digitizer memory. */ /* Include the following header files */ #include #include #include #include #include
length = (sizeof(set_commands) / sizeof(char*)); /* Execute each command using a loop */ for (loop = 0; loop < length; loop++) { IOOUTPUTS(ADDR, set_commands[loop], strlen(set_commands[loop])); } /* function call to check for digitizer configuration errors */ check_error("ad_conf"); } /****************************************************************************/ void ad_fetch(void) { char go; int i = 0, readings = 20; float *rdgs; /* dynamically allocate memory for readings */ rdgs = malloc(20 * sizeof(floa
IOOUTPUTS(ADDR, "*RST;*CLS", 9); } /****************************************************************************/ void check_error(char *func_tion) { char into[161]; intlength = 160; IOOUTPUTS(ADDR, "SYST:ERR?", 9); IOENTERS(ADDR, into, &length); if (atoi(into) != 0) /* Query error register */ /* Enter error message */ /* Determine if error is present */ /* If errors present, print and exit */ { while (atoi(into) != 0) { printf("Error %s in function %s\n\n", into, func_tion); IOOUTPUTS(ADDR, "SYST:ERR?",
HP BASIC 10 20 30 40 50 DIM Setting$[1000] OUTPUT 70905;"CONF?" ENTER 70905;Setting$ PRINT Setting$ END !query CONFigure command QUERY.C /* This program queries HP E1429 settings */ /* Include the necessary header files */ #include #include #include
IOOUTPUTS(ADDR, qry_cmd, strlen(qry_cmd)); IOENTERS(ADDR, qry_resp, &length); printf("\n%s = %s", qry_cmd, qry_resp); } Checking for Errors The following HP BASIC program shows the lines and subprogram which can be added to HP BASIC programs to check for errors. Line 140 clears the digitizer standard event status register. Lines 150 and 160 unmask the appropriate bits in the digitizer’s status byte register and standard event status register.
140 OUTPUT @A_d;"*CLS" 150 OUTPUT @A_d;"*SRE 32" 160 OUTPUT @A_d;"*ESE 60" 170 ! 180 !Subprogram calls would be here 190 ! 200 WAIT .
/****************************************************************************/ void main(void) { check_error(); /* call error check function */ } /****************************************************************************/ void check_error(void) { char into[161]; int length = 160; IOOUTPUTS(ADDR, "SYST:ERR?", 9); IOENTERS(ADDR, into, &length); if (atoi(into) != 0) /* Query error register */ /* Enter error message */ /* Determine if error is present */ /* If errors present, print and exit */ { while (at
Where to go Next • For additional progamming examples: Chapter 2: Using the Digitizer • For the digitizer description of operation: Chapter 3: Understanding the Digitizer • For information on the digitizer command set: Chapter 4: Command Reference • For the digitizer operating specifications: Appendix A: Specifications • For a listing of the digitizer error messages: Appendix B: Useful Tables • For register programming information: Appendix C: Register Programming 48 Getting Started Chapter 1
Chapter 2 Using the Digitizer Chapter Contents This chapter contains example programs that show you how to use the digitizer. The programs, which demonstrate the various features of the digitizer, are presented in the same sequence as the features are covered in Chapter 3 - "Understanding the Digitizer". The examples in this chapter include: • • • • • • • • • Configuring the Digitizer Input . . . . . . . . . . . . . . . . . . . . . . . Taking a Burst of Readings . . . . . . . . . . . . . . . . . . . . . .
Configuring the Digitizer Input This program demonstrates the commands used to configure the digitizer’s input section. The program sets up the digitizer to take 10 readings on the 1V range of the digitizer’s single ended input port. This includes: • enabling/disabling the input ports • setting the input impedance • switching the 10 MHz filter into the signal path. • setting the signal range INPUT.
Taking a Burst of Readings This program demonstrates: • how to set the arm count for multiple bursts of (post-arm) readings • how to set the arm source to VXI backplane trigger line ECLTRG0 and use the HP E1406 Command Module to apply arming pulses to the trigger line. ARMCNT.
Level Arming This program demonstrates: • how to set the arm source such that the digitizer is armed when the input signal enters a specified voltage range (window) from a level outside the range. • how to set the arm slope such that an arm occurs when the input signal enters the arm window from either a positive-going or negative-going direction. • how to set the voltage levels which define the arm window.
Pre- and Post-Arm Readings This program demonstrates: • how to program the digitizer to take a minimum of 100 pre-arm readings and 100 post-arm readings. • how to set the arm source to an external signal applied to the "Ext 1" BNC. PREPOST.
Specifying a Sample Rate This program demonstrates: • how to set the digitizer trigger (sample) source • how to set the sample rate In this example, a 1 kHz square wave is sampled at a rate which includes the 11th harmonic. All samples are post-arm. SAMPLE.
2. Specifying the Sample Count. The sample count (i.e. trigger count) is specified by the size parameter (50) of the CONFigure command. This is the most convenient way to specify the sample count since size is a required parameter of CONFigure. TRIGger:STARt:COUNt can be used to set/change the sample count without also changing the entire configuration with CONFigure. 3. Additional Information.
2. Pre- and Post-Arm Sample Rates. With dual rate sampling, pre-arm and post-arm readings occur at different sample rates. It is recommended that pre-arm readings use the faster of the two sample rates. The reason is once the arm is received, one addtional sample at the pre-arm rate must occur before the post-arm rate is used. 3. Dual Rate Sampling Reference Sources.
MULT_AD.
/* digitizer commands */ INIT /* put digitizer 1 in wait-for-arm state */ INIT /* put digitizer2 in wait-for-arm state */ /* Command Module commands */ OUTP:TTLT0:STAT ON /* enable line TTLT0 */ "Press Enter (return) to arm the digitizers" OUTP:TTLT0:IMM /* apply a pulse to TTLT0 */ /* digitizer commands */ Comments FETC1? /* retrieve readings from digitizer1, channel 1 */ FETC2? /* retrieve readings from digitizer1, channel 2 */ FETC1? /* retrieve readings from digitizer2, channel 1 */ FETC2? /*
6. Additional Information. Additional information on using arming, triggering, and reference signals to synchronize other digitizers can be found in Chapter 3 - "Understanding the Digitizer". Additional information on the CONFigure command can be found in Chapter 1 - "Getting Started". Using the Packed Data Format This program demonstrates: • how to specify the digitizer’s packed data format • how to remove the ANSI/IEEE Standard 488.
/* Function Prototypes */ void rst_clr(void); void ad_confread(void); void check_error(char *func_tion); /****************************************************************************/ void main(void) /* run the program */ { rst_clr(); /* reset the digitizer */ ad_confread(); /* function which configures the digitizer */ /* and takes the readings */ } /****************************************************************************/ void ad_confread(void) { int length = 0, loop = 0, i = 0, swap = 0, bytes = 0, l
/* set number of bytes placed in memory, and number of bytes read */ swap = sizeof(int); /* place 2 bytes/reading in memory */ bytes = 20 * swap; /* read 40 bytes */ IOOUTPUTS(ADDR, "READ?", 5); /* retrieve the readings */ IOENTERAB(ADDR, rdgs, &bytes, swap); /* enter the readings and */ /* remove the block header */ /* Remove line feed which trails the last data byte */ length = 1; IOENTERS(ADDR, lf_remove, &length); /* print label */ label = (rdgs[0] & 0x000F); printf("\nLabel #: %d", label); /* convert
/****************************************************************************/ void check_error(char *func_tion) { char into[161]; intlength = 160; IOOUTPUTS(ADDR, "SYST:ERR?", 9); IOENTERS(ADDR, into, &length); if (atoi(into) != 0) /* Query error register */ /* Enter error message */ /* Determine if error is present */ /* If errors present, print and exit */ { while (atoi(into) != 0) { printf("Error %s in function %s\n\n", into, func_tion); IOOUTPUTS(ADDR, "SYST:ERR?", 9); IOENTERS(ADDR, into, &length);
4. Packed Reading Conversion Formula. The equation for converting packed readings to voltages is: readingvoltage = (readingpacked / 16) * reading resolution The reading resolutions, which are a function of the signal range, are listed in Chapter 3 in the section "Converting Packed Readings". VME Bus Data Transfers The following programs demonstrate: • how post-arm readings are transferred from the digitizer’s A/D converter directly to the VME bus (VME_REAL.
/* Function prototypes */ long get_base_addr(void); void rst_clr(void); void ad_conf(void); void mem_read(long base_addr); void check_error(char *function); /****************************************************************************/ void main(void) { long base_addr; /* variable for digitizer A24 base address */ rst_clr(); base_addr = get_base_addr(); ad_conf(); mem_read(base_addr); } /* reset and clear the digitizer */ /* function call to calculate and */ /* return digitizer A24 base address */ /* funct
/****************************************************************************/ void mem_read(long base_addr) { int readings = 100, i = 0; float *rdgs; char rd_mem[80]; /* command string variable */ /* dynamically allocate memory for readings */ rdgs = malloc(100 * sizeof(float)); /* Create the (HP E1406 Command Module) command string which reads the data register */ sprintf(rd_mem, "DIAG:PEEK? %ld, %d", base_addr+0x0C,16); /* Send DIAG:PEEK? command which accesses the data register */ /* and triggers meas
/* base address of (A24) offset register in A16 address space */ long base_addr = (0x1FC000 + (logical_addr * 64)) + 6; float a24offst; char rd_addr[80]; /* A24 offset from A16 offset register */ /* command string variable */ /* Create the command string which reads the A24 base address */ sprintf(rd_addr, "DIAG:PEEK? %ld, %d", base_addr,16); /* Send DIAG:PEEK? command */ IOOUTPUTS(CMD_MOD, rd_addr, strlen(rd_addr)); /* Read value from offset register */ IOENTER(CMD_MOD, &a24offst); /* Multiply offset val
4. System Configuration. The system configuration on which the program VME_REAL.C was developed is listed on page 1-10. VME_SEG1.C /* VME_SEG1.C - This program demonstrates how to transfer segmented readings */ /* over the VME bus. The program sets up 2 bursts (segments) of 10 pre-arm */ /* and 10 post-arm readings. A reading is taken each time the digitizer’s */ /* data register is accessed, and is transferred real time, over the VME bus.
/****************************************************************************/ void ad_conf(void) { int length = 0, loop = 0; /* use the "set_commands" array to configure digitizer channel 1 */ char static *set_commands[] = {"CONF1:ARR:VOLT (20),5,(@3)", /* set 20 readings per burst, 5V range */ "ARM:STAR:SOUR IMM", /* set arm source immediate */ "ARM:STAR:COUN 2", /* set 2 bursts (arms) */ "TRIG:STAR:SOUR VME", /* Data register access triggers readings */ "SENS:SWE:OFFS:POIN -10", /* set 10 pre-arm reading
/* Create the command string which reads bit 1 */ sprintf(bit_str, "DIAG:PEEK? %ld, %d", base_addr+0x43,8); /* Send DIAG:PEEK? to access the data register 20 times. */ while (loop < 2) /* two bursts (segments) */ { for (i = index;i < readings; i++) { IOOUTPUTS(CMD_MOD, read_str, strlen(read_str)); IOENTER(CMD_MOD, &rdgs[i]); } /* Check bit 1 of offset register 43h before proceeding with */ /* the next segment.
free(rdgs); } /****************************************************************************/ long get_base_addr(void) { /* digitizer logical address */ long logical_addr = (ADDR - 70900L) * 8; /* base address of (A24) offset register in A16 address space */ long base_addr = (0x1FC000 + (logical_addr * 64)) + 6; float a24offst; char rd_addr[80]; /* A24 offset from A16 offset register */ /* command string variable */ /* Create the command string which reads the A24 base address */ sprintf(rd_addr, "DIAG:PEE
IOOUTPUTS(ADDR, "SYST:ERR?", 9); IOENTERS(ADDR, into, &length); if (atoi(into) != 0) /* Query error register */ /* Enter error message */ /* Determine if error is present */ /* If errors present, print and exit */ { while (atoi(into) != 0) { printf("Error %s in function %s\n\n", into, func_tion); IOOUTPUTS(ADDR, "SYST:ERR?", 9); IOENTERS(ADDR, into, &length); } exit(1); } } Comments 1. Segmented Readings. Multiple bursts of pre-arm and post-arm readings segment memory (see Figure 3-13).
VME Bus Data Transfers Using an Embedded Controller The following programs transfer data over the VME bus using the following system configuration: • Controller: RadiSys® EPC®-7 Embedded Controller • Runtime library: Standard Instrument Control Library (SICL) for DOS • Compiler: Borland© C++ (.CPP) These programs are also contained on the C language example programs disk (HP E1429-10302). SEGTST16.CPP This program transfers 16-bit readings (real time) from the channel 1 A/D converter to the VME bus.
Dig = new E1429; if (!Dig->IsValid()) { printf("Digitizer could not be opened (%s).
/* ********************* ReadData ********************* */ int ReadData(E1429 *Dig) { int SegCnt, ReadCnt; WORD *Readings, *Reading, *Reading2; const static NReadings = 20, NSegments = 2; const static float Scale = 0.0025 / 16.
// Options|Compiler|CodeGeneration|Model: Set to Large // Options|Directories|Include Directories: Add C:\EPCONNEC\INCLUDE // Options|Directories|Library Directories: Add C:\EPCONNEC\LIB // Project Items: INST.CPP, E1429.CPP, SEGTST32.CPP, BSICL.LIB, EPCMSC.LIB #include #include #include "e1429.
/* ********************** Measure ********************* */ int Measure(E1429 *Dig) { int Errors; char Buf[BUFLEN+1], **Com; static char *Commands[] = { "*RST", "CONF1:ARR:VOLT (20), 5, (@3)", "CONF2:ARR:VOLT (20), 5, (@4)", "ARM:STAR:SOUR IMM", "ARM:STAR:COUN 2", "TRIG:STAR:SOUR VME", "SENS:SWE:OFFS:POIN -10", "VINS:CONF:VME:MODE GEN", "VINS:CONF:VME:FEED ’CONV:BOTH32’", "INIT", NULL }; for (Com = Commands; *Com != NULL; Com++) Dig->SendMessage(*Com); Errors = 0; while (Dig->GetErrorMessage(Buf,BUFLEN) != N
printf(" **** Channel 1 **** **** Channel 2 ****\n"); printf(" Seg 1 Seg 2 Seg 1 Seg 2\n"); printf(" ---------- ---------- ---------- ----------\n"); Reading = Readings; Reading2 = Readings + NReadings; for (ReadCnt = 1; ReadCnt <= NReadings; ReadCnt++) { printf("%2d%+10.4f%+10.4f %+10.4f%+10.4f\n",ReadCnt, Scale*LOWORD(*Reading), Scale*LOWORD(*Reading2), Scale*HIWORD(*Reading), Scale*HIWORD(*Reading2) ); Reading++; Reading2++; } printf("\n"); free(Readings); return 0; } SEGTST16.CPP and SEGTST32.
#define LOWORD(lWord) ((WORD)(lWord)) #define HIWORD(lWord) ((WORD)((LONG)(lWord) >> 16)) class RegInst { static RegInst *MappedInst; int Valid; int Mapped; int MapSpace; unsigned int PageStart, PageCount; UBYTE *SuggestedAddr; protected: INST Inst; UBYTE *BaseAddr; void Unmap(void); public: RegInst(UWORD lAddr = 0); ~ RegInst(void); int IsValid(void) { return (this != NULL && Valid); } INST GetInstID(void) { return Inst; } void SetMapping(int mapSpace, unsigned int pageStart, unsigned int UBYTE *suggestedA
class MessInst : public RegInst { public: MessInst(WORD lAddr) : RegInst(lAddr) { } void Clear(void) { iclear(Inst); } void SendMessage(const char *message); char *ReceiveMessage(char *message, int maxLen = 80); char *GetErrorMessage(char *message, int maxLen = 80); }; #endif INST.CPP #include #include #include #include "inst.
void RegInst::SetMapping(int mapSpace, unsigned int pageStart, unsigned int pageCount, UBYTE *suggestedAddr) { int WasMapped; if (this != NULL) { WasMapped = Mapped; if (Mapped) Unmap(); MapSpace = mapSpace; PageStart = pageStart; PageCount = pageCount; SuggestedAddr = suggestedAddr; if (WasMapped) Map(); } } void RegInst::Map(void) { if (this != NULL) { Valid = 0; if (Inst != NULL) { MappedInst->Unmap(); BaseAddr = imap(Inst,MapSpace,PageStart,PageCount,SuggestedAddr); if (BaseAddr != NULL) { MappedInst =
/* ************************* MessInst ************************** */ void MessInst::SendMessage(const char *message) { unsigned long ActualLen; char Buf[BUFLEN+1]; strcpy(Buf,message); strcat(Buf,"\n"); iwrite(Inst,Buf,strlen(Buf),0,&ActualLen); } char *MessInst::ReceiveMessage(char *message, int maxLen) { int Reason; unsigned long ActualLen; char *SPtr, Buf[BUFLEN+1]; iread(Inst,message,maxLen,&Reason,&ActualLen); message[ActualLen] = ’\0’; SPtr = message + strlen(message) - 1; while (SPtr >= message && *SP
E1429.H #ifndef E1429_DEFD #define E1429_DEFD #include "inst.h" class E1429 : public MessInst { int MemoryMode; public: E1429(WORD lAddr = 40); void SetDataReg(UWORD value) { wSet(0x0c,value); } UWORD GetDataReg(void) { return wGet(0x0c); } void MGetDataReg(UWORD *dest, ULONG count) { wMGet(0x0c,dest,count); } ULONG GetLongDataReg(void); // Cannot use lGet here because of ilpeek problem void MGetLongDataReg(ULONG *dest, ULONG count) { lMGet(0x0c,dest,count); } }; #endif E1429.CPP #include
Local Bus Data Transfers The following programs demonstrate: • how readings are transferred over the Local bus from a single digitizer to the HP E1488 memory card (LOCAL_AD.C) • how readings in digitizer memory are transferred over the Local bus from two digitizers to the HP E1488 memory card (LBUS2PST.C) • how readings from two digitizer A/Ds are transferred over the Local bus to the HP E1488 memory card (LBUSAUTO.C) For completeness, the entire C language versions of these programs are listed.
/****************************************************************************/ void main(void) /* run the program */ { rst_clr(ADDR); /* reset the digitizer */ rst_clr(ADDR_MEM); /* reset the memory card */ configure(); /* configure the digitizer and the memory card */ initiate(); /* initiate the digitizer and memory card; */ /* retrieve the readings from the memory card */ } /****************************************************************************/ void configure(void) { int length = 0, loop = 0; /* us
length = (sizeof(memory) / sizeof(char*)); for (loop = 0; loop < length; loop++) { IOOUTPUTS(ADDR_MEM, memory[loop], strlen(memory[loop])); } /* check for configuration errors */ check_error("digitizer", ADDR); check_error("memory", ADDR_MEM); } /****************************************************************************/ void initiate(void) { int i = 0, readings = 20, swap = 0, bytes = 0, length = 1, *rdgs; float rdy; char lf_remove[1]; /* dynamically allocate memory for readings */ rdgs = malloc(20 * siz
/* convert and display the readings; readings are in the sequence */ /* channel 2 reading 1, channel 1 reading 1, channel 2 reading 2, */ /* channel 1 reading 2, and so on */ for (i = 0; i < readings; i++) { rdgs[i] /= 16; if (rdgs[i] >= 2047 || rdgs[i] <= -2046) printf("\nReading overrange"); else printf("\nReading %d = %.6E", i, (rdgs[i] * 0.
Comments 1. Digitizer Configuration. Both channel’s HI differential inputs (ports 3 and 4) are CONFigured for 10 readings on the 5V range. Two readings (channel 1 and channel 2) are taken on each sample trigger. The sample rate, as set by the CONFigure command, is 50 ns (20 MHz). Thus, data is transferred at a rate of 40 MSamples (80 MBytes)/second. Before setting the digitizer’s Local bus configuration the Local bus chip is reset.
LBUS2PST.C This program transfers readings in digitizer memory from two digitizers to the HP E1488 memory card. The program shows how the digitizers are used in the Local bus GENerate and APPend modes. /* LBUS2PST.C - This program demonstrates how to transfer readings in */ /* digitizer memory from multiple digitizers to the E1488 memory card. The */ /* leftmost digitizer is set to GENerate mode and the inner digitizer is set */ /* to the APPend mode.
char static *digitizer1[] = {"CONF1:ARR:VOLT (10),5,(@3)", "VINS:LBUS:RES", "VINS:LBUS:MODE GEN", "VINS:LBUS:FEED ’MEM:CHAN1’"}; /* set 10 readings, 5V range, */ /* channel, 1 input port 3 */ /* reset the Local bus chip */ /* set Local bus mode to GENerate */ /* set Local bus feed */ /* use the "digitizer2" array to configure the appender digitizer */ char static *digitizer2[] = {"CONF1:ARR:VOLT (10),5,(@3)", "VINS:LBUS:RES", "VINS:LBUS:MODE APP", "VINS:LBUS:FEED ’MEM:CHAN1’"}; /* set 10 readings, 5V ran
/* Execute each command in "memory" */ length = (sizeof(memory) / sizeof(char*)); for (loop = 0; loop < length; loop++) { IOOUTPUTS(ADDR_MEM, memory[loop], strlen(memory[loop])); } /* check for digitizer and memory card configuration errors */ check_error("digitizer1", ADDR_G); check_error("digitizer2", ADDR_A); check_error("memory", ADDR_MEM); } /****************************************************************************/ void initiate(void) { int i = 0, readings = 20, swap = 0, bytes = 0, length = 1, *rd
/* remove line feed which trails the last data byte */ IOENTERS(ADDR_MEM, lf_remove, &length); /* convert and display the readings; the generator digitizer readings */ /* occur first, followed by the appender digitizer readings */ for (i = 0; i < readings; i++) { rdgs[i] /= 16; if (rdgs[i] >= 2047 || rdgs[i] <= -2046) printf("\nReading overrange"); else printf("\nReading %d = %.6E", i, (rdgs[i] * 0.
while (atoi(into) != 0) { printf("Error %s in %s\n\n", into, array); length =160; IOOUTPUTS(address, "SYST:ERR?", 9); IOENTERS(address, into, &length); } exit(1); } } Comments 1. GENerator Digitizer Configuration. Channel 1 of the GENerator digitizer is CONFigured for 10 readings on the 5V range. Before setting the digitizer’s Local bus configuration, the Local bus chip is reset. Next, the Local bus mode is set to GENerate and the feed (data source) is set to MEMory:CHANnel1. 2.
5. Reading Sequence and Format. When this program executes, the readings are transferred to the memory card and later displayed in the following sequence: GENerator digitizer reading 1 GENerator digitizer reading n . . APPender digitizer reading 1 APPender digitizer reading n The memory card was set up to store the readings in the digitizer’s packed data format. The packed readings are signed, 16-bit numbers preceded by the ANSI/IEEE Standard 488.2-1987 Definite Length Arbitrary Block header.
#define ADDR_G 70905L #define ADDR_I 70906L #define ADDR_MEM 70903L #define CMD_MOD 70900L /* I/O path from the PC to the generator digitizer */ /* I/O path from the PC to the inserter digitizer */ /* I/O path from the PC to the memory card */ /* I/O path from the PC to the Command Module */ /* Function Prototypes */ void rst_clr(long address); long get_base_addr(void); void configure(void); void initiate(long base_addr); void check_error(char *func_tion, long address); /**********************************
/* use the "digitizer2" array to configure the inserter digitizer */ char static *digitizer2[] = {"CONF1:ARR:VOLT (10),5,(@3)", /* set 10 readings, 5V range, */ /* channel, 1 input port 3 */ "OUTP:TTLT0:FEED ’READY’", /* feed ready signal to next digitizer */ "OUTP:TTLT0:STAT ON", /* enable ready signal feed */ "VINS:LBUS:RES", /* reset the Local bus chip */ "VINS:LBUS:MODE INS", /* set Local bus mode to INSert */ "VINS:LBUS:FEED ’CONV:CHAN1’"}; /* set Local bus feed */ /* use the "memory" array to config
for (loop = 0; loop < length; loop++) { IOOUTPUTS(ADDR_MEM, memory[loop], strlen(memory[loop])); } /* check for digitizer configuration errors */ check_error("digitizer1", ADDR_G); check_error("digitizer2", ADDR_I); check_error("memory", ADDR_MEM); } /****************************************************************************/ void initiate(long base_addr) { int i = 0, readings = 20, swap = 0, bytes = 0, length = 1, *rdgs; int bit_reg = 0; float rdy, bit_pat = 0; char lf_remove[1], command[80]; /* dynamica
IOOUTPUTS(ADDR_I, "INIT", 4); IOOUTPUTS(ADDR_G, "*OPC?",5); IOENTER(ADDR_G, &rdy); /* initiate the inserter digitizer */ /* wait for generator digitizer to finish */ IOOUTPUTS(ADDR_MEM, "TRAC:DATA? SET1", 15); /* retrieve readings from memory card */ IOENTERAB(ADDR_MEM, rdgs, &bytes, swap); /* enter readings and remove block header */ /* remove line feed which trails the last data byte */ IOENTERS(ADDR_MEM, lf_remove, &length); /* convert and display readings; the inserter digitizer readings */ /* occur
/* Read value from offset register */ IOENTER(CMD_MOD, &a24offst); /* Multiply offset value by 256 for 24-bit address value */ a24offst *= 256.
Comments 1. GENerator Digitizer Configuration. Channel 1 of the GENerator digitizer is CONFigured for 10 readings on the 5V range. The arm source is set to TTLT0. This VXI backplane trigger line is controlled by the INSerter digitizer which feeds its READy signal to arm the GENerator digitizer after its readings are complete.
5. Reading Sequence and Format. When this program executes, the readings are transferred to the memory card and later displayed in the following sequence: INSerter digitizer reading 1 INSerter digitizer reading n . . GENerator digitizer reading 1 GENerator digitizer reading n The memory card stores the readings in the digitizer’s packed data format. Packed readings are signed, 16-bit numbers preceded by the ANSI/IEEE Standard 488.2-1987 Definite Length Arbitrary Block header.
Using the Digitizer Status Registers This program demonstrates: • how to use the condition register, transition filter, enable register, and status byte to determine when events monitored by the condition register occur. One of the conditions monitored by the operation status group’s condition register is when the digitizer receives an arm signal. When armed, a high-to-low transition of the wait-for-arm bit (bit 6) in the condition register occurs.
Comments 1. Setting the Transition Filter. When the digitizer is INITiated, a low-to-high transition of bit 6 in the condition register occurs indicating the digitizer is in the wait-for-arm state. When an arm is received, a high-to-low transition of bit 6 occurs. The power-on/reset setting of the transition filter allows the positive transition to be recognized and the negative transition to be ignored.
Chapter 3 Understanding the Digitizer Chapter Contents This chapter contains the HP E1429 Digitizer description of operation. Where applicable, the chapter relates the digitizer’s SCPI commands to the digitizer hardware they control. The main sections of the chapter include: • • • • • • • • • • • HP E1429A Digitizer Block Diagram . . . . . . . . . . . . . . . . . . The Message and Register Interfaces . . . . . . . . . . . . . . . . . . The Digitizer Input Section . . . . . . . . . . . . . . . . . . . . .
Figure 3-1.
The Message and Register Interfaces The HP E1429 digitizer can be programmed as a message-based device or as a register-based device (Appendix C). When the digitizer functions as a message-based device, the processor within the message interface (Figure 3-1) converts SCPI (ASCII) command strings to register reads and writes through the register interface. When the digitizer functions as a register-based device, command opcodes are written directly to the digitizer registers from the register interface.
The Digitizer Input Section The HP E1429 2-channel digitizer has single-ended and differential input ports on each channel. Each input port has a BNC connector and is DC coupled. A detailed block diagram of the input section is shown in Figure 3-3. Only one channel is shown since both are identical. Figure 3-3. HP E1429 Digitizer Input Section SCPI Command Control The digitizer’s input section including the input state, input impedance, and low-pass filtering is controlled by the SCPI INPut subsystem.
[SENSe[]] :FUNCtion "" [SENSe[]] :VOLTage [:DC] :RANGE Note Each command in these subsystems is covered in detail in Chapter 4 "Command Reference". Each input parameter setting is unique to each port. The settings are "remembered" so that changes made to one port do not affect the changes made previously to the other port. However, the signal range set (or changed) for one port applies to the other port as well.
Enabling the Input Ports Each input port has a relay that is used to enable and disable the input. This relay is controlled by the command: INPut[][:STATe] The settings are: ON - the input is enabled. OFF - the input is disabled. For the single ended input, the port is set to a high impedance. At power-on or following a reset, each input port is enabled ( is ON).
The settings are: ON - 10 MHz filter is switched to the signal path. OFF - 10 MHz filter is removed from the signal path. Enabling the filter reduces the noise on the input signal. Disabling the filter allows sub-sampling applications over the digitizer’s 50 MHz bandwidth. The filter mode of one input port is independent of the filter mode of the channel’s other port. At power-on or following a reset, the filter is disabled on all input ports.
The attenuators used are based on the expected value or range specified. Table 3-1 shows the attenuators used as a function of the expected value and range. Table 3-1. HP E1429 Digitizer Measurement Ranges Input Port Range (MEAS/CONF) Measurement Range 20 dB 20 dB Internal Attenuators Input Post 6 dB 14 dB Attenuator Attenuator 1,2,3,4 ±0.1 0.10235 -0.10230 to 0.10235 off off off off 1,2,3,4 ±0.2 0.2047 -0.2046 to 0.2047 off off on off 1,2,3,4 ±0.5 0.
Arming and Triggering The HP E1429 digitizer uses the SCPI Arm-Trigger configuration shown in Figure 3-4. This section describes the Arm-Trigger state sequence and identifies the different ways to arm and trigger the digitizer. Figure 3-4.
The ARM-TRIG State Diagram The state diagram of Figure 3-4 shows that the digitizer operates within four states: idle, initiated, wait-for-arm, and wait-for-trigger. The path through the states depends upon whether pre-arm sampling is part of the measurement configuration. Both paths begin with the digitizer in the idle state. The digitizer enters the idle state when power is applied, or following a reset or an ABORt.
Arming the Digitizer Before the digitizer takes a sample it must be "armed", which means it must be in the wait-for-trigger state. Figure 3-5 shows the digitizer arming and triggering sources. Figure 3-5.
The digitizer hardware associated with arming the digitizer is controlled by the SCPI ARM subsystem. The commands in this subsystem include: ARM [:STARt|SEQuence[1]] :COUNt :DELay [:IMMediate] :LEVel[] :NEGative :POSitive :SLOPe[] :SOURce[]
• HOLD - disables either ARM:SOURce1 or ARM:SOURce2. This is the reset source for ARM:SOURce2. • IMMediate - arms the digitizer immediately after INITiate[:IMMediate] is received. This choice is only valid for ARM:SOURce1. If IMMediate is specified, HOLD must be specified for ARM:SOURce2. IMMediate is the reset value for ARM:SOURce1. Note Setting the Arm Signal Slope An active reference oscillator is required for the digitizer to recognize and accept an arm signal from any source.
Note Arm Window Boundaries For arm source TTLTRG, the digitizer arms on the negative-going edge of the signal. For arm source ECLTrg, the digitizer arms on the positive-going edge. These sources are not affected by the ARM:STARt:SLOPe command. The boundaries of the window are set by the voltage levels of ARM[:STARt]:LEVel:POSitive and ARM[:STARt]:LEVel:NEGative.
The Arm Level Range When setting the input voltage level which arms the digitizer, the levels are restricted to the current signal range as set by the expected value parameter of the CONFigure or MEASure command, or as set by the SENSE:VOLTage:RANGE command. Table 3-1 lists the digitizer’s signal ranges. Note Setting the Arm Delay When level arming, arms that occur because of multiple passes through the arm level are ignored until the trigger count is reached.
When only post-arm readings are specified, an error will occur when the total number of readings (ARM:COUNt * TRIGger:COUNt) is greater than 524,288 readings. However, an error will not occur if the arm count or trigger count is set to INFinity, or if the readings are going the VME bus or Local bus directly from the A/D converter. When pre-arm readings are included in a measurement sequence with an arm count > 1, digitizer memory is segmented.
This allows the digitizer to synchronize other digitizers or events. The commands used to output the arm signal are: OUTPut:EXTernal[1]:FEED
Routing the Signal to a Source The arm signal can be routed to the locations described above, provided the port or trigger line is not also used as an input for a reference clock source, arm source, or trigger source.
Triggering the Digitizer After the digitizer is armed it enters the wait-for-trigger state. Thus, when trigger signals are received, the digitizer samples the inputs on its channels (Figure 3-5). The hardware associated with triggering the digitizer is controlled by the SCPI TRIGger subsystem, and by selected commands in the SENSe subsystem.
The Sample Period Setting the Sample Period The sample period is the interval at which the digitizer takes readings. The sample period is derived from a reference which can be the digitizer’s internal 20 MHz oscillator, or a reference from an external source (see "The Digitizer Reference Clock").
To get the 10 µs sample period (100 kHz rate), the digitizer processor divides the reference by 200 (N): 20 MHz / N = 20 MHz / 200 = 100 kHz 1 / 100 kHz = 10 µs Oversampling The Nyquist criteria states that the sample rate must be at least 2 times the maximum frequency component of the input signal. To limit aliasing, it is recommended that a sample rate 4 times or greater the maximum frequency component be used.
Note The Digitizer Reference Clock It is recommended that pre-arm readings use the faster of the two sample rates. One additional sample pulse at the pre-arm rate, after the arm occurs, is required for the sample rate to change. The digitizer does not sample on this additional pulse. Post-arm sample pulses may be ignored depending on how fast they occur following the rate change. Refer to Appendix A "Specifications", for additional information on dual rate sampling characteristics.
Note Setting the Trigger Count An active reference clock (oscillator) is required for the digitizer to recognize and accept arm signals. The trigger count is the total number of readings (pre- and post-arm) per arm event. The trigger count is normally set by the parameter of the CONFigure and MEASure commands.
Trigger Synchronization Signals The trigger and reference clock signals can be "routed" to the following locations: "Ext 1" BNC port ECLTRG trigger line This allows the digitizer to synchronize other digitizers or events. The commands used to output the trigger and reference signals are: OUTPut:ECLTrg:FEED • = "TRIGger[:STARt|SEQuence[1]]" Outputs a trigger signal to the ECLT trigger line each time a convert pulse is sent to the A/D converter.
OUTPut:EXTernal[1]:FEED • = "TRIGger[:STARt|SEQuence[1]]" Outputs a trigger signal to the "Ext 1" BNC port each time a convert pulse is sent to the A/D converter. • = "SENSe[1|2]:ROSCillator" The significant edge of a TTL signal is the falling edge. Therefore, the output goes low with the falling edge of an external reference signal, and goes low with the rising edge of reference sources ECLTrg and CLK10.
OUTPut:TTLTrg:FEED • = "READy" The level on the selected TTLTRG trigger line goes low while the trigger system is initiated. The line goes high after the readings complete, and then goes low again for the next burst of readings. When taking post-arm readings only, the signal returns high when the arm count and trigger count are both satisfied.
Enabling the Synchronization Signal In order for the trigger or clock synchronization signals to be routed to the "Ext 1" BNC port or to an ECLTRG or TTLTRG trigger line, the routing must be enabled. This is done with the commands: OUTPut:EXTernal[1][:STATe] OUTPut:ECLTrg[:STATe] OUTPut:TTLTrg[:STATe] For each command, the settings are: ON - enables the port or trigger line to route the signal. OFF - disables the port or trigger line from routing the signal.
to 16-bits. When both channels readings are selected, the data is expanded to 32-bits; 16-bits per reading. Similarly, readings sent to the Local bus from either the A/D or memory are expanded to 16- or 32-bits, depending on whether one or two channels is selected. The readings are transferred eight bits at a time, however. Figure 3-7. HP E1429 Digitizer Data Flow How Readings are Stored The digitizer can store 512K (524,288) readings from each channel in memory.
Figure 3-8. HP E1429 Digitizer Reading Storage Segmented Memory The HP E1429 digitizer is capable of pre-arm and post-arm readings. Pre-arm readings are taken after the digitizer is INITiated and before an arm is received. Post-arm readings are taken after an arm is received. When multiple reading sequences consist of pre- and post-arm readings, digitizer memory is partioned into segments (Figure 3-9).
Figure 3-10 shows the relationship between pre- and post-arm readings and memory segments. Figure 3-10. Memory Segments with Pre - and Post-arm Readings The MEMory Subsystem The digitizer’s MEMory subsystem contains commands which enable non-volatile memory and which query the charge on the battery maintaining memory.
The settings are: ON - enables the battery; memory is non-volatile. OFF - disables the battery; memory is lost when power is cycled (factory setting). If memory is to be battery-backed, the battery must be enabled before readings are taken. Cycling power or resetting the digitizer does not affect the battery state set by MEMory:BATTery:STATe. Battery life is normally four years if it remains enabled.
PACKed,16 format returns signed, 16-bit numbers preceded by the ANSI/IEEE Standard 488.2-1987 Definite Length Arbitrary Block header (Figure 3-11). Packed readings always represent a value between -1.0225 and +1.0230 or an overrange value, and must be converted (by the user) to the actual reading value (see "Packed Reading Conversions"). REAL,64 format returns/retrieves data as 64-bit REAL numbers also preceded by the ANSI/IEEE Standard 488.2-1987 Definite Length Arbitrary Block header (Figure 3-11).
Removing the Arbitrary Block Header Following are two methods of removing the block data header. The first method uses the HP BASIC programming language. The second method uses a command from the HP 82335 HP-IB Command Library for C.
C Language Example (16-bit readings) /* dynamically allocate memory for readings */ rdgs = malloc(20 * sizeof(int)); /* set number of bytes placed in memory, and number of bytes read */ swap = sizeof(int);/* place 2 bytes/reading in memory */ bytes = 20 * swap;/* read 40 bytes */ IOOUTPUTS(ADDR, "READ?", 5);/* retrieve the readings */ IOENTERAB(ADDR, rdgs, &bytes, swap); /* enter the readings */ /* and remove the block header */ /* Remove line feed which trails the last data byte */ length = 1; IOENTERS(A
Overrange Indications The digitizer indicates an overrange condition (input greater than the selected range can measure) by returning the values shown in Table 3-3. An amplifier overrange (single-ended or differential input) sets bit 0 in the Table 3-3. Digitizer Overload Readings Condition Reading A/D Code A/D Overrange (positive reading) +9.900000E+037 +2047 A/D Overrange (negative reading) -9.900000E+037 -2046 -9.
Table 3-4.
Retrieving Readings Using READ? The most common method of retrieving readings from the digitizer is using the READ? subsystem which consists of the command: READ[]? The parameters are: 1 - returns readings from channel 1 (default channel) 2 - returns readings from channel 2 READ? is equivalent to executing the following sequence of commands: • ABORt - aborts the readings after the arm count and trigger count is reached. • INITiate - places the digitizer in wait-for-arm state.
The commands used to fetch (retrieve) readings from memory are: FETCh[]? If the parameter is ’1’ or is not specified, the readings (pre- and post-arm) from channel 1 and from the most recent INITiate - ARM TRIGger sequence are retrieved. If the parameter is ’2’, the readings from channel 2 are retrieved. FETCh[]:RECover? This command is used to retrieve readings from non-volatile (battery-backed) memory following a power failure.
SENSe[< chan>]:SWEep:OFFSet:POINts? This command will return 0 if no pre-arm readings are specified, or a negative number representing the number of pre-arm readings. Note Using DIAGnostic:UPLoad: SADDress? If the digitizer measurement sequence is aborted (ABORt command), the FETCh[]:COUNt? command is the only way to determine the number of readings to be retrieved by FETCh?.
Memory Management In certain applications it may be necessary to retrieve a selected set of readings from digitizer memory. This section explains where readings are stored in memory and how to determine the memory addresses of any set of readings. The DIAGnostic Subsystem This section introduces two commands used to locate and retrieve readings from memory.
Locating Segmented Readings For segmented readings (SENSe:SWEep:OFFSet:POINts ≤ -3), the algorithm for locating the readings is similar to that for unsegmented readings, but is slightly more complicated. The number of memory segments is determined by the specified arm count (ARM:STARt:COUNt) as shown in Table 3-5. Table 3-5. Arm Count Vs.
The DIAGnostic:MEMory:ADDResses? command returns a list of 32-bit integers for each segment in memory. In each 32-bit list, bit 1 is the aborted flag and bit 0 is the memory wrapped flag. Bit 31 through bit 2 is the value of the address counter for that segment. Thus, to obtain the memory address only, a divide by 4 (right shift of 2) of the 32-bit list must be done.
Assume that this 32-bit value is FFF8116. Bit 0 is high (’1’) indicating readings have wrapped around the segment. Bit 1 is low (’0’), indicating that this segment completed normally and was not aborted (by the user with the ABORt command). The address returned is divided by 4 so that the aborted and wrapped bits are discarded, and the address counter value of 3FFE016 (26211210) remains.
VME Bus Data Transfers Another method of transferring readings to the VME (VXI data transfer) bus is with the digitizer’s VINStrument (Virtual INStrument) subsystem and accessing the digitizer’s data register. This method, which combines message-based (SCPI) programming and reading the data register directly, is faster than the previous methods (READ?, FETCh?, DIAGNostic:UPLoad:ADDRess?) in that readings can be retrieved from the A/D converter or from memory in the A/D’s packed data format.
Figure 3-12. Digitizer Registers in A16 and A24 Address Space Note Determining the A24 Base Address The following information on determining the data register address is based on the computer configuration shown in Figure 3-12, and on address mapping as performed by the HP E1406 Command Module’s resource manager.
2. Execute the following HP E1406 Command Module command: VXI:CONFigure:DeviceLIST? The C language example programs disk contains the program Query.C.
1FC00016 + (40 * 64)16 1FC00016 + A0016 = 1FCA0016 or decimal 2,080,768 + (40 * 64) 2,080,768 + 2560 = 2,083,328 Given the A16 base address and the "offset" of the Offset register (06 from Figure 3-12), the digitizer’s A24 base address can be determined as shown in the program A24_READ.C. /* A24_READ.C - This program reads the digitizer’s A24 base address. */ /* Include the following header files */ #include #include
float a24offst;/* A24 offset from A16 offset register */ char rd_addr[80];/* command string variable */ /* Create the command string which reads the A24 base address from the offset register*/ sprintf(rd_addr, "DIAG:PEEK? %ld, %d", base_addr,16); /* Send DIAG:PEEK? command */ IOOUTPUTS(CMD_MOD, rd_addr, strlen(rd_addr)); /* Read value from offset register */ IOENTER(CMD_MOD, &a24offst); /* Multiply offset value by 256 for 24-bit address value */ a24offst *= 256.
The VINStrument Subsystem The commands within the VINStrument subsystem used for VME data transfers are shown below: VINStrument [:CONFigure] :VME :FEED :MEMory :INITiate [:MODE] :SEND :ADDRess :DATA? VME Bus Transfer Programming Sequence To configure the digitizer for VME bus data transfers: • Use the CONFigure command and the low-level digitizer commands to specify the number of readings, the expected value of the readings, the input port, the arm source, etc.
Setting the VME bus Data Source The source of the readings transferred over the VME bus is set with the command: VINStrument[:CONFigure]:VME:FEED The parameters are given below. Sources beginning with "MEMory: " are the post measurement sources (modes), sources beginning with "CONVerter: " are the real time sources (modes). " MEMory:CHANnel1": Channel 1 memory is the data source for the VME bus. One 16-bit reading is returned.
Reading the Data Register As shown in Figure 3-12, the digitizer’s data register is mapped into the HP E1406 Command Module’s A24 address space. A command used to read the data register is the Command Module command: DIAGnostic:PEEK?
, : the address (A24 base + offset) of the data register : the number of bits per digitizer reading. For the VME transfer modes, width is 16 (bits) with the exception of modes "MEMory:BOTH32" and "CONVerter:BOTH32", which are 32 bits.To transfer segmented readings, the data register is accessed until each reading (pre- and post-arm) in the segment is transferred. After the last reading is transferred, bit 1 of the arm status register (base +4316) or bit 9 of the condition register is monitored for a low to high transition. When the bit is high (’1’), the next segment can be transferred. Figure 3-13.
Multiple VME Bus Data Transfers During real time data transfers, readings are taken directly from the A/D converter and sent to the VME bus. These readings are also stored in digitizer memory. Transferring (real time or post measurement) readings from memory does not remove the readings from memory. As a result, a set of readings can be transferred to the VME bus multiple times.
Local Bus Data Transfers This section describes the use of the VXI backplane Local bus. The HP E1429B digitizer uses the Local bus for high-speed (80 MBytes/second) data transfers between two or more devices installed in adjacent mainframe slots. Local Bus Description The Local bus is a set of 12 signal lines on the backplane P2 connector. The Local bus is segmented such that each device with Local bus capability has two interfaces, one to each of the modules in the physically adjacent slots.
A Local bus key (Figure 1-1) prevents devices with incompatible Local bus signal levels from being installed in adjacent slots. How Data is Transferred Data is transferred over the Local bus in units of blocks and frames (Figure 3-15). A frame consists of a series of blocks, and each block is a stream of data bytes generated by a single device. If only one device is generating data, then the block size and frame size are the same. Figure 3-15.
Generate: In this mode, a device is sending data to the Local bus. Consume: In this mode, a device is receiving data from the Local bus. Pipeline: In this mode, a device is neither generating nor consuming data. Data is passed through from the device on the left to the device on the right. Append: In this mode, a device pipelines the data until the end-of-frame flag is detected. When the flag is detected, the device appends its block of data and sets new end-of-block and end-of-frame flags.
Digitizer Local Bus Commands The commands used to configure the HP E1429B digitizer for Local bus data transfers are part of the VINStrument subsystem: VINStrument [:CONFigure] :LBUS :FEED :MEMory :INITiate [:MODE] :RESet :SEND :POINts :AUTO :TEST :DATA Local Bus Transfer Configurations The programming sequence used for Local bus transfers depends on the transfer configuration.
Single Digitizer In a single digitizer configuration, the digitizer is usually the data generator and a device such as the HP E1488 memory card is the consumer. With this configuration, the programming sequence is: 1. Use the CONFigure command and the low-level digitizer commands to configure the digitizer for the required measurements. 2.
1. Use the CONFigure command and the low-level digitizer commands to configure the digitizers for the required measurements. 2. Use the VINStrument subsystem to reset the leftmost digitizer’s Local bus chip, to set the Local bus transfer mode to generate, and to set the data source (post measurement or real time transfer).
Setting the Local Bus Transfer Mode The Local bus transfer mode is set with the command: VINStrument[:CONFigure]:LBUS[:MODE] The parameters are: APPend: Local Bus data is received from the left, and passed on to the right until an end of frame is detected. When end of frame is received from the left side, all data from this module is appended, followed by an end of block marker and a new end of frame. After sending the end of frame marker, the module enters the paused state.
Setting the Local Bus Data Source The source of the readings transferred over the Local bus is set with the command: VINStrument[:CONFigure]:LBUS:FEED The parameters follow. Sources beginning with "MEMory: " are the post measurement sources, sources beginning with "CONVerter:" are the real time (A/D) sources. The Local bus data source is independent of any Local bus transfer mode. " MEMory:CHANnel1" : Channel 1 memory is the data source for the Local bus.
Additionally, if the transfer configuration involves multiple digitizers, appender digitizer readings will follow the generator digitizer readings. Inserter digitizer readings will precede the generator digitizer readings. Data in the packed format are left-justified, signed 2’s complement numbers (Figure 3-8). See "Packed Reading Conversions" on page 134 for information on converting the readings to voltages.
The Digitizer Status Registers This chapter describes the HP E1429 digitizer status system. Included is information on the STATus subsystem commands, the status groups used by the digitizer, the conditions monitored by each group, and information on how to enable a condition to interrupt a computer.
Questionable Signal Status Group Condition Register STATus:QUEStionable:CONDition? Transition Filter STATus:QUEStionable:NTRansition STATus:QUEStionable:PTRansition Event Register STATus:QUEStionable[:EVENt]? Enable Register STATus:QUEStionable:ENABle Status Byte (Summary bit) Standard Event Status Group Event Register Enable Register *ESE Operation Status Group Transition Filter 0 1 1 2 2 QUES QUES MAV MAV ESB ESB RQS X *ESR? (Summary bit) C
The Questionable Signal Status Group The Condition Register 15 14 13 The digitizer’s Questionable Signal status group monitors overload conditions, the frequency accuracy of the divide-by-n reference source, and error conditions in non-volatile calibration memory. Overload conditions, divide-by-n frequency accuracy, and non-volatile calibration memory errors are monitored with the following bits in the Condition register. All other bits are unused.
NTRansition sets the negative transition. For each bit unmasked, a 1-to-0 transition of that bit in the Condition register sets the associated bit in the Event register. PTRansition sets the positive transition. For each bit unmasked, a 0-to-1 transition of that bit in the Condition register sets the associated bit in the Event register. is the decimal, hexadecimal (#H), octal (#Q), or binary (#B) value of the Condition register bit to be unmasked.
The Condition Register 15 14 13 Calibration, waiting for an arm signal, execution of the INITiate:IMMediate command, and memory partitioning are monitored with the following bits in the Condition register. All other bits are unused. 12 unused 11 10 9 8 READY BUSY 7 6 ARM 5 4 3 2 1 unused 0 CAL CALibrating: Bit 0 is set (1) during calibration. The bit is cleared (0) otherwise. Waiting for ARM: Bit 6 is set (1) when the digitizer enters the wait-for-arm state.
is the decimal, hexadecimal (#H), octal (#Q), or binary (#B) value of the Condition register bit to be unmasked. (Bits 0, 6, 8, and 9 have corresponding decimal values of 1, 64, 256, and 512.) The Event Register The Event register latches transition events from the Condition register as specified by the Transition Filter.
Device Dependent Error (DDE): Bit 3 is set (1) when an error other than a command error, execution error, or query error has occurred. Query Error (QYE): Bit 2 is set (1) when the digitizer output queue is read and no data is present, or when data in the output queue has been lost. Operation Complete (OPC): Bit 0 is set (1) when the *OPC command is received. *OPC is used to indicate when all pending (or previous) digitizer commands have completed.
The Status Byte Status Group The Status Byte Register The registers in the Status Byte Status Group enable conditions monitored by the other status groups to generate a service request. The Status Byte register contains the summary bits of the Questionable Signal Status Group (QUES), the Operation Status Group (OPER), and the Standard Event Status Group (ESB). The register also contains the message available bit (MAV) and the service request bit (RQS).
Reading the Status Byte Register The Status Byte register can be read with either of the following commands: *STB? SPOLL Both commands return the decimal weighted sum of all set bits in the register. The difference between the commands is that *STB? does not clear bit 6 (RQS service request). The serial poll (SPOLL) does clear bit 6. All bits in the Status Byte register with the exception of MAV are cleared with the command: *CLS MAV is cleared when data is read from the output queue.
Synchronizing the Digitizer One method of synchronizing the digitizer with other digitizer’s or with other instruments is to determine when the digitizer parser is idle. This is done using the command: STATus:OPC:INITiate together with the commands: *OPC *OPC? *WAI The behavior of *OPC, *OPC?, and *WAI depends on the state set by STATus:OPC:INITiate.
How to Save and Recall a Configuration Digitizer configurations are saved and recalled with the commands: *SAV *RCL where register is a number from 0 to 9. The following example shows how a configuration can be saved and recalled.
Notes 176 Understanding the HP E1429 Digitizer Chapter 3
Chapter 4 Command Reference Chapter Contents This chapter describes the Standard Commands for Programmable Instruments (SCPI) command set and the IEEE 488.2 Common Commands for the HP E1429A/B 20 MSa/s 2-Channel Digitizer. Included in this chapter are the following sections: • • • • • • • • Command Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . SCPI Command Format. . . . . . . . . . . . . . . . . . . . . . . . . . . . . SCPI Command Parameters. . . . . . . . . . . . . . . . . .
MEASure . . . . . . . . . . . . . . . . . . . . . . . . 236 MEMory . . . . . . . . . . . . . . . . . . . . . . . . . :BATTery . . . . . . . . . . . . . . . . . . . . . . [:STATe] . . . . . . . . . . . . . . . . . . . . . :CHARge? . . . . . . . . . . . . . . . . . . . 240 240 240 241 OUTPut . . . . . . . . . . . . . . . . . . . . . . . . . :ECLTrg.. . . . . . . . . . . . . . . . . . . . :FEED . . . . . . . . . . . . . . . . . . . . . . . [:STATe] . . . . . . . . . . . . . . . . . . . . . :EXTernal[1]. .
SCPI Command Format The HP E1429 digitizer is programmed with SCPI commands. SCPI commands are based on a hierarchical structure, also known as a tree system. In this system, associated commands are grouped together under a common node or root, thus, forming subtrees or subsystems. An example is the digitizer’s ’ARM’ subsystem shown on the following page.
Implied (Optional) Keywords Implied or optional keywords are those which appear in square brackets ([ ]). The brackets are not part of the command syntax and must not be sent to the digitizer. Consider the syntax ARM[:STARt]COUNt. Suppose you send the following command: ARM:COUN 100 In this case, the digitizer responds as if you had executed the command as: ARM:STAR:COUN 100 Variable Command Syntax Some commands will have what appears to be a variable syntax.
• Discrete Selects from a finite number of values. These parameters use mnemonics to represent each valid setting. An example is the TRIGger[:STARt]:SOURce command where source can be BUS, ECLTrg0, ECLTrg1,EXTernal1, EXTernal2, ... • String STRING PROGRAM DATA parameters are enclosed with single quotation marks (’) or double quotation marks ("). Examples of string program data parameters are those associated with the OUTPut...
Definite length block: # Where the value of equals the number of . The value of taken as a decimal integer indicates the number of in the block. Optional Parameters Command parameters shown within square brackets ([ ]) are optional. The brackets are not part of the syntax and are not sent to the digitizer. If you do not specify a value for an optional parameter, the instrument chooses a default value.
Command couplings can often result in “ Settings conflict” errors when the program executes. When a coupled command is executed, the command setting is evaluated by the digitizer processor. If the setting causes an illegal digitizer configuration, a "Settings conflict" error occurs. The error message lists the conflicting settings, and then reports the values set by the digitizer processor.
Linking Commands Linking commands means sending multiple commands in the same output string. This is done to avoid "settings conflict" errors since (command) coupling interactions are not resolved until the carriage return (CR) is received. Linking IEEE 488.2 Common Commands Use a semicolon between the commands. For example: *RST;*CLS;*OPC? Linking Multiple SCPI Commands A semicolon (;) is used to separate commands within the same subsystem and saves typing.
ABORt ABORt The ABORt command removes the HP E1429 from the wait-for-trigger state and places it in the idle state, irrespective of any other settings. Measurement is halted and can only be restarted by another INITiate[:IMMediate] command. There is no query form of this command. Comments • ABORt does not affect any other settings of the HP E1429. • Both measurement channels are aborted with this command. • Local bus and VME bus data transfers are aborted.
ARM The ARM command subsystem controls the third state in a four state measurement process. The four states which occur during a successful reading are idle, initiated, wait-for-arm, and wait-for-trigger. The last two states have event detection associated with them which control when they exit the current state. These four states are more fully described as follows: • Idle -- In this state, the instrument is not sampling. This is the state where setting changes are done via commands to the instrument.
ARM[:STARt]:COUNt • The active edge for generation of an arm event (ARM:STARt:SLOPe) on the selected arm source (n = 1 or n = 2). • The measurement signal level to attain before allowing a measurement to begin (ARM:STARt:LEVel). This is used with ARM:SOURce INTernal. It is also possible to create a window bounded by two levels (ARM:LEVel:POSitive and ARM:LEVel:NEGative) such that arming occurs when the signal level either exits or enters the defined window.
ARM[:STARt]:COUNt Parameters Parameter Name Parameter Type Range of Values Default Units count numeric 1 through 65535 | MINimum|MAXimum| 9.9E+37|INFinity none MINimum selects 1 arm. When only post-arm readings are specified, MAXimum is computed as: 524,288 / TRIGger:COUNt, up to a maximum of 65,535 arms . When pre-arm readings have been specified, MAXimum selects 128 arms. 9.9E+37 is equivalent to INFinity. Comments • Executable when initiated: No • Coupled Command: Yes.
ARM[:STARt]:COUNt ARM:STARt:COUNt Number of Memory Segments Maximum Readings (TRIGger:STARt:COUNt) 1 1 524,288 2 2 262,144 3-4 4 131,072 5-8 8 65,536 9 - 16 16 32,768 17 - 32 32 16,384 33 - 64 64 8,192 65 - 128 128 4096 NOTE: If the non-volatile mode of memory is enabled (MEMory:BATTery:STATe ON), then all of the maximum reading counts shown above decrease by four. These four memory locations in each segment hold the data necessary to recover all readings after a power failure.
ARM[:STARt]:DELay • Related Commands: ABORt, INITiate:IMMediate, TRIGger:STARt:COUNt, SENSe:SWEep:POINts, SENSe:SWEep:OFFSet:POINts • *RST Condition: ARM:STARt:COUNt 1 Example Setting the arm count ARM:COUN 10 Set 10 measurement cycles per INITiate [:STARt]:DELay ARM[:STARt]:DELay specifies how long to delay entering the wait-for-trigger state after the arming pulse is received and processed.
ARM[:STARt][:IMMediate] • The actual delay time after receipt of arm event is not precisely the delay time specified above. There is an inherent delay of typically 230 ns plus an amount of sample period uncertainty. Refer to Appendix A - "Specifications" for additional information on the inherent delay. • Related Commands: TRIGger:STARt:COUNt, SENSe:SWEep:OFFSet:POINts • *RST Condition: ARM:STARt:DELay 0 Example Setting the arming delay ARM:DEL .
ARM[:STARt]:LEVel[]:NEGative Example Arming for measurement ARM:SOUR1 EXTernal Set arming source1 to be the EXT1 BNC connector INITiate Begin measurement, wait for arming pulse ARM Arm start trigger immediately, don’t wait for external pulse [:STARt]:LEVel[]:NEGative ARM[:STARt]:LEVel[]:NEGative selects the input voltage level which will arm a measurement cycle.
ARM[:STARt]:LEVel[]:POSitive Example Setup to arm only when the signal on channel 2 falls through -0.48 volts. ARM:SOUR1 INT2 Set arming source 1 to arm when the specified level is met on channel 2 ARM:SLOP1 NEG The signal must fall through the level set by ARM:LEVel2:NEG for arming to occur ARM:LEV2:NEG -0.48 Arm when the signal passes through the -.
ARM[:STARt]:SLOPe[] • When POSitive and NEGative voltage levels are specified, the levels must be separated by an amount defined by: (50 mV / 1.0235V) * measurement range This accounts for offset errors in the levels specified, and enables arms at those levels to be accepted. • Related Commands: ARM:STARt:SOURce, ARM:STARt:SLOPe • *RST Condition: ARM:STARt:LEVel:POS 1.022418 Example Setup to arm when the signal on channel 1 goes outside of a the window bounded by 0.5V and 0V.
ARM[:STARt]:SLOPe[] Comments • Executable when initiated: No • Coupled Command: Yes. A settings conflict error occurs if ARM:STARt:SLOPe EITHer is set and ARM:STARt:SOURce EXTernal is set.The EITHer setting is only valid when the associated ARM:STARt:SOURce is set to INTernal. • ARM:STARt:SLOPe1 controls the slope on ARM:STARt:SOURce1 and ARM:STARt:SLOPe2 controls the slope on ARM:STARt:SOURce2. Note that ’1’ and ’2’ refer to the arm source and not a channel number.
ARM[:STARt]:SOURce[] [:STARt]:SOURce[] ARM[:STARt]:SOURce[] configures the arm system to respond to the specified source(s). Unless one of the two sources is set to HOLD, both will be active, and an occurrence of the selected event on either source will arm the system for measurement. The sources available are: • BUS: The Group Execute Trigger (GET) HP-IB command or the IEEE-488.2 *TRG common command. • ECLTrg0 and ECLTrg1: The VXIbus ECL trigger lines.
ARM[:STARt]:SOURce[] Parameters Parameter Name Parameter Type Range of Values Default Units n decimal 1|2 none source discrete BUS|ECLTrg0| ECLTrg1|IMMediate| EXTernal1|INTernal[1]| INTernal2|HOLD TTLTrg0 to TTLTrg7 none Choice IMMediate is only available for ARM:STARt:SOURce1. Comments • Executable when initiated: No • Coupled Command: Yes. The command is coupled to the ARM[:STARt]:SLOPe[], ARM[:STARt]:LEVel:NEGative, and ARM[:STARt]:LEVel:POSitive commands.
CALibration[] The CALibration command subsystem is used in the calibration of the HP E1429. The HP E1429 has commands to prevent and detect accidental or unauthorized calibration of the instrument. The CALibration subsystem includes both these security-related commands and the actual calibration commands.
CALibration[]:DATA • Executing the CALibration:GAIN, or CALibration:ZERO commands with calibration security disabled (CALibration:SECure:STATe OFF set) and with CALibration:STORe:AUTO ON, increments the calibration number by one. With CALibration:STORe:AUTO ON, a complete calibration of all input ranges increments the number by several counts.
CALibration[]:DATA Comments • Executable when initiated: No • Coupled Command: No • Sending calibration constants with this command will cause the HP E1429 to calibrate to these constants. A check is done on the values before usage and an error (-222 "Data out of range") results if they are not within a valid range.
CALibration[]:DELay Each channel contains 62 calibration constants. The following list describes what the constant is at each array index location. The array is assumed to start with index number 0. Index 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 Contents Index offset for 1.
CALibration[]:GAIN Comments • Executable when initiated: No • Coupled Command: No • Before executing this command, both channels must be set to the single-ended setting and 1.0235 volt range. This can be accomplished by executing either *RST or the combination of CONF:ARR:VOLT (1),1.0,(@1) with CONF2:ARR:VOLT (1),1.0,(@2). • This setting was calibrated before the HP E1429 left the factory. Under normal conditions, it is not necessary to execute this command again.
CALibration[]:GAIN Parameters Parameter Name Parameter Type Range of Values Default Units chan numeric 1 or 2 none readings numeric 100 to 32767 |DEFault none period numeric reference period to reference period * 4E8 |DEFault Seconds flag boolean ON | OFF | defaults to ON none Comments • Executable when initiated: No • Coupled Command: No • Before executing CALibration[]:GAIN you must do the following steps.
CALibration[]:GAIN sample rate, the command would appear as: CAL:GAIN DEF, .05, one • CALibration:GAIN forces the internal reference (20 MHz) oscillator to be used. Sample rates are attained using that reference. • The default number of readings is 1000, and the default period is 1.0E-4 seconds. These numbers were chosen such that the product of the two is a period that is an integral multiple of both 50 Hz and 60 Hz line cycles (.1 seconds in this case).
CALibration[]:SECure:CODE :SECure:CODE CALibration[]:SECure:CODE sets the code which is required to disable calibration security. Calibration security must have been previously disabled.
CALibration[]:SECure:STATe :SECure:STATe CALibration[]:SECure:STATe ,[] enables or disables calibration security. Disable the calibration security to calibrate the HP E1429, change the security code, or change the protected user data.
CALibration[]:STORe :STORe CALibration[]:STORe stores the current calibration constants into non-volatile calibration memory. Parameters Parameter Name Parameter Type Range of Values Default Units chan numeric 1 or 2 none Comments • Executable when initiated: No • Coupled Command: No • CALibration:SECure:STATe must be OFF before executing this command.
CALibration[]:STORe:AUTO :STORe:AUTO CALibration[]:STORe:AUTO selects whether or not the calibration constants will be automatically stored when commands like CALibration:GAIN and CALibration:ZERO complete.
CALibration[]:VALue Maximum Gain Calibration Values (V) Voltage Range (Volts) Allowable Ports -.10180 and .10185 0.10235 1,2,3,4 -.2036 and .2037 0.2047 1,2,3,4 -.5090 and .50925 0.51175 1,2,3,4 -1.0180 and 1.0185 1.0235 1,2,3,4 -2.036 and 2.037 2.037 3,4 -5.090 and 5.0925 5.1175 3,4 -10.180 and 10.185 10.235 3,4 -20.360 and 20.370 20.37 3,4 -50.900 and 50.925 51.175 3,4 -101.80 and 101.85 102.35 3,4 < -48.925 and > 48.975 102.
CALibration[]:ZERO Example Setting the calibration value CAL2:VAL 5.00 Input on channel 2 is 5.00 V :ZERO CALibration[]:ZERO [[,,[]]] performs a calibration of the zero offset using the specified number of readings and sample rate on the specified range(s). When this command completes, the new calibration constants will be automatically stored to non-volatile calibration memory unless the CALibration:STORe:AUTO command is set to OFF.
CALibration[]:ZERO • MINimum and MAXimum are not allowed with this command. • Optional parameters that are left blank are filled from left to right. Therefore, it may be necessary to use the syntax DEFault to note that a particular parameter has been defaulted. For example, to default the number of readings and specify a sample rate, the command would appear as: CAL:ZERO DEF, .05, one • CALibration:ZERO forces the internal reference (20 MHz) oscillator to be used.
CONFigure[] The CONFigure subsystem provides a fast way to place the HP E1429 into a known state, ready to take measurements. An INITiate;FETCh? is then all that is necessary to take a measurement after the CONFigure command has been executed. If desired, CONFigure may be used to quickly get to a known state, from which other states such as TRIGger:STARt:SOURce or TRIGger:STARt:TIMer can be "fine tuned" to desired values before the INITiate;FETCh? sequence is executed.
CONFigure[]:ARRay:[VOLTage][:DC] Parameters Parameter Name Parameter Type Range of Values Default Units chan numeric 1|2 none size numeric 1 | 7 to 524288 none expected value numeric -102.30 to 102.35 | DEFault | MINimum | MAXimum volts resolution numeric .00005 to .
CONFigure[]:ARRay:[VOLTage][:DC] Maximum Expected Value (V) Voltage Range (Volts) Resolution (Volts) ± .1 0.10235 .00005 ± .2 0.2047 .00010 ± .5 0.51175 .00025 ±1 1.0235 .0005 ±2 2.047 .0010 ±5 5.1175 .0025 ± 10 10.235 .005 ± 20 20.47 .010 ± 50 51.175 .025 ±100 102.35 .05 Comments • Executable when initiated: No • Coupled Command: No • If no input port is given, CONFigure1 defaults to (@1) and CONFigure2 defaults to (@2).
CONFigure[]:ARRay:[VOLTage][:DC] • The CONFigure command configures the HP E1429 to do the measurement specified by the parameters given with CONFigure. All instrument settings will be forced to their *RST values, with the following exceptions. In particular, note that all OUTPut signals are turned off and their FEED’s are changed to reset values, and that both the local bus (VINStrument:LBUS) and VME bus (VINS:VME) are turned off.
DIAGnostic The DIAGnostic subsystem contains several commands which were developed to test the instrument at the factory. Several of these commands may prove useful for trouble shooting or special applications, and so they are written up here.
DIAGnostic:CALibration[]:GAIN:SENSitivity? :CALibration[]:GAIN:SENSitivity? DIAGnostic:CALibration[]:GAIN:SENSitivity? returns a real number which is the sensitivity constant calculated for use during the most recently executed CAL:GAIN command. The channel parameter is irrelevant because the data returned always applies to the last executed CAL:GAIN command regardless of which channel was involved.
DIAGnostic:FETCh? useful for tagging data which is going out over the local bus or VME bus when multiple channels or HP E1429’s are involved.
DIAGnostic:FETCh? • Refer to the "Memory Management" section in Chapter 3 for information on where segmented readings are stored in memory. • Both channels can be fetched interleaved by specifying DIAG:FETC3?. When both channels are fetched, the channel 1 data is the first data point, and the count specified is the number of readings to be taken on each channel, and is thus limited to 1000 per channel. • The start_addr must be divisible by 4.
DIAGnostic:MEMory[]:FILL :MEMory[]:FILL DIAGnostic:MEMory[]:FILL sets up num_segments in memory and fills each with count readings. Each data point is calculated from the formula: data = (((current_segment - 1) * 10 + n) modulo 2000) * 16 Where n is the data point of interest between 1 and count. Only the specified channel is filled with these data points, the other channel is filled with reading values of 0.
DIAGnostic:PEEK? • The wrapped bit (bit 0) usually indicates that enough pre-arm data was taken to cause data to be overwritten, since each segment is a circular buffer. It is possible for a wrapped bit to be set even though no data was actually overwritten. This occurs because the address counter always points to the next location in memory that is to be filled, and therefore a false wrap indication will occur if exactly "buffer size" data points were taken.
DIAGnostic:POKE Comments • Executable when initiated: Yes • Coupled Command: No • The specified address is assumed to be relative to the local processor and is not the A24 offset, but is instead the full address (i.e. E0000C16 would specify the data register, as opposed to the VME A24 offset of C16).
DIAGnostic:SGET? :SGET? DIAGnostic:SGET? returns the state (0 or 1) of the specified bit of the serial control register. This register is the one which controls things such as signal conditioning, signal routing, input filter state, and input impedance.
FETCh[] The FETCh? command is used in conjunction with the INITiate:IMMediate command to obtain readings. The FETCh:COUNt command is used to indicate how many readings are available. Subsystem FETCh[]? :COUNt? Syntax :RECover? [query only] [query only] [query only] FETCh? FETCh[]? returns readings from the specified channel in the format set by the FORMat:DATA command. An INITiate:IMMediate command must have been issued previously or else error -230, "Data corrupt or stale" will occur.
• The data may be read any number of times, as long as no parameters have changed which could affect new data (such as changing TRIGger:STARt:COUNt, ARM:STARt:COUNt, SENSe:SWEep:OFFSet:POINts, *RST, *RCL, etc.). If any measurement parameters are changed, then error -230;"Data corrupt or stale" will occur. • The number of readings that FETCh? is going to return for each channel can be determined two ways. The simplest way is to use the FETCh:COUNt? query. This will return how many readings will be fetched.
FETCh[]:COUNt? Example 2 Reading back PACKed data (HP BASIC program) DIM Ndig$[1],Count$[9] Dimension parameters for header ASSIGN @X TO 70905;FORMAT OFF Turn format off for array data OUTPUT 70905;"FETC1?" Query for channel 1 measurement data ENTER @X USING "#,X,K,K";Ndig$;Count$[1;VAL(Ndig$)] Strip the header preceeding the data ALLOCATE INTEGER Meas_data(1:VAL(Count$)/2) Allocate an array to hold the data ENTER @X;Meas_data(*) Read in the measurement data ENTER 70905 USING "B";Junk Need to s
FETCh[]:RECover? :RECover? FETCh[]:RECover? returns readings from the specified channel in the format set by the FORMat:DATA command. This command is used to fetch data that was saved during a power failure and which cannot be fetched by the FETCh? command due to the "Data corrupt or stale" error. Parameters Parameter Name Parameter Type Range of Values Default Units chan numeric 1|2 none Comments • Executable when initiated: No • Coupled Command: No.
FORMat The FORMat command subsystem is used to specify the output format of the readings from the HP E1429 Digitizer. Subsystem FORMat [:DATA] [,] Syntax [:DATA] FORMat[:DATA] [,] specifies the output format for measurement data.
FORMat[:DATA] • ASCii,9 format sends data back as comma separated ASCII numbers. The data is converted internally to reflect the SENSe:VOLTage:RANGe setting, and no further conversion is needed by the user. The optional parameter 9 is the number of significant digits in the data. This parameter is always 9 and may not be changed. To read this data into an array, it is first necessary to determine how many readings are coming back from the FETCh? or READ? .
INITiate The INITiate subsystem controls the initiation of the trigger subsystem and prepares the HP E1429 to take voltage measurements. Once initiated, triggers are armed on both channels, and a trigger received from the programmed source (TRIGger:STARt:SOURce command) will cause voltage measurements to begin on both channels. Normally, all measurement setup (setting measurement ranges, arm and trigger sources, etc.) should be done before this command is sent.
INITiate[:IMMediate] Readings may not be obtained from memory until the trigger system has returned to the idle state. The FETCh? and READ? commands may be invoked before the trigger system is in the idle state. These commands will wait until the trigger system is idle before returning readings. The trigger idle state may be determined externally from the high-to-low transition of the BUSY bit (bit 8) of the STATus:OPERation:CONDition register.
INPut[] The INPut command subsystem controls characteristics of the input signal, including state (on/off), low-pass filtering, and input source impedance. There are two types of input ports on the HP E1429, single ended and differential, for a total of 4 input ports. Since this is a two channel instrument, two input ports share each channel. The differential input ports are labeled ports 3 and 4. Input ports 1 and 2 are single ended. Ports 1 and 3 share channel 1, and ports 2 and 4 share channel 2.
INPut[]:FILTer[:LPASs][:STATe] :FILTer[:LPASs][:STATe] INPut[]:FILTer[:LPASs][:STATe] enables or disables the 10 MHz input filter.
INPut[][:STATe] Parameters Parameter Name Parameter Type Range of Values Default Units port numeric 1|2|3|4 none impedance numeric 50|75|1.0E6|1MOHM| MINimum|MAXimum Ohms Input ports 1 and 2 : MINimum selects 50Ω; MAXimum selects 75Ω. Input ports 3 and 4 : MINimum selects 1 MΩ; MAXimum selects 1 MΩ.
INPut[][:STATe] Comments • Executable when initiated: Yes • Coupled Command: No • Enabling or disabling the input port while the digitizer is taking readings (initiated) may cause unexpected reading values due to relay settling during the transition.
MEASure[] The MEASure? query subsystem provides a complete measurement sequence, including configuration and reading of the data. MEASure? is used when the generic measurement is acceptable and default triggering and timebase values may be used. The MEASure? query is the same as doing the command sequence of ABORt;CONFigure;INITiate;FETCh?.
MEASure[]:ARRay[:VOLTage][:DC]? Parameters Parameter Name Parameter Type Range of Values Default Units chan numeric 1|2 none size numeric 1 | 7 to 524288 none expected value numeric -102.30 to 102.35 | DEFault | MINimum | MAXimum volts resolution numeric .00005 to .
MEASure[]:ARRay[:VOLTage][:DC]? Maximum Expected Value (V) Voltage Range (Volts) Resolution (Volts) ± .1 0.10235 .00005 ± .2 0.2047 .00010 ± .5 0.51175 .00025 ±1 1.0235 .0005 ±2 2.047 .0010 ±5 5.1175 .0025 ± 10 10.235 .005 ± 20 20.47 .010 ± 50 51.175 .025 ±100 102.35 .05 Comments • Executable when initiated: No • Coupled Command: No • If no input port is given, MEASure1 defaults to (@1) and MEASure2 defaults to (@2).
MEASure[]:ARRay[:VOLTage][:DC]? • The MEASure command configures the HP E1429 to do the measurement specified by the parameters given with MEASure. All instrument settings will be forced to their *RST values, with the following exceptions. In particular, note that all OUTPut signals are turned off and their FEED’s are changed to reset values, and that both the local bus (VINStrument:LBUS) and VME bus (VINS:VME) are turned off.
MEMory The MEMory subsystem controls whether memory will be non-volatile and determines the battery charge. Subsystem MEMory :BATTery Syntax [:STATe] CHARge? [query only] :BATTery[:STATe] MEMory:BATTery[:STATe] enables or disables non-volatile memory. If state ON (1) is set, then measurement data will be preserved in the HP E1429A’s internal memory when power fails or the instrument is turned off.
MEMory:BATTery:CHARge? :BATTery:CHARge? MEMory:BATTery:CHARge? returns 1 if the battery has sufficient charge to maintain memory, and returns 0 if the battery has insufficient charge to maintain memory.
OUTPut The OUTPut subsystem controls which output path (if any) will receive the synchronization pulses generated by the HP E1429. Sync pulses can be sent to the "Ext 1" BNC, the VXI TTL trigger lines, the VXI ECL trigger lines, or any combination of these three.
OUTPut:ECLTrg[:STATe] Note These pulses will also be generated when data is read out of memory from the VINStrument:LBUS or VINStrument:VME subsystems.
OUTPut:EXTernal[1]:FEED Parameters Parameter Name Parameter Type Range of Values Default Units n numeric 0|1 none mode boolean OFF|0|ON|1 none Comments • Executable when initiated: No • Coupled Command: Yes, this command will cause a settings conflict error if the same ECLTRG trigger line is used in any of the following: SENSe:ROSCillator:SOURce, ARM:STARt|SEQuence1:SOURce1, ARM:STARt|SEQuence1:SOURce2 or TRIGger:STARt|SEQuence1:SOURce.
OUTPut:EXTernal[1]:FEED “ [SENSe[1|2]]:SWEep:OFFSet:POINts”: Changes the normally high output level to low after the pre-arm count (SENSe:SWEep:OFFSet:POINts) has been met. This would be used to determine when an arming event could occur without getting an "Arm ignored" error due to the pre-arm count not being satisfied. The level would not return to high again until either the next arm cycle (if ARM:STARt:COUNt > 1) or the next INITiate command if this is the last or only arm cycle.
OUTPut:EXTernal[1][:STATe] Comments • Executable when initiated: No • Coupled Command: No • Related Commands: OUTPut:EXTernal[1]:[:STATe] • *RST Condition: OUTPut:EXTernal:FEED “ TRIGger:STARt” Example Setting the sync pulse source OUTP:EXT:FEED “ROSC” Output the reference oscillator pulses :EXTernal[1][:STATe] OUTPut:EXTernal[1][:STATe] enables or disables output of the synchronization pulse on the front panel "Ext 1" BNC.
OUTPut:TTLTrg:FEED “ ARM[:START|:SEQuence[1]]”: Changes the normally high output level to low as soon as an ARM event (ARM:STARt:SOURce) is processed. The level remains low until the ARM cycle is completed by TRIGger:STARt:COUNt readings being taken. This signal begins at the detection of the arm event, and does not include any programmed delay (ARM:STARt:DELay). The expected use of this signal is to allow a master module to detect an arm event and then arm other modules by using this signal.
OUTPut:TTLTrg[:STATe] :TTLTrg[:STATe] OUTPut:TTLTrg[:STATe] enables or disables routing of the synchronization pulse to the specified VXIbus TTL trigger lines (TTLTRG0* through TTLTRG7*). Parameters Parameter Name Parameter Type Range of Values Default Units n numeric 0 through 7 none mode boolean OFF|0|ON|1 none Comments • Executable when initiated: No • Coupled Command: Yes.
READ[] The READ? command is used to cause a measurement and to retrieve the readings from that measurement. It is equivalent to executing the commands: ABORt, INITiate:IMMediate, FETCh?. Subsystem READ[]? Syntax [query only] READ? READ[]? returns readings from the specified channel in the format specified by the FORMat:DATA command.
The number of pre-arm readings may be determined by taking the absolute value of the query SENSe:SWEep:OFFSet:POINts? which returns either 0 (no pre-arm readings) or a negative number which is the pre-arm count. If the measurements were ABORted, use FETCh:COUNt? to determine the number of readings. • Using the above method, it is also possible to calculate the end of pre-arm data and the beginning of post-arm data when both are present in a measurement.
SENSe The SENSe subsystem is used to specify the reference oscillator frequency (if external) and source, the input port used on a particular channel, and the pre-arm and post-arm reading counts. Each section of the subsystem is separately documented in the following sections of the Command Reference.
[SENSe[]]:FUNCtion The SENSe:FUNCtion commands select which of the input ports gets connected to a particular channel. SENSe1 selects the input for the sensor on channel 1 (ports 1 or 3), and SENSe2 selects the input for the sensor on channel 2 (ports 2 or 4). Subsystem [SENSe[]] :FUNCtion "" Syntax [SENSe[]]:FUNCtion [SENSe[]]:FUNCtion "" determines which input port will be connected to the specified sensing channel.
[SENSe[]]:FUNCtion [SENSe[]]:FUNCtion • *RST Condition: SENSe1:FUNCtion "VOLT1", SENSe2:FUNCtion "VOLT2" Example Selecting the single ended input on channel 2 SENS2:FUNC “VOLT4” [SENSe[]]:FUNCtion Subsystem Connect port 4 to channel 2 Command Reference 253
[SENSe[]]:ROSCillator The SENSe:ROSCillator subsystem controls the reference oscillator source and frequency used to generate sample rates for taking measurements. Subsystem [SENSe[]] :ROSCillator Syntax :EXTernal :FREQuency :SOURce Since the triggering and timebase circuits of the HP E1429 are shared between both sensing channels, the settings for [SENSe[]]:ROSCillator are the same for both values of chan (1 and 2).
[SENSe[]]:ROSCillator:SOURce • Using MINimum or MAXimum to specify this frequency is not recommended unless the external reference frequency is 20 kHz (MINimum) or 20 MHz (MAXimum). In order for the digitizer processor to produce the intended sample rates, the exact frequency value must be specified.
[SENSe[]]:ROSCillator:SOURce • Use SENSe:ROSCillator:EXTernal:FREQuency to indicate the frequency of an external reference oscillator.
[SENSe[]]:SWEep The SENSe:SWEep commands select how many readings will be taken during a measurement, and how many of the readings occur before (pre-arm) and after (post-arm) the arm event. Since the triggering and timebase circuits of the HP E1429 are shared between both sensing channels, the settings for [SENSe[]]:SWEep are the same for both values of chan (1 and 2). Setting SENSe1:SWEep values will also set SENSe2:SWEep values and vice versa.
[SENSe[]]:SWEep:OFFSet:POINts Number of Memory Segments Maximum Number of Readings 1 524,288 2 262,144 4 131,072 8 65,536 16 32,768 32 16,384 64 8,192 128 4,096 NOTE: If the non-volatile mode of memory is enabled then the maximum number of readings for each memory partition decreases by four. These four memory locations in each segment hold the data necessary to recover all readings after a power failure.
[SENSe[]]:SWEep:OFFSet:POINts Comments • Executable when initiated: No • Coupled Command: Yes. This command is coupled to TRIGger:STARt:COUNt, SENSe:SWEep:POINts, ARM:STARt:COUNt, ARM:STARt:DELay, and MEMory:BATTery:STATe. • Readings which are taken before the arm event occurs are called "pre-arm" readings. Readings taken after the arm event are called "post-arm" readings. • The INITiate command "triggers" pre-arm readings.
[SENSe[]]:SWEep:POINts :POINts [SENSe[]]:SWEep:POINts specifies how many readings will be taken during each ARM:STARt:COUNt cycle of the trigger system. This command is the same as (and is coupled to) TRIGger:STARt:COUNt. Changing either changes the value of the other as well. Parameters Parameter Name Parameter Type Range of Values Default Units chan numeric 1|2 none count numeric 1 | 7 through 16,777,215 | MINimum|MAXimum| 9.
[SENSe[]]:SWEep:POINts Comments • Executable when initiated: No • Coupled Command: Yes. This command is coupled to TRIGger:STARt:COUNt, SENSe:SWEep:OFFSet:POINts, ARM:STARt:COUNt, and MEMory:BATTery:STATe. • SENSe:SWEep:POINts values between 1 and 7 will be rounded to 1 or 7, whichever is closer to the specified count. • If the count is set to INFinity or 9.
[SENSe[]]:VOLTage[:DC] The SENSe:VOLTage[:DC] commands select the voltage range, and report back the resolution associated with the selected range. Subsystem [SENSe[]] :VOLTage Syntax [:DC] :RANGe :RESolution? [query only] :RANGe [SENSe[]]:VOLTage[:DC]:RANGe selects the range for voltage measurement on the specified channel. Parameters Parameter Name Parameter Type Range of Values Default Units chan numeric 1|2 none range numeric -102.30 to 102.
[SENSe[]]:VOLTage[:DC] :RANGe Range Setting (V) Measurement Range (V) Resolution (Volts) Allowable 0.10235 -.10230 to .10235 .00005 1,2,3,4 0.2047 -.2046 to .2047 .00010 1,2,3,4 0.51175 -.5115 to .51175 .00025 1,2,3,4 1.0235 -1.0230 to 1.0235 .0005 1,2,3,4 2.047 -2.046 to 2.047 .0010 3,4 5.1175 -5.115 to 5.1175 .0025 3,4 10.235 -10.230 to 10.235 .005 3,4 20.470 -20.460 to 20.470 .010 3,4 51.175 -51.150 to 51.175 .025 3,4 102.35 -102.30 to 102.35 .
[SENSe[]]:VOLTage[:DC] :RESolution? Example Selecting the 102.35 Volt range on channel 2 SENS2:FUNC “VOLT4” Connect differential port 4 to channel 2 SENS2:VOLT:RANG 75 Select 102.35 volt range. Any number greater than 51.175 forces the next highest (102.35 V) range. :RESolution? [SENSe[]]:VOLTage[:DC]:RESolution? returns the resolution associated with the current SENS:VOLT:RANGe setting, on the specified channel.
STATus The STATus subsystem controls the SCPI-defined Operation and Questionable Signal status registers. Each is comprised of a condition register, an event register, an enable mask, and negative and positive transition filters. Each status register works as follows: when a condition occurs, the appropriate bit in the condition register is set or cleared. If the the corresponding transition filter is enabled for that bit, the same bit is set in the associated event register.
STATus:OPC:INITiate Questionable Signal Status Register Only bits 0 (VOLTage), 2 (TIME), and 8 (CALibration) are defined. All other bits are always 0. Bit 0 - VOLTage: Set (1) if an overload voltage is detected during a measurement. Cleared (0) otherwise. Bit 2 -TIME: Set (1) if the divide-by-n of the reference oscillator source can not generate a sample rate that is within 1% of the rate specified by TRIG:TIMer1 or TRIG:TIMer2. Cleared (0) otherwise.
STATus:OPERation|:QUEStionable:CONDition? Comments • Executable when initiated: Yes • Coupled command: No • Related commands: *OPC, *OPC?, *RST, *WAI, ABORt, INITiate:IMMediate, VINStrument:CONFigure:VME:MEMory:INITiate, VINStrument:CONFigure:LBUS:MEMory:INITiate, STATus:PRESet • *RST Condition: unaffected • Power-on Condition: STATus:OPC:INITiate ON Example Setting immediate completion mode STAT:OPC:INIT OFF Complete immediately for *OPC, etc.
STATus:OPERation|:QUEStionable[:EVENt]? Parameters Parameter Name Parameter Type Range of Values Default Units unmask numeric or non-decimal numeric 0 through +32767 none The non-decimal numeric forms are the #H, #Q, or #B formats specified by IEEE-488.2.
STATus:OPERation|:QUEStionable:NTRansition :OPERation|:QUEStionable:NTRansition STATus:OPERation|:QUEStionable:NTRansition sets the negative transition mask. For each bit unmasked, a 1-to-0 transition of that bit in the associated condition register will set the same bit in the associated event register.
STATus:PRESet Parameters Parameter Name Parameter Type Range of Values Default Units unmask numeric or non-decimal numeric 0 through +32767 none The non-decimal numeric forms are the #H, #Q, or #B formats specified by IEEE-488.2.
SYSTem The SYSTem command subsystem returns error messages and the SCPI version number to which the HP E1429A/B complies. Subsystem SYSTem :ERRor? Syntax :VERSion? [query only] [query only] ERRor? SYSTem:ERROR? returns the error messages in the error queue. See Appendix B for a listing of the digitizer error numbers and messages. Comments • As errors are detected, they are placed in the error queue.
TRIGger The TRIGger command subsystem controls the fourth state in a four state measurement process. The four states which occur during a successful reading are idle, initiated, wait-for-arm, and wait-for-trigger. The last two states have event detection associated with them which control when they exit the current state. These four states are more fully described as follows: • Idle -- In this state, the instrument is not measuring.
overwrite each other multiple times times before the arm event occurs and the current cycle of readings completes with the post-arm readings being taken. After all post-arm readings have been taken in a partition, if ARM:STARt:COUNt is not yet satisfied, the instrument directs the next burst of readings into the next memory partition.
TRIGger[:STARt]:COUNt [:STARt]:COUNt TRIGger[:STARt]:COUNt specifies the total number of readings which will be taken during each ARM:STARt:COUNt cycle of a measurement. This command is identical to (and coupled to) SENSe:SWEep:POINts; setting either will set both to the same count. Parameters Parameter Name Parameter Type Range of Values Default Units chan numeric 1|2 none number numeric 1 | 7 through 16,777,215 | MINimum|MAXimum| 9.9E+37|INFinity none MINimum selects 1 reading.
TRIGger[:STARt]:COUNt Comments • Executable when initiated: No • Coupled Command: This command is coupled to SENSe:SWEep:POINts, SENSe:SWEep:OFFSet:POINts, ARM:STARt:COUNt, and MEMory:BATTery:STATe. • TRIGger:STARt:COUNt values between 1 and 7 will be rounded to 1 or 7, whichever is closer to the specified count. • If the count is set to INFinity or 9.9E+37, the ABORt command must be used to return the trigger system to the idle state before any readings taken may be read from memory.
TRIGger[:STARt][:IMMediate] [:STARt][:IMMediate] TRIGger[:STARt][:IMMediate] will cause a reading to be taken immediately when the digitizer is in the wait-for-trigger state (ARM event has occurred), regardless of the selected trigger source. The number of triggers (set by TRIGger:STARt:COUNt) will be decremented by one. The selected trigger source remains unchanged. There is no query form of this command.
TRIGger[:STARt]:SOURce • DEXTernal: Samples are taken at a dual rate, using the signal on the Ext 1 input to pace pre-arm readings, and the signal on the Ext 2 input to pace the post-arm readings. • DTIMer: Samples are taken at a dual rate, using the TRIGger:STARt:TIMer1 rate to pace pre-arm readings, and the TRIGger:STARt:TIMer2 rate to pace the post-arm readings. • TTLTrg0 through TTLTrg7: The VXIbus TTL trigger lines. • EXTernal1: The HP E1429’s front panel "Ext 1" BNC connector.
TRIGger[:STARt]:TIMer[1] • The active edges for the various sources are as follows: ECLtrg0, ECLtrg1 and DECLtrg active edge is the rising edge. TTLTrg and DTTLtrg active edge is the falling edge. EXTernal1, EXTernal2, and DEXTernal active edge is the falling edge. • When using DECLtrg, DEXTernal, or DTIMer, at least one pre-arm pulse must occur after the arming signal has been received.
TRIGger[:STARt]:TIMer[1] Comments • Executable when initiated: No • Coupled Command: This command is coupled to the TRIGger:STARt:TIMer2 command and TRIGger:STARt:SOURce command as noted below: Unless TRIGger:STARt:SOURce is DTIMer, the settings of TRIGger:STARt:TIMer1 and TRIGger:STARt:TIMer2 are not coupled, and changing one will not affect the setting of the other.
• Related Commands: TRIGger:STARt:TIMer2, TRIGger:STARt:SOURce • *RST Condition: 5.0E-8 seconds. PERIOD VALUE TABLE The following sample periods are available with the digitizer’s internal 20 MHz reference oscillator. Multiple Period (Seconds) Multiple Period (Seconds) Multiple Period (Seconds) 1 5.0E-8 2 1.0E-7 4 2.0E-7 10 5.0E-7 20 1.0E-6 40 2.0E-6 100 5.0E-6 200 1.0E-5 400 2.0E-5 1000 5.0E-5 2000 1.0E-4 4000 2.0E-4 10,000 5.0E-4 20,000 1.0E-3 40,000 2.0E-3 100,000 5.
TRIGger[:STARt]:TIMer2 Comments • Executable when initiated: No • Coupled Command: This command is coupled to the TRIGger:STARt:TIMer1 command and TRIGger:STARt:SOURce command as noted below: Unless TRIGger:STARt:SOURce is DTIMer, the settings of TRIGger:STARt:TIMer1 and TRIGger:STARt:TIMer2 are not coupled, and changing one will not affect the setting of the other.
• Related Commands: TRIGger:STARt:TIMer1, TRIGger:STARt:SOURce • *RST Condition: 1.0E-7 seconds. PERIOD VALUE TABLE The following sample periods are available with the digitizer’s internal 20 MHz reference oscillator. Multiple Period (Seconds) Multiple Period (Seconds) Multiple Period (Seconds) 1 5.0E-8 2 1.0E-7 4 2.0E-7 10 5.0E-7 20 1.0E-6 40 2.0E-6 100 5.0E-6 200 1.0E-5 400 2.0E-5 1000 5.0E-5 2000 1.0E-4 4000 2.0E-4 10,000 5.0E-4 20,000 1.0E-3 40,000 2.0E-3 100,000 5.
VINStrument The VINStrument subsystem operates with the ARM and TRIGger subsystems to control the virtual instrument features of the HP E1429A/B. These features include the ability to use the Local bus and the VME (VXI data transfer) bus to obtain buffered measurement data from memory or real time measurement data directly from the analog to digital converter.
VME (VXI data transfer) Bus transfers When data is transferred over the VME bus directly from the A/D converter, a read of VME A24 address space, offset 12 (0C16), causes a measurement to be taken and transferred all in the same read cycle. During the read cycle, the HP E1429 takes a reading and puts the data into the register before the read cycle completes. The ARM sources may be set to any legal source for this mode, but TRIGger:START:SOURce must be set to VME.
VINStrument [:CONFigure]:LBUS:FEED [:CONFigure]:LBUS:FEED VINStrument[:CONFigure]:LBUS:FEED indicates the source of the data which will be output to the Local bus. The data source may be channel 1, channel 2, or both channels. The data may come from memory or directly from the A/D converter(s). Sources beginning with "MEMory: " are the post measurement modes, sources beginning with "CONVerter: " are the real time modes.
VINStrument[:CONFigure]:LBUS:MEMory:INITiate • When VINStrument:CONFigure:LBUS:FEED is one or both A/D converters, care must be taken that other active instruments in the pipeline can maintain the data generation rate. If data is available from the A/D converter but the Local bus is busy and can not accept it, the data is lost and error 1019; "Data loss detected during LBUS transfer" is reported.
VINStrument[:CONFigure]:LBUS[:MODE] • This command results in an error if VINStrument:CONFigure:LBUS:FEED is not one of the "MEMory" choices (i.e. "MEMory:BOTH", etc.). • If the data in memory is in multiple segments (ARM:STARt:COUNt > 1 and SENSe:SWEep:POINts:DELay < 0), then there will be a small time delay between transfer of each segment while the CPU switches the memory address to point to the next segment. • This command has no query form.
VINStrument[:CONFigure]:LBUS:RESet which is in GENerate mode. The mode is not active until either an INITiate command or a VINStrument:CONFigure:LBUS:MEMory:INITiate command is sent. OFF: The Local bus interface is disabled immediately upon receipt of this command. Local bus data is neither used nor passed through. PIPeline: Local bus data is passed through and not altered. This mode becomes effective immediately upon receipt of this command.
VINStrument[:CONFigure]:LBUS:SEND:POINts Comments • Executable when initiated: No • Coupled command: No • The HP E1429B Local bus chip must be reset after each data transfer. When resetting the Local bus chip, the Local bus chips on all devices to the right of the HP E1429B must also be reset in a left-to-right sequence. Refer to the product documentation for information on how a particular device’s Local bus chip is reset.
VINStrument[:CONFigure]:LBUS:SEND:POINts:AUTO • Coupled command: VINStrument:CONFigure:LBUS:SEND:POINts:AUTO and VINStrument:CONFigure:LBUS:FEED settings determine the allowable values of this command. • For a more complete discussion and example of when this command should be used, see "Local Bus Data Transfers" in Chapter 3.
VINStrument[:CONFigure]:TEST:DATA • Coupled command: Yes, VINStrument:CONFigure:LBUS:FEED and VINStrument:CONFigure:LBUS:SEND:POINts are coupled to this command. • If VINStrument:CONFigure:LBUS:SEND:POINts:AUTO is OFF, the measurement does not complete normally. After the data has been taken and transferred, the Local bus is left in a running state.
VINStrument[:CONFigure]:TEST:DATA The legal range of values is -32768 to 32767. Only the upper 12 bits are stored into memory. The lower 4 bits are ignored, and the actual values sent over the Local bus for these lower 4 bits are determined by the current setting of the DIAGnostic:CHANnel:LABel command. Comments • Executable when initiated: No • Coupled command: Yes.
VINStrument[:CONFigure]:VME:FEED [:CONFigure]:VME:FEED VINStrument[:CONFigure]:VME:FEED selects which data source will feed the VME (VXI data transfer) bus. The bus is driven by reading the data register, offset 12 (0C16) in A24 address space. Sources beginning with "MEMory: " are the post measurement modes, sources beginning with "CONVerter: " are the real time modes. The possible sources are: " MEMory:CHANnel1" : Channel 1 memory is the data source for the VME bus.
VINStrument[:CONFigure]:VME:MEMory:INITiate Parameters Parameter Name Parameter Type Range of Values Default Units source string "CONVerter:BOTH" | "CONVerter:BOTH32" | "CONVerter:CHANnel1" | "CONVerter:CHANnel2" | "MEMory:BOTH" | "MEMory:BOTH32" | "MEMory:CHANnel1" | "MEMory:CHANnel2" | none Comments • Executable when initiated: No • Coupled command: Yes. This command is coupled to the TRIGger subsystem.
VINStrument[:CONFigure]:VME[:MODE] VINStrument:CONFigure:VME:FEED. However, if these settings were not in effect when the measurement was taken, then VINStrument:CONFigure:VME:MEMory:INITiate must be sent before data is retrieved from memory via the data register. This command results in an error if VINStrument:CONFigure:VME:MODE is OFF. This command has no query form.
VINStrument[:CONFigure]:VME:SEND:ADDRess:DATA? Parameters Parameter Name Parameter Type Range of Values Default Units mode discrete GENerate|OFF none Comments • Executable when initiated: No • Coupled command: Yes, VINStrument:CONFigure:VME:MODE GENerate is not allowed unless VINStrument:CONFigure:LBUS:MODE is set to OFF or PIPeline.
VINStrument:IDENtity? :IDENtity? VINStrument:IDENtity? returns a response consisting of 4 fields, indicating the virtual instrument capability of the HP E1429: HEWLETT-PACKARD VIRTUAL INSTRUMENT,ANY ATOD,0,A.01.00 The first and last fields indicate that the HP E1429 conforms to revision A.01.00 of HP’s Virtual Instrument/Local Bus System Specification. The second field indicates that the HP E1429 is a analog-to-digital converter. The third field is reserved for future use.
IEEE-488.2 Common Commands This section describes the IEEE-488.2 Common Commands implemented in the HP E1429. The table below shows the commands listed by functional group; however, commands are listed alphabetically in the reference. Examples are shown in the reference when the command has parameters or returns a non-trivial response; otherwise, the command string is as shown in the table. For additional information, refer to IEEE Standard 488.2-1987.
*CLS *CLS *CLS clears the Standard Event Status Register, the Operation Status Register, the Questionable Signal Register, and the error queue. This clears the corresponding summary bits (3, 5, & 7) in the Status Byte Register. *CLS does not affect the enable masks of any of the status registers.
*EMC and *EMC? • Coupled command: No • Related Commands: *EMC, *GMC, *LMC, *RMC • *RST Condition: none; macro definitions are unaffected • Power-On Condition: no macros are defined Example Define macro to start measurement *DMC " RESTART","ABOR;INIT" Define macro *EMC and *EMC? *EMC enables and disables macro usage. When enable is zero, macros usage is disabled. Any non-zero value enables macro usage. The query form returns 1 if macro usage is enabled, 0 if disabled.
*ESR? • Coupled command: No • Related Commands: *ESR?, *SRE, *STB? • *RST Condition: unaffected • Power-On Condition: no events are enabled Example Enable all error events *ESE 60 Enable error events *ESR? *ESR? returns the value of the Standard Event Status Register. The register is then cleared (all bits 0).
*IDN? Example Query macro definition *GMC? " RESTART" Query macro definition *IDN? *IDN? returns indentification information for the HP E1429. The response consists of four fields: HEWLETT-PACKARD,E1429,0,A.01.00 The first two fields identify this instrument as model number E1429 manufactured by Hewlett-Packard. The third field is 0 since the serial number of the HP E1429 is unknown to the firmware. The last field indicates the revision level of the firmware.
*LRN? *LRN? *LRN? returns a sequence of commands that may be re-sent to the HP E1429 to return it to its current programming state. Only those commands that are affected by *RST are included in the sequence. Exceptions include MEMory:BATTery:STATe, the STATus subsystem commands, and the CALibration:SECurity command state. Note *LRN? should be sent singly in a program message, since the number of commands in the returned sequence is large, and may vary depending on firmware revision.
*OPC? *OPC? *OPC? causes the HP E1429 to wait for all pending operations to complete. A single ASCII “ 1" is then placed in the output queue. If STATus:OPC:INITiate OFF is set, the ASCII “ 1" will be placed in the output queue when all commands received prior to the *OPC? have been executed. If ON is set, *OPC? waits for the digitizer to return to the idle state before placing the ” 1" in the output queue. No other commands will be executed until the “ 1" is placed in the output queue.
*RCL Note When shipped from the factory, the protected user data area contains information regarding when the HP E1429 was last calibrated.
*RMC • *RST Condition: all saved states set to the same state as the *RST state *RMC *RMC purges only the specified macro definition. NOTE: At printing time, *RMC is a command proposed and accepted for a revision and re-designation of IEEE-488.2. Comments • Use the *PMC command to purge all macro definitions in one command.
*SAV *SAV *SAV stores the current programming state into one of the 10 possible stored state areas. Number indicates which of the stored state areas should be used. This command stores the states of all commands affected by *RST. Exceptions include MEMory:BATTery:STATe, the STATus subsystem commands, and the CALibration:SECurity command state.
*STB? • *RST Condition: unaffected • Power-On Condition: no bits are enabled Example Enable service request on Message Available bit *SRE 16 Enable request on MAV *STB? *STB? returns the value of the Status Byte Register. Bit 6 (decimal weight 64) is set if a service request is pending. STB? should not be used to read the Status Byte register if a service request is generated by a message available (MAV) condition. Comments • *STB? is a query.
*TST? *TST? *TST? causes the HP E1429 to execute its internal self-test and return a value indicating the results of the test. A zero (0) response indicates that the self-test passed. A one (1) response indicates that the test failed. A failure also generates an error message with information on why the test failed. Additional information on the failure is provided by the DIAGnostic:TEST? command. When the test completes, all commands are set to their *RST values.
Table 4-1. HP E1429A/B Command Quick Reference. Subsystem ARM CALibration Commands Description ARM[:STARt]:COUNt Specifies the number of measurement cycles (bursts) to occur. ARM[:STARt]:DELay Delay from when the digitizer is armed to when it enters the wait-for- trigger state. ARM[:STARt][:IMMediate] Places the digitizer in the wait-for-trigger state, independent of the selected ARM:STARt:SOURce.
Table 4-1. HP E1429A/B Command Quick Reference (Cont’d). Subsystem Commands Description DIAGnostic:FETCh[]? , Returns count number of readings beginning at start_addr. DIAGnostic:MEMory[]:FILL , Fill num_segments in memory with count readings. DIAGnostic:MEMory[]:ADDResses? Returns the addresses of the next memory locations to be written to in each segment.
Table 4-1. HP E1429A/B Command Quick Reference (Cont’d). Subsystem Commands Description OUTPut:ECLTrg:FEED Specifies the source of the synchronization pulse routed to ECLTRG0 or ECLTRG1. OUTPut:ECLTrg[:STATe] Enables/disables the routing of the synchronization pulse. OUTPut:EXTernal[1]:FEED Specifies the source of the synchronization pulse routed to the "Ext 1" BNC port. OUTPut:EXTernal[1][:STATe] Enables/disables the routing of the synchronization pulse.
Table 4-1. HP E1429A/B Command Quick Reference (Cont’d). Subsystem TRIGger VINStrument Commands Description ABORt Removes the digitizer from the wait-for-trigger state. TRIGger[:STARt]:COUNt Specifies the total number of (pre- and post-arm) readings taken during each arm cycle. TRIGger[:STARt][:IMMediate] Sends an immediate trigger to the digitizer. A reading is taken if the digitizer is in the wait-for-trigger state. TRIGger[:STARt]:SOURce Sets the trigger source.
SCPI Conformance Information The HP E1429A/B 20 MSa/s 2-Channel Digitizer conforms to the SCPI-1992.0 standard. The following tables list all the SCPI confirmed, approved, and non-SCPI commands that the HP E1429A/B can execute. Table 4-2. SCPI Confirmed Commands.
Table 4-3. Non-SCPI Commands.
Notes 316 SCPI Conformance Information Chapter 4
Appendix A Specifications Appendix Contents This appendix contains the HP E1429A/B 20 MSa/s 2-Channel Digitizer operating specifications. Except as noted, the specifications apply under the following conditions: • • • • Period: Temperature: Relative humidity: Warm up time: 1 year 0° - 55° C ≤ 65% @ 0° - 40° C 1 hour References to the Local Bus Interface apply ONLY to E1429B; otherwise, E1429A and E1429B are identical except as noted.
Read-Out To VME Bus After measurement completion, memory read-out may be requested for either channel separately or for both channels interleaved. Memory access is via repeated reading from a single VME register address; 16- or 32-bit accesses are permitted. This is the "channel I/O" model; i.e. memory can not be mapped or shared as can VME memory.
Total Readings per Partition (total memory size)/(number of partitions) When the non-volatile mode of memory is enabled, this number is reduced by four readings. Pre-Arm Data before the arm event can be stored in a circular-overwrite mode (per partition) until the event occurs. Amplitude Characteristics and Signal Conditioning A/D Converter 50Ω input, -1.0225V to 1.0230V range Each channel contains a high-performance 12-bit, 20MSa/s A/D converter.
Output Formats ASCII (9 significant digits) or REAL 64 (IEEE 64-bit binary) formats represent input voltage in volts, scaled appropriately according to voltage range setting used. PACKED denotes 2’s complement binary integers, with the raw A/D code (including sign) occupying the leftmost 12 bits of a 16-bit word, padded with four zero bits on the right. Any of the above formats can be returned under the Word Serial protocol.
Differential Nonlinearity (4.4.1.2, 3680 Hz sine wave, codes -2045 to +2046) 1 LSB (no missing codes) A/D Converter Supplemental Characteristics Integral Nonlinearity (4.4.3, Note 1057-1) 2 LSB Maximum Static Error (4.4.4.1, Note 1057-1) 2% Word Error Rate (4.15) qualified error level word error rate >16 LSB <2.5E-7 >32 LSB <6E-8 >64 LSB <5E-9 Single-ended inputs Connector : BNC Coupling : DC Impedance : 50Ω or 75Ω ±0.
Accuracy is specified for the average of 100 readings (with CAL:ZERO performed within 24 hours prior to reading in a stable environment). For temperatures outside 18-28 degrees C, add the following temperature coefficients for each degree below 18 C or above 28 C: Range % of peak-to-peak full-scale, per degree 0.1 0.2 others 0.055 0.035 0.025 Single-ended inputs, supplemental characteristics Analog Bandwidth (4.6.
Coupling : DC Impedance : 1 MΩ in parallel with 25 pF (nominal) Ranges : A/D responds to the difference of the two input voltages on the(+) and (-) connectors. -0.10225V -0.2045V -0.51125V -1.0225V -2.045V -5.1125V -10.225V -20.45V -51.125V -102.25V to to to to to to to to to to 0.10230V 0.2046V 0.5115V 1.0230V 2.046V 5.115V 10.230V 20.46V 51.15V 102.30V Overload: On-the-fly flagging includes amplifier overload. Ranges 0.1V to 5V: input impedance remains nominally constant up to ±10V.
DC Accuracy: ±0.5% of reading ±1% of peak-to-peak full-scale Accuracy is specified for the average of 100 readings with inputs terminated in <1 kΩ and CAL:ZERO performed within 24 hours prior to reading in a stable ambient. For temperatures outside18-28 degrees C, add the following temperature coefficients for eachdegree below 18 C or above 28 C: Range % of peak-to-peak full scale, per degree 0.1024 0.2048 others 0.055 0.035 0.025 Differential Inputs, supplemental characteristics Analog Bandwidth (4.6.
Crosstalk (4.11) On 1V range, relative to full-scale input: DC - 1 MHz 1 - 10 MHz Frequency and Sample Rate Characteristics -75 dB -70 dB Both channels always sample simultaneously at the indicated rates and times. Tolerances: All internally-generated frequencies and rates are ±0.0075% initial tolerance. Internal Timer The Internal Timer generates time intervals useful in controlling the sample rate. It divides a reference frequency by 1x10n, 2x10n, or 4x10n, n = 0 to 8.
Dual-Rate: The Pre-Count readings can be measured at one sample rate; then the Post-Count readings can be measured at another sample rate. The possible sample rate sources occur in pairs. There are four possible pairs: { EXT1 BNC (pre), EXT2 BNC (post); or vice-versa } { ECLTRG0 (pre), ECLTRG1 (post); or vice-versa } { REFERENCE (pre), REFERENCE/N (post)} { REFERENCE/N (pre), REFERENCE (post)} (N=2,4,10,20,40...4E8).
Let the Reference period be T.
P2 Local Bus : (E1429B only) Modes per HP Virtual Instrument Protocol: Append Generate Off Pipeline Data Source Data can be sourced directly from the A/Ds or from memory -either channel or both channels interleaved. Pacing Real-time (during measurements) paced by arm/trigger system From memory (after measurements) paced by receiving module on local bus Maximum speed: 80 MByte/sec (i.e.
Currents in Amps (typical) E1429A +5V : I(pm) 2.9 I(dm) 0.5 +12V : I(pm) 0.2 I(dm) 0.04 - 12V : I(pm) 0.2 I(dm) 0.04 +24V : I(pm) 0.1 I(dm) 0.05 -24V : I(pm) 0.1 I(dm) 0.05 -5.2V : I(pm) 3.6 I(dm) 0.36 -2V : I(pm) 1.2 I(dm) 0.12 +5VS : I(pm) 0 I(dm) 0 E1429B 3.1 0.5 0.2 0.04 0.2 0.04 0.1 0.05 0.1 0.05 4.1 0.36 1.3 0.12 0 0 Typical Watts/Slot: 41.5 45.3 dPressure (H2O): 0.8 mm AirFlow (liters/s):3.8 EMC: To meet EMC requirements in Europe, a backplane connector shield kit is included.
Notes 330 Specifications Appendix A
Appendix B Useful Tables Appendix Contents The tables in this appendix contain information often referred to during HP E1429A/B programming. The tables in this appendix include: • Table B-1. HP E1429A/B Example Program Listing . . . . . . 332 • Table B-2. HP E1429A/B Power-on/Reset Conditions . . . . 334 • Table B-3. HP E1429A/B Error Messages . . . . . . . . . . . . . .
Table B-1. HP E1429A/B Example Program Listing Location Program Name Language Chapter 1 IDN.C HP BASIC, C SLFTST.C " E1429A/B Self Test. RSTCLS.C " Resetting and clearing the digitizer. LRN.C " Power-on/reset configuration. MEAS.C " Making a measurement with the digitizer. CONF.C " Configuring the digitizer. QUERY.C " Queries SCPI command settings. ERRORCHK.C " Error checking program. INPUT.C C Configures the digitizer input. ARMCNT.C " Takes a burst of readings. ARMLEVEL.
Table B-1. HP E1429A/B Example Program Listing (Cont’d) Location Program Name Language Chapter 2 (Cont’d) LOCAL_AD.C C Local bus data transfer using a single digitizer. LBUS2PST.C " Local bus data transfer from digitizer memory using multiple digitizers. LBUSAUTO.C " Local bus data transfer from the digitizer A/D using multiple digitizers. STATUS.C " Demonstrates the use of the digitizer status registers. Appendix C REG_PROG.
Table B-2. HP E1429A/B Power-On/Reset Configuration ( returned by *LRN?) Parameter Command Power-on/Reset Setting Macro useage *EMC +0 Automatic cal constant storage CAL:STOR:AUTO 1 (enabled) Channel 1 calibration value CAL1:VAL +1.01850000E+000 Channel 2 calibration value CAL2:VAL +1.01850000E+000 Reading format :FORM ASC,+9 Channel 1 S/E input filter :INP1:FILT 0 (disabled) Channel 1 S/E input impedance IMP +5.
Table B-2. HP E1429A/B Power-On/Reset Configuration (Cont’d) Parameter Command Power-on/Reset Setting Arm count :ARM:COUN +1.00000000E+000 Arm delay DEL +0.00000000E+000 Arm source1 SOUR IMMediate Arm slope1 SLOP1 POSitive Arm level1 (negative) :ARM:LEV:NEG -1.02241848E+000 Arm level1 (positive) POS +1.02241848E+000 Arm source2 :ARM:SOUR2 HOLD Arm slope2 SLOP2 POSitive Arm level2 (negative) :ARM:LEV2:NEG -1.02241848E+000 Arm level2 (positive) POS +1.
Table B-3. HP E1429A/B Error Messages Code Message -101 Invalid character -102 Syntax error -103 Invalid separator -104 Data type error -105 GET not allowed -108 Parameter not allowed -109 Missing parameter -112 Program mnemonic too long -113 Undefined header -121 Invalid character in number -123 Exponent too large -124 Too many digits More than 255 digits were used to specify a number. -128 Numeric data not allowed A number was specified when a letter was required.
Table B-3. HP E1429A/B Error Messages (Cont’d) Code Message -161 Invalid block data -168 Block data not allowed 171 Invalid Expression -178 Expression data not allowed 181 Invalid outside macro definition A macro parameter placeholder ($
Table B-3. HP E1429A/B Error Messages (Cont’d) Code Message -230 Data corrupt or stale -231 Data questionable -240 Hardware error -270 Macro error *RMC was executed and name is not defined. -271 Macro syntax error A syntax error occurred among the commands within the macro. -272 Macro execution error Macro program data sequence could not be executed due to a syntax error within the macro definition.
Table B-3. HP E1429A/B Error Messages (Cont’d) Code Message -410 Query INTERRUPTED -420 Query UNTERMINATED The controller (computer) attempts to read a query response from the digitizer without having first sent a complete query command. -430 Query DEADLOCKED The digitizer’s input and output buffers are full and the digitizer cannot continue.
Table B-3. HP E1429A/B Error Messages (Cont’d) Code Message 1019 Data loss detected during LBUS transfer 1020 Indefinite block not allowed When executing the VINStrument:TEST:DATA command, the data must be in the IEEE-488.2 definite length block format. 1021 LBUS still running, ABOR or VINS:LBUS:RES needed The HP E1429B digitizer is in the interleaved transfer mode and the LBUS chip is still active. The chip must be reset before the next INITiate command.
n Appendix C Register Programming Appendix Contents The HP E1429A/B 20 MSa/s 2-Channel Digitizer is a message-based device. As such, it supports the VXI word-serial protocol used to transfer ASCII command strings and is capable of converting the SCPI commands it receives to reads and writes of its hardware registers. Register-based programming allows direct access to the hardware registers.
Each program uses a combination of SCPI commands and register reads/writes. In most cases SCPI commands set the initial digitizer configuration. Register reads/writes are used to modify the configuration, re-initialize the digitizer, and retrieve readings. Reading and Writing to the Registers The examples in this appendix are based on the system configuration listed previously.
Addressing the Registers Access to the digitizer’s registers is through addresses mapped into A24 address space. At power-on, the system resource manager (HP E1406) reads the digitizer’s Device Type register (in A16 address space) to determine the amount of A24 memory the digitizer needs (4096 bytes). The resource manager allocates a block of A24 memory to the digitizer and writes the base (starting) address into the digitizer’s Offset register (also in A16 space).
Note Determining the A24 Base Address The following information on determining register addresses is based on the computer configuration shown in Figure C-1, and on address mapping as performed by the HP E1406 Command Module’s resource manager. For configurations with embedded controllers or configurations with a resource manager other than the HP E1406 Command Module, refer to those manuals containing information on A24 address mapping.
3. The hexadecimal number in bold is the digitizer’s A24 base address. 4. Read the digitizer’s offset register in A16 address space. As shown in Figure C-1, the Offset register is one of the digitizer’s configuration registers.
A24_READ.C /* A24_READ.C - This program reads the digitizer’s A24 base address. */ /* Include the following header files */ #include #include
/* Multiply offset value by 256 for 24-bit address value */ a24offst *= 256.; return (long)a24offst; } Note Multiplying the value of the offset register (a24offst) by 256 (10016) converts the 16-bit register value to a 24-bit address. Register Descriptions The registers used to configure the digitizer are shown on the following pages. The registers are listed by functional group. Listed with each register are its bit definitions and, where applicable, the bit settings at power-on or following a reset.
A24 Register Table Category Input Configuration Registers Address Read Registers Write Registers base + 0316 A/D Status Register base + 0516 A/D Serial Read Register C-350 base + 0B16 A/D Serial Write Register C-350 A/D Parallel Strobe Register C-351 A/D Shift Register Arm and Trigger (timebase) Configuration Registers See Page...
Category Memory Control Registers Appendix C Address Read Registers Write Registers See Page...
The Input Configuration Registers The input configuration registers are used to set the following digitizer input parameters: • • • • Input enable Input impedance Input filter Measurement range The A/D Status Register base +0316 The A/D status register is a read only register that returns the status of the digitizer’s input section. The register bits are defined below. Only the use of bit 0 is documented. Address 7 base + 0316 6 5 4 3 Ch. 2 Diff. Ch. 1 Diff. Ch2. S/E Ch1.
The A/D Parallel Strobe Register base +0B16 The A/D parallel strobe register is a write only register that latches the A/D configuration held by the A/D shift register to the analog-to-digital converter. Address base + 0B16 7 6 5 not used 4 3 2 0 - idle 1 - strobe 1 0 not used Setting bit 2 to ’1’ latches the configuration represented by the bits in the A/D shift register to the A/D. Only one strobe is required.
Bit Name Function Bit 0 ENSYNC1 Enable Ext1 output 26 1 ENSYNC2 Enable Ext2 output 27 Name Function OPENINH Input protection inhibit TESTLEDS LED test 2 ENEXT1 Enable Ext1 input 28 not used 3 ENEXT2 Enable Ext2 input 29 not used 4 CALSELA Lower bit of cal source select 30 not used 5 CALSELB Upper bit of cal source select 31 not used 6 TERM75 1 0 - Ch1 input impedance 50Ω 1 - Ch1 input impedance 75Ω 32 CH1HCAL 0 - switches H_CAL to ch1 +input 1 - switches HI to ch1 +input 7
The Arm and Trigger Configuration Registers The following registers are used to set the digitizer’s arm and trigger parameters. The Abort and Arm Immediate Register base + 4116 The function of the Abort and Arm Immediate register depends on whether you are writing to the register, or reading the register.
Last TRG*: Bit 4 is set to ’0’ when the last programmed arm count is reached (base + 5516 and base + 5716). The bit is set to ’1’ when the burst of readings associated with the arm are complete. Begin samp: Bit 3 is set to ’0’ with the first reading in each arm burst and is set to ’1’ after the last reading in each arm burst. Delayed: Bit 2 is set to ’1’ after the programmed arm delay (base + 5116 and base + 5316) has elapsed.
The Arm Internal Bus Register base + 4716 The function of the arm internal bus register is defined below. Address 7 6 5 4 3 2 1 0 register write: arm trigger base + 4716 Writing any 8-bit value to the register generates an arm trigger when the arm source is an HP-IB Group Execute Trigger or the IEEE-488.2 *TRG command. The Arm Source Register base + 4916 The Arm source register is used to set the source and slope of the signal which arms the digitizer. The register bits are described below.
Source 1 slope: Bit 3 sets the slope of arm source 1. For all arm sources except a TTLTrg trigger line (bits 2 - 0 =001) and the HP-IB GET command or *TRG command (bits 2 - 0 =010), the slope should be set to positive (0). Arm source 1: Bits 2 - 0 set arm trigger source 1. Arm source 2 and arm source 1 are ORed together so that an arm from either source arms the digitizer. Setting bits 2 - 0 as follows sets the arm source indicated. 0 0 0 - "Ext 1" BNC connector.
reclk/10: Setting bit 4 to ’1’ causes the reference divider to be reclocked by the reference clock / 10. Setting bit 4 to ’0’ causes the reference divider to be reclocked by the reference clock. pre-trig: Setting bit 3 to ’1’ enables pre- and post-arm readings. thold: Setting bit 2 to ’1’ sets arm trigger hold which prevents the digitizer from accepting arm signals from any source except an arm immediate (writing any value to base + 4116).
Bit Descriptions Sample/Hold: Setting bit 7 to ’1’ sets sample trigger hold which prevents the digitizer from accepting sample trigger signals. Sample Infinite: Setting bit 6 to ’1’ sets infinite sample triggers. Triggering continues until aborted (base + 4116) or until the bit is set to ’0’ and the post arm reading count is reached. One sample trigger occurs after the bit is set to ’0’ even if the post-arm trigger count is reached. Sample Infinite overrides Sample Once (bit 5).
The Reference Oscillator Register base + 4F16 The reference oscillator register sets the reference source from which the sample rate is derived. The register is also used to output synchronization signals.
Reference oscillator source: Bits 2 - 0 set the reference oscillator source from which the sample rate is derived. The sources include: 0 0 0 - the digitizer’s internal 20 MHz oscillator. 0 0 1 - backplane trigger line ECLTrg0. 0 1 0 - backplane trigger line ECLTrg1. 0 1 1 - the EXT2 front panel BNC connector. 1 0 0 - backplane 10 MHz (CLK10) signal. The Arm delay Register base + 5116 and base +5316 The arm delay is set using the arm delay registers defined below.
The Trigger Immediate Register base + 5D16 A trigger immediate occurs when any 8-bit value is written to the trigger immediate register shown below. Address 7 6 5 4 3 2 1 0 register write: sends trigger (sample) immediate base + 5D16 The Decade Division Register base +6116 The decade division register is used with the binary division register to divide the reference frequency in order to obtain the desired sample rate. The register bits are defined below.
The Pre-Arm Reading Count Registers base + 7316 and base + 7516 The pre-arm reading count registers are defined below. Address 7 6 5 4 3 2 1 0 base + 7316 = pre-arm reading count least significant byte base + 7516 = pre-arm reading count most significant byte base + 7316 base + 7516 Register 73: Contains the least significant byte of the pre-arm reading count. Register 75: Contains the most significant byte of the pre-arm reading count.
The Memory Control Registers The following memory control registers are used to initialize digitizer memory. The Traffic Register base +0216 The traffic register is a read/write register that selects data and clock sources for the high-speed data bus. The bits are defined as follows.
The high-speed internal (data) bus routes data between the A/D, digitizer memory, the local bus, and the VME (VXI data transfer) bus (Figure 3-7). There is no user-access to the high-speed internal bus. The Pulse Register base +0816 The pulse register is a read/write register that generates high-speed clock signals when the traffic register’s high-speed clock source is set to ’pulse register’ .
The Memory Control Register base +2116 The memory control register is a read/write register that controls the operation of digitizer memory. The register bits are defined below.
The Memory Address Registers base +2316 to base +2716 The memory address registers are read only registers that return the address where the last reading in the set will be stored. These registers are useful for determining if the digitizer has been re-initiated by indicating the number of readings that have been taken. For example, if 100 readings are to be taken when the digitizer is re-initiated, the memory address registers point to the location where the 100th reading is to be stored.
The Terminal Address Register base +2B16 The terminal address register is a read/write register that sets the last address of a memory segment. It is used with the base address registers to define the memory segment. Address 7 6 5 4 3 2 1 Terminal address base + 2B16 0 Base address Terminal Address. The terminal address field specifies the last address in a memory segment before returning to the base address. Base Address.
Configuring the Digitizer Input This section contains the procedures used to configure the digitizer’s input section. The configuration includes: • • • • Enabling the Single Ended and Differential Inputs Setting the input impedance Enabling the 10 MHz filter Setting the measurement range The digitizer must be in the idle state when configuring the input section. Using the A/D Shift Register Each input parameter listed above is set by the digitizer’s A/D shift register.
Reading and Writing to the Shift Register 1. Define a programming loop which counts from 55 to 0 and which contains the following. A. Read and save the current shift register bit at the output (bit 55) position using the A/D status register (base + 0316). B. If the loop count does not equal the bit position to be changed, write back the bit using the A/D serial register (base + 0516).
The impedance of the single-ended inputs can be set to 50Ω or 75Ω. At power-on or following a reset, the impedance is set to 50Ω. The impedance is changed using the following bits of the A/D shift register.
Table C-4. HP E1429 Digitizer Attenuator Settings Measurement Range 20 dB 20 dB Internal Attenuators Input Post 6 dB 14 dB Attenuator Attenuator bits 37,45 38,46 bits 34, 42 bits 35, 43 -0.10230 to 0.10235 OFF OFF OFF OFF -0.2046 to 0.2047 OFF OFF ON OFF -0.5115 to 0.51175 OFF OFF OFF ON -1.0230 to 1.0235 OFF ON OFF OFF -2.0460 to 2.0470 OFF ON ON OFF -5.115 to 5.1175 OFF ON OFF ON -10.230 to 10.235 ON ON OFF OFF -20.460 to 20.470 ON ON ON OFF -51.150 to 51.
Procedure 1. Route the input signal to the attenuators. A. To set the measurement range, the input signal must be routed to the attenuators. This is done by setting bit 10 (channel 1) or bit 15 (channel 2) to ’1’. 2. Set the required attenuation. A. From Table C-1 and with the bit positions known, set the bits for the required attenuation (measurement range) using the procedure for reading and writing to the shift register. 3. Copy the shift register bits to the shift register latch. A.
Setting the Digitizer Configuration Note Setting the Arm Sources The digitizer configuration covered in this section includes: • • • • • • • • setting the arm sources setting the arm count setting the arm delay setting the reference source setting the trigger source sending arm immediate sending trigger immediate aborting measurements The trigger count (pre-arm and post-arm reading counts) and the sample rate are set when the timebase processor is initialized.
Setting the Arm Count The registers used to set the arm count are listed below. • Arm count registers base + 5516 and base + 5716 Procedure 1. Load the arm count registers. A. With the digitizer in the idle state, write the decimal equivalent of the most significant byte to register 55. Writing the decimal equivalent of the least significant byte to register 57. You can set the arm count from 1 to 65,535 arms.
Procedure 1. Determine the reference period. A. The reference from which the arm delay is derived is set with bit 0 of the arm control register. The setting of bit 0 (to ’0’ or ’1’) depends on the reference clock and the amount of delay required. Determine the reference from which the delay is derived and set bit 0 accordingly. Retain the settings of bits 7 - 1.
Setting the Trigger Source The register used to set the digitizer’s trigger (sample) source is listed below. • Trigger source register base + 4D16 Procedure The trigger source can be set/changed when the digitizer is in the idle state or while it is initiated. 1. Setting/changing the trigger source while in the idle state: A. Write the decimal equivalent bit pattern to the trigger source register while retaining the settings of the other bits (base + 4D16). 2.
2. Send the arm immediate signal. A. Read the Abort and Arm Immediate register (base + 4116). Reading the registers sends an arm immediate signal. Sending a Trigger Immediate Signal A trigger immediate signal triggers the digitizer, overriding the sample/hold bit of the trigger source register.’The registers used to send a trigger immediate signal are: • Trigger Immediate register base + 5D16 • Trigger Source register base + 4D16 Procedure 1. Suspend sample triggers (e.g. trigger hold). A.
2. Send abort signal. A. Write any 8-bit value to the Abort and Arm Immediate register (base + 4116). 3. Re-enable sample triggers. A. Set bit 7 (base + 4D16) to ’0’ to enable sampling for the next reading (measurement) sequence. Re-initiating the Digitizer Initiating the digitizer places the digitizer in the wait-for-arm state. When an arm is received while in this state, the digitizer moves to the wait-for-trigger state where it samples when trigger signals are received.
Procedure 1. Initialize the memory control register. A. Set bits 2 - 0 of the memory control register (base + 2116) to ’0’. Retain the settings of bits 7 - 3. 2. Determine the starting address of the memory segment. A. The segment size is the number of readings to be taken and must be divisible by 4. The starting address is computed as: starting address = ending address - (segment size - 1) The re-initiation procedure assumes one segment of post-arm readings.
For example, if the segment size is 10,000 readings, the terminal and base addresses would be: start address = 524,287 - 9,999 = 514,288 514,288 / 4 = 128,572 = 1F63C16 terminal address = 254 + 1 (since 128,572 > 65,535) base address = F63C (the ’1’ is part of the terminal address: 254 + 1) MSB 1111 0110 24610 LSB 0011 1100 6010 24610 is written to register base + 2D16 6010 is written to register base + 2F16 5. Enable memory to be written to. A.
The registers used to initialize the processor are summarized below.
Procedure 1. Reset and initialize the timebase processor. A. Write the following data to the registers indicated. Except for the abort and arm immediate register (base +4116), these registers must not be set to any other values; therefore, they are not listed in the "Register Descriptions" section.
A. Load the pre-arm reading count registers. With the digitizer in the idle state, write the decimal equivalent of the least significant byte to register 73. Write the decimal equivalent of the most significant byte to register 75. You can set the pre-arm reading count from 3 to 65,535 readings. For example, to program 500 pre-arm readings, a pre-arm reading count of 498 (500 - 2) is loaded into the registers.
4. Set the sample rate. A. If the trigger source is not reference period / N (base + 4D16 bits 4 - 2 =1 0 0), the decade division register and binary division register must be set as follows: write a value of 1 to base + 6116 write a value of 132 to base + 6316 B. If the trigger source is the reference period / N ( base + 4D16 bits 4 - 2 =1 0 0), then to set the sample rate (period) you must know the rate you want and the reference frequency. From these values, a value (N) is determined as shown below.
6. Load the arm count and send the initiate pulse. A. Load the arm count and initialize the trigger counters by writing (any value) to the arm count latch register (base + 5916) three times. B. Initiate the timebase processor by writing any value to the timebase initiation register (base +4516). Note The memory address registers (base +2316 to base +2716) are useful for determining if the digitizer has been re-initiated by indicating the number of readings that have been taken.
Procedure 1. Place the last reading (from the A/D) into memory. A. Using the traffic register (base + 0216) set the pulse register as the high-speed clock source by setting bits 3 - 2 to 0 0. Retain the settings of the other bits. B. Send a clock pulse to the internal high-speed bus by reading or writing (any value) to the pulse register (base + 0816). 2. Initialize the memory control register. A. Set bits 2 - 0 of the memory control register (base + 2116) to ’0’. Retain the settings of bits 7 - 3. 3.
5. Set the terminal (ending) address. A. The terminal address is the ending address of the memory segment. This address is computed as: terminal address = (ending address - 4095) / 2048 Again, the procedure is for one segment of post-arm readings. Therefore, the terminal address is: terminal address = (524,287 - 4095) / 2048 = 254 B. Divide the starting address (see Step 4) by 4. If this value is > 65,535 (FFFF16), add 1 to the terminal address value (254). C.
7. Send three clock pulses to the internal high-speed bus by reading or writing (any value) to the pulse register (base + 0816) three times. This initializes the transfer stages. 8. Set the clock source to the digitizer data register. A.
All other digitizer parameters (e.g. arm source, arm count) remain as set by the previous CONFigure command. Note Appendix C The following program contains a C function which re-initiates the digitizer (void initiate (long base_addr)). This function shows the exact sequence the registers must be written to in order to successfully re-initate the digitizer. When modifying this program, be sure that the sequence for re-initiating the digitizer remains the same.
REG_PROG.C /* REG_PROG.C - This program configures the digitizer using register reads */ /* and writes. The program sets an initial digitizer configuration using */ /* the CONFigure command and takes a set of readings using the READ? */ /* command. Register reads and writes are then used to change the measurement */ /* range, change the trigger source, change the post-arm reading count, re-initiate */ /* the digitizer, and retrieve the readings.
initiate(base_addr); /* function call which prepares memory to store readings */ memory_retrieve(base_addr); /* function call which prepares memory to retrieve readings */ data_read(base_addr); /* function call which reads the data register */ } /****************************************************************************/ void conf_read(void) { /* This function uses the CONFigure command to set up 20 readings on the */ /* 5V range. The READ? command is used to take the readings.
/****************************************************************************/ void input_config(long base_addr) { /* This function changes the measurement range from 5V as set by the CONFigure */ /* command, to 1V using the A/D shift register. The range is changed by */ /* enabling/disabling various attenuators on the input signal path.
/* turn channel 1 20 dB post attenuator on */ /* read bit 35 by reading the A/D status register */ case 35:IOOUTPUTS(CMD_MOD, stat_read, strlen(stat_read)); IOENTER(CMD_MOD, &bit); /* set bit 35 to ’0’ by writing to the A/D serial register */ sprintf(stat_write,"DIAG:POKE %ld, %d, %d", base_addr+0x05,8,0); IOOUTPUTS(CMD_MOD, stat_write, strlen(stat_write)); break; /* turn channel 1 20 dB input attenuator off */ /* read bit 34 by reading the A/D status register */ case 34:IOOUTPUTS(CMD_MOD, stat_read, strlen
/* copy the shift register bits to the shift register latch by */ /* writing a value of 4 to the strobe register */ sprintf(strobe_write,"DIAG:POKE %ld, %d, %d", base_addr+0x0B,8,4); IOOUTPUTS(CMD_MOD, strobe_write, strlen(strobe_write)); } /****************************************************************************/ void set_trig_source(long base_addr) { /* This function sets the digitizer trigger source to the reference period / n.
/* initialize the memory control register by setting bits 2 - 0 to ’0’*/ sprintf(command, "DIAG:PEEK? %ld, %d", base_addr+0x21,8); IOOUTPUTS(CMD_MOD, command, strlen(command)); IOENTER(CMD_MOD, &bit_pat); /* retain register settings, set memory control register bits 2 - 0 */ /* to ’0’ */ bit_reg = (int)(bit_pat + ((bit_pat >= 0) ? .5 : -.
/****************************************************************************/ void initiate(long base_addr) { /* This function initializes and initiates the timebase processor. This includes */ /* initializing the processor, setting the trigger (post-arm) count, setting */ /* the sample rate, setting the A/D as the data source for memory, and initiating */ /* the timebase processor. Note that the registers must be read and written to */ /* in the sequence shown.
/* write middle-significant-byte of post-arm count */ sprintf(command, "DIAG:POKE %ld, %d, %d", base_addr+0x79,8,0); IOOUTPUTS(CMD_MOD, command, strlen(command)); /* write most-significant-byte of post-arm count */ sprintf(command, "DIAG:POKE %ld, %d, %d", base_addr+0x7B,8,0); IOOUTPUTS(CMD_MOD, command, strlen(command)); /* initialize the sample rate registers */ sprintf(command, "DIAG:POKE %ld, %d, %d", base_addr+0x63,8,129); IOOUTPUTS(CMD_MOD, command, strlen(command)); sprintf(command, "DIAG:POKE %ld, %
sprintf(command, "DIAG:PEEK? %ld, %d", base_addr+0x02,8); IOOUTPUTS(CMD_MOD, command, strlen(command)); IOENTER(CMD_MOD, &bit_pat); /* retain register settings, set pulse register as the high-speed */ /* clock source */ bit_reg = (int)(bit_pat + ((bit_pat >= 0) ? .5 : -.
/****************************************************************************/ void memory_retrieve(long base_addr) { /* This function sets the address locations of the readings in digitizer memory, */ /* and enables the readings to be retrieved using the digitizer’s data register.
/* enable data to be read from memory and enable the address counter */ sprintf(command, "DIAG:PEEK? %ld, %d", base_addr+0x21,8); IOOUTPUTS(CMD_MOD, command, strlen(command)); IOENTER(CMD_MOD, &bit_pat); /* retain register settings, set memory control register bits 2 - 0 */ /* to ’1 1 0’ */ bit_reg = (int)(bit_pat + ((bit_pat >= 0) ? .5 : -.
/* initialize the transfer stages by sending three clock pulses to the */ /* internal high-speed bus */ sprintf(command, "DIAG:POKE %ld, %d, %d", base_addr+0x08,8,0); IOOUTPUTS(CMD_MOD, command, strlen(command)); IOOUTPUTS(CMD_MOD, command, strlen(command)); IOOUTPUTS(CMD_MOD, command, strlen(command)); /* set the digitizer data register as the high-speed clock source */ /* (digitizer memory is still the data source) */ sprintf(command, "DIAG:PEEK? %ld, %d", base_addr+0x02,8); IOOUTPUTS(CMD_MOD, command, st
/* Send the DIAG:UPL:SADD? command which accesses the data register */ /* and retrieves the readings */ IOOUTPUTS(CMD_MOD, rd_mem, strlen(rd_mem)); /* retrieve and enter the readings, */ IOENTERAB(CMD_MOD, rdgs, &bytes, swap); /* remove the block header */ /* remove the line feed which trails the last data byte */ IOENTERS(CMD_MOD, lf_remove, &length); /* convert and print each reading as a voltage */ for (i = 0; i < 20; i++) { rdgs[i] /= 16; /* remove label from each reading */ if (rdgs[i] >= 2047 || rdgs[
/* Multiply offset value by 256 for 24-bit address value */ a24offst *= 256.
Notes 404 Register Programming Appendix C
Appendix D Local Bus Interleaved Transfers Appendix Contents This appendix contains information on interleaved data transfers using the HP E1429B and the Local bus. Interleaved Transfers In an interleaved transfer, multiple digitizers transfer one reading or one set of readings (both channels) per block. The leftmost digitizer is set to the GENerate mode and the inner digitizer(s) is set to the INSert mode. A device such as the HP E1488 memory card is usually the consumer.
For example, if a configuration consists of two digitizers and both channels on each digitizer are used, the maximum sample rate for each digitizer is: 40 MSamples / 4 channels = 10 MHz As another example, if a configuration consists of two digitizers and only three channels are used, the maximum sample rate for each digitizer is: 40 MSamples / 3 channels = 13.3 MHz For the digitizer using two channels this would be 26.6 MSamples/ second since a single sample trigger causes both channels to sample.
These commands are sent as a single command string in order to prevent "Settings conflict" errors. Note that the readings per block and the interleaved transfer mode need only be specified when doing interleaved Local bus transfers. Programming Procedure The programming procedure for interleaved transfers is: 1. Use the CONFigure command and the low-level digitizer commands to configure the digitizers for the required measurements. All digitizers must have the same trigger source and the same sample rate.
7. Use INITiate:IMMediate to activate the rightmost (INSerter) digitizer. 8. Beginning with the leftmost (GENerator) digitizer, abort each digitizer before using the Local bus again. Example Program This program demonstrates how to use multiple digitizers to transfer readings, interleaved, to an HP E1488 memory card (consumer). The program takes 10 readings on both channels of two digitizers. Therefore, 10 frames of data (40 readings) are sent to the memory card.
/****************************************************************************/ void main(void) /* run the program */ { clrscr(); rst_clr(ADDR_G); /* reset generator digitizer */ rst_clr(ADDR_I); /* reset inserter digitizer */ rst_clr(ADDR_MEM); /* reset memory card */ configure(); /* configure the digitizers and the memory card */ initiate(); /* initiate the digitizers and the memory card */ /* retrieve the readings from the memory card */ } /*****************************************************************
/* use the "memory" array to configure the memory card */ char static *memory[] = {"FORM:DATA PACK", "TRAC:DEL:ALL", "TRAC:DEF SET1, 80", "VINS:LBUS:RES", "VINS:LBUS:MODE CONS", "STAT:OPC:INIT OFF"}; /* set packed data format */ /* delete all readings on memory card */ /* store readings (80 bytes) in "SET1" */ /* reset the Local bus chip */ /* set Local bus mode to consume */ /* execute *OPC? after INIT is parsed */ /* Execute each command in "digitizer1" using a loop */ length = (sizeof(digitizer1) / siz
/****************************************************************************/ void initiate(void) { int i = 0, readings = 40, swap = 0, bytes = 0, length = 1, *rdgs; float rdy; char lf_remove[1]; /* dynamically allocate memory for readings */ rdgs = malloc(40 * sizeof(float)); swap = sizeof(int); bytes = 40 * swap; /* allocate computer memory for reading storage */ /* each reading in memory is two bytes */ /* read 80 bytes */ IOOUTPUTS(ADDR_MEM, "INIT", 4); /* initiate the memory card */ IOOUTPUTS(ADDR_
else printf("\nReading %d = %.6E", i, (rdgs[i] * 0.
Comments 1. GENerator Digitizer Configuration. Both channels of the GENerator digitizer are CONFigured for 10 readings on the 5V range. Thus, each block of data generated is four bytes (two bytes/reading), followed by the end-of-block (EOB) and end-of-frame (EOF) flags. The GENerator digitizer’s trigger source is set to ECLT0. This VXI backplane trigger line is controlled by the INSerter digitizer which feeds its (internal) trigger signal to the GENerator digitizer.
5. Aborting the Digitizers. Following interleaved transfers, the Local bus chip of each digitizer is left in an active (running) state. Starting with the leftmost (GENerator) digitizer, it is necessary to ABORt each digitizer before the next use of the Local bus. 6. Reading Sequence and Format.
Index HP E1429A/B Digitizer User’s Manual B *IDN? command, sending, 20 A A/D readings, 137 A24 base address, 344 A24 base address, determining, 147 A24 registers, accessing, 343 Abbreviated Commands, 179 ABORt, 185 ABORt subsystem, 185 Aborting measurements, procedure, 377 Accessing the registers, 343 Addressing the digitizer over HP-IB, 19 Addressing the digitizer using an embedded controller, 19 Analog-to-digital converter, 129 Arm count, setting, 117 Arm delay, setting, 117 Arm immediate, register proc
Using, 39 when to use, 39 CONFigure command, using, 34 CONFigure, taking readings, 40 Configuring the channels, 37 Configuring the digitizer input, register-based, 368 Conformance Information SCPI, 314 Conformity, declaration, 11 Converting packed readings, 136 Coupled Commands Executing, 29 Coupling groups, 182 Coupling groups, with MIN and MAX parameters, 183 D Data flow and storage, 129 Data flow, digitizer, 129 Data format Local bus transfers, 163 VME bus transfers, 153 Data formats, 133 Data Register
dual rate sampling, 55 level arming, 52 Local bus data transfers, 83 pre- and post-arm readings, 53 specifying a sample rate, 54 taking a burst of readings, 51 using, 49 using multiple digitizers, 56 using the digitizer status registers, 101 using the packed data format, 59 VME bus data transfers, 63 VME bus data transfers using an embedded controller, 72 Example programs disk C compiliers used, 31 compiling and linking, 31 Executable when initiated, commands, 183 Executing Coupled Commands, 29 F FETCh? su
Local bus interleaved transfers programming procedure, 407 Local bus programming sequence multiple digitizers and interleaved transfers, 405 multiple digitizers and serial transfers, 160 single digitizer, 160 Local bus transfer configurations, 159 Local bus transfers, digitizer configuration restrictions, 161 Local bus transfers, setting the mode, 162 Local bus, setting the interleaved transfer mode, 406 Locating readings in memory, 142 Locating segmented readings, 143 Locating the data register, 146 Locati
R Rate, arm, 118 Re-initiating the digitizer, 378 READ? subsystem, retrieving readings, 139 Reading and writing to the shift register, 369 Reading resolution, 136 Reading the data register, 153 Readings, locating in memory, 142 Readings, transfer rates, 137 Recalling digitizer configurations *RCL, 175 Reference clock, 124 Reference source setting, 124 Register descriptions arm count, 374 arm delay, 360 arm source, 373 Register interface, 105 Register programming aborting measurements, 377 setting the arm co
Signal phase, changing with registers, 376 Single digitizer, 160 Single-ended input 1V range, 110 Specifications, 317 Specifying the external reference frequency, 124 Standard Commands for Programmable Instruments, SCPI, 184 Standard Event status group, 170 standard event status enable register, 171 standard event status register, 170 Standard Event status register reading, 171 Status Byte register reading, 173 Status Byte status group, 172 Service Request Enable register, 173 Status Byte register, 172 Stat