CompuScope SDK Manua.. - Egmont Instruments

Volume II: 

CompuScope Applications 

Programming Interface 

(API) Reference Manual 

Supporting the 

CompuScope SDK for C/C++ for 

Windows 

for all Gage CompuScope models 

For SDK Version 3.50+ 

P/N: 0045032 

Reorder #: MKT-SWM-SDK25 

0404

© Copyright Gage Applied Technologies, Inc. 2002 

Fourth Edition (May 2002) 

GAGE, GAGESCOPE, GAGEBIT, GAGEPCI, GAGEP500, COMPUSCOPE, COMPUSCOPE 85G, COMPUSCOPE 85GC, COMPUSCOPE 

82G, COMPUSCOPE 8500, COMPUSCOPE 12100, COMPUSCOPE 1250, COMPUSCOPE 14100, COMPUSCOPE 14100C, COMPUSCOPE 

1450, COMPUSCOPE 1602, COMPUSCOPE 1610, COMPUSCOPE 1610C, GSINST, PCIINST, P500INST, 85DETECT, MULTI- 

CARD, COMPUGEN, CGWIN, COMPUGEN 1100, and INSTRUMENT MANAGER, are registered trademarks of Gage Applied 

Technologies, Inc. 

MS-DOS, WINDOWS, WINDOWS 95, WINDOWS 98, WINDOWS NT, WINDOWS ME, AND WINDOWS XP are trademarks of 

Microsoft Incorporated. MATLAB is a trademark of TheMathWorks Inc. LABVIEW and LABWINDOWS/CVI are trademarks of 

National Instruments Corp. IBM, IBM PC, IBM PC/XT, IBM PC AT and PC-DOS are trademarks of International Business 

Machines Corporation. 

Changes are periodically made to the information herein; these changes will be incorporated into new editions of the 

publication. Gage Applied Technologies, Inc. may make improvements and/or changes in the products and/or programs 

described in this publication at any time. 

Copyright © 2002 Gage Applied Technologies, Inc. All Rights Reserved, including those to reproduce this publication or parts 

thereof in any form without permission in writing from Gage Applied Technologies, Inc. 

The installation program used to install the the CompuScope SDKs for Windows, InstallShield, is licensed software provided by 

InstallShield Software Corp., 900 National Parkway, Ste. 125, Schaumburg, IL. InstallShield is Copyright ©1998 by 

InstallShield Software Corp., which reserves all copyright protection worldwide. InstallShield is provided to you for the 

exclusive purpose of installing the CompuScope SDKs. In no event will InstallShield Software Corp. be able to provide any 

technical support for CompuScope SDKs. 

How to reach Gage Applied Technologies, Inc. 

Product Manager - CompuScope SDKs 

Gage Applied Technologies, Inc. 

How to reach Gage from outside North America 

Tel: (514) 633-7447 

Fax: (514) 633-0770 

Toll-free phone: (800) 567-4243 

Toll-free fax: (800) 780-8411 

Online technical support form: 

E-mail: prodinfo@gage-applied.com 

Website: http://www.gage-applied.com 

www.gage-applied.com/support.asp 

Please complete the following section and keep it handy when calling Gage Applied Technologies, Inc. for technical support: 

Owned by: ___________________________ 

Serial Number: ___________________________ 

Purchase Date: ___________________________ 

Purchased From: ___________________________ 

You must also have the following information when you call: 

. Software Driver and Application version 

. Software Development Kit type and version 

· Brand name and type of computer 

· Processor and bus speed 

· Total memory size 

· Information on all other hardware in the computer

Gage Applied Technologies, Inc. Software & Documentation License Agreement 

CAREFULLY READ THE FOLLOWING TERMS AND CONDITIONS BEFORE OPENING THE 

COMPUSCOPE SDK PACKAGE. OPENING THE COMPUSCOPE SDK PACKAGE INDICATES 

ACCEPTANCE OF THESE TERMS AND CONDITIONS. IF YOU DO NOT AGREE WITH THEM, 

PROMPTLY RETURN THE PACKAGE UNOPENED AND YOUR MONEY WILL BE REFUNDED. 

Title to the media on which the program is recorded and to documentation in support thereof is transferred to you, 

but title to the program is retained by Gage Applied Technologies, Inc. You assume responsibility for the selection 

of the program to achieve your intended results, and for the installation, use, and results obtained from the 

program. 

LICENSE 

Under the terms and conditions of this License Agreement you may: 

a) use the program on a single machine; 

b) copy the program into any machine-readable or printed form for backup or modification purposes in support of 

your use of the program on the single machine. Copying of documentation and other printed material is 

prohibited; 

c) modify the program and/or merge it into another program for your use on the single machine (any portion of 

this program merged into another program will continue to be subject to the terms and conditions of this 

Agreement); and 

d) transfer the program and license to another party if the other party agrees to accept the terms and conditions of 

this Agreement. If you transfer the program, you must at the same time either transfer all copies whether in 

printed or machine-readable form to the same party or destroy any copies not transferred; this includes all 

modifications and portions of the program contained or merged into other programs. 

You must reproduce and include the copyright notice on any copy, modification or portion merged into another 

program. 

You may not use, copy, modify, or transfer the program, or any copy, modification or merged portion, in whole or 

in part, except as expressly provided for in this License Agreement. 

If you transfer possession of any copy, modification or merged portion of the program to another party, your 

license is automatically terminated. 

TERMS 

The license is effective until terminated. You may terminate it at any time by destroying the program together with 

all copies, modifications and merged portions in any form. The license will also terminate upon conditions set 

forth elsewhere in this Agreement or if you fail to comply with any term or condition of this Agreement. You 

agree upon such termination to destroy the program together with all copies, modifications and merged portions in 

any form. 

LIMITED WARRANTY 

Gage Applied Technologies, Inc. warrants the media on which the program is furnished to be free from defects in 

materials and workmanship under normal use for a period of one year from the date of delivery to you as 

evidenced by a copy of your receipt. 

THE PROGRAM IS PROVIDED “AS IS” WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR 

IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF MERCHANTABILITY 

AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK TO THE QUALITY AND 

PERFORMANCE OF THE PROGRAMS LIES WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, 

YOU (AND NOT GAGE APPLIED TECHNOLOGIES, INC.) ASSUME THE ENTIRE COST OF ALL 

NECESSARY SERVICING, REPAIR OR CORRECTION. 

SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OF IMPLIED WARRANTIES, SO THE 

ABOVE EXCLUSION MAY NOT APPLY TO YOU. THIS WARRANTY GIVES YOU SPECIFIC LEGAL 

RIGHTS AND YOU MAY ALSO HAVE OTHER RIGHTS WHICH VARY FROM ONE JURISDICTION TO 

ANOTHER. 

Continued on next page

Continued from previous page 

Gage Applied Technologies, Inc. does not warrant that the functions contained in the program will meet your 

requirements or that the operation of the program will be uninterrupted or error free. However, Gage Applied 

Technologies, Inc. warrants the media on which the program is furnished to be free from defects in materials and 

workmanship under normal use for a period of one year from the date of delivery to you as evidenced by a copy of 

your receipt. 

LIMITATIONS OF REMEDIES 

Gage Applied Technologies, Inc.’s entire liability and your exclusive remedy shall be: 

a) with respect to defective media during the warranty period, Gage Applied Technologies, Inc. will replace 

media not meeting Gage Applied Technologies, Inc.’s “Limited Warranty” if returned to Gage Applied 

Technologies, Inc. or its authorized representative with a copy of your receipt, or 

b) if Gage Applied Technologies, Inc. or its representative is unable to deliver replacement media free of defects 

in materials and workmanship, you may terminate the Agreement by returning the program and your money 

will be refunded. 

IN NO EVENT WILL GAGE APPLIED TECHNOLOGIES, INC. BE LIABLE FOR ANY DAMAGES, 

INCLUDING ANY LOST PROFITS, LOST SAVINGS OR OTHER INCIDENTAL OR CONSEQUENTIAL 

DAMAGES ARISING OUT OF THE USE OF OR INABILITY TO USE SUCH PROGRAM, EVEN IF GAGE 

APPLIED TECHNOLOGIES, INC. OR ITS AUTHORIZED REPRESENTATIVE HAS BEEN ADVISED OF 

THE POSSIBILITY OF SUCH DAMAGES, OR ANY CLAIM BY ANY OTHER PARTY. 

SOME JURISDICTIONS DO NOT ALLOW THE LIMITATION OR EXCLUSION OF LIABILITY FOR 

INCIDENTAL OR CONSEQUENTIAL DAMAGES, SO THE ABOVE LIMITATION OR EXCLUSION MAY 

NOT APPLY TO YOU. 

GENERAL 

You may not sublicense, assign or transfer the license or the program except as expressly provided in this 

Agreement. Any attempt otherwise to sublicense, assign or transfer any of the rights, duties or obligations 

hereunder is void. 

This Agreement is governed by the laws of the Province of Quebec, Canada. 

The parties agree that this Agreement be written in English. Les partis consentent à ce que cette entente soit 

rédigée en anglais. 

Should you have any questions concerning this Agreement, you may contact Gage Applied Technologies, Inc. in 

writing. Please check the Gage website (http://www.gage-applied.com/aboutgag/contact.htm) for the most current 

address. 

YOU ACKNOWLEDGE THAT YOU HAVE READ THIS AGREEMENT, UNDERSTAND IT AND AGREE 

TO BE BOUND BY ITS TERMS AND CONDITIONS. YOU FURTHER AGREE THAT IT IS THE 

COMPLETE AND EXCLUSIVE STATEMENT OF THE AGREEMENT BETWEEN US WHICH 

SUPERSEDES ANY PROPOSAL OR PRIOR AGREEMENT, ORAL OR WRITTEN, AND ANY OTHER 

COMMUNICATIONS BETWEEN US RELATING TO THE SUBJECT MATTER OF THIS AGREEMENT.

Global Table of Contents 

Volume I CompuScope C/C++ Software Development Kit 

Manual 

Chapter 1 

Chapter 2 

Chapter 3 

Chapter 4 

Chapter 5 

Appendices 

CompuScope SDK for C/C++ for Windows Preface 

Basic CompuScope Operation 

Introduction to CompuScope Windows Drivers and 

C/C++ SDK 

Writing a C Application for CompuScope Cards 

Sample Programs 

Data Structures Used by CompuScope drivers 

CompuScope Power Management 

Compiling CompuSCope SDK C/C++ Sample 

Programs under LabWindows CVI 

CompuGen Cards 

Volume II CompuScope API Reference Manual 

CompuScope API Routines 

Appendices Comparison of Various Data Transfer Routines 

Frequently Asked Questions 

Multiple/Independent Mode Operation 

Multiple Record Mode Operation

Table of Contents - CompuScope API Reference Manual 

III COMPUSCOPE API ROUTINES 4 

Recommended CompuScope API Subroutines 5 

Recommended Routines - Quick Summary 6 

Driver, System and Board Location Routines 7 

Parameter Control Routines 7 

Address Routines 7 

Data Transfer Routines 8 

Multiple/Independent Mode Routines 8 

Multiple Record Mode Routines 9 

Miscellaneous Routines 9 

Recommended API Routines that Support CompuScope 85G and 85GC 10 

Recommended CompuScope API Subroutines - Detailed Description 11 

gage_abort 12 

gage_abort_capture 13 

gage_board_abort_capture 14 

gage_board_force_capture 15 

gage_board_start_capture 16 

gage_board_type_size_to_text 17 

gage_busy 18 

gage_calculate_addresses 19 

gage_calculate_mra_addresses 20 

gage_calculate_mr_addresses 22 

gage_capture_mode 24 

gage_delay_trigger_32 26 

gage_driver_initialize 28 

gage_driver_remove 31 

gage_force_capture 32 

gage_get_config_filename 33 

gage_get_driver_info 34 

gage_get_driver_info_structure 35 

gage_get_error_code 36 

gage_get_independant_operation 37 

gage_input_control 38 

gage_mem_read_master 39 

gage_multiple_record 40 

gage_multiple_record_acquisitions_32 41 

gage_need_ram 42

gage_normalize_address 43 

gage_power_control 44 

gage_read_config_file 45 

gage_select_board 47 

gage_set_ext_clock_variables 48 

gage_set_independant_operation 49 

gage_software_trigger 50 

gage_start_capture 51 

gage_transfer_buffer 52 

gage_transfer_buffer_3 53 

gage_trigger_control_2 55 

gage_triggered 58 

Legacy CompuScope API Subroutines - Detailed Description 59 

gage_acquire_average 60 

gage_detect_multiple_record 63 

gage_get_boards_found 64 

gage_get_data 65 

gage_get_records 66 

gage_get_status 67 

gage_get_trigger_address 68 

gage_get_trigger_view_offset 69 

gage_gpib_command 70 

gage_init_clock 71 

gage_mem_read_chan_a 72 

gage_mem_read_chan_b 73 

gage_mem_read_dual 74 

gage_mem_read_single 75 

gage_multiple_record_acquisitions 76 

gage_offset_adjust 77 

gage_read_cal_table 78 

gage_read_master_status 79 

gage_set_delay_trigger 80 

gage_set_records 81 

gage_set_trigger_depth 82 

gage_set_trigger_view_offset 83 

gage_support_to_text 84 

gage_transfer_buffer_2 85 

gage_trigger_address 86 

gage_trigger_control 87 

gage_trigger_view_transfer 89 

gage_trigger_view_transfer_2 90 

gage_trigger_view_transfer_3 91 

gage_use_cal_table 92 

CompuScope API Reference Manual 2

IV APPENDICES 93 

Appendix A Comparison of Various Data Transfer Routines 94 

Buffered Access Routines 94 

Single Sample Access Routines 96 

Appendix B Frequently Asked Questions 97 

Appendix C Multiple/Independent Mode Operation 100 

Appendix D Multiple Record Mode Operation 102 

Hardware Perspective 102 

Turning ON Multiple Record 105 

Downloading Multiple Record Data 105 

Embedded Enhanced Trigger Bits 106 

CompuScope API Reference Manual 

3

III 

CompuScope API 

Routines 

This section deals with the Applications Programming Interface (API) C sub-routines that are supported by 

the CompuScope drivers. These routines are used to control all CompuScope hardware functionality and 

are all that a programmer needs to use to get CompuScope hardware up and running. Sample programs 

that illustrate how to use the API subroutines are provided with the CompuScope C/C++ SDK. These 

programs are described in Volume I. 

The CompuScope C/C++ SDK is intended for use with a Windows C compiler. While other environments 

are not officially supported, an intermediate programmer should be able to use the Gage API subroutines 

from other environments. For instance, while Visual Basic is not officially supported, Visual Basic sample 

programs are available from Gage upon request. Furthermore, Visual Basic prototypes are listed for all 

API subroutines in the manual. In addition, C sample programs can be compiled from LabWindows CVI 

by following the guidelines laid out in Volume I of this manual. In fact, the API routines can be called 

from any environment that allows functions within a Dynamically Linked Library (DLL) to be called. The 

user need only make function calls to the gage_drv.dll, the main Gage CompuScope driver DLL, using the 

C sample programs as a guide to subroutine call sequencing. 


Recommended 


Subroutines 

The Recommended CompuScope API Subroutines are the most frequently used routines for application 

programs operating CompuScope hardware. These routines allow all frequently used hardware 

functionality to be optimally exploited. The Recommended routines are used by Gage SDKs and standalone 

software and so are regularly and thoroughly tested. 

The functionality of the Recommended Subroutines are virtually never changed and any changes will be 

documented appropriately in future releases of the drivers. New Recommended Subroutines, however, 

may be added from time to time in order to exploit new features on CompuScope hardware. Please read 

the readme text files installed with the CompuScope drivers and C/C++ SDKs for information relating to 

changes in the API routines. 


5

Recommended Routines 

- Quick Summary 

The recommended CompuScope API Routines are divided in the following categories: 

• Driver, System and Board Location Routines 

• Parameter Control Routines 

• Addresses Routines 

• Data Transfer Routines 

• Multiple/Independent Mode Operation Routines 

• Multiple Record Mode Operation Routines 

• Miscellaneous Routines 

The following tables give the name and brief description of the recommended CompuScope API routines: 


Driver, System and Board Location Routines 

Name of the Routine 

gage_driver_initialize 

gage_driver_remove 

gage_get_config_filename 

gage_get_driver_info 

gage_get_driver_info_structure 

gage_read_config_file 

gage_select_board 

Description 

Fully configures each board found in the system. 

Removes all the data structures from the memory that were 

created by the drivers or the DLL. 

Determines the complete path to the configuration file that 

contains the board location data. 

Fills a structure or record with the relevant information 

from the driver variables as to the current settings for the 

current CompuScope board. 

Returns the relevant information about the main structure 

used by the driver and also retrieves the driver version and 

number. 

Reads the configuration file and stores the data in an array 

of words. 

Sets the driver so that the current board is the board 

identified by the number passed to the routine. 

Parameter Control Routines 


gage_capture_mode 

gage_input_control 

gage_delay_trigger_32 

gage_set_ext_clock_variables 

gage_trigger_control_2 

Sets the data capture mode. 

Description 

Used to set up the input channels of the CompuScope 

boards. 

Ignores the trigger for a specified amount of time 

Sets the needed variables when using an external clock. 

Takes advantage of certain CompuScope boards’ ability to 

have 2 different trigger inputs (source, slope and level) and 

is used to set up the trigger parameters of the CompuScope 

boards. 

Address Routines 


gage_calculate_addresses 

gage_calculate_mra_addresses 

gage_calculate_mr_addresses 

Description 

Returns the start, trigger and end addresses. 

Corrects the trigger address based on the ETB bit 

information located in the data acquired from the card at the 

raw calculated trigger address. 

Returns the start, trigger and end addresses for the specified 

channel of the current board to the calling routine. 


7

Data Transfer Routines 


gage_mem_read_master 

gage_transfer_buffer 

gage_transfer_buffer_3 

Description 

Reads one sample out of CompuScope board’s memory for 

channel A of the master CompuScope board. 

Copies the number of sample points of the CompuScope 

board’s memory space from the specified channel to the 

supplied buffer. 

Similar to the gage_transfer_buffer_2. Returns an offset 

to the beginning of the dword aligned buffer used by the 

driver. 

Multiple/Independent Mode Routines 


gage_abort_capture 

gage_board_abort_capture 

gage_board_force_capure 

gage_board_start_capture 

gage_force_capture 

gage_get_independant_operation 

gage_set_independant_operation 

gage_start_capture 

Description 

Used to regain control of the CompuScope board(s). This 

routine is reconfigured when in Multiple/Independent mode 

to work with independent boards. This reconfiguration is 

done automatically when the 

gage_set_independant_operation routine is called. 

Used to regain the control of the selected CompuScope 

board when in Multiple/Independent mode. 

Used to force the capture of data by the selected 

CompuScope board when in Multiple/Independent mode. 

Used to force the capture of data by the selected 

CompuScope board when in Multiple/Independent mode. 

Forces the capture of data by the CompuScope board(s). 

This routine is reconfigured when in Multiple/Independent 

mode to work with independent boards. This 

reconfiguration is done automatically when the 

gage_set_independent_operation routine is called. 

Used to check if the boards are in Multiple/Independent 

mode or not. 

Sets the driver to initialize the Multiple/Independent mode. 

Prepares the CompuScope hardware for data acquisition. 

This routine is reconfigured when in Multiple/Independent 

mode to work with independent boards. This 

reconfiguration is done automatically when the 

gage_set_independent_operation routine is called. 


Multiple Record Mode Routines 




gage_multiple_record 

gage_multiple_record_acquisitions_32 

Description 

Corrects the trigger address based on the ETB bit 

information located in the data acquired from the card at the 

raw calculated trigger address. 

Returns the starting, trigger and ending addresses for the 

specified channel of the current board to the calling routine. 

Allows the application program to force the CompuScope 

hardware to capture only the depth specified when the 

trigger event occurs. The card then re-arms automatically 

itself to accept another trigger event and record that data 

immediately following the first capture. 

Sets the number of Multiple Record groups that will be 

taken by the CompuScope hardware. 

Miscellaneous Routines 


gage_abort 


gage_board_type_size_to_text 

gage_busy 


gage_get_error_code 

gage_need_ram 

gage_normalize_address 

gage_power_control 

gage_software_trigger 


gage_triggered 

Description 

Used to regain control of the CompuScope board(s). 

Used to regain control of the CompuScope board(s). 

Returns the pointer to the string that contains the 

information about the installed CompuScope board. 

Determines if CompuScope board is busy capturing the data 

or not. 

Forces the capture of data by the CompuScope board(s). 

Returns the error code associated with the last call to the 

CompuScope driver. 

Allows the application program to access the CompuScope 

hardware’s RAM buffers. 

Calculates the logical address for the CompuScope 

hardware. 

Used to control the automatic power management available 

on the CompuScopes equipped with this feature. 

Will trigger the hardware when the trigger source has been 

set to GAGE_SOFTWARE. 

Prepares the CompuScope hardware for data acquisition. 

Determines if the CompuScope hardware has encountered a 

trigger event or not. 


9

Recommended API 

Routines that Support 

CompuScope 85G and 

85GC 

Gage API subroutines were created for CompuScopes that have traditional CompuScope architecture. The 

CompuScope 85G and 85GC has drastically different internal architecture since it was created from 

Tektronix chipsets with their own software protocols. Consequently, support for the CS85G and CS85GC 

was added by “wrapping” existing 85G chipset protocols with existing Gage API subroutine calls. Only a 

subset of the Recommended API subroutines is supported for the CS85G and CS85GC. None of the 

Legacy subroutines are supported for the CS85G and CS85GC. Please note that the CS85G and CS85GC 

do not support PCI bus-mastering data transfer. Consequently, the PCI bus-mastering data transfer 

routines, do not actually do bus-mastering for these CompuScope models. Below is a list of the 

recommended subroutines that are supported for the CS85G and CS85GC. 


gage_busy 















Recommended 


Subroutines - Detailed 

Description 


11

gage_abort 

Syntax 

C: 

void GAGEAPI gage_abort (void); 

Visual BASIC: 

sub gage_abort () 

Remarks 

gage_abort is used to regain control of a CompuScope board, primarily in the event that the CompuScope 

does not finish capturing in the expected time period. This is rare and may indicate hardware problems, 

such as an external clock signal that unexpectedly went inactive. gage_abort forces the board to stop 

capturing data and enter a not busy state. After a gage_abort, valid data in on-board memory may still be 

available for download. Some users have intentionally issued the gage_abort command when they know 

that the signal of interest has already been captured. In order to do another capture, the CompuScope 

hardware must be rearmed using, say, the gage_start_capture command. 

Note that gage_abort routine will only abort the current board, which has to be selected by calling the 

gage_select_board routine. 

Return Value 

None. 

See Also 

gage_busy, gage_abort_capture and gage_select_board. 

Examples 

C: 

gage_abort (); 

Visual BASIC: 

Call gage_abort () 



Syntax 

C: 

void GAGEAPI gage_abort_capture (int16 reset_trigger_source); 

Visual BASIC: 

sub gage_abort_capture (ByVal reset_trigger_source As Integer) 

Remarks 

gage_abort is used to regain control of a CompuScope board, primarily in the event that the CompuScope 

does not finish capturing in the expected time period. gage_abort_capture forces the board to stop 

capturing data and enter a not busy state. The gage_abort_capture routine is similar to gage_abort, 

except that it wipes out the contents of CompuScope on-board memory. In order to do another capture, the 

CompuScope hardware must be rearmed using, say, the gage_start_capture command. 

gage_abort_capture also works for multiple CompuScope board configurations. If data recovery is not 

important in aborting capture using a multiple board CompuScope system, gage_abort_capture should 

usually be used. 

The reset_trigger_source parameter is used to re-initialize the trigger source after the hardware has been 

aborted. This is normally set to the initial trigger source used, which is one of the constants 

(GAGE_CHAN_A, GAGE_CHAN_B, GAGE_EXTERNAL or GAGE_SOFTWARE) defined in the file 

GAGE_DRV.H. 

Return Value 

None. 

See also 

gage_busy and gage_forced_trigger_capture. 

Examples 

C: 

gage_abort_capture (GAGE_CHAN_A); 

Visual BASIC: 

Call gage_abort_capture (GAGE_CHAN_A) 


13

gage_board_abort_capture 

Syntax 

C: 

void GAGEAPI gage_board_abort_capture (int16 mi_board); 

Visual BASIC: 

Sub gage_board_abort_capture (ByVal mi_board As Integer) 

Remarks 

gage_board_abort_capture has identical functionality to the gage_ abort_capture routine, but is used to 

control CompuScopes operating in Multiple Independent mode. 

mi_board is used to specify the CompuScope to which the command will be applied. 

Return Value 

None 

See also 

gage_abort_capture, gage_select_board, gage_set_independant_operation, gage_board_force_capture, 

gage_board_start_capture and Appendix: Multiple/Independent Mode Operation. 

Examples 

C: 

gage_board_abort_capture (mi_board); 

Visual BASIC: 

Call gage_board_abort_capture (mi_board) 


gage_board_force_capture 

Syntax 

C: 

void GAGEAPI gage_board_force_capture (int16 mi_board); 

Visual BASIC: 

Sub gage_board_force_capture (ByVal mi_board As Integer) 

Remarks 

gage_board_force_capture has identical functionality to the gage_force_capture routine, but is used to 



Return Value 

None 

See also 

gage_force_capture, gage_select_board, gage_set_independant_operation, gage_board_force_capture, 

gage_board_start_capture and Appendix: Multiple/Independent Mode Operation.. 

Examples 

C: 

gage_board_force_capture (mi_board); 

Visual BASIC: 

Call gage_board_force_capture (mi_board) 


15

gage_board_start_capture 

Syntax 

C: 

void GAGEAPI gage_board_start_capture (int16 mi_board, int16 auto_trigger); 

Visual BASIC: 

Sub gage_board_start_capture (ByVal mi_board As Integer, ByVal auto_trigger As Integer) 

Remarks 

gage_board_start_capture has identical functionality to the gage_start_capture routine, but is used to 



Return Value 

None 

See also 

gage_start_capture, gage_select_board, gage_set_independant_operation, gage_board_force_capture, 

gage_board_start_capture and Appendix: Multiple/Independent Mode Operation.. 

Examples 

C: 

gage_board_start_capture (mi_board, board.source == GAGE_SOFTWARE); 

Visual BASIC: 

Call gage_board_start_capture (mi_board, auto_trigger) 



Syntax 

C: 

LPSTR GAGEAPI gage_board_type_size_to_text (LPSTR string, uInt32 string_size, uInt32 action, 

uInt32 board, uInt32 far *bt, uInt32 far *eeopt, 

uInt32 far *ver, uInt32 far *max_mem); 

Remarks 

The gage_board_type_size_to_text routine is used to convert the board type parameter, returned by the 

drivers, into a text string that indicates the corresponding CompuScope model and/or memory size. 

The parameter string is a pointer to the string into which the CompuScope name will be returned by the 

routine. string_size is the size of the string pointed to by string. 

action can be one of the following constants defined in GAGE_DRV.H file:- 

GAGE_GBTSTT_BOARD 

GAGE_GBTSTT_MEMORY 

GAGE_GBTSTT_BOTH 

GAGE_GBTSTT_LONG_NAME 

GAGE_GBTSTT_ALL_UPPER_CASE 

0x01 

0x02 

0x03 

0x04 

0x08 

These constants determine in which format the string is returned. The constants can be ‘ORed’ together in 

order to request, say, CompuScope’s LONG_NAME in ALL_UPPER_CASE.. 

board is the CompuScope board number from which information is to be requested (referred to as the 

“currently selected CompuScope”). If this parameter is 0 then the installed hardware is ignored and the 

returned string contents are determined by the following four parameters. 

*bt returns the type of the currently selected CompuScope. This will be a combination of predefined 

constants GAGE_ASSUME_XXXXX, where XXXXX is a board type. Board type constants are defined in 

GAGE_DRV.H file. 

*eeopt returns the available eeprom options for the currently selected CompuScope. The options are 

represented by one or more constants “ORed” together. The available constants are defined in EEPROM.H 

*ver returns the hardware version of the currently selected CompuScope. 

*max_mem returns the size of the memory on the currently selected CompuScope. 

If *bt, *eeopt, *ver and *max_mem values are NULL, the routine will fill them. 

Return Value 

Returns the pointer to the string with above-mentioned parameters. 

See Also: gage_support_to_text 

Examples C: gage_board_type_size_to_text (str, sizeof(str), 1L, 1,NULL, NULL, NULL, NULL); 


17

gage_busy 

Syntax 

C: 

int16 GAGEAPI gage_busy (void); 

Visual BASIC: 

function gage_busy () As Integer 

Remarks 

gage_busy determines if the CompuScope board is busy capturing data. The on-board memory of the 

CompuScope board cannot be accessed while the board is capturing the data. Generally, therefore, 

gage_busy is repeatedly called until it returns a 0 before download of data from on-board CompuScope 

memory is attempted. 

Return Value 

A non-zero or true value is returned if the board is busy (capturing data); otherwise a 0 value is returned. 

See also 


Examples 

C: 

is_busy = gage_busy (); 

Visual BASIC: 

is_busy = gage_busy 



Syntax 

C: 

void GAGEAPI gage_calculate_addresses (int16 chan, int16 op_mode, float tbs, int32 far *trig, 

int32 far *start, int32 far *end); 

Visual BASIC: 

Sub gage_calculate_addresses (ByVal chan As Integer, ByVal op_mode As Integer, ByVal tbs As Single, 

trig As Long, start As Long, ending As Long) 

Remarks 

gage_calculate_addresses gives back the on-board CompuScope memory addresses that are used to 

retrieve the captured samples from the CompuScope on-board memory. This routine returns three 

important addresses - the trigger address, the start address, and the end address - for the specified channel 

of the current CompuScope to the calling routine. The programmer must make sure that the current 

CompuScope board is selected by calling gage_select_board prior to calling gage_calculate_address 

routine. In this manner, the addresses for the current CompuScope card are retrieved. 

The chan parameter controls which channel's addresses on the current board are calculated and returned. 

This parameter should be set to GAGE_CHAN_A. Addresses for both channel A and channel B on a dualchannel-only 

board will always be the same. 

op_mode is either GAGE_SINGLE_CHAN or GAGE_DUAL_CHAN constant for analog input 

CompuScopes. Digital input CompuScopes also support GAGE_QUAD_CHAN constant. Use the value 

that controlled the most recent data capture. 

tbs is the "Time Between Samples" in nanoseconds for the captured signal. For example, if you have 

sampled the signal at 10 MS/s then this value would be 100.0. Similarly, a signal sampled at 1 KS/s would 

require this value to be set to 1000000.0. 

*trig is the address where the trigger event occurred. 

*start will be the first valid address of the most recent data capture. The address holds the first pre-trigger 

data point. 

*end will be the last valid address of the most recent data capture. The address holds the last post-trigger 

data point. 

For a Master/Slave CompuScope system, the trigger, start and end addresses should be calculated using 

gage_calculate_addresses first for all CompuScopes in the system before a data transfer routine is called. 

Return Value 

None. 

See also: gage_normalize_address 

Examples 

C: 

gage_calculate_addresses (GAGE_CHAN_A, gdi.mode, tbs, &trig_addr, &start_addr, &end_addr); 

Visual BASIC: 

Call gage_calculate_addresses (GAGE_CHAN_A, board.opmode, srtable(board.srindex).calc, 

trigger_address, starting_address, ending_address) 


19


Syntax 

C: 

int32 GAGEAPI gage_calculate_mra_addresses (int16 board_type, uInt16 version, int16 chan, 

int16 op_mode, float tbs, int32 far *trig, int32 far *start, 

int32 far *end, int16 data); 

Visual BASIC: 

Function gage_calculate_mra_addresses (ByVal board_type As Integer, ByVal version As Integer, 

ByVal chan As Integer, ByVal op_mode As Integer, 

ByVal tbs As Single, trig As Long, start As Long, 

ending As Long, ByVal ad_data As Integer) As Long 

Remarks 

This routine corrects the trigger addresses when reading the data from a CompuScope Multiple Record 

capture. Due to the architecture of the hardware, the lowest few significant bits (depending on the 

CompuScope model) of the trigger address are not maintained. These bits are called Enhanced Trigger 

Bits (ETBs). With the appropriate CompuScope hardware modification, these bits are embedded within an 

early data point (typically the first) of each Multiple Record group. The gage_calculate_mra_addresses 

routine is used to adjust the trigger address according to the Embedded ETBs. 

Embedded ETBs is a standard feature on most PCI and cPCI CompuScopes. In order to determine if your 

CompuScope manual supports embedded ETBs, run a board information query using the CompuScope 

configuration utility as described in the Driver Installation Guide for CompuScope Cards. The feature will 

show up as MULTIPLE_RECORD_ADJUST. 

The gage_calculate_mra_addresses routine must be called after the raw Multiple Record trigger address 

has been determined by calling the gage_calculate_mr_addresses routine. For a CompuScope with 

embedded ETBs, the trigger address returned by gage_calculate_mr_addresses actually contains the 

address of the data point containing the embedded ETBs. The user then downloads the data point at this 

location and passes it to gage_calculate_mra_addresses as the data parameter. 

gage_calculate_mra_addresses then returns the true adjusted start, trigger and end addresses. 

board_type is the type of the CompuScope hardware being used. The CompuScope board type can be 

determined by calling gage_get_driver_info routine and passing the board_type field to this routine. 

version is the hardware version of the current CompuScope. The CompuScope board version can be 

determined by calling gage_get_driver_info routine and passing the board_version field to 

gage_calculate_mra_addresses routine. 

chan is set to 0 for getting addresses for channel A on current CompuScope, and is set to 1 for getting 

addresses for channel B on current CompuScope. 

op_mode is the mode that was set when calling gage_capture_mode routine. Use the value that 

controlled the most recent data capture, either GAGE_SINGLE_CHAN or GAGE_DUAL_CHAN. 

GAGE_QUAD_CHAN can also be used for digital input CompuScopes such as CS3200. 


sampled the signal at 10 MS/s then this value would be 100.0. Similarly, a signal sampled at 1 kS/s would 


*trig is the adjusted trigger address. 


*start is the adjusted start address. 

*end is the adjusted end address. 

data is the data located at the raw trigger address. The raw trigger address was returned by an earlier call 

to gage_calculate_mr_addresses. The data parameter was then obtained by downloading the 

CompuScope data point at the raw trigger address. Gage recommends that this be done using the 

gage_mem_read_master routine, which correctly handles Master/Slave CompuScope systems. 

Return Value 

The return value is equal to the Enhanced Trigger Bits (ETBs) located in the data sample passed to this 

routine. 

See also 

gage_multiple_record, gage_calculate_mr_addresses and the Appendix entitled Multiple Record Mode 

Operation. 

Examples 

C: 

/* Get the raw addresses. */ 

gage_calculate_addresses (GAGE_CHAN_A, gdi.mode, tbs, &trig_addr, &start_addr, &end_addr); 

/* Read the data at the raw trigger address to retrieve the enhanced trigger bits. */ 

data = gage_mem_read_single (trig_addr); 

/* trig, start and end now hold the adjusted addresses. */ 

gage_calculate_mra_addresses ( gage_driver_info.board_type, gage_driver_info.version, 0, 

GAGE_SINGLE_CHAN, srtable[board.srindex].sr_calc, &trig, &start, 

&end, data); 

Visual BASIC: 

‘ Get the raw addresses. 

Call gage_calculate_addresses(GAGE_CHAN_A, board.opmode, srtable(board.srindex).calc, 

trigger_address, starting_address, ending_address) 

‘ Read the data at the raw trigger address to retrieve the enhanced trigger bits. 

data = gage_mem_read_single (trigger_address) 

‘ trig, start and end now hold the adjusted addresses. 

gage_calculate_mra_addresses(gage_driver_info.board_type, gage_driver_info.version, 0, 

GAGE_SINGLE_CHAN, srtable(board.srindex).sr_calc, trigaddr, 

startaddr, endaddr,data) 


21


Syntax 

C: 

int32 GAGEAPI gage_calculate_mr_addresses (int32 group, int16 board_type, int32 depth, int32 

memory, int16 chan, int16 op_mode, float tbs, int32 far 

*trig, int32 far *start, int32 far *end); 

Visual BASIC: 

Function gage_calculate_mr_addresses (ByVal group As Long, ByVal board_type As Integer, 

ByVal depth As Long, ByVal memory As Long, 

ByVal chan As Integer, ByVal op_mode As Integer, 

ByVal float As Single, trig As Long, startaddr As Long, 

endaddr As Long) As Long 

Remarks 

gage_calculate_mr_addresses gives back three important addresses - the trigger address, the start address, 

and the end address - for the specified channel of the current CopuScope to the calling routine. The 

CompuScope board must have been set to Multiple Record mode with a call to gage_multiple_record 

routine before the data acquisition. After a Multiple Record acquisition, CompuScope on-board memory 

will contain several sequentially stacked captured records, each referred to as a “group”, each of which 

consist only of post-trigger data. Remember to set the current board, using gage_select_board, prior to 

calling gage_calculate_mr_addresses so that the addresses for the proper CompuScope card are retrieved. 

The group parameter is the requested group number for which the addressed will be returned. If the group 

parameter is 1, addresses for the first Multiple Record group are returned. Similarly, -1 returns addresses 

for the last group and n returns addresses for the nth group. A 0 will return the addresses for the entire 

acquisition without regard for the group numbering, treating all the groups as one big acquisition. If the 

group parameter is out of range then the last Multiple Record group is returned. 

board_type is the type of the CompuScope hardware being used. This can be determined by calling 

gage_get_driver_info and passing the board_type field to this routine. 

The depth parameter must be equal to the requested trigger depth for the most recent Multiple Record 

acquisition. Note that this depth refers to the depth of each individual group and not the depth of the entire 

acquisition. For instance, if a user acquired 2048 groups of 1024 points each, then the depth should be set 

to 1024 and not to 1024 x 2048. 

memory is the total amount of memory available during the Multiple Record capture. It is the full depth of 

the channel memory, which depends on the current capture mode, DUAL or SINGLE. This value can be 

obtained from the gage_driver_info_type structure in the max_available_memory field. It will be the full 

memory depth of the CompuScope in single channel mode and half the memory depth in dual channel 

mode. 

chan parameter controls whether a hardware or software Multiple Record is performed. If chan equals 0, a 

hardware Multiple Record address calculation is performed. In hardware multiple record mode, the 

CompuScope card acquires the specified amount of post-trigger data points for the first record, stores the 

record in on-board CompuScope memory, rearms itself and gets ready to capture the next record. This 

process is repeated until the specified number of records are captured and stored in CompuScope on-board 

memory. All data records are stacked sequentially in CompuScope on-board memory. Some extra 


padding between records exists and this padding is accounted for in the address calculation if chan is set 

equal to 0 

The chan equals –1 mode refers to the software multiple record. This option is provided primarily as a 

means of reading Multiple Record SIG files, stored by GageScope ® or by another Gage software utility. 

After a Multiple Record capture, CompuScope memory contains stacked multiple records separated by a 

few points of padding, which varies depending on the CompuScope model. GageScope ® is capable of 

storing all Multiple Records within a single SIG file. For simplicity, GageScope ® removes the inter-record 

padding. So, for instance, for a Multiple Record capture of 2048 records of 1024 points each, GageScope ® 

stores exactly 2048 x 1024 points to the SIG file. If a user wanted to read such a Multiple Record SIG file 

and to calculate the record addresses within the file, he or she should call gage_calculate_mr_addresses 

with chan equals –1. Such a Multiple Record file with no inter-record padding is sometimes called a 

“Software Multiple Record SIG file”. The SIG file header contains a field that indicates that it is a 

Software Multiple Record SIG file. Refer to the GageScope ® manual for the SIG file format information. 

op_mode is the mode that was set when calling gage_capture_mode routine. Use the value that 

controlled the most recent data capture, either GAGE_SINGLE_CHAN or GAGE_DUAL_CHAN. 

GAGE_QUAD_CHAN can also be used for digital input CompuScopes. 


sampled the signal at 10 MS/s then this value would be 100.0. Similarly, a signal sampled at 1 kS/s would 


*trig will be the address where trigger event occurred. It may be adjusted in software, depending on the 

type of hardware being used. 

*start will be the first valid address of the group requested for the most recent data capture. 

*end will be the last valid address of the group requested for the most recent data capture. 

In Multiple Record mode, the start and trigger addresses will typically be the same. In the hardware 

multiple record, the difference between the trigger and end addresses may be larger then the requested 

depth, depending upon the CompuScope hardware being used. This is due to the architecture of the 

hardware and the sample rate being used. 

For a Master/Slave CompuScope system, the trigger, start and end addresses should be calculated using 

gage_calculate_mr_addresses first for all CompuScopes in the system before a data transfer routine is 

called. 

Return Value 

The return value is equal to the Multiple Record group number that corresponds to the returned addresses. 

Normally, this return value will be equal to the group parameter. If the group parameter exceeds the 

actual number of groups, however, then the maximum Multiple Record group number is returned. 

See also: 

gage_multiple_record and the Appendix entitled Multiple Record Mode Operation. 

Examples 

C: group = gage_calculate_mr_addresses (0L, gage_driver_info.board_type, 

gage_driver_info.trigger_depth, gage_driver_info.max_available_memory, 0, GAGE_DUAL_CHAN, 

srtable[board.srindex].sr_calc, *trig, *start, *end); 

Visual BASIC: group = gage_calculate_mr_addresses(0, gage_driver_info.board_type, 

gage_driver_info.trigger_depth, gage_driver_info.max_available_memory, 0, GAGE_DUAL_CHAN, 

srtable(board.srindex).sr_calc, trigaddr, startaddr, endaddr) 


23


Syntax 

C: 

int16 GAGEAPI gage_capture_mode (int16 mode, int16 rate, int16 multiplier); 

Visual BASIC: 

function gage_capture_mode (ByVal mode As Integer, ByVal rate1 As Integer, 

ByVal multiplier As Integer): As Integer 

Remarks 

The gage_capture_mode routine is used to set the mode and sampluing rate that will be used for the next 

CompuScope acquisition. 

mode is the desired mode of capture, either single (GAGE_SINGLE_CHAN) or dual 

(GAGE_DUAL_CHAN). Some CompuScope models may only support one of the two modes. 

GAGE_QUAD_CHAN can also be used for digital input CompuScopes like the CS3200. 

The rate and multiplier values together form the requested sample rate. For example, to request a 10 

MS/s sample rate, the rate would be set to 10 (or preferably GAGE_RATE_10) and multiplier to 

GAGE_MHZ. 

The rate can be any valid value. Check your CompuScope Hardware Manual for valid rates for your 

CompuScope model. The valid multiplier values are as follows and are defined in GAGE_DRV.H file. 

#define GAGE_HZ 1 

#define GAGE_KHZ 2 

#define GAGE_MHZ 3 

#define GAGE_GHZ 4 

#define GAGE_EXT_CLK 5 

The multiplier value GAGE_EXT_CLK is used to set the CompuScope external clock mode, if your 

CompuScope is equipped with the external clock feature. When using external clock, the rate should 

normally be set to 0. The actual external clock rate should be set before calling gage_capture_mode 

routine with a call to gage_set_ext_clock_variables routine. This is an important step, since the drivers 

must know what the actual external clock frequency is in order to appropriately set internal low level 

timing values on the CompuScope hardware. 

On some CompuScope boards (for example CS8500) the values 1, 2, 4, 8 for rate can also be used with 

external clock (multiplier value = GAGE_EXT_CLK). These non-zero settings will decimate thesupplied 

external clock signal by the rate factor, if supported. 

The gage_capture_mode routine is generally only called once before a series of acquisitions in order to set 

the input mode and sampling rate. The call to gage_capture_mode is generally made in conjunction with 

calls to gage_set_ext_clock_variables (if using external clock), gage_multiple_record (if using Multiple 

Record mode), gage_input_control (to control input settings) and gage_trigger_control (to set trigger 

parameters) in order to set up the CompuScope hardware for the next acquisition. These routines need 

only be called once unless you need to change any parameters for a subsequent acquisition. 


Return Value 

If the function is successful then a 1 is returned , which indicates that the requested parameters have been 

successfully set in the CompuScopehardware. If the function fails, then the routine will return a 0 and no 

changes to previous CompuScope settings are made. gage_get_error_code may be called to obtain the 

error code. Possible causes of errors are an invalid mode or invalid sample rate selection. 

See Also 

gage_input_control, gage_trigger_control_2, gage_set_ext_clock_variables and gage_multiple_record. 

Examples 

C: 

gage_capture_mode (GAGE_SINGLE_CHAN, GAGE_RATE_10, GAGE_KHZ); 

Visual BASIC: 

dummy = gage_capture_mode (GAGE_SINGLE_CHAN, GAGE_RATE_10, GAGE_KHZ) 


25


Syntax 

C: 

uInt32 GAGEAPI gage_delay_trigger_32 (int16 action, uInt32 *DelayLow, uInt32 *DelayHigh); 

Visual BASIC: 

Function gage_delay_trigger_32 (ByVal action As Integer, ByVal DealyLow As Long, ByVal DealyHigh 

As Long) As Long 

Remarks 

The gage_delay_trigger_32 routine, when invoked, ignores the trigger for a specified amount of time or 

number of samples. Normally, pre-trigger data will only be captured until an event fulfilling the trigger 

conditions occurs. Ensuring that a specific amount of pre-trigger data are captured can be done by using 

the gage_delay_trigger_32 routine and then calling gage_start_capture. gage_start_capture will then 

ignore triggers until the specified amount of pre-trigger data has been acquired. gage_delay_trigger_32 

allows the amount of pre-trigger data to be specified in points or time. 

GAGE_SET_DELAY_TIME 

This parameter sets the delay time in 100’s of microseconds (µs). For example, when a delay of 1 

millisecond (ms) is desired, this parameter should be set to 10 since 10*100 µs = 1000 µs which 

comes out to be precisely one millisecond. 

GAGE_GET_DELAY_TIME 

When this parameter is specified, the gage_delay_trigger_32 routine returns the value of the 

delay in units of 100’s of µs previously set in the drivers. This value is passed back as the 

DelayLow variable. One effective use of this feature would be to first call 

gage_delay_trigger_32 routine with GAGE_SET_DELAY_SAMPLES parameter, specifying the 

number of samples in delay. Immediately after, the gage_delay_trigger_32 routine could be 

called again with GAGE_GET_DELAY_TIME to retrieve the delay time in 100s of µs. 

GAGE_SET_DELAY_SAMPLES 

This parameter sets the delay time in number of samples. 

GAGE_GET_DELAY_SAMPLES 

When this parameter is specified, the gage_delay_trigger_32 routine returns the value of the 

delay in number of samples previously set in the drivers. 

The DelayLow parameter can be used as an input or output parameter for the delay in time or in number of 

samples. 

As an input, DelayLow is the actual delay value in time (units of 100 µs) when 

GAGE_SET_DELAY_TIME is specified as the action parameter. DelayLow is the delay value in 

number of samples when GAGE_SET_DELAY_SAMPLES is specified as the action parameter. 

DelayLow is the output when the trigger delay time is to be read back. User must specify the 

corresponding value of the trigger delay either in time or number of samples. In case 

GAGE_GET_DELAY_TIME is specified as action parameter, the value of the delay t time will be returned 

as Delaylow in units of 100s of microseconds. Similarly, if GAGE_GET_DELAY_SAMPLES, then 

Delaylow will contain the dealy in samples. 


The DelayHigh parameter is reserved for future use. 

Return Value 

Returns a 0 if the delay values are passed correctly. Returns an unsigned 32 bit integer otherwise. 

See also 

None 

Examples 

C: 

gage_delay_trigger_32 (GAGE_SET_DELAY_TIME, &Delay_Time, &Delay_High); 

Visual BASIC: 

gage_delay_trigger_32 (GAGE_SET_DELAY_TIME, DelayLowAddr, DelayHighAddr); 


27


Syntax 

C: 

int16 GAGEAPI gage_driver_initialize (uInt16 far *records, uInt16 memory); 

Visual BASIC: 

function gage_driver_initialize (records As Integer, ByVal memory As Integer) As Integer 

Remarks 

The gage_driver_initialize routine fully configures each CompuScope found in the system and initializes 

the drivers. From then on, a call to gage_select_board will be required to access any CompuScope. 

Below is a detailed description of the values returned by gage_driver_initialize. These values are used 

internally by other CompuScope API subroutines. Understanding these values is not necessary for most 

users who need only call gage_driver_initialize once and move on. 

The records parameter is a word (2 byte) array, which must be provided by the calling program. Before 

the gage_driver_initialize routine is called, the first half of the records variable must have been 

previously initialized to contain the segment / index for each CompuScope in the system. This is best done 

with a call to the gage_read_config_file routine. Also before the gage_driver_initialize routine is called, 

the second half of the records variable should contain all zeros. The array gage_board_location has been 

made available within the drivers to be passed as the records parameter and is 

GAGE_B_L_BUFFER_SIZE words long. 

CompuScope gage_board_location (defined in GAGE_DRV.H file) array “pseudo structure” 

GAGE_B_L_ELEMENT_SIZE 

GAGE_B_L_STATUS_SIZE 

array index: 0 1 2 3 ... 30 31 32 33 34 35 ... 62 63 

meaning: S1 I1 S2 I2 ... S16 I16 B1 E1 B2 E2 ... B16 E16 

GAGE_B_L_STATUS_START 

where: Sx = segment for CompuScope x, 

Ix = index for CompuScope x, 

Bx = returned board type for CompuScope x, 

Ex = returned status error for CompuScope x. 

/* CompuScope definitions for gage_board_location sizing. */ 

#define GAGE_B_L_MAX_CARDS 16 

#define GAGE_B_L_SIZEOF_ELEMENT 2 

#define GAGE_B_L_ELEMENT_SIZE 2 

#define GAGE_B_L_STATUS_SIZE 2 

#define GAGE_B_L_STATUS_START (GAGE_B_L_MAX_CARDS * 

GAGE_B_L_ELEMENT_SIZE) 


#define GAGE_B_L_BUFFER_SIZE (GAGE_B_L_MAX_CARDS * 

(GAGE_B_L_ELEMENT_SIZE + 

GAGE_B_L_STATUS_SIZE)) 

The recommended method of setting up the gage_board_location array with the CompuScope board 

indices and memory segments is to call the gage_read_config_file routine with a filename argument that 

was determined by a call to by gage_get_config_filename . 

uInt16 gage_board_location[GAGE_B_L_BUFFER_SIZE]; 

The first segment and I/O index locations are: 

gage_board_location[0] = segment; 

gage_board_location[1] = index; 

/* “segment” is a word that is set to equal the desired 

segment for board 1. */ 

/* “index” is a word that is set to equal the desired I/O index 

for board 1. */ 

The format of the array is that the first GAGE_B_L_STATUS_START words contain the CompuScope 

segment and index values, each sequential pair occupying GAGE_B_L_ELEMENT_SIZE words - one for 

each of the possible GAGE_B_L_MAX_CARDS CompuScopes. 

A status field is provided for each potential board location, which is GAGE_B_L_STATUS_SIZE words in 

length. The values for the status field are constants, which correspond to bit positions in the status field 

and must be masked to determine which errors occurred when initializing the CompuScope hardware. The 

low nibble (4 bits) is for problems with the segment and index. GAGE_BAD_LSB_SEGMENT means 

that the low order byte of the segment was not equal to zero. GAGE_BAD_MSB_SEGMENT is used 

when the segment is either less then A000 hex or greater then DF00 hex (the valid area in the memory map 

reserved for slot resources is 0A0000 hex to 0DFFFF hex). GAGE_BAD_LSB_INDEX is set when the 

least significant bit of the index is not zero. GAGE_BAD_MSB_INDEX is used when the high order byte 

of the index is either equal to 00 hex or greater then 03 hex (the valid area in the I/O map reserved for slot 

resources is 0100 hex to 03ff hex). 

If the status bits are zero after the above test, then the board initialization continues. If the expected board 

does not properly respond, then the GAGE_DETECT_FAILED bit is set and initialization stops. If the 

board is found then the board's memory is checked and sized. If any byte of memory does not match its 

preset value then the GAGE_MEMORY_FAILED bit is set and initialization of this board stops. 

The status board word contains the board type found during initialization. This word is set after the driver 

tries to detect the hardware. Therefore, this word could be set but the board is not initialized due to a 

memory error. There is a constant GAGE_ASSUME_XXXXX (where XXXXX is board type) available 

that can be masked with the status word to determine the board type. 

The memory parameter allows the memory self-test to be disabled by supplying the size of the memory in 

kilobytes of the installed board(s). The constant GAGE_MEMORY_SIZE_TEST will force the memory 

test to be performed. Note that the memory size for all installed boards in the master/slave configuration 

must be the same or a conflict can occur and the data returned may be invalid for the boards with the 

incorrect memory size assigned. 

Several memory size constants are available for specifying default memory size for any of the current 

CompuScope cards; GAGE_MEMORY_SIZE_016K, GAGE_MEMORY_SIZE_032K, 

GAGE_MEMORY_SIZE_064K, GAGE_MEMORY_SIZE_128K, GAGE_MEMORY_SIZE_256K, 

GAGE_MEMORY_SIZE_512K, GAGE_MEMORY_SIZE_001M, GAGE_MEMORY_SIZE_002M, 

GAGE_MEMORY_SIZE_004M, GAGE_MEMORY_SIZE_008M and GAGE_MEMORY_SIZE_016M. 


29

The constant GAGE_MEMORY_SIZE_TEST will force the memory test to be performed. If an incorrect 

memory size is found then the status field for the segment and index record in question will have the 

GAGE_BAD_MEMORY_SIZE bit set. If the status is zero and the corresponding segment and index 

record are non-zero, then this particular board was properly initialized. If, however, the status is zero and 

the segment and index record are also zero then the "board" is the premature end of the records array. By 

default the first board found will be selected. 

A local data structure in the driver is created for each board. To allow access to this structure the routine 

gage_get_driver_info has been implemented. gage_get_driver_info queries the driver about information 

on the current selected board. This method should be maintained for compatibility with future releases of 

the CompuScope drivers, rather than using the internal driver variables directly. 

The last area of the status word returns the type of CompuScope board found. These maskable bits can be 

detected by using the GAGE_ASSUME_XXXXX (where XXXXX is a board type) constant. This is 

useful in case the driver could not detect the memory size but was able to detect the CompuScope board 

type. 

Return Value 

The value returned is the number of active CompuScope boards found. If one or more of the boards was 

expected but not found, the number of found boards will be returned as a negative number with the 

absolute value equal to the number of boards actually initialized. A return of zero (0) indicates that either 

no boards are found or there is a problem with the array that has been passed to this routine, preventing 

initialization. 

See also 

gage_read_config_file, gage_get_driver_info and gage_select_board 

Examples 

C: 

gage_driver_initialize((uInt16 far *)gage_board_location, GAGE_MEMORY_SIZE_TEST); 

Visual BASIC: 

boards = gage_driver_initialize(gage_board_location(0), GAGE_MEMORY_SIZE_TEST) 



Syntax 

C: 

void GAGEAPI gage_driver_remove (void); 

Visual BASIC: 

Sub gage_driver_remove () 

Remarks 

gage_driver_remove is used to remove from memory all data structures that were created by the 

CompuScope drivers. This routine should be used upon exit from a CompuScope application program. 

Using gage_driver_remove ensures that the memory allocated by the drivers is returned to the operating 

system for use by other applications. 

Return Value 

None. 

See also 


Examples 

C: 

gage_driver_remove (); 

Visual BASIC: 

Call gage_driver_remove (); 


31


Syntax 

C: 

void GAGEAPI gage_force_capture (int16 reset_trigger_source); 

Visual BASIC: 

Sub gage_force_capture (ByVal reset_trigger_source As Integer) 

Remarks 

gage_force_capture is used to force the capture of data by the CompuScope hardware. The routine is 

primarily used when a trigger event has not occurred in an expected time period. gage_force_capture 

send a electrical signal the CompuScope hardware so that it triggers as if a real trigger event had occurred. 

The reset_trigger_source parameter specifies the trigger source that will be used for the next acquisition 

after gage_force_capture. This is normally set to the initial trigger source used. 

gage_force_capture should be used for single boards or for multiple boards in a Master/Slave 

configuration. Multiple/Independent boards should use the routine gage_board_force_capture, since 

gage_force_capture will force all boards in a Multiple/Independent system to trigger. 

Return Value 

None 

See also 

gage_board_force_capture 

Examples 

C: 

gage_force_capture (board.source); 

Visual BASIC: 

Call gage_force_capture (board.source) 


gage_get_config_filename 

Syntax 

C: 

int16 GAGEAPI gage_get_config_filename (LPSTR cfgfn); 

Visual BASIC: 

function gage_get_config_filename (ByVal cfgfn As String) As Integer 

Remarks 

gage_get_config_filename determines the complete path to the configuration file that contains the board 

location data created by a Windows-based configuration utility (such as Gage Config or Instrument 

Manager). The configuration file is called GAGESCOP.INC and resides in the same Windows directory 

as the CompuScope driver DLL (gage_drv.dll). 

cfgfn is a string variable that must be long enough to hold the returned path. 

Return Value 

A true value is returned, if the routine successfully returned the configuration filename. 

See also 


Examples 

C: 

ret = gage_get_config_filename ((LPSTR)(board_loc_file)); 

Visual BASIC: 

i = gage_get_config_filename (board_loc_file) 


33


Syntax 

C: 

void GAGEAPI gage_get_driver_info ((gage_driver_info_type far *)(driver_info)); 

Visual BASIC: 

Sub gage_get_driver_info (driver_info As gage_driver_info_type) 

Remarks 

gage_get_driver_info fills a structure or record with driver variables that describe the current settings nn 

the current CompuScope hardware. 

The driver_info structure is a subset of the record used by the driver and includes only those values that 

have meaning to the control program. 

It is recommended that the gage_get_driver_info_structure subroutine be used to determine the size of 

the structure of type gage_driver_info_type, so that it can be dynamically allocated. For further details on 

this structure type, please see the Appendix: Data Structures Used by Gage Drivers in the CompuScope 

C/C++ SDK Manual. 

Return Value 

None. 

See Also 


Examples 

C: 

gage_get_driver_info ((gage_driver_info_type far*)(&driver_info)); 

Visual BASIC: 

Call gage_get_driver_info (driver_info) 



Syntax 

C: 

void GAGEAPI gage_get_driver_info_structure (uInt16 far *major_version, uInt16 far *minor_version, 

uInt16 far *board_support, gage_driver_info_type far * far * gdi, 

int32 far *gdi_size); 

Visual BASIC: 

Sub gage_get_driver_info (major_version As Integer, minor_version As Integer, board_support As 

Integer, gdi As gage_driver_info_type, gdi_size As Long) 

Remarks 

gage_get_driver_info_structure returns relevant information about the main structure of type 

gage_driver_info_type that is used by the CompuScope drivers. It is recommended that 

gage_get_driver_info_structure be called before calling gage_get_driver_info in order to determine the 

size of the gage_driver_info_type structure type for memory allocation purposes. This procedure will 

maintain compatibility with future versions of the CompuScope drivers, where the size of the 

gage_driver_info_type may increase. 

The major_version and minor_version parameters return the current CompuScope driver version. 

board_support returns the CompuScope boards that are supported by the current CompuScope drivers. 

This will be a combination of predefined constants GAGE_ASSUME_XXXXX, where XXXXX is a board 

type. Board type constants are defined in the file GAGE_DRV.H. 

The gdi parameter returns a pointer to the structure of type gage_driver_info_type that is allocated and 

filled by the CompuScope drivers. This structure is a subset of the more complete record used by the 

drivers and includes only those values that have meaning to the control program. 

gdi_size is the current size of to a structure of type gage_driver_info_type in the current version of the 

CompuScope drivers. gdi_size can be used to allocate the proper amount of memory to hold a structure of 

type gage_driver_info_type,. This variable is very useful since the size of gage_driver_info_type can 

increase with newer driver versions. Using gdi_size ensures that an application program can be easily 

updated for newer CompuScope driver versions. The new drivers can then be used without having to 

recompile the application program. Note that any new fields will be unavailable to the application program 

until it is recompiled with the new header files. 

Return Value 

None. 

See Also: gage_get_driver_info 

Examples 

C: 

gage_get_driver_info_structure ((uInt16 far *)(&major_version), (uInt16 far *)(&minor_version), 

(uInt16 far *)(&board_support),(gage_driver_info_type far * far *)(&gdi), 

(int32 far *)(&gdi_size)); 

Visual BASIC: 

Call gage_get_driver_info_structure(major_version, minor_version, board_support, gdi, gdi_size) 


35

gage_get_error_code 

Syntax 

C: 

int16 GAGEAPI gage_get_error_code(void); 

Visual BASIC: 

Function gage_get_error_code () As Integer 

Remarks 

gage_get_error_code returns the error code associated with the last call to the CompuScope drivers. 

Return Value 

The return value is a combination of the error that occurred and the CompuScope board that caused the 

error. The function returns a value, which is encoded with the high byte containing the CompuScope board 

in error, and the low byte is set equal to the defined error constant. These error code constants are defined 

in gage_drv.h – one of the common CompuScope driver files. For instance, GAGE_NO_ERROR indicates 

that no error actually occurred, while GAGE_NO_SUCH_COUPLING indicates that the requested input coupling was 

not available on the selected CompuScope. 

Examples 

C: 

error = gage_get_error_code (); 

Visual BASIC: 

ret = gage_get_error_code() 


gage_get_independant_operation 

Syntax 

C: 

int16 GAGEAPI gage_get_independant_operation (void); 

Visual BASIC: 

Function gage_get_independant_operation () As Integer 

Remarks 

gage_get_independant_operation is used to check if the boards are in Multiple/Independent mode. 

Return Value 

A non-zero value is return if the boards are in Multiple/Independent mode, and a zero is returned if they are 

not in Multiple/Independent mode. 

See also 

gage_set_independant_operation and Appendix: Multiple/Independent Mode Operation. 

Examples 

C: 

independent = gage_get_independant_operation(); 

Visual BASIC: 

independent = gage_get_independant_operation 


37


Syntax 

C: 

int16 GAGEAPI gage_input_control (int16 channel, int16 enable, int16 coupling, int16 gain); 

Visual BASIC: 

Function gage_input_control (ByVal channel As Integer, ByVal enable As Integer, 

ByVal coupling As Integer, ByVal gain As Integer) As Integer 

Remarks 

gage_input_control is used to set up the input parameters for each signal input channel on CompuScope 

hardware. 

The channel parameter is either channel A (constant GAGE_CHAN_A defined in GAGE_DRV.H) or 

channel B (constant GAGE_CHAN_B defined in GAGE_DRV.H). 

The enable parameter either enables the channel to capture data or disables the data capture on that 

channel. The constants GAGE_INPUT_ENABLE or GAGE_INPUT_DISABLE should be used. This 

functionality is not useful on modern CompuScopes and the user should simply enable all channels. 

coupling controls the input coupling (either DC or AC ) and is set using the constants GAGE_DC and 

GAGE_AC. 

The gain parameter controls the input ranges for each input channel. Possible constants are listed in the 

Appendix: Data Structures Used by CompuScope Drivers in the CompuScope C/C++ SDK Manual. For 

instance, in order to set the input range to ±1 Volts, the user should assign GAGE_PM_1_V to the gain 

parameter. 

In single channel mode, both channels should be set to the same parameters. 

To set the impedance for an input channel, the gain should be bitwise "ORed" with the desired impedance, 

either GAGE_1_MOHM_INPUT or GAGE_50_OHM_INPUT. For instance, in order to set the input 

range to ±1 Volts with an input impedance of 50 Ohms, the user should assign (GAGE_PM_1_V | 

GAGE_50_OHM_INPUT) to the gain parameter, where "|" is C syntax for bit-wise OR. 

Some CompuScopes, such as the CompuScope 1610, support two input types: single-ended or differential. 

To set the input type for an input channel, the gain should be bitwise "ORed" with the desired input type, 

either GAGE_SINGLE_ENDED_INPUT or GAGE_DIFFERENTIAL_INPUT. For instance, in order to 

set the input range to ±1 Volts and input type of differential, the user should assign (GAGE_PM_1_V | 

GAGE_DIFFERENTIAL_INPUT) to the gain parameter, where "|" is C syntax for bit-wise OR. 

Return Value 

A 1 is returned if the routine has successfully set the requested input control parameters. A 0 is returned if 

the routine fails to implement requested input control parameters. gage_get_error_code may be called to 

obtain the error code. You should always check the return value. 

See also: gage_trigger_control_2 and gage_capture_mode 

Examples 

C: gage_input_control (GAGE_CHAN_A, GAGE_INPUT_ENABLE, GAGE_DC, GAGE_PM_1_V | 

GAGE_1_MOHM_INPUT); 

Visual BASIC: dummy = gage_input_control (GAGE_CHAN_A, GAGE_INPUT_ENABLE, 

GAGE_DC,GAGE_PM_1_V OR GAGE_1_MOHM_INPUT) 


gage_mem_read_master 

Syntax 

C: 

int16 GAGEAPI gage_mem_read_master (int32 location); 

Visual BASIC: 

Function gage_mem_read_master (ByVal location As Long) As Integer 

Remarks 

gage_mem_read_master reads one sample out of the on-board memory of the Master CompuScope in a 

Master/Slave CompuScope system. It can used in a loop to retrieve data from a range of addresses from 

the Master CompuScope board. 

location is an address in the CompuScope memory from which a single sample point will be retrieved. 

The gage_calculate_addresses routine is very useful for determining the range of CompuScope on-board 

memory addresses that contains valid data from the latest acquisition. gage_calculate_addresses returns 

the start, trigger and end address for the last CompuScope acquisition. 

Return Value 

The return value is the raw data sample downloaded from the address location in the on-board memory of 

the Master CompuScope. 

See also 

gage_calculate_addresses. 

Examples 

C: 

data = gage_mem_read_master (address); 

Visual BASIC: 

data = gage_mem_read_master (address) 


39

gage_multiple_record 

Syntax 

C: 

void GAGEAPI gage_multiple_record (uInt16 mode); 

Visual BASIC: 

Sub gage_multiple_record (ByVal mode As Integer) 

Remarks: 

gage_multiple_record is used to put the CompuSCope hardware in Multiple Record Mode. In Multiple 

Record mode, the CompuScope hardware captures a record of the specified depth after a trigger event 

occurs. After an acquisition, the CompuScope then re-arms itself to accept another trigger event and 

record the data immediately following the first capture. Sequential data records are stacked in 

CompuScope on-board memory. The Multiple Record process continues until a previously specified 

number of Multiple Records has been captured. Throughout Multiple Record operation, the CompuScope 

BUSY signal remains active. 

The CompuScope TRIGGER signal can be monitored using the gage_triggered routine. This monitoring 

can used during the Multiple Record operation in order to how many Multiple Records have been acquired, 

if the trigger repetition rate is slow enough. The CompuScope board cannot be busy when accessing onboard 

memory. Consequently, data cannot be downloaded until the Multiple Record operation has been 

terminated. The BUSY status must be checked with the gage_busy routine in order to verify that Multiple 

Record operation is complete before downloading data. 

The mode parameter must be set to 1 in order to enable Multiple Record Mode. The mode parameter must 

be set to 0 in order to return to conventional Single Record Mode. By default, the CompuScope drivers set 

the hardware to be in Single Record Mode upon initialization. 

VERY IMPORTANT: When the Multiple Record feature is to be used, the gage_capture_mode, 

gage_input_control and gage_trigger_control_2 routines must be called (to set internal variables) after 

calling gage_multiple_record, regardless of whether the CompuScope settings need to be changed. 

Multiple Record capability is standard only on some CompuScope models. Check your CompuScope 

hardware manual in order to determine if Multiple Record mode is available on your CompuScope model. 

Return Value: None 

See also 

gage_start_capture, gage_busy, gage_triggered, gage_multiple_record_acquisitions_32 and Appendix: 

Multiple Record Mode Operation. 

Examples 

C: 

gage_multiple_record (1); 

Visual BASIC: 

Call gage_multiple_record (1) 


gage_multiple_record_acquisitions_32 

Syntax 

C: 

uInt32 GAGEAPI gage_multiple_record_acquisitions_32 (uInt32 number); 

Visual BASIC: 

Function gage_multiple_record_acquisitions_32 (ByVal number As Integer) As Integer 

Remarks: 

gage_multiple_record_acquisitions_32 sets the number of Multiple Record groups that will be acquired 

by the CompuScope hardware during the next Multiple Record acquisition. This routine is only available 

for PCI and cPCI CompuSocpes (the CP500-class boards) 

number is the number of Multiple Record groups. 

This routine should be called immediately after calling the gage_multiple_record routine. 

Return Value 

Returns the number of groups requested. If the number of groups requested exceeds the maximum 

possible supported by the CompuScope hardware, the routine then returns the maximum supported number 

of groups. 

See also 

gage_multiple_record and Appendix: Multiple Record Mode Operation. 

Examples 

C: 

gage_multiple_record_acquisition_32 (10); 

Visual BASIC: 

Call gage_multiple_record_acquisitions_32 (10) 


41

gage_need_ram 

Syntax 

C: 

void GAGEAPI gage_need_ram (int16 need); 

Visual BASIC: 

Sub gage_need_ram (ByVal need As Integer) 

Remarks 

gage_need_ram allows the application program to access the CompuScope hardware’s RAM buffers to 

download the data that have been captured by the board. The routine is primarily used to turn off the 

power to CompuScope analog conversion circuitry when the power mode is set to AUTO, as controlled by 

the gage_power_control routine. 

need can be either 1 or 0. 

gage_need_ram(1) allows the application program to access the CompuScope board’s memory. 

gage_need_ram(0) connects the CompuScope memory back to the acquisition bus, allowing data capture. 

The gage_need_ram routine must be called with a value of 1 before using any of the data transfer routines 

to allow access to the CompuScope memory. When finished, gage_need_ram(0) should be called to allow 

data capture to occur again. 

You must get all trigger addresses using the gage_calculate_addresses routines before you call 

gage_need_ram(1). Also, for a Master/Slave CompuScope Multi-card system, the trigger addresses 

should be calculated first for all CompuScopes in the system before gage_need_ram(1) is called. 

Return Value 

None. 

See also 

gage_busy 

Examples 

C: 

gage_need_ram (TRUE); 

Visual BASIC: 

Call gage_need_ram (TRUE) 


gage_normalize_address 

Syntax 

C: 

int32 GAGEAPI gage_normalize_address (int32 start, int32 address, int32 ram_size); 

Visual BASIC: 

Function gage_normalize_address (ByVal start As Long, ByVal address As Long, 

ByVal ram_size As Long) As Long 

Remarks 

gage_normalize_address calculates the distances between CompuScope memory addresses to allow the 

application programmer to compare different addresses obtained from the gage_calculate_addresses 

function. This routine manipulates the addresses obtained from gage_calculate_addresses to allow the 

application program to compare their values accounting for the memory rollover that occurs with the 

circular buffer architecture used by all versions of the CompuScope hardware. 

For instance, suppose that there a CompuScope with 1 MegaSample of on-board memory had been filled 

with pre-trigger data. In this case, we might encounter a situation where the memory rollover occurred 

during the capture of post-trigger data. In this case, the trigger address might be 950,000 while the end 

address was 50,000. Determining the number of post-trigger points by subtracting the trigger address from 

the end address would incorrectly yield a negative number. The correct number of points could be 

calculated by calling gage_normalize_address with arguments of the trigger address, the ending address 

and the amount of on-board CompuScope memory. 

start is the address from where you want to start calculating. 

address is any address that is of interest in the CompuScope memory. 

ram_size is the size of the CompuScope memory on the card in question. This size can be determined with 

a call to the gage_get_driver_info routine. 

Return Value 

The return value is the difference between address and start accounting for any memory buffer rollover 

that may have occurred as determined by ram_size. Note that start does not necessarily need to be the 

starting address. Any two addresses can be compared using this routine. 

See also 

gage_calculate_addresses and gage_get_driver_info 

Examples 

C: 

address = gage_normalize_address (trigger_address, end_address, max_available_memory); 

Visual BASIC: 

address = gage_normalize_address (trigger_address, end_address , max_available_memory) 


43

gage_power_control 

Syntax 

C: 

int16 GAGEAPI gage_power_control (int16 mode); 

Visual BASIC: 

Function gage_power_control (mode As Integer) As Integer 

Remarks 

gage_power_control is used to control the automatic power management available on some CompuScope 

models. These models are able to power down the high power analog conversion circuitry when it is not in 

use for power conservation and for minimizing wear and tear on the circuitry. By default, CompuScope 

models that consume a lot of power, such as the CS8500 and CS82G, are set to AUTO mode. In this 

mode, the conversion circuitry power is automatically turned on before an acquisition and then is turned 

off after the acquisition. 

For the acquisition of multiple triggers with a high repeat rate, the user may want to change the power 

mode to ON, from its default of AUTO. This way, the power is left on through the multiple acquisitions, 

so that no time is wasted turning the power on and off between acquisitions, which may take several 

milliseconds. The user must take care to return the power to AUTO mode after the multiple trigger 

acquisitions are finished. 

The mode can be one of three predefined constants, which can either be GAGE_POWER_ON (1), 

GAGE_POWER_OFF (0) or GAGE_POWER_AUTO_MASK (0x0002) defined in GAGE_LOW.H file. 

GAGE_POWER_ON turns on the power to CompuScope analog conversion circuitry leaves it on. In this 

mode, power is not turned off by calling gage_need_ram(TRUE). This mode is useful for fast repetitive 

capture, where the user does not want to waste time controlling the power between acquisitions. 

GAGE_POWER_OFF turns off the power. This mode is useful if your computer is left on but the 

CompuScope board is not in use. 

GAGE_POWER_AUTO_MASK turns the CompuScope board on and off automatically when 

appropriate, thereby conserving power. The CompuScope conversion circuitry is turned on when 

CompuScope capture begins by the gage_start_capture routine and is turned off when 

gage_need_ram(TRUE) is called and before data transfer is initiated. 

Return Value 

The return value is the mode passed to the board. If the mode is invalid or power control is not supported 

on the board, a negative value is returned. 

See also: gage_need_ram 

Examples: C: pw = gage_power_control (GAGE_POWER_AUTO_MASK); 

Visual BASIC: pw = gage_power_control (GAGE_POWER_AUTO_MASK) 



Syntax 

C: 

int16 GAGEAPI gage_read_config_file (LPSTR filename, uInt16 far *records); 

Visual BASIC: 

Function gage_read_config_file (ByVal filename As String, records As Integer) As Integer 

Remarks 

gage_read_config_file reads a file and stores the data in an array of words. 

filename is a text string that tells the routine the name of the file that contains the indices and starting 

segment values for each of the installed CompuScope boards. This filename is usually determined by 

calling gage_get _config_filename, which provides the full path and filename of the GAGESCOP.INC 

file that the Windows drivers use for locating the CompuScope hardware. Alternatively, the filename can 

be explicitly passed to the gage_read_config_file routine, if the user wishes to use an alternate 

configuration file. 

The records parameter is assumed to be an uninitialized word (2 byte) array. The array is initialized by 

gage_read_config_file with the values found in the configuration file. The status elements of records are 

all initialized to 0. The array gage_board_location has been made available within the drivers to be passed 

as the records parameter and is GAGE_B_L_BUFFER_SIZE words long. 

Please note that CompuScope memory segment and index values are variable for ISA and ISA/PCI 

CompuScopes only. For PCI (CP500) CompuScopes, the memory segments and index values will always 

be returned as 0xffff (65535 decimal). 

CompuScope gage_board_location (defined in GAGE_DRV.H file) array “pseudo structure” 

GAGE_B_L_ELEMENT_SIZE 

GAGE_B_L_STATUS_SIZE 

array index: 0 1 2 3 ... 30 31 32 33 34 35 ... 62 63 

meaning: S1 I1 S2 I2 ... S16 I16 B1 E1 B2 E2 ... B16 E16 

where: Sx = segment for CompuScope x, 

Ix = index for CompuScope x, 

Bx = returned board type for CompuScope x, 

Ex = returned status error for CompuScope x. 

/* CompuScope definitions for gage_board_location sizing. */ 

#define GAGE_B_L_MAX_CARDS 16 

#define GAGE_B_L_SIZEOF_ELEMENT 2 

#define GAGE_B_L_ELEMENT_SIZE 2 

#define GAGE_B_L_STATUS_SIZE 2 

GAGE_B_L_STATUS_START 


45

#define GAGE_B_L_STATUS_START (GAGE_B_L_MAX_CARDS * 

GAGE_B_L_ELEMENT_SIZE) 

#define GAGE_B_L_BUFFER_SIZE (GAGE_B_L_MAX_CARDS * 

(GAGE_B_L_ELEMENT_SIZE + 

GAGE_B_L_STATUS_SIZE)) 

The format of the array is: first GAGE_B_L_STATUS_START words are for the CompuScope segment 

and index values, each pair occupying GAGE_B_L_ELEMENT_SIZE words, for each of the possible 

GAGE_B_L_MAX_CARDS boards. A status field is provided for each potential CompuScope location 

that is GAGE_B_L_STATUS_SIZE words in length. The values for the status fields are initialized to 0 by 

gage_get _config_filename. The status fields are updated by the gage_driver_initialize routine, whose 

description explains their meaning. 

Return Value 

If the return value is greater than 0, it represents the number of records initialized. 

If the number is less than zero, it corresponds to the error encountered. The errors are: 

-1 file does not exist. 

-2 file cannot be opened. 

-3 file size cannot be determined. 

-4 file size module four is not zero. 

-5 file size indicates that more boards than the driver supports are present. 

-6 file cannot be read successfully. 

-7 file cannot be closed. 

(0 is reserved for future use.) 

See also 

gage_driver_initialize and gage_get_config_filename 

Examples 

C: 

expected = gage_read_config_file ((char far*)("GAGESCOP.INC"), 

(uInt16 far*)(&gage_board_location)); 

Visual BASIC: 

expected = gage_read_config_file (board_loc_file, gage_board_location (0)) 


gage_select_board 

Syntax 

C: 

int16 GAGEAPI gage_select_board (int16 board); 

Visual BASIC: 

Function gage_select_board (ByVal board As Integer) As Integer 

Remarks 

The gage_select_board routine is for use with a Multi-Card CompuScope system. Once called with an 

argument that specifies the board number, gage_select_board directs subsequent subroutine calls to this 

specified board. 

In a Master/Slave CompuScope system, the Master controls many functions, such as the sampling rate and 

trigger controls. Furthermore, only the Master CompuScope needs to be sent the gage_start_capture 

command and only the Master needs to be polled with gage_triggered and gage_busy. Commands that 

control these functionalities that are managed by the Master CompuScope are automatically only sent to 

the Master CompuScope. However, the captured data must be downloaded separately from each 

CompuScope in the Master/Slave system. Also, channel parameters, such as input range, coupling and 

terminating impedance must be separately sent to each CompuScope, after calling the gage_select_board 

routine. 

In a Multiple/Independent CompuScope system, all functions (i.e. the initialization, setup, capture and data 

transfer) must be performed separately for each CompuScope, using gage_select_board routine. 

The board number is the CompuScope board to which all subsequent subroutines call will be applied. The 

board number assignments can be determined using a CompuScope configuration utility, such as Gage 

Config or Instrument Manager. 

Return Value 

The integer returned equals the value passed to the function as board. If an error occurs or the value 

passed to the function exceeds the number of boards installed in the system then the return value does not 

equal board and gage_get_error_code may be called to obtain the error code. 

See also 


Examples 

C: 

current_board = gage_select_board (i); 

Visual BASIC: 

current_board = gage_select_board (i) 


47

gage_set_ext_clock_variables 

Syntax 

C: 

void GAGEAPI gage_set_ext_clock_variables (int16 op_mode, uInt16 external_clock_delay, 

float external_clock_rate); 

Visual BASIC: 

Sub gage_set_ext_clock_variables (ByVal op_mode As Integer, ByVal external_clock_delay As Integer, 

ByVal exterrnal_clock_rate As Single) 

Remarks 

gage_set_ext_clock_variables is used to set the required variables for use of an external clock. Signal. 

Not all CompuScopes are equipped with an external clock input. On some CompuScope models, such as 

the CS12100, it is an optional modification, which must be purchased with the CompuScope. 

gage_set_ext_clock_variables should be called before the gage_capture_mode routine. If you are using 

an external clock, you must use the GAGE_EXTERNAL_CLOCK constant as the rate and multiplier 

values when calling the gage_capture_mode routine. 

op_mode is a current CopmuScope operating mode, which should be set using the constants 

GAGE_SINGLE_CHAN or GAGE_DUAL_CHAN (or GAGE_QUAD_CHAN for digital CompuScopes). 

The external_clock_delay parameter sets the clock delay to synchronize the external clock to the 

CompuScope board. Using a value of -1 will let the drivers calculate this value. Use another value to 

override this option. The values calculated by the driver will be 0 if the sample rate is greater than 5 MHz 

or the maximum of 1 and 10,000 / external_clock_rate otherwise. It is recommended that –1 be used for 

the external_clock_delay. 

external_clock_rate is frequency of the signal connected to the EXTERNAL CLOCK input of the 

CompuScope. It is important that this value be set correctly, since the CompuScope hardware needs to 

know this value so that the drivers can set internal CompuScope timing parameters. 

The frequency at which sampled data will be stored in memory may differ from the external_clock_rate. 

For instance for the CS1602, the sampling rate is one-eighth of the external_clock_rate. For the CS12100 

with the regular external clock upgrade, the sampling rate is one-half of the external_clock_rate, when the 

CS12100 is in dual channel mode. 

Return Value: None 

See also: gage_capture_mode 

Examples: C: 

gage_set_ext_clock_variables (GAGE_SINGLE_CHAN,-1, 10000000.0); 

Visual BASIC: 

Call gage_set_ext_clock_variables (GAGE_SINGLE_CHAN,-1, 10000000.0) 


gage_set_independant_operation 

Syntax 

C: 

void GAGEAPI gage_set_independant_operation (int16 independant); 

Visual BASIC: 

Sub gage_set_independant_operation (ByVal independant As Integer) 

Remarks 

gage_set_independant_operation sets the driver to initialize the Multiple/Independent CompuScope 

operation mode. In Multiple/Independent mode, two or more CompuScopes can be operated completely 

independently of each other with completely different CompuScope parameters. 

Before initializing the CompuScope hardware, with the gage_driver_initialize routine, the 

gage_set_independant_operation routine must be called to enable Multiple/Independent CompuScope 

operation. Before setting up each board with the desired parameters, you should select the board by calling 

the gage_select_board routine. 

When operating CompuScopes in Multiple/Independent mode, the routines; gage_board_start_capture, 

gage_board_force_capture and gage_board_abort_capture should be used in place of 

gage_start_capture, gage_force_capture and gage_abort_capture, respectively. These routines select 

the appropriate board internally. 

The independant parameter when used with a non-zero value will set the CompuScope hardware for 

Multiple/Independent operation. 

Once the CompuScope hardware has been set for independent mode the routine 

gage_set_independant_operation with the value 0 for the independant parameter can be called to disable 

Multiple/Independent operation. gage_set_independant_operation must be called before calling the 

gage_driver_initialize routine when independent operation mode is required. 

Return Value 

None 

See also 

gage_get_independant_operation, gage_board_start_capture, gage_board_force_capture, 

gage_board_abort_capture and Appendix H: Multiple/Independent Mode Operation. 

Examples 

C: 

gage_set_independant_operation (1); 

Visual BASIC: 

Call gage_set_independant_operation (1) 


49

gage_software_trigger 

Syntax 

C: 

void GAGEAPI gage_software_trigger (void); 

Visual BASIC: 

Sub gage_software_trigger () 

Remarks 

A call to the gage_software_trigger routine will trigger the hardware immediately, if the trigger source 

has been previously set to GAGE_SOFTWARE. 

The gage_start_capture routine will automatically software trigger the CompuScope hardware, if it is 

passed a non-zero argument. 

Return Value 

None. 

See also 

gage_trigger_control_2 and gage_start_capture 

Examples 

C: 

gage_software_trigger (); 

Visual BASIC: 

Call gage_software_trigger () 



Syntax 

C: 

void GAGEAPI gage_start_capture (int16 auto_trigger); 

Visual BASIC: 

Sub gage_start_capture (ByVal auto_trigger As Integer) 

Remarks 

gage_start_capture is used to start the CompuScope hardware acquiring pre-trigger data and awaiting a 

trigger event.. The hardware must have been previously configured for the desired operation mode, input 

ranges and trigger conditions with calls to gage_capture_mode, gage_input_control and 

gage_trigger_control_2. 

In a Master/Slave CompuScope system, gage_start_capture starts acquisition on all CompuScopes in the 

system. 

The auto_trigger parameter, when assigned a non-zero value, causes gage_start_capture to trigger the 

CompuScope hardware immediately after starting data capture. The trigger source must have been 

previously set to GAGE_SOFTWARE for this parameter to have a predictable effect with all versions of 

CompuScope boards. Please note that is the auto_trigger parameter, which must be set to 0 for software 

triggering and not the trigger source. If software triggering is not required, then the auto_trigger value 

should be set to 1. 

Return Value 

None. 

See also 


Examples 

C: 

gage_start_capture (GAGE_SOFTWARE == board.source); 

Visual BASIC: 

Call gage_start_capture (auto_trigger) 


51


Syntax 

C: 

void GAGEAPI gage_transfer_buffer (int32 ta, int16 channel, void far *buffer, int32 nsamples); 

Visual BASIC: 

Sub gage_transfer_buffer (ByVal ta As Long, ByVal channel As Integer, buffer As Integer, ByVal 

nsamples As Integer) 

Remarks 

gage_transfer_buffer is used to copy nsamples points from the specified channel to the supplied buffer 

beginning from CompuScope on-board memory address ta. The channel can be either GAGE_CHAN_A 

or GAGE_CHAN_B, and refers to the A/D converter memory bank. The relevant addresses can be 

obtained by calling gage_calculate_addresses. The buffer must have been previously typecast to the 

appropriate size. For 8 bit CompuScopes, the buffer should typecast for uInt8 values. For CompuScopes 

with more than 8 bit resolution, the buffer should typecast for int16 values. 

gage_transfer_buffer uses a CPU mediated PCI data transfer method. For the fastest PCI bus-mastering 

data transfer, use gage_transfer_buffer_3. 

For all CompuScope boards with two channels operating in single channel mode, both A/D converters are 

used. The two converters are connected to the conditioned input from the Channel A BNC and are clocked 

180 O out of phase. Data from each converter are then stored in their respective memory banks, as usual. 

After capture, gage_transfer_buffer must then be used to download the data from both memory banks. 

This is done by calling gage_transfer_buffer twice, once with channel equal to GAGE_CHAN_A , which 

transfer the even points, and once with channel equal to GAGE_CHAN_B, which transfer the odd points.. 

The user must then interleave the two downloaded data sets in order to reconstruct the complete data 

record. 

Return Value 

None. 

See also 

gage_transfer_buffer_3 and Appendix: Comparison of Various Data Transfer Routines. 

Example 

C: 

gage_transfer_buffer (current_address, GAGE_CHAN_A, (uInt8 far *)(buffer), 512); 

Visual Basic: 

gage_transfer_buffer (ByVal ta As Long, ByVal channel As Integer, buffer As Integer, ByVal nsamples As 

Integer) 



Syntax 

C: 

uInt32 GAGEAPI gage_transfer_buffer_3 (int32 ta, int16 channel, void far *buffer, int32 nsamples); 

Visual BASIC: 

Function gage_transfer_buffer_3 (ByVal ta As Long, ByVal channel As Integer, buffer As Integer, ByVal 

nsamples As Integer) As Integer 

Remarks 

gage_transfer_buffer_3 is used to copy nsamples points from the specified channel to the supplied 

buffer beginning from address ta. The channel can be either GAGE_CHAN_A or GAGE_CHAN_B. The 

relevant addresses can be obtained by calling gage_calculate_addresses. . The buffer must have been 

previously typecast to the appropriate size. For 8 bit CompuScopes, the buffer should typecast for uInt8 

values. For CompuScopes with more than 8 bit resolution, the buffer should typecast for int16 values. 

The CompuScope PCI boards will use PCI bus-mastering if available in hardware, otherwise a CPU 

mediated PCI data transfer method is used. PCI bus-mastering is the fastest possible PCI data transfer 

method. 

The buffer must be padded so that it is slightly longer than the memory required to store nsample samples. 

The required amount of padding is different for different CompuScope models. The best padding method 

is to use the variable user_buffer_padding, which is returned by the drivers and is the amount of extra 

padding in Bytes required for the current CompuScope model.. Simply add user_buffer_padding to the 

amount of memory to be allocated. 

Unlike gage_transfer_buffer, in single channel mode gage_transfer_buffer_3 automatically downloads 

data from both CompuScope A/D converter memories and internally interleaves them. Consequently, 

the user application does not need to interleave the data when the acquisition has been performed in 

single channel mode using gage_transfer_buffer_3. In single channel mode, gage_transfer_buffer_3 

need only be called once with channel equal to GAGE_CHAN_A 

Return Value 

Returns an offset from the beginning of the dword-aligned buffer that the driver uses. 

Internally using PCI bus-mastering, PCI CompuScope hardware can only transfer data from a d-word (4 

byte) boundary in CompuScope on-board memory. For instance, data can be downloaded starting from 

hexadecimal addresses 0x3000 or 3004, but not starting from hexadecimal addresses 0x3001. 

The returned offset gives the byte address location of the address ta, specified in the call to 

gage_transfer_buffer_3. For instance, if ta were equal to hex 0x3003, then the CompuScope would be 

forced to download data from hexadecimal addresses 0x3000. The offset would then be returned as 

0x3003 – 0x3000 = 3. 

See also: gage_transfer_buffer and Appendix: Comparison of Various Data Transfer Routines. 

Examples: 


53

C: 

offset = gage_transfer_buffer_3(current_address, GAGE_CHAN_A, (uInt8 far *)(buffer), 512); 

new_ptr = (uInt8 *)(buffer+offset); 

first_value = new_ptr[0]; 

Visual BASIC: 

gage_transfer_buffer_3 (ByVal ta As Long, ByVal channel As Integer, buffer As Integer, ByVal nsamples 

As Integer) 



Syntax 

C: 

int16 GAGEAPI gage_trigger_control_2 (int16 source_1, int16 source_2, int16 ext_coupling, 

int16 ext_gain, int16 slope_1, int16 slope_2, int16 level_1, 

int16 level_2, int32 depth, int16 trigger_from_bus, int16 trigger_to_bus); 

Visual BASIC: 

Function gage_trigger_control_2 (ByVal source_1 As Integer, ByVal source_2 As Integer, 

ByVal ext_coupling As Integer, ByVal ext_gain As Integer, 

ByVal slope_1 As Integer, ByVal slope_2 As Integer, 

ByVal level_1 As Integer, ByVal level_2 As Integer, 

ByVal depth As Long, ByVal trigger_from_bus As Integer, 

ByVal trigger_to_bus As Integer) As Integer 

Remarks 

gage_trigger_control_2 is used to set the trigger parameters and capture depth on CompuScope hardware. 

The routine accepts two sets of values for the three main trigger parameters, the trigger source, the trigger 

level and the trigger slope. 

Some CompuScope models, such as the CS14100, have two separate trigger circuits. The two sets of 

trigger parameters are used to control each of these trigger circuits. The outputs of each circuit are 

logically ORed together to specify the trigger event. The two trigger circuits may be used, for instance, to 

effect "absolute value triggering" on channel A. This is done by setting both source_1 and source_2 to 

GAGE_CHAN_A, setting level_1 and level_2 values that correspond to equal and opposite voltages and 

setting slope_1 and slope_2 to GAGE_POSITIVE and GAGE_NEGATIVE, respectively. In this way, the 

CompuScope will trigger whenever the voltage on the channel A input goes above level_1 or below 

level_2. 

In order to disable the second trigger circuit, simply set source_2 to GAGE_SOFTWARE. For 

CompuScopes that are not equipped with two trigger circuits, the "_2" parameters have no effect. 

source_1 and source_2 can be either channel A, B, external trigger or software trigger. The constants 

GAGE_CHAN_A, GAGE_CHAN_B, GAGE_EXTERNAL and GAGE_SOFTWARE should be used to 

specify their respective sources. The two sources do not have to be the same. To disable one of the 

triggers, set it to GAGE_SOFTWARE. If a software trigger is desired, then both trigger sources must be 

set to GAGE_SOFTWARE. 

ext_coupling controls the coupling of the EXTERNAL TRIGGER BNC input on the CompuScope 

hardware. ext_coupling can be set to either DC or AC by using the constants GAGE_DC and GAGE_AC, 

respectively. If the trigger source is not external, this parameter will be ignored, although it should be set 

to a valid value. 

ext_gain controls the input sensitivity of the EXTERNAL TRIGGER BNC input on the CompuScope 

hardware. ext_gain can be set to either ±5 Volt or ±1 Volt by using the constants GAGE_PM_5_V and 

GAGE_PM_1_V, respectively. If the trigger source is not external, this parameter will be ignored, 

although it should be set to a valid value. 


55

slope_1 and slope_2 are the trigger slopes and can be either positive or negative. The constants 

GAGE_POSITIVE and GAGE_NEGATIVE should be used. 

The level_1 and level_2 parameters can be any value between 0 and 255 for 8-bit CompuScopes. The 

values are scaled internally to match the trigger input range selected. The minimum input level is 0 while 

the maximum trigger level is 255. The trigger level voltage can be calculated from the equation: 

TRIGGER LEVEL VOLTAGE = [(level – 128)/128] * INPUT SENSITIVITY OF TRIGGER SOURCE 

For instance, suppose the trigger source was channel A and channel A was set to the ±200 milliVolt input 

range. If level_1 was set to 192, then the trigger level voltage is calculated as: 

TRIGGER LEVEL VOLTAGE = [(192– 128)/128] * 200 mV = 100 mV 

For CompuScopes with more than 8-bit resolution, the level_1 and level_2 parameters can be any value 

between 0 and 4096. The values are scaled internally to match the trigger input range selected. The 

minimum input level is 0 while the maximum trigger level is 4095. The trigger level voltage can be 

calculated from the equation: 

TRIGGER LEVEL VOLTAGE = [(level – 2048)/2048] * INPUT SENSITIVITY OF TRIGGER SOURCE 

For instance, suppose the trigger source was external trigger and ext_gain was set to GAGE_PM_5_V. If 

level_1 was set to -1024, then the trigger level voltage is calculated as: 

TRIGGER LEVEL VOLTAGE = [(1024– 2048)/2048] * 5V = -2.5V 

The depth parameter sets the trigger depth, which is the number of samples to be captured after the trigger 

event. The minimum value varies for different CompuScope models and operating modes. For instance, 

for the CS14100 in single record/single channel mode the minimum depth is 512 samples, while in 

multiple record/dual channel mode the minimum depth is 256. See your CompuScope hardware manual 

for the valid minimum settings. 

Increments to the capture depth cannot be 1. There is a minimum depth increment for each different 

CompuScope model and operating mode. For instance for the CS14100 in single record/single channel 

mode, the depth may be increased from the minimum of 512 points in increments of 256 points. See your 

CompuScope hardware manual for the valid increment settings. 

Several defined constants are available to the application programmer in order to set the depth. These are 

listed in gage_drv.h and in the CompuScope C/C++ SDK manual. For instance, the constant 

GAGE_POST_4K can be used to set the depth to 4096 points. Direct numeric values can also be used to 

specify the depth. 

If the specified depth parameter does not conform to the minimum and increment requirements of the 

CompuScope hardware, the driver will adjust the depth to an appropriate allowed value. 

The trigger_from_bus parameter should always be set to TRUE (non-zero). For normal operation in a 

Master/Slave Multi-Card CompuScope system, the trigger_to_bus parameter should be set to TRUE (nonzero) 

for the Master CompuScope and to FALSE (zero) for the Slave CompuScope(s). With these settings, 

the Master CompuScope will serve as the Master trigger source and will pass its trigger signal to all Slave 

CompuScopes. Some CompuScope models support triggering from Slave CompuScopes. For these 

models, the trigger_to_bus parameter may be set to 1 for the Slave CompuScope(s). With these settings, 

a trigger event on any Slave CompuScope, with its own trigger settings, will cause the whole Master/Slave 


system to trigger. This is useful, for instance, in some nuclear particle detection experiments, where a 

particle pulse can occur on any channel of a multi-channel system. 

Please note that, whatever causes the trigger event in a Master/Slave CompuScope system, all 

CompuScopes in the Master/Slave system will always be triggered together. 

Return Value 

A one is returned if execution of the routine was successful. A zero is returned when the routine fails, and 

gage_get_error_code may be called to obtain the error code. 

See also 

gage_capture_mode, gage_input_control and see the Appendix: Data Structures Used by Gage Drivers in 

the CompuScope C/C++SDK Manual. 

Examples: 

C: 

gage_trigger_control_2 (GAGE_CHAN_A, GAGE_EXTERNAL, GAGE_DC, GAGE_PM_1_V, 

GAGE_POSITIVE, GAGE_NEGATIVE, 160, 100, GAGE_POST_16K, TRUE, 

TRUE ); 

Visual BASIC: 

dummy = gage_trigger_control_2 (GAGE_CHAN_A, GAGE_EXTERNAL, GAGE_DC, 

GAGE_PM_1_V, GAGE_POSITIVE, GAGE_NEGATIVE, 160, 100, 

GAGE_POST_16K, TRUE, TRUE ) 


57


Syntax 

C: 

int16 GAGEAPI gage_triggered (void); 

Visual BASIC: 

Function gage_triggered () As Integer 

Remarks 

gage_triggered determines if a trigger event has occurred on the CompuScope hardware 

Return Value 

A non-zero or true value is returned if the CompuScope hardware has been triggered, otherwise a false 

value is returned. 

See also 

gage_busy 

Examples 

C: 

triggered = gage_triggered (); 

Visual BASIC: 

triggered = gage_triggered 


Legacy CompuScope 

API Subroutines - 

Detailed Description 

The section describes the Legacy CompuScope API Subroutines. These routines are supported but are not 

frequently used for application programs. Generally, the functionality of the Legacy routines is available 

with a Recommended routine and the Legacy routines are maintained only in order to provide 

compatibility with older customer software applications. The Legacy routines are generally not used 

within Gage SDKs or stand-alone software and are, therefore, not regularly tested. Furthermore, the 

documentation of the Legacy routines has not been updated and includes references to currently 

unavailable CompuScopes models. It is strongly advised that only the Recommended routines be used in 

new software designs. Please read the readme text files contained in the CompuScope driver disk(s) for 

information relating to any changes in the API routines. 


59

gage_acquire_average 

Syntax 

C: 

int32 GAGEAPI gage_acquire_average (int16 channel, int32 nsamples, int32 naverages, int16 sum, 

int32 far *avg_buffer, void far *data_buffer, 

int32 data_buffer_size, int32 timeout); 

Visual BASIC: 

Function gage_acquire_average (ByVal channel As Integer, ByVal nsamples As Long, 

ByVal naverages As Long, ByVal sum As Integer, 

avg_buffer As Long, data_buffer As Any, 

data_buffer_size As Long, timeout As Long) As Long 

Remarks 

gage_acquire_capture finds the average of a number of acquisitions. This routine does the entire capture 

and transfer of data internally and does not return until either all captures are completed or an error has 

occurred. 

channel is the channel where the acquisitions will take place. It has a value of 1 for Board 1 Channel A, 2 

for Board 1 Channel B, 3 for Board 2 Channel A, 4 for Board 2 Channel B, etc. 

nsamples is the number of points to be sampled for each acquisition. 

naverages is the number of traces to sum. The routine will not complete until this number has been 

captured by the digitizer. 

sum is a flag that is set to one to skip the division by naverages. This will allow an application to make use 

of the unaveraged data to increase dynamic range. Normally the average is performed. 

*avg_buffer is a pointer to a buffer containing either the sum of all the data traces or the averaged data, 

depending on the value of the sum flag. The size of this buffer must be at least nsamples*sizeof(int32). 

The buffer must allocated by the calling program. 

*data_buffer is a pointer to a buffer for use by this routine to store data points returned from the digitizer 

before they are summed into data_buffer. This buffer must be at least as large as (data_buffer_size) and 

sized to the sample size of the CompuScope card being used (data_buffer_size * 1 byte for the 8-bit 

CompuScope cards and data_buffer_size * 2 bytes per sample for the 12/16-bit CompuScope cards). This 

buffer must be allocated by the calling program. This buffer is not used by the calling program, but is only 

a scratch space for this routine. 

data_buffer_size is the size of the buffer (data_buffer). 

timeout is the amount of time the software should wait for the hardware to respond to a trigger event. The 

resolution of the timeout is in hundreds of microseconds. A minus one (all bits set) will cause the software 

to wait indefinitely for the trigger event to occur (therefore, if no trigger ever occurs then the software will 

appear to hang since it is waiting for an event to happen that never will). 


Return Value 

1 if no error and a negative number if an error occurs. 

The following is a list of return codes including possible errors. 

Constant in GAGE_DRV.H 

Value, description 

============================================================================ 

GAGE_AA_SUCCESSFUL 

1L The routine completed correctly and the average 

buffer, "avg_buffer", contains the averaged of 

summed data. 

GAGE_AA_ROUTINE_UNAVAILABLE 

GAGE_AA_INVALID_TRIGGER_SOURCE 

GAGE_AA_INVALID_TRIGGER_DEPTH 

GAGE_AA_INVALID_BUFFER_SIZES 

GAGE_AA_INVALID_CHANNEL 

GAGE_AA_UNAVAILABLE_CHANNEL 

GAGE_AA_INVALID_AVERAGE_NUM 

0L The routine is not implemented and the task 

could not be performed. This is temporary return 

value until all cards have had this routine 

implemented. 

-1L This routine will not function with a software 

controlled trigger. Only a valid hardware trigger 

source is allowed. This can be channel A, channel B 

or the external trigger input. 

-2L Board returned a different number of points than 

requested, the acquisition depth is less than the 

requested average number of samples. 

-3L The "data_buffer_size" parameter is not at least 

as large as the number of samples required for each 

average. 

-4L The channel specified does not currently exist. 

Example: channel 3 (board 2 channel A) was 

specified and the current CompuScope installed 

system has only one board. 

-5L The channel specified is not currently available 

or enabled, therefore it does not have any valid data 

to be averaged. Example: channel 2 (board 1 channel 

B)was specified and the current acquisition mode is 

single channel mode. 

-6L This value is returned when the number of 

averages (naverages) is greater than the maximum 

32-bit integer (0x7fffffff hex or 2,147,483,647 

decimal) divided by the size of the sample resolution 

(256 for 8-bit cards and 4096 for 12-bit cards). This 

is calculated by using 0x7fffffff and shifting it to the 

right by the number of bits of sample resolution 

(8 or 12). 


61

GAGE_AA_INVALID_SAMPLE_NUM 

GAGE_AA_TRIGGER_TIMEOUT 

GAGE_AA_BUSY_TIMEOUT 

-7L This value is returned when the number of 

samples (nsamples) is greater than the maximum 

transfer allowed using the implemented transfer 

method. Currently this is 4K/8K samples for all 

boards except the CS2125, which is 8K/16K samples 

for dual/single mode acquisition, respectively. This 

will be increased to 64K for 16-bit environments and 

4G for 32-bit environments when the arbitrary length 

transfer_buffer routines are implemented on all 

boards. 

-8L Board was not triggered within the board's 

time-out time period. 

-9L Board did not become non-busy within the 

board's time-out period. 

If an error occurs, the routine aborts immediately and returns to the calling program. 

See also 

gage_peak_detect(). 

Examples 

C: 

result = gage_acquire_average (channel, nsamples, naverages, sum, avg_buffer, data_buffer, 

nsamples, timeout); 

Visual BASIC: 

result = gage_acquire_average (channel, nsamples, naverages, sum, avg_buffer(0), data_buffer(0), 

nsamples, timeout) 


gage_detect_multiple_record 

Syntax: 

C: 

int16 GAGEAPI gage_detect_multiple_record (void); 

Visual BASIC: 

function gage_detect_multiple_record () As Integer 

Remarks 

gage_detect_multiple_record is used to determine if a CompuScope board has Multiple Record 

capability. Multiple record capability is standard only on some CompuScope boards. This feature is 

available on all the CSx012, CSx012/PCI boards, CS8500, CS12100, CS1250, CS2125 and CS265, and it 

is optional on CS250 and CS220 boards. 

Return Value 

A TRUE (non-zero) value is returned if the CompuScope hardware has Multiple Record capability and a 

FALSE (zero) otherwise. 

See also 

gage_multiple_record and Appendix I: Multiple Record Mode Operation. 

Examples 

C: 

mr_available = gage_detect_multiple_record; 

Visual BASIC: 

mr_available = gage_detect_multiple_record 


63

gage_get_boards_found 

Syntax 

C: 

int16 GAGEAPI gage_get_boards_found(void); 

Visual BASIC: 

Function gage_get_boards_found () As Integer 

Remarks 

gage_get_boards_found determines and returns the number of CompuScope boards that were detected 

when the last call to the gage_driver_initialize routine was made. 

Return Value 

The number of CompuScope boards currently installed by the driver. 

See also 


Examples 

C: 

boards_found = gage_get_boards_found (); 

Visual BASIC: 

boards_found = gage_get_boards_found 


gage_get_data 

Syntax 

C: 

void GAGEAPI gage_get_data (void); 

Visual BASIC: 

Sub gage_get_data () 

Remarks 

gage_get_data sets the CompuScope board in its capture mode. After this call the CompuScope is 

digitizing the input data and placing the values into the on-board memory while waiting for a trigger event. 

Once the trigger event has occurred, the CompuScope will capture a number of samples specified by the 

depth parameter passed to gage_trigger_control before terminating. Instead of gage_get_data, the 

gage_start_capture routine should normally be used in order o fully support all possible CompuScope 

hardware configurations, especially when using multiple CompuScopes. 

gage_get_data may be used in some cases, after a call to gage_init_clock, in order to speed up the rearming 

of the CompuScope hardware. Note that using this method does not allow the amount of pretrigger 

data to be ensured. Pre-trigger data will only be captured until an event fulfilling the trigger 

conditions occurs. Ensuring a specific number of pre-trigger data points can only be done by setting this 

number of points using the gage_delay_trigger_32 routine and then calling gage_start_capture. Using 

this method, gage_start_capture will ignore triggers until the specified amount of pre-trigger data has been 

acquired. 

Return Value 

None. 

See also 

gage_abort , gage_trigger_control and gage_init_clock 

Examples 

C: 

gage_get_data (); 

Visual BASIC: 

gage_get_data 


65

gage_get_records 

Syntax 

C: 

int16 GAGEAPI gage_get_records (uInt16 far *records, int16 record, uInt16 far *segment, 

uInt16 far *index, uInt16 far *typename, uInt16 far *status); 

Visual BASIC: 

Function gage_get_records (records As Integer, ByVal record As Integer, segment As Integer, 

index As Integer, typename As Integer, status As Integer) As Integer 

Remarks 

gage_get_records can be used to read the gage_board_location array. The array must be allocated by the 

calling program. The array is initialized by using a call to either gage_set_records or 

gage_read_config_file. 

The record parameter is the board number of the record to be read, beginning with 0. 

The segment, index, typename and status parameters are the values in the gage_board_location array for 

that particular board. 

segment and index are the values that were set by the GSINST.EXE or GAGECFG.EXE configuration 

program. 

The typename and status parameters return the board type and the initialization status of the board as one 

of the predefined constants (GAGE_ASSUME_XXXXX, where XXXXX is a board type, etc.) declared in 

the file GAGE_DRV.H. 

The status parameter will hold any errors that occurred during board initialization. 

Return Value 

The return value is one if the record parameter is in the range (0 to GAGE_B_L_MAX_CARDS - 1) and 

zero otherwise. If the return value is one, the segment, index, typename and status parameters will 

contain valid values for the specified record. 

See also 

gage_set_records, gage_driver_initialize and gage_read_config_file 

Examples 

C: 

gage_get_records ((uInt16 far *)gage_board_location), 0, (uInt16 far *)(&segment), 

(uInt16 far *)(&index), (uInt16 far *)(&typename), (uInt16 far *)(status)); 

Note: the typecasts may not be necessary, depending on the memory model used. 

Visual BASIC: 

ret = gage_get_records (gage_board_location (0), 0, segment, index, typename, status) 


gage_get_status 

Syntax 

C: 

int16 GAGEAPI gage_get_status (void); 

Visual BASIC: 

Function gage_get_status () As Integer 

Remarks 

This routine is used to read back various control signals generated by the currently selected CompuScope 

board. The routine thus provides the application writer feedback about the current board’s operational 

state. It is recommended that the gage_triggered and gage_busy routines be used instead, since they 

provide a more consistent interface for all hardware. 

Return Value 

Returns the Status register. Please see your hardware manual, if applicable, for information on the status 

register. It will be different for different CompuScope boards. 

See also 

gage_busy, gage_triggered and gage_read_master_status 

Examples 

C: 

status = gage_get_status(); 

Visual BASIC: 

ret = gage_get_status 


67

gage_get_trigger_address 

Syntax 

C: 

int32 GAGEAPI gage_get_trigger_address (void); 

Visual BASIC: 

Function gage_get_trigger_address () As Long 

Remarks 

This routine gets the trigger address in the CompuScope board. Once a trigger event is detected, the 

address into which the data was being written is tagged as the trigger address. It is recommended that the 

gaeg_calculate_addresses routines routine now be used for this propose. 

Return Value 

Returns the trigger address. 

See also 

gage_calculate_addresses and gage_trigger_address 

Examples 

C: 

address = gage_get_trigger_address(); 

Visual BASIC: 

address = gage_get_trigger_address 


gage_get_trigger_view_offset 

Syntax 

C: 

void GAGEAPI gage_get_trigger_view_offset (int32 far *offset); 

Visual BASIC: 

Sub get_trigger_view_offset (offset As Long) 

Remarks 

gage_get_trigger_view_offset can be used to get the current trigger view offset when using the routines 

gage_trigger_view_transfer, gage_trigger_view_transfer_2 and gage_trigger_view_transfer_3. 

The default value of the offset parameter is 0, which means that capture will start at the trigger address. 

This value can be changed to transfer pre-trigger data, for example by using the routine 

gage_set_trigger_view_offset. 

Return Value 

None. 

See also 

gage_set_trigger_view_offset 

Examples 

C: 

gage_get_trigger_view_offset ((int32 far *)offset); 

Note: the typecast is unnecessary if the application program is large model 

Visual BASIC: 

Call gage_get_trigger_view_offset (offset) 


69

gage_gpib_command 

Syntax 

C: 

int32 GAGEAPI gage_gpib_command (char* strCommand, int nByteSize, char* rvBuffer, int 

nBufferSize); 

Remarks 

gage_gpib_command allows the application program to access functionality built into the on-board 

digitization module, that is not available through the standard Gage API, FOR THE COMPUSCOPE 85G 

OR 85GC ONLY. For instance, gage_gpib_command is used to implement TV triggering on the CS85GC. 

strCommand is a string, initialized by the user, that contains the command to be sent to the CS85G or 

85GC digitization module. 

nByteSize is the length, initialized by the user, of the string that contains the command to be sent (the 

strCommand argument above). 

rvBuffer is a string that may be returned by the CS85G or 85GC digitization module, upon execution of 

the latest command. This string is often empty. 

nBufferSize is the length of the string that may be returned by the CS85G or 85GC digitization module 

(the rvBuffer argument above). 

Return Value 

The return value is a signed 32 bit integer. A return value of 0 indicates that the gage_gpib_command 

routine has been implemented properly. Any other value signifies an error while implementing the routine. 

Examples 

C: 

gage_gpib_command (strCmd, strlen(strCmd), strQueryInf, sizeof(strQueryInf)); 


gage_init_clock 

Syntax 

C: 

void GAGEAPI gage_init_clock (void); 

Visual BASIC: 

Sub init_clock () 

Remarks 

gage_init_clock is used to initialize the CompuScope clock circuitry. This routine should be called before 

initiating data capture with gage_get_data. It is recommended that the gage_start_capture routine, which 

calls gage_init_clock internally, be used instead. 

gage_init_clock can be used, in some cases, in conjunction with gage_get_data in order to speed up the 

re-arming of the CompuScope hardware. Note that using this method does not allow the amount of pretrigger 

data to be ensured. Pre-trigger data will only be captured until an event fulfilling the trigger 

conditions occurs. Ensuring a specific number of pre-trigger data points can only be done by setting this 

number of points using the gage_delay_trigger_32 routine and then calling gage_start_capture. Using 

this method, gage_start_capture will ignore triggers until the specified amount of pre-trigger data has been 

acquired. 

Return Value 

None. 

See also 

gage_get_data and gage_start_capture 

Examples 

C: 

gage_init_clock (); 

Visual BASIC: 

Call gage_init_clock () 


71

gage_mem_read_chan_a 

Syntax 

C: 

int16 GAGEAPI gage_mem_read_chan_a (int32 location); 

Visual BASIC: 

Function gage_mem_read_chan_a (ByVal location As Long) As Integer 

Remarks 

gage_mem_read_chan_a reads one sample out of the CompuScope memory for channel A in dual 

channel mode and returns it as an integer. It is usually used in a loop to retrieve data from a range of 

addresses from a CompuScope board. 

location is an address in the CompuScope memory and usually starts at the trigger address. It can precede 

and/or follow the trigger address as set by the current trigger depth. 

The gage_calculate_addresses routine is very useful for determining the valid addresses and should be 

used instead of directly invoking the gage_trigger_address routine for future compatibility with the 

CompuScope drivers. 

When using the gage_mem_read_chan_a routine, access to the CompuScope memory must be obtained 

by calling gage_need_ram(1) beforehand, and released by calling gage_need_ram(0) when finished. 

Return Value 

The byte (or integer) corresponding to the specified location for channel A is returned as an unsigned 

integer (0 - 255) for 8 bit CompuScopes, a signed 12 bit integer (-2048 - 2047) for the 12 bit CompuScopes 

and a signed 16 bit integer (-32768 to 32767) for the 16 bit CompuScopes. 

See also 

gage_mem_read_chan_b, gage_mem_read_dual, gage_mem_read_single, gage_need_ram, 

gage_calculate_addresses and Appendix: Comparison of Various Data Transfer Routines. 

Examples 

C: 

data = gage_mem_read_chan_a (address); 

Visual BASIC: 

data = gage_mem_read_chan_a (address) 


gage_mem_read_chan_b 

Syntax 

C: 

int16 GAGEAPI gage_mem_read_chan_b (int32 location); 

Visual BASIC: 

Function gage_mem_read_chan_b (ByVal location As Long) As Integer 

Remarks 

gage_mem_read_chan_b reads one sample out of the CompuScope memory for channel B in dual 

channel mode and returns it as an integer. It is usually used in a loop to retrieve data from a range of 

addresses from a CompuScope board. 






When using gage_mem_read_chan_a, access to the CompuScope memory must be obtained by calling 

gage_need_ram(1) beforehand, and released by calling gage_need_ram(0) when finished. 

Return Value 

The byte (or integer) corresponding to the specified location for channel B is returned as an unsigned 

integer (0 - 255) for 8 bit CompuScopes, as a signed 12 bit integer (-2048 - 2047) for the 12 bit 

CompuScopes and a signed 16 bit integer (-32768 to 32767) for the 16 bit CompuScopes. 

See also 

gage_mem_read_chan_a, gage_mem_read_dual, gage_mem_read_single, gage_calculate_addresses and 

Appendix : Comparison of Various Data Transfer Routines. 

Examples 

C: 

data = gage_mem_read_chan_b (address); 

Visual BASIC: 

data = gage_mem_read_chan_b (address) 


73

gage_mem_read_dual 

Syntax 

C: 

int16 GAGEAPI gage_mem_read_dual (int16 channel, int32 location); 

Visual BASIC: 

Function gage_mem_read_dual (ByVal channel As Integer, ByVal location As Long) As Integer 

Remarks 

gage_mem_read_dual reads one sample out of CompuScope memory in dual channel mode and returns it 

as an integer. It is usually used in a loop to retrieve data from a range of addresses from a CompuScope 

board. 

channel can be one of the constants GAGE_CHAN_A or GAGE_CHAN_B. 






When using gage_mem_read_dual, access to the CompuScope memory must be obtained by calling 


Return Value 

The byte (or integer) corresponding to the specified location for channel A or channel B is returned as an 

unsigned integer (0 - 255) for 8 bit CompuScopes, as a signed 12 bit integer (-2048 - 2047) for the 12 bit 

CompuScopes and a signed 16 bit integer (-32768 to 32767) for the 16 bit CompuScopes. 

See also 

gage_mem_read_single, gage_mem_read_chan_a, gage_mem_read_chan_b, gage_calculate_addresses and 

Appendix: Comparison of Various Data Transfer Routines. 

Examples 

C: 

data = gage_mem_read_dual (GAGE_CHAN_A, address); 

Visual BASIC: 

data = gage_mem_read_dual (GAGE_CHAN_A, address) 


gage_mem_read_single 

Syntax 

C: 

int16 GAGEAPI gage_mem_read_single (int32 location); 

Visual BASIC: 

Function gage_mem_read_single (ByVal location As Long) As Integer 

Remarks 

gage_mem_read_single reads one byte out of CompuScope memory in single channel mode and returns it 

as an integer. It is usually used in loop to retrieve data from a range of addresses from a CompuScope 

board. 






When using gage_mem_read_single, access to the CompuScope memory must be obtained by calling 


Return Value 

The byte (or integer) corresponding to the specified location for channel A returned as an unsigned integer 

(0 - 255) for 8 bit CompuScopes, as a signed 12 bit integer (-2048 - 2047) for the 12 bit CompuScopes and 

a signed 16 bit integer (-32768 to 32767) for the 16 bit CompuScopes. 

See also 

gage_mem_read_dual, gage_mem_read_chan_a, gage_mem_read_chan_b, gage_calculate_addresses and 

Appendix: Comparison of Various Data Transfer Routines. 

Examples 

C: 

data = gage_mem_read_single (address); 

Visual BASIC: 

data = gage_mem_read_single (address) 


75

gage_multiple_record_acquisitions 

Syntax 

C: 

void GAGEAPI gage_multiple_record_acquisitions (uInt16 number); 

Visual BASIC: 

Sub gage_multiple_record_acquisitions (ByVal number As Integer) 

Remarks: 

gage_multiple_record_acquisitions sets the number of Multiple Record groups that will be acquired by 

the CompuScope hardware. This routine is only available for the CP500-class boards. 

number is the number of Multiple Record groups. 

This routine should be called immediately after calling the gage_multiple_record routine. 

Return Value 

None. 

See also 

gage_multiple_record and Appendix I: Multiple Record Mode Operation. 

Examples 

C: 

gage_multiple_record_acquisition (10); 

Visual BASIC: 

Call gage_multiple_record_acquisitions (10) 


gage_offset_adjust 

Syntax 

C: 

void GAGEAPI gage_offset_adjust (int16 channel, int16 offset_adjust); 

Remarks 

gage_offset_adjust is used to adjust the input DC offset on CompuScope models for which this 

functionality is available. 

The channel parameter can be either GAGE_CHAN_A or GAGE_CHAN_B. 

For CompuScopes with more than 8 bit resolution, the offset_adjust parameter will cause the DC offset 

value to change by the specified amount. So, if the gage_offset_adjust is called repeatedly with the same 

value of offset_adjust, then the input DC offset will change by the same amount upon each call. 

For all available CompuScope boards with DC offset adjust capability except the CS8500, the 

offset_adjust can be any integer between -2047 and +2047. The -2047 setting will provide the largest 

possible negative DC offset available for the current CompuScope input range. Similarly, the +2047 setting 

will provide the largest possible positive DC offset available for the current CompuScope input range. If 

the value of offset_adjust is set to 0, the routine performs an automatic calibration of the CompuScope 

board, if the autocalibration capability is available. In this case, the inputs of the CompuScope board must 

be connected to the ground of the circuit under test. 

Note that the gage_offset_adjust routine should be called whenever the input range or operation mode 

(SINGLE or DUAL) are changed. Also, some CompuScope models require that gage_offset_adjust be 

called after changing the sampling rate. 

For the CompuScope 8500, the offset_adjust parameter specifies an absolute, rather than a relative, DC 

offset. The offset_adjust parameter is passed as a percentage between -100% and +100% of the full-scale 

input range. Values greater than or equal to +100 will change the offset by 100% and values less than or 

equal to -100 will change the offset by -100%. Any values exceeding +/- 100 will have no further effect on 

the signal offset or position. Therefore, a value of 100 will yield a 100 percent offset and a value of -100 

will yield a -100 percent offset and 0 will be zero. For example, calling this routine twice with an offset of 

10% will leave the offset at 10%. 

Note that, unlike for the higher resolution CompuScope models, the offset set by gage_offset_adjust 

remains in effect on the CS8500 when the input range is changed by calling the gage_input_control 

routine. 

Return Value: None. 

Example: C: 

gage_offset_adjust (GAGE_CHAN_A, offset_adjust); 

Visual BASIC: This routine is currently not supported under Visual BASIC. 


77

gage_read_cal_table 

Syntax 

C: 

int16 GAGEAPI gage_read_cal_table (LPSTR caltable_name); 

Visual BASIC: 

Sub gage_read_cal_table (ByVal caltable_name As String) As Integer 

Remarks 

This routine reads a calibration file that can be used to prevent 12 bit CompuScope boards from 

autocalibrating every time the gain or mode is changed with the gage_input_control or 

gage_capture_mode routines. 

caltable_name is the name of the file or the file name with full path. By default, the name of the file is 

CALTABLE.DAC. It can be created with TESTCALB.EXE, which is included on the SDK distribution 

disk. The file can also be created with GageScope ® for DOS, GagePCI and GageP500 (go to the Capture 

menu and to the Calib table item). Just follow the prompts to create the file. If the file is not found in the 

same directory as the executable, the driver will force the board to autocalibrate when gain is changed. 

This routine should be called after gage_driver_initialize and before calling gage_capture_mode. 

This method can eliminate the delays that can occur during the autocalibration of some CompuScope 

boards. The calibration is system-dependent. A calibration table made on one computer may not be 

accurate on another computer, even if the same CompuScope board is used. 

Note: The CSx012/PCI SDK for Win NT will automatically detect the CALTABLE.DAC file and use it, if 

it is found in the WINNT\SYSTEM32\DRIVERS directory. Therefore, there is no reason to use this 

routine with the CSx012/PCI SDK for Win NT. 

Return Value 

Returns a 1 if successful, a 0 otherwise. 

See also 

gage_use_cal_table 

Examples 

C: 

ret = gage_read_cal_table (“caltable.dac”); 

Visual BASIC: 

ret = gage_read_cal_table (“caltable.dac”) 


gage_read_master_status 

Syntax 

C: 

int16 GAGEAPI gage_read_master_status (void); 

Visual BASIC: 

Function gage_read_master_status () As Integer 

Remarks 

gage_read_master_status reads the status bits from the Master card, regardless of how many 

CompuScope boards are in the system. 

Return Value 

The integer returned equals the status bits from the Master board status register. This value is currently an 

integer from 0 to 7, with bit 0 representing the busy bit, bit 1 representing the ram full bit and bit 2 

representing the trigger bit. These bit patterns may or may not match the hardware status register pattern. 

See also 

gage_busy and gage_triggered 

Examples 

C: 

status = gage_read_master_status (); 

Visual BASIC: 

status = gage_read_master_status 


79

gage_set_delay_trigger 

Syntax 

C: 

uInt16 GAGEAPI gage_set_delay_trigger (int16 action, uInt16 delay_trigger); 

Visual BASIC: 

Function gage_set_delay_trigger (ByVal action As Integer, ByVal delay_trigger As Integer) As Integer 

Remarks 

gage_set_delay_trigger ignores the trigger for the amount of time specified. 

The action parameter, if equal to 1, ignores the trigger for the specified delay trigger. 

delay_trigger is in 1/10 ms = 100 us. 

If action is 0 then the routine returns only the current value of the delay. The default delay is 0. 

Return Value 

Returns the current value of the trigger delay. 

See also 

None 

Examples 

C: 

trig_delay = gage_set_delay_trigger (1, 100); 

Visual BASIC: 

trig_delay = gage_set_delay_trigger (1, 100) 


gage_set_records 

Syntax 

C: 

int16 GAGEAPI gage_set_records (uInt16 far *records, int16 record, uInt16 segment, uInt16 index, 

uInt16 typename, uInt16 status); 

Visual BASIC: 

Function gage_set_records (records As Integer, ByVal record As Integer, ByVal segment As Integer, 

ByVal index As Integer, ByVal typename As Integer, ByVal status As Integer) 

As Integer 

Remarks 

gage_set_records is used to initialize the gage_board_location array when the configuration file 

(GAGESCOP.INC) is either not found or not used. Using this routine is preferred because the format of 

the gage_board_location file is subject to change. The array gage_board_location should be allocated by 

the calling program and should be large enough (64 words) to hold the initialization for 

GAGE_B_L_MAX_CARDS boards. 

The record parameter is the number of the board to be initialized. 

The segment, index, typename and status parameters are the desired values for that particular board. 

segment and index are the values that are used by the GSINST.EXE, PCIINST.EXE, P500INST.EXE and 

GAGECFG.EXE configuration programs. 

The typename and status should be zero in a call to gage_set_records. 

Return Value 

The return value is one if the record parameter is in the range (0 to GAGE_B_L_MAX_CARDS - 1) and 

zero otherwise. 

See also 

gage_driver_initialize and gage_get_records 

Examples 

C: 

gage_set_records ((uInt16 far *)gage_board_location, 0, seg, ind, , 0, 0); 

Visual BASIC: 

dummy = gage_set_records (gage_board_location (0), 0, seg, ind, , 0, 0) 


81

gage_set_trigger_depth 

Syntax 

C: 

int16 GAGEAPI gage_set_trigger_depth (int32 depth); 

Visual BASIC: 

This routine is currently not supported under Visual BASIC. 

Remarks 

gage_set_trigger_depth is used to set up one of the trigger parameters for the CompuScope board. 

The depth parameter sets the trigger depth, that is the number of samples captured after the trigger event. 

The resolution of this parameter is 64 samples in dual channel mode and 128 samples in single channel 

mode for the CompuScope boards, except 16 samples for the CompuScope LITE and a power of two for 

the CompuScope 220. The trigger resolution in Multiple Record mode is twice that of non-Multiple 

Record mode. 

Setting the trigger depth can help reduce the capturing overhead when only a screen’s worth of data is 

required. Several defined constants are available to the application programmer to illustrate the use of this 

parameter. The constants GAGE_POST_0K, GAGE_POST_1K, GAGE_POST_2K, GAGE_POST_4K, 

GAGE_POST_8K, GAGE_POST_16K, GAGE_POST_32K, GAGE_POST_64K, GAGE_POST_128K, 

GAGE_POST_256K, GAGE_POST_512K, GAGE_POST_1M, GAGE_POST_2M, GAGE_POST_4M 

and GAGE_POST_8M are for the trigger depths of 0, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 

131072, 262144, 524288, 1048576, 2097152, 4194304 and 8388608 bytes, respectively. Other values can 

be used. If the trigger depth is not a multiple of the trigger resolution, it is rounded up to the nearest 

multiple. 

It is recommended that the gage_trigger_control or gage_trigger_control_2 routines be used instead so 

as to maintain compatibility with future versions of the drivers. 

Return Value 

A one is returned if successful and a zero is returned when the routine fails, and gage_error_code contains 

the error code. 

See also 

gage_trigger_control 

Examples 

C: 

gage_set_trigger_depth (512); 


gage_set_trigger_view_offset 

Syntax 

C: 

void GAGEAPI gage_set_trigger_view_offset (int32 offset); 

Visual BASIC: 

Sub gage_set_trigger_view_offset (ByVal offset As Long) 

Remarks 

The gage_set_trigger_view_offset routine allows the application program to change where data transfer 

begins when using gage_trigger_view_transfer, gage_trigger_view_transfer_2 or 

gage_trigger_view_transfer_3 by offsetting the trigger address. Once the offset has changed, it keeps its 

new value until the program is restarted or it is changed again. 

The default value for the offset is 0, which denotes the trigger address. A negative offset can be used to 

capture pre-trigger data. A positive offset can be used to start transfer from after the trigger address. 

Care should be taken when using a negative number so that you don’t get data from before the start 

address. The valid start, trigger and ending addresses can be obtained from a call to 

gage_calculate_addresses. 

Return Value 

None. 

See also 

gage_get_trigger_view_offset and gage_calculate_addresses 

Examples 

C: 

gage_set_trigger_view_offset (offset); 

Visual BASIC: 

Call gage_set_trigger_view_offset (offset) 


83

gage_support_to_text 

Syntax 

C: 

LPSTR GAGEAPI gage_support_to_text (LPSTR string, uInt32 string_size, uInt32 board_support); 

Remarks 

The gage_support_to_text routine is used to get the names of the CompuScope boards supported by the 

current version of the installed drivers. 

The parameter string is a pointer to the string. 

string_size is the size of the string pointed to by string. 

board_support returns the CompuScope boards that are supported by the driver. This will be a 

combination of predefined constants GAGE_ASSUME_XXXXX, where XXXXX is a board type. Board 

type constants are defined in GAGE_DRV.H file. 

Return Value 

Returns the pointer to the string with above-mentioned parameters. 

See Also 


Examples 

C: 

gage_support_to_text (str, sizeof(str), board_support); 



Syntax 

C: 

void far* GAGEAPI gage_transfer_buffer_2 (int32 ta, int16 channel, void far *buffer, int32 nsamples); 

Visual BASIC: 


Remarks 

gage_transfer_buffer_2 is used to copy nsamples points from the specified channel to the supplied 

buffer beginning from address ta. The channel can be either GAGE_CHAN_A or GAGE_CHAN_B. The 

relevant addresses can be obtained by calling gage_calculate_addresses routine. The buffer should be 

typecast to the appropriate size before accessing it. The CompuScope PCI boards will use bus-mastering if 

available, otherwise this routine is the same as gage_transfer_buffer. 

Because bus-mastering requires the buffer to be dword-aligned, the driver may have to change its starting 

address. The return value is a pointer that points to where the actual data begins. The difference between 

the buffer address passed to the routine and the one returned will be 0, 1, 2 or 3 addresses. 

Note: The buffer that the calling program allocates should be 4 samples larger than the requested size. 

For all CompuScope boards with two channels, single channel mode uses both of the channels. The 

captured data must be transferred one channel at a time. The even addresses will be from channel A and the 

odd addresses will be from channel B. The data must then be interleaved by the application when using 

gage_transfer_buffer, gage_trigger_view_transfer, gage_transfer_buffer_2 and 

gage_trigger_view_transfer_2 routines. 

Please see the Sample Programs section in the CompuScope SDK Manual for further details. 

Return Value 

Returns a pointer that points to where the actual data begins. 

See also 

gage_transfer_buffer, gage_transfer_buffer_3 and Appendix B: Comparison of Various Data Transfer 

Routines. 

Examples 

C: 

ptr = gage_transfer_buffer_2(current_address, GAGE_CHAN_A, (uInt8 far *)(buffer), 512); 

first_value = ptr[0]; 


85

gage_trigger_address 

Syntax 

C: 

int32 GAGEAPI gage_trigger_address (void); 

Visual BASIC: 

Function gage_trigger_address () As Long 

Remarks 

gage_trigger_address finds the address in CompuScope memory where the trigger event occurred. 

Once a trigger event is detected, the address into which the data was being written is tagged as the trigger 

address. 

This routine will only access the hardware once per acquisition. The trigger address is then stored in the 

driver structure for future or repeated use. The gage_get_trigger_address routine accesses the 

CompuScope hardware every time it is called. In Multiple Record operation, gage_get_trigger_address 

should be used, if it is necessary to monitor the trigger addresses while capturing the data. 

Return Value 

The long integer returned is the trigger address. 

See also 

gage_get_trigger_address and gage_calculate_addresses 

Examples 

C: 

address = gage_trigger_address (); 

Visual BASIC: 

address = gage_trigger_address 


gage_trigger_control 

Syntax 

C: 

int16 GAGEAPI gage_trigger_control (int16 source, int16 ext_coupling, int16 ext_gain, int16 slope, 

int16 level, int32 depth); 

Visual BASIC: 

Function gage_trigger_control (ByVal source As Integer, ByVal ext_coupling As Integer, 

ByVal ext_gain As Integer, ByVal slope As Integer, 

ByVal level As Integer, ByVal depth As Long) As Integer 

Remarks 

gage_trigger_control is used to set up the trigger parameters of the CompuScope. 

source can be either channel A, EXTERNAL or SOFTWARE and the constants GAGE_CHAN_A, 

GAGE_EXTERNAL and GAGE_SOFTWARE should be used to indicate their respective sources. 

ext_coupling can be either DC or AC for the external trigger input as indicated by the constants 

GAGE_DC and GAGE_AC respectively. The CS512 and CS512/PCI have TTL external trigger input, 

therefore this parameter has no effect. 

ext_gain can be either of the constants GAGE_PM_5_V or GAGE_PM_1_V for the external trigger input. 

The CS512 and CS512/PCI have TTL external trigger input therefore this parameter has no effect. 

slope is the trigger slope and can be either positive or negative. The constants GAGE_POSITIVE or 

GAGE_NEGATIVE should be used. 

level can be any value between 0 and 255. The values are scaled internally to match the trigger input range 

selected. The minimum input level is 0 while the maximum trigger level is 255 (these correspond to -1V 

and +1V respectively for the x1 input gain). The CS512 and CS512/PCI have TTL external trigger input, 

therefore this parameter has no effect. 

The depth parameter sets the trigger depth, that is, the number of samples captured after the trigger event. 

The minimum value is 0. This can help reduce the capturing overhead when only a few points of data are 

required. Several defined constants are available to the application programmer to illustrate the use of this 

parameter. The constants GAGE_POST_0K, GAGE_POST_1K, GAGE_POST_2K, GAGE_POST_4K, 

GAGE_POST_8K, GAGE_POST_16K, GAGE_POST_32K, GAGE_POST_64K and 

GAGE_POST_128K, GAGE_POST_256K, GAGE_POST_512K, GAGE_POST_1M, GAGE_POST_2M, 

GAGE_POST_4M and GAGE_POST_8M are for the trigger depths of 0, 1024, 2048, 4096, 8192, 16384, 

32768, 65536, 131072, 262144, 524288, 1048576, 2097152, 4194304 and 8388608 bytes respectively. 

Other values besides these constants can be used. The depth parameter should be a multiple of the trigger 

resolution. If the depth is not a multiple of the trigger resolution, it is rounded up to the nearest multiple. 

Note: If external trigger is not used, some parameters such as ext_gain and ext_coupling have no effect. 

All the parameters, however, should be set to the valid values for the CompuScope board in use. 


87

Return Value 

A one is returned if successful and a zero is returned when the routine fails, and gage_get_error_code may 

be called to obtain the error code. The application program should always check the return values. 

See also 

gage_capture_mode, gage_input_control, gage_trigger_control_2 and see the Appendix: Data Structures 

Used by Gage Drivers in the CompuScope SDK Manual. 

Examples 

C: 

gage_trigger_control (GAGE_CHAN_A, GAGE_DC, GAGE_PM_1_V, GAGE_POSITIVE, 160, 

GAGE_POST_16K); 

Visual BASIC: 

dummy = gage_trigger_control (GAGE_CHAN_A, GAGE_DC, GAGE_PM_1_V, GAGE_POSITIVE, 

160, GAGE_POST_16K) 


gage_trigger_view_transfer 

Syntax 

C: 

void GAGEAPI gage_trigger_view_transfer (int16 channel, uInt8 far *buffer, int16 nsamples); 

Visual BASIC: 

Sub gage_trigger_view_transfer (ByVal channel As Integer, buffer(0) As Integer, 

ByVal nsamples As Integer) 

Remarks 

gage_trigger_view_transfer is used to copy nsample points of the CompuScope memory space, from the 

channel specified in the parameter channel to the supplied buffer array buffer starting with the trigger 

address of the most recent data capture. The starting point of the transferred data can be changed, by using 

gage_set_trigger_view_offset. The default starting point is the trigger address. 

For PCI (CP500) CompuScopes, there is no intrinsic limitation on the amount of data that can be 

transferred at a time by gage_trigger_view_transfer. Please note, however, that for ISA CompuScopes, a 

maximum of 4K samples may be transferred at a time. For 8-bit ISA CompuScopes, the sample size is 1 

byte, so 4K samples equals 4K bytes. The 12 bit and 16 bit ISA CompuScopes use integer samples, 

therefore 4K samples equals 4K integers. 


captured data must be transferred one channel at a time and put together by the application program. The 

even addresses will be from channel A and the odd addresses will be from channel B. Please see the 

Sample Programs section in the CompuScope SDK Manual for further details. 

Return Value 

None. 

See also 

Appendix: Comparison of Various Data Transfer Routines 

Examples 

C: 

gage_trigger_view_transfer (GAGE_CHAN_A, (uInt8 far *)(buffer), 512); 

Visual BASIC: 

Call gage_trigger_view_transfer (GAGE_CHAN_A, buffer(0), 512) 


89

gage_trigger_view_transfer_2 

Syntax 

C: 

void far* GAGEAPI gage_trigger_view_transfer_2 (int16 channel, void far *buffer, int32 nsamples); 

Visual BASIC: 


Remarks 

gage_trigger_view_transfer_2 is used to copy nsample points of the CompuScope memory space, from 

the channel specified in the parameter channel to the supplied buffer array buffer starting with the trigger 

address of the most recent data capture. 

The CompuScope PCI boards will use bus-mastering if available; otherwise this routine is the same as 

gage_trigger_view_transfer. 

The calling program should typecast this buffer to the appropriate type before accessing the data. 

Because bus-mastering requires the buffer to be dword-aligned, the driver may have to change its starting 

address. The return value is a pointer to where the actual data begins. The difference between the buffer 

address passed to the routine and the one returned will be 0, 1, 2 or 3 addresses. 

Note: The buffer that the calling program allocates should be 4 samples larger than the requested size. 


captured data must be transferred one channel at a time and put together by the application program. The 

even addresses will be from channel A and the odd addresses will be from channel B. Please see the 

Sample Program section in the CompuScope SDK Manual for further details. 

Return Value 

Returns a pointer that points to where the actual data begins. 

See also 

gage_trigger_view_transfer and Appendix B: Comparison of Various Data Transfer Routines. 

Examples 

C: 

ptr = gage_trigger_view_transfer_2 (GAGE_CHAN_A, (uInt8 far *)(buffer), 512); 

first_value = ptr[0]; 


gage_trigger_view_transfer_3 

Syntax 

C: 

uInt32 GAGEAPI gage_trigger_view_transfer_3 (int16 channel, void far *buffer, int32 nsamples); 

Visual BASIC: 


Remarks 

gage_trigger_view_transfer_3 is used to copy nsample points of the CompuScope memory space, from 

the channel specified in the parameter channel, to the supplied buffer array buffer starting with the trigger 

address of the most recent data capture. 

The CompuScope PCI boards will use bus-mastering if available; otherwise this routine is the same as 

gage_trigger_view_transfer. 

The buffer must be at least two dwords longer than the required size to store nsample samples. The 

calling program should typecast this buffer to the appropriate type before accessing the data. 

The application does not need to interleave the data when the acquisition has been performed in single 

channel mode, as is the case with gage_transfer_buffer, gage_trigger_view_transfer, 

gage_transfer_buffer_2 and gage_trigger_view_transfer_2. These routines should be used for new 

development when they are available. 

Return Value 

Returns an offset to the beginning of the dword-aligned buffer that the driver uses. The offset is the 

difference between the buffer passed to the driver and the buffer the driver uses. 

See also 

gage_trigger_view_transfer and Appendix B: Comparison of Various Data Transfer Routines. 

Examples 

C: 

offset = gage_trigger_view_transfer_3 (GAGE_CHAN_A, (uInt8 far *)(buffer), 512); 

new_ptr = (uInt8 *)(buffer+offset); 

first_value = new_ptr[0]; 

Examples 

C: 

gage_trigger_view_transfer_3 (GAGE_CHAN_A, (uInt8 far *)(buffer), 512); 


91

gage_use_cal_table 

Syntax 

C: 

int16 gage_use_cal_table (int16 action); 

Visual BASIC: 

Function gage_use_cal_table (ByVal action As Integer) As Integer 

Remarks 

This routine sets an internal driver variable that controls whether or not a CompuScope 12 bit board will be 

autocalibrated when the gain is changed. 

If action is 1, the driver variable is set and the board will use the internal DAC table rather than 

autocalibrate. The new value of the driver variable is returned. 

If action is 0, the variable is cleared and autocalibration is performed. This is the default value. 

If action is not 1 or 0, the current value is returned but nothing is changed. Also note that the DAC table 

should be set, by reading in a calibration file containing the proper values with gage_read_cal_table. 

Return Value 

The return value is the current state of the driver variable. 

See also 

gage_read_cal_table 

Examples 

C: 

gage_use_cal_table (1); 

Visual BASIC: 

gage_use_cal_table (1) 


IV 

Appendices 


93

Appendix A 

Comparison of Various 

Data Transfer Routines 

Buffered Access Routines 

All buffered routines read a block of data from CompuScope on-board memory; achieving high data 

transfer rates and thus allowing significant optimization of application performance. However, most 

buffered routines have access to only one CompuScope A/D converter's memory at a time. Therefore, in 

single channel mode, these routines will read only the odd or the even samples. The two buffers must be 

interleaved later by the user applications. In dual channel mode no interleaving is necessary, since each 

A/D converter's memory holds the data from a separate input channel. The only exception is the 

gage_transfer_buffer_3 routine which, when called in single channel mode, automatically downloads the 

data from both A/D converters' memories and does the interleaving within the drivers. 

The gage_transfer_buffer and gage_trigger_view_transfer routines provide a CPU mediated data 

transfer (i.e., a transfer where the CPU acts as mediator between host memory and the CompuScope 

board). The only difference between the two routines is in how the addresses for data to be downloaded 

are specified. gage_transfer_buffer transfers data starting from the absolute address given as one of the 

parameters. By contrast, gage_trigger_view_transfer transfers data starting from a reference address 

position. This reference address is available in the trigger_view_offset global driver variable, which is set 

by the function set_trigger_view_offset. For both the gage_transfer_buffer and 

gage_trigger_view_transfer routines, the user application must allocate and provide a host buffer of 

sufficient size to hold the requested data. 

For PCI (CP500) CompuScopes, there is no intrinsic limitation on the amount of data that can be 

transferred at a time by gage_trigger_view_transfer. However, the gage_trigger_view_transfer routine 

can only transfer 4 KSamples at a time on ISA bus CompuScopes. Several of these transfers can be 

chained together using the gage_set_trigger_view_offset routine to form one larger transfer, as shown 

below: 

offet = 0; 

position = 0; 

while (depth > 0) 

{ 

if (depth > 4096) 

transfer_depth = 4096; 

else 

transfer_depth = depth; 

gage_set_trigger_view_offset (offset); 

gage_trigger_view_transfer (GAGE_CHAN_A, (int16*) (buffer+position), transfer_depth); 

depth -= transfer_depth; 


} 

offset += transfer_depth; 

position += transfer_depth; 

Note: At the end of this routine buffer will hold all the data. The 4 Kilosample transfer size limitation only 

applies for the gage_trigger_view_transfer routine using ISA bus CompuScopes. 

For PCI CompuScopes that support PCI busmastering, the gage_transfer_buffer_2 and 

gage_trigger_view_transfer_2 routines execute a PCI bus-mastering data transfer from on-board 

CompuScope memory to host memory (PC RAM). In bus-mastering mode, data are transferred directly 

from CompuScope memory to host memory with no CPU mediation required. PCI bus-mastering is the 

fastest available PCI data transfer method and can achieve sustained data transfer rates of 100 

MegaBytes/second. 

The difference between the gage_transfer_buffer_2 and gage_trigger_view_transfer_2 routines is 

exactly the same as the difference between gage_transfer_buffer and gage_trigger_view_transfer. That 

is, gage_transfer_buffer accepts absolute CompuScope on-board memory addresses, while 

gage_trigger_view_transfer downloads data starting at the address specified by the trigger_view_offset 

global driver variable. 

Internally using PCI bus-mastering, PCI, PCI CompuScope hardware can only transfer data from a d-word 

(4 byte) boundary in CompuScope on-board memory. For instance, data can be downloaded starting from 

hexadecimal addresses 0x3000 or 3004, but not starting from hexadecimal addresses 0x3001. Because the 

gage_transfer_buffer and gage_trigger_view_transfer routines use CPU mediated data transfer, these 

details are handled by the drivers and the user need be concerned with data alignment issues. Since 

gage_transfer_buffer_2 and gage_trigger_view_transfer_2 do PCI bus-mastering with no CPU 

mediation, however, the user must deal with these data alignment issues. 

Both gage_transfer_buffer_2 and gage_trigger_view_transfer_2 return a pointer that gives the byte 

address location in host memory of the start of the data requested by the call. For instance, let us assume 

that the user requested transfer of data starting from CompuScope on-board memory address hex 0x3002. 

Let us suppose also that the user allocated a buffer whose starting address is hex 0x10000. Due to its 

hardware architecture, the CompuScope would be forced to download data from hexadecimal addresses 

0x3000. gage_transfer_buffer_2 and gage_trigger_view_transfer_2 would then return a pointer with 

the value of 0x3002 – 0x3000 + 0x10000= 0x10002. So the user application should start looking at the 

data starting at pointer value 0x10002 and not at 0x10000. 

Because the CompuScope is forced to download data from a d-word boundary, the drivers may need to 

download more data than is requested by the users. Consequently, the target host memory buffer must be 

slightly larger than the requested amount of data to be transferred. The required amount of padding is 

different for different CompuScope models. The best padding method is to use the variable 

user_buffer_padding, which is returned by the drivers and is the amount of target buffer padding in Bytes 

required for the current CompuScope model. Simply add user_buffer_padding to the amount of memory 

to be allocated for the target host memory buffer. 

gage_transfer_buffer_3 and gage_trigger_view_transfer_3 are two routines that are similar to 

gage_transfer_buffer_2 and gage_trigger_view_transfer_2 routines, except for two very important 

differences: 

1. Both gage_transfer_buffer_2 and gage_trigger_view_transfer_2 return a pointer that gives the 

byte address location in host memory of the start of the data requested by the call. By contrast, 

the return value of gage_transfer_buffer_3 is an offset in bytes that specifies the location within 

the user allocated buffer to the start of the requested data. For gage_trigger_view_transfer_3, 

the return value is an offset in Bytes that specifies the location within the user allocated buffer to 


95

the data whose address was specified by the trigger_view_offset global driver variable. For 

instance, let us assume that the user requested transfer of data starting from CompuScope onboard 

memory address hex 0x3002. This is done by passing 0x3002 as the first argument to 

gage_transfer_buffer_3 or by setting the value of the trigger_view_offset global driver variable to 

0x3002 before calling gage_trigger_view_transfer_3 Due to its hardware architecture, the 

CompuScope would be forced to download data from hexadecimal addresses 0x3000. 

gage_transfer_buffer_3 and gage_trigger_view_transfer_3 would then return an offset with the 

value of 0x3002 – 0x3000 = 2. This returned offset of 2 indicates that the start of the requested 

data is in the 3 rd byte of the host memory buffer (0 means 1 st Byte, 1 means 2nd Byte, etc). 

2. The second feature is that the data from both A/D converter memories are automatically 

interleaved in single channel mode. Behind the scenes in single channel mode, both 

gage_transfer_buffer_3 and gage_trigger_view_transfer_3 download the data from both A/D 

converter memories and interleaves them within the driver. The user is then presented with the 

complete single channel mode data record. Therefore, the application does not need to interleave 

the data when the acquisition has been performed in single channel mode. By contrast, in the 

case of gage_transfer_buffer, gage_trigger_view_transfer, gage_transfer_buffer_2 and 

gage_trigger_view_transfer_2, it is the application’s responsibility to interleave the transferred 

data in single channel mode. Since they are easier to use, therefore, gage_transfer_buffer_3 or 

gage_trigger_view_transfer_3 should be used for new software development. 

Single Sample Access Routines 

gage_mem_read_chan_a and gage_mem_read_chan_b 

These functions read one sample (which is 1 byte for 8 bit CompuScope boards and 2 bytes for 12, 14 and 

16 bit CompuScope boards) from CompuScope on-board memory for channel A or channel B respectively 

in dual channel mode. The functions are usually used to read relatively small amounts of data or to read 

non-sequential data from a CompuScope board regardless of the operating mode. 

gage_mem_read_dual is very similar to gage_mem_read_chan_a and gage_mem_read_chan_b. It 

reads one sample from CompuScope memory in dual channel mode, having the channel number as one of 

the parameters. This function is best suited for an application where there is prior knowledge that the data 

acquisition will be occurring in dual channel mode and both channels should be read. 

gage_mem_read_single is the counterpart of gage_mem_read_chan_a and gage_mem_read_chan_b for 

single channel mode. All three of these routines maintain the same parameters and return values 

gage_mem_read_master reads one sample from CompuScope memory for channel A of the Master 

CompuScope board. The Gage drivers detect the mode of operation, single or dual channel. This function 

is mostly used in conjunction with gage_calculate_mra_addresses to read embedded enhanced trigger bits 

from CompuScope memory. Embedded ETB information must always be read from the Master 

CompuScope. 

All Single Sample Access or gage_mem_read routines provide a “read ahead” caching mechanism, which 

reads a larger block of data from the CompuScope memory behind the scenes. This allows faster response 

of multiple calls to a gage_mem_read routine in order to download sequential data points. The size of the 

cache buffer, however, varies among the CompuScope boards. When call to a gage_mem_read routine is 

made, behind the scenes the driver downloads a multi-point block of data from CompuScope memory. 

This block is then stored in the driver and is used as long as address locations for subsequent 

gage_mem_read calls fall within it. 


Appendix B 

Frequently Asked 

Questions 

Q: When I run the sample programs provided on the SDK diskette, why do I get the message 

"No CompuScope boards found"? 

A: CompuScope boards need to be configured before acquiring data. Once Gage cards are properly 

configured, a configuration file, GAGESCOP.INC, is created and saved in the Windows system 

directory. Please see your Driver Installation Guide on use of the Windows board configuration 

utility. When an application, such as an SDK sample program, is executed, the Windows drivers 

look for this configuration file. If the configuration file is not found at the expected location, “No 

CompuScope boards found” message will be displayed on the Windows desktop. 

Q: Why did my program compile and run with a previous version of the driver, but not with the 

new version of the driver? 

A: You may have updated your driver to a newer version in which either the Major or Minor version 

numbers. This indicates that the common files, which contain important data structure 

declarations, have changed. For instance, if you updated from CompuScope driver version 

3.48.02 to 3.50.00, then since the Minor number 48 has been updated to 50, the common files 

must have been changed. Common files between an application and the drivers can lead to 

incompatibility that causes linking errors or incorrect operation. The solution is simply to update 

your common files. The new common files are included with the new drivers. You simply need 

to copy these new common files to your application folder, overwriting the old ones and 

recompile. This will make you application compatible with the new drivers. 

Q: My program calls gage_start_capture with the auto_trigger parameter set to TRUE. Why 

doesn’t the data capture occur immediately? 

A: The trigger source must be set to GAGE_SOFTWARE, through a call to gage_trigger_control, 

for this parameter to have a predictable effect of immediately triggering the CompuScope 

hardware. 

Q: I’m using the gage_trigger_ view_ transfer routine in single channel mode. When I examine 

the captured data, every other point is missing. Why? 

A: In single channel mode on two channel CompuScopes, the data is divided between the memories 

of the two on-board A/D converters on the CompuScope. Accordingly, gage_trigger_ 

view_transfer must be called once with each channel to transfer all the data. The two data sets 

must then be interleaved by the user application. This is also true of gage_transfer_buffer, 


97

gage_trigger_view_transfer, gage_transfer_buffer_2 and gage_trigger_view_transfer_2. The 

recommended routine, gage_transfer_buffer_3, automatically does the interleaving in the driver 

and so is the preferred data transfer routine. 

Q: Why can’t I compile sample programs under a Borland C compiler? 

A: If you are using a Borland C compiler, you will have to recreate the GAGE_DRV.LIB file, using 

the IMPLIB.EXE utility supplied by Borland. This is because of an incompatibility between 

Microsoft-generated LIB files and Borland compilers. 

The syntax is: implib gage_drv.lib gage_drv.dll. 

This will create a Borland compatible LIB file. You can then recompile the sample programs with 

this LIB file. 

Q: Why can’t I install the C/C++ CompuScope SDK on Windows NT or 2000? 

A: You have to be logged on as the Administrator to install the C/C++ SDK in Windows NT or 2000. 

This built-in security ensures that not anyone can install software on your PC. You don't need, 

however, to be the Administrator to run the SDK programs. 

Q: Why am I getting a trigger without a trigger signal connected? 

A: You have probably made a common mistake in the gage_start_capture routine. The parameter 

should be either a 1 or a 0. If you are using software trigger it should be 1, otherwise it should be 

0. Our sample programs use gage_start_capture (board->source == GAGE_SOFTWARE), which 

is an evaluation not an assignment, and so requires the double "=" symbol.. The argument 

becomes 1 if the source is software and 0 otherwise. If you write gage_start_capture (board- 

>source = GAGE_SOFTWARE), this assigns GAGE_SOFTWARE to board->source, making the 

parameter non-zero. A non-zero parameter will cause a software trigger. Change the single "=" to 

a double "=" and the problem will be resolved. 

Q: Why I am getting the data from the wrong part of the signal? 

A: Most of our sample programs have a timeout for both busy and trigger. The trigger timeout is 

used to ensure that if the user runs the program without a signal connected, the program won't 

appear to hang while it is waiting for a trigger. After a pre-set time, the sample program will call 

gage_force_capture(), which will force the CompuScope hardware to trigger immediately. The 

busy timeout is similar and causes the capture to be aborted if it has taken too long. In the sample 

programs, the default values for the trigger and busy timeouts are unusually set to high values like 

100 seconds. If a trigger time-out does occur, then the CompuScope will trigger at a time that is 

unrelated to the nature of the signal. Depending on the speed of the computer and the trigger 

repeat rate, the trigger timeout value may have to be increased. 

Q: Why I am not getting a trigger? 

A: Check that the trigger level is correct. A common error is to use a TTL signal, which swings 

between 0 and 5 Volts as an external trigger source and set the trigger level to 0 volts. The actual 

0 level of the signal may actually be several tens of milliVolts above zero. The signal thus never 


actually passes through zero and the CompuScope is never triggered. To resolve this problem, 

simply raise the trigger level to one that corresponds to 1 Volt or so. Using the wrong external 

trigger input range can also cause this problem. 

Q: The program runs, but why is the data capture incorrect? 

A: The order in which CompuScope parameter setup routines are called for data capture is important. 

gage_trigger_control should be called after gage_input_control, which should be called after 

gage_capture_mode. It is recommended that the programmer use the SetBoard() routine to 

implement CompuScope settings, since this routine calls all setup routines in the correct order. 

The SetBoard () routine resides in app_supp.c , which is included with every C sample program. 

Q: Why is Multiple Record mode behaving erratically in my program? 

A: The order in which the driver routines are called is important. gage_multiple_record should be 

called before gage_capture_mode, gage_input_control or gage_trigger_control. Also, if you 

change the Multiple Record settings, gage_trigger_control must be called again. . It is 

recommended that the programmer use the SetBoard() routine to implement CompuScope 

settings, since this routine calls all setup routines in the correct order. The SetBoard () routine 

resides in app_supp.c , which is included with every C sample program. 

Q: Why I am not able to properly capture the data with an external clock? 

A: There can be several reasons for this. The nature of the required external clock signal is different 

for each CompuScope model. The voltage levels, signal shape, duty cycle and allowed frequency 

range must also be respected. Please see your hardware manual for these details. Many 

CompuScopes terminate the external clock input with a 50 Ohm load for good signal propagation. 

The users signal must then be capable of driving a 50 Ohm load. Finally, the external clock 

function is optional on some models, so make sure that your CompuScope is actually equipped 

with the external clock option. 

Most CompuScopes have a minimum operating frequency. Consequently, the clock signal cannot 

be turned off while the CompuScope is operating. It is best to have a free-running clock source 

that is always active. 

Another important point is to correctly set the external clock frequency in your application 

program. The drivers have no other means of knowing this frequency. The drivers need to know 

the external clock frequency in order to internally set low level timing delays on the CompuScope. 

If you tell the drivers the incorrect external clock frequency, this may lead to incorrect 

CompuScope operation. 


99

Appendix C 

Multiple/Independent 

Mode Operation 

In cases where there is more than one CompuScope board installed in one host computer. This is called a 

Multi-card CompuScope system. There are two types of Multi-card CompuScope systems: a Master/Slave 

CompuScope system and a Multiple/Independent CompuScope system. 

A Master/Slave CompuScope system consists of identical CompuScopes working in a synchronous 

manner for true simultaneous sampling and triggering on all channels in the system. The Master/Slave 

configuration must be specified at the time of order. The CompuScopes are then prepared as a 

Master/Slave system at the factory. The CompuScopes can no longer then be operated as independent 

CompuScopes unless they are reconfigured at the factory. All CompuScopes in the system, Master and 

Slaves, share start and trigger signals, as well as the sampling clock. The Master CompuScope provides all 

these timing signals to the Slaves. All capture parameters, such as the post-trigger depth and sampling rate, 

are set to the same value for all CompuScopes in the system. Only the CompuScope channel parameters 

(i.e. input range, coupling and impedance) can be set independently for each CompuScope. 

] 

A Multiple/Independent CompuScope system consists of different single CompuScopes that can be 

operated independently, with completely different sampling rates and trigger conditions. This system 

allows, for example, capturing a signal with one CompuScope at a very high sampling rate to see high 

frequency signal components, and capturing the same signal at a lower sample rate with another 

CompuScope to see low frequency signal components. 

These are the only two types of systems that are currently supported by the CompuScope Windows drivers. 

So, while the drivers can operate a single Master/Slave system or a Multiple/Independent system consisting 

of many independent CompuScopes, the two types of systems cannot be combined. So, for instance, the 

drivers do not support operation of two Master/Slave systems in the same PC. Similarly, the drivers do not 

support a Master/Slave system installed in the same PC with a single independent CompuScope. The only 

way to make use of such a system is to use the CP500_ED.EXE utility. CP500_ED can be used to disable 

CompuScope models so that only one system is recognized and operated by the drivers. 

By default, the CompuScope drivers assume Master/Slave Multi-Card operation. In order to use the boards 

in the Multiple/Independent mode of operation, the routine gage_set_independant_operation must be 

called before initializing Multiple/Independent CompuScopes. The CompuScope board order can be 

determined using a CompuScope configuration utility, such as Gage Config or Instrument Manager. 

The application program is able to select to which CompuScope it communicates by calling the 

gage_select_board routine with the board number as a parameter. This routine is used to then configure 

each board separately using standard configuration routines. 

Gage drivers provide special routines for starting the capture, forcing a trigger and aborting the capture for 

the a system of Multiple Independent CompuScopes. These routines are called 


gage_board_start_capture, gage_board_force_capture, and gage_board_abort_capture, respectively. 

Data retrieval is done in the same manner as in Master/Slave mode. That is, the CompuScope is first 

selected using the gage_select_board routine and its data are downloaded using any of the data transfer 

subroutines. 

For both types of Multi-card CompuScope systems, Master/Slave and Multiple/Independent, the 

gage_driver_initialize routine is called to initialize the entire system. In a Master/Slave system, starting 

and aborting a capture can be done with a single subroutine call that is automatically sent to the Master 

CompuScope. In a Multiple/Independent system, starting and aborting a capture must be down separately 

for each CompuScope in the system by sending the appropriate call separately to each board. 


101

Appendix D 

Multiple Record Mode 

Operation 

Hardware Perspective 

Multiple Record is a feature supported by most CompuScope boards. It allows the user to take advantage 

of the CompuScope card’s very deep on-board acquisition memory. Even though the PCI bus allows very 

fast data throughput to PC memory, there are applications in which data bursts cannot be downloaded in 

time to prepare for the next trigger. Examples of such applications are radar pulses, ultrasound pulses, 

lightening pulses and imaging signals. 

Multiple Record Mode allows the CompuScope board to acquire successive rapidly repeating triggers. 

Between acquisitions, the CompuScope is re-armed in hardware to prepare for the next acquisition with no 

CPU intervention required. This hardware re-arm is lightning fast and usually occurs within under a 

microsecond. Successive acquisitions are then stacked in CompuScope on board memory. These Multiple 

Records are then usually downloaded all at once after their acquisition. Since, in Multiple Record Mode, 

all CompuScope re-arming is down in hardware, no communication with the CPU is required throughout 

the Multiple Record sequence. This has the advantage of providing deterministic operation with no 

possibility of spurious performance degradation due to the multi-tasking, non-RealTime nature of the 

Windows operating system. 

Between Multiple Record acquisitions, the on-board counter that determines the current on-board memory 

address to which the next data point will be stored is stopped. This counter is only re-started once the next 

trigger event occurs. Consequently, unlike in Single Record Mode, there are no pre-trigger data 

available in Multiple Record Mode. 

The CP500-class PCI and cPCI CompuScope boards allow the user to specify the number of Multiple 

Records to acquire. Multiple Record acquisition is completed when the requested number of records has 

been acquired. Acquired data cannot be downloaded until the complete Multiple Record Mode acquisition 

is completed or aborted. 


Like in Single Record mode, there is a minimum post-trigger depth of each Multiple Record that can be 

specified for a given CompuScope model. The depth can then be increased from this minimum in specific 

increments. See your CompuScope hardware manual for minimum depth and depth increment values in 

Multiple Record Mode. 

The total number of Multiple Records that can be acquired is slightly less than the total acquisition memory 

available divided by the post trigger depth. For instance, for a CompuScope with 1 MegaSamples of onboard 

memory capturing 2048 point Multiple Records in single channel mode, almost 1 MegaSample / 

2048 = 512 Multiple Records can be acquired (Note. 1 MegaSample = 1024 ×1024 Samples). The 

CompuScope cannot capture exactly 512 records, since a few points of inter-Record padding is required 

between sequential records. So, slightly more than 2048 points are acquired for each record and , 

consequently, less than 512 records can be acquired. The amount of padding is small (less than 10 points 

for most CompuScope models), but slightly reduces the number of records that can be captured 

As with Normal Single Record Acquisition, the GET DATA signal is strobed low to initiate a Multiple 

Record acquisition. This clears the TRIGGER and RAM FULL signals and their status bits and initializes 

the data acquisition counters to zero. The BUSY signal and status bit are now set to high. The data 

conversion process does not begin until a trigger event occurs. 

When a trigger event does occur, the sample depth counter begins to decrement. When this counter 

expires, it clears both the TRIGGER signal and its status bit, (instead of the BUSY signal as in Single 

record Mode). This allows another trigger event to again start the data capture process and acquired 

another record. A minimal number of sample clocks is required to reset the TRIGGER signal before 

another trigger event will be recognized. This number varies with CompuScope model number but is 

under 20 for all current models. 

The Multiple Record process continues until all of the requested records have been acquired. This event 

clears the BUSY signal, thus ending the Multiple Record acquisition. The following figure is a detailed 

timing diagram for a Multiple Record acquisition. 


103

Illustration of a Multiple Record acquisition for the capture of three groups. The top illustrates a timing 

diagram and CompuScope memory usage is illustrated below. 


Turning ON Multiple Record 

To determine if your CompuScope is capable of performing a Multiple Record acquisition, check your 

CompuScope hardware manual. To set up the currently selected CompuScope to perform a Multiple 

Record capture, you must call gage_multiple_record with a parameter of 1. A 0 parameter will turn off 

Multiple Recording if it was previously selected. If Multiple Record is chosen, the trigger depth set in the 

call to gage_trigger_control or gage_trigger_control_2 is used to set the size of each individual record. 

The minimum trigger depth and increment depend upon the CompuScope model. Because some driver 

parameters must be adjusted for Multiple Record operation, the sequence of calls is important. 

gage_multiple_record must be called before calling gage_capture_mode. The proper sequence of calls is 

as follows: 

gage_multiple_record (1); 

gage_multiple_record_acquisitions (number_of_acquisitions); 

gage_capture_mode (GAGE_DUAL_CHAN, GAGE_RATE_10, GAGE_MHZ); 

gage_input_control (GAGE_CHAN_A, GAGE_ENABLE, GAGE_DC, GAGE_PM_1_V); 

gage_input_control (GAGE_CHAN_B, GAGE_ENABLE, GAGE_DC, GAGE_PM_1_V); 

gage_trigger_control (GAGE_CHAN_A, GAGE_DC, GAGE_PM_1_V, GAGE_POSTIVE, 128, 

GAGE_POST_4K); 

If more than one CompuScope is to be used in Multiple Record mode, then the functions must be called for 

each individual CompuScope. gage_select_board can be used to select each CompuScope to be set. 

Downloading Multiple Record Data 

Multiple Record data is usually downloaded one record or group at a time. The function 

gage_calculate_mr_addresses is used to return the starting, trigger and ending addresses for each 

individual group. One of the parameters is the group number, whose valid range of values is 1 to the 

number of groups captured. If the group number is set to 0, the function will return the starting, trigger and 

ending address for the entire series of groups, treating them all as if they were one large capture. If the 

group number is -1, gage_calculate_mr_addresses will return the group number and the relevant 

addresses for the last group captured. 

If the channel parameter is -1, the captures are treated as a Software Multiple Record. Software Multiple 

Record is a format in which each record is arranged one after the other with no inter-record padding, unlike 

in CompuScope on-board memory where there is always some inter-record padding. This format is used to 

store data in Software Multiple Record SIG files. Setting the channel parameter to –1, therefore, is a useful 

method of calculating record addresses retrieved from a Software Multiple Record SIG file. 

As mentioned above, due to CompuScope hardware architecture, there is always some inter-Multiple 

Record padding in CompuScope on-board memory. This padding depends on the CompuScope model, 

mode and sampling rate but will be consistent for all the groups in a given Multiple Record capture. For 

this reason, application programs should use the driver function gage_calculate_mr_addresses to read 

back the captured data, rather than incorrectly assuming, for instance, that the third 1000-point record will 

start at address 2000 and end at address 3000. 

The prototype of gage_calculate_mr_addresses is: 

int32 gage_calculate_mr_addresses (int32 group, int16 board_type, int32 depth, int32 memory, 

int16 chan, int16 op_mode, float tbs, int32 far *trig, int32 far *start, int32 far *end); 

The trig, start and end variables are used to obtain the relevant addresses for each individual group. The 

valid range of group numbers is from 1 to the number of groups captured by the Multiple Record 

acquisition. The return value of gage_calculate_mr_addresses is equal to the group number passed to it 


105

as long the group number is less than or equal to the number of acquired groups. When the passed group 

number is not equal to the return value, this indicates that the passed group number is outside the rage of 

valid captured groups. 

The recommended way of downloading all the groups in a Multiple Record capture is shown below: 

gage_get_driver_info (&gdi); 

tbs = 1000000000 / sample_rate; /* tbs is time between samples in nanoseconds. The correct value must 

be passed to address calculation routines for correct operation */ 

group = 1; 

while (group == gage_calculate_mr_addresses (group, gdi.board_type, gdi.depth, 

gdi.max_available_memory, chan, gdi.mode, tbs, &trig, &start, &end) { 

} 

size = end - trig +1; 

offset = gage_transfer_buffer_3 (trig, GAGE_CHAN_A, buffer, size); 

display_data(offset); /*User-supplied routine that displays buffer, beginning at offset*/ 

group++; 

The above sample code assumes that the buffer has already been allocated. The capture was in dual 

channel mode and only data from channel A is being transferred from the CompuScope acquisition 

memory to PC memory. 

Note that size was calculated to be end – trig +1. In Multiple Record mode there is no pre-trigger data, so 

the end address will always be greater than the trigger address. 

The above method is convenient if you don't know the total number of groups that have been captured 

because of the inter-record padding. If you've aborted the capture after a predetermined number of groups, 

or the driver routine gage_multiple_record_acquisitions is available for your CompuScope board, you 

can use a for loop to read only the number of groups of interest. 

Embedded Enhanced Trigger Bits 

A factory option available on most CompuScope boards with Multiple Record is Embedded Enhanced 

Trigger Bits. Due to the architecture of the CompuScope Multiple Record hardware, there is some 

uncertainty inherent in the trigger address because the least significant bits of this address are not 

maintained. The Embedded ETB option embeds the least significant bits of the trigger address (the ETBs) 

in an early sample of each Multiple Record group. After download, these embedded ETBs can be 

recovered and then used to resolve the trigger address uncertainty. 

On CompuScopes with the Embedded ETB functionality, the trigger address returned by 

gage_calculate_mr_addresses will point to the sample that that contains the enhanced trigger bits (ETBs). 

This sample must be downloaded using the gage_mem_read_master function as illustrated below: 

data = gage_mem_read_master(trig); 

In a Master/Slave CompuScope system, the ETBs for records from all CompuScopes in the system (Master 

and Slaves) must be downloaded from the Master CompuScope. Using the gage_mem_read_master 

function, as illustrated above, ensures that the ETBs are always downloaded from the Master CompuScope. 

The embedded ETBs are used to adjust the trigger address using the gage_calculate_mra_addresses 

function. The prototype of this function is shown below: 

int32 gage_calculate_mra_addresses (int16 board_type, uInt16 board_version, int16 chan, int16 


op_mode, float tbs, int32 far *trig, int32 far *start, int32 far *end, int16 data); 

Note that the chan parameter in this routine is 0-based. That is, channel A is specified by 0 and channel B 

is specified by 1. The data variable is the data located at the raw trigger address. This must have been 

previously downloaded as described above. 

The recommended way of calculating Multiple Record addresses using the embedded ETBs in order to 

correct the trigger address and then downloading the record data is shown below: 


tbs = 1000000000 / sample_rate; /* tbs is time between samples in nanoseconds. The correct value must 

be passed to address calculation routines for correct operation */ 

group = 1; 

while (group == gage_calculate_mr_addresses (group, gdi.board_type, gdi.depth, 

gdi.max_available_memory, chan, gdi.mode, tbs, &trig, &start, &end) { 

} 

data = gage_mem_read_master (trig); 

gage_calculate_mra_addresses (gdi.board_type, gdi.board_version, chan-1, gdi.mode, tbs, &trig, 

&start, &end, data); 

size = (end - trig) +1; 

offset=gage_transfer_buffer_3(trig, GAGE_CHAN_A, buffer, size); 

display_data(offset); /*User-supplied routine that displays buffer, beginning at offset*/ 

group++; 

Due to varying amounts of inter-record padding throughout a Multiple Record Acquisition, the groups 

differ in size after embedded ETBs have been used to adjust the trigger addresses. 

An application program can check if Enhanced ETBs are available on the current CompuScope hardware 

by comparing the ee_options field of the gage_driver_info_type structure and comparing it against the 

EEPROM_OPTIONS_MULREC_ADJUST constant (defined in the EEPROM.H file). For example: 


if (gdi.ee_options & EEPROM_OPTIONS_MULREC_ADJUST) 

printf ("embedded trigger bits available\n"); 

Notes 

If you are using Multiple Record, you should generally not use a busy timeout. A busy timeout is usually 

used to abort a capture if it is not finished within a predefined amount of time. Because a Multiple Record 

capture is actually a series of captures, the Multiple Record acquisition can last a long and perhaps 

indeterminate amount if time. Consequently, an incorrect busy timeout value may prematurely abort 

Multiple Record acquisition before all the captures are complete. If you must use a busy timeout, make 

sure that the timeout value exceeds the longest possible total Multiple Record acquisition time. 


107

Technical Support 

Gage Applied Technologies, Inc. offers technical support for all its Software Development Kits. 

In order to serve you better, we have created a web-based technical support system that is available to you 

24 hours a day. 

By utilizing the internet to the fullest, we are able to provide you better than ever technical support without 

increasing our costs, thereby allowing us to provide you the best possible product at the lowest possible 

price. 

To obtain technical support, simply visit: 

www.gage-applied.com/support.asp 

Please complete this form and submit it. Our form processing system will intelligently route your request 

to the Technical Support Specialist (TSS) most familiar with the intricacies of your product. This TSS will 

be in contact with you within 24 hours of form submittal. 

In the odd case that you have problems submitting the form on our web site, please e-mail us at 

support@gage-applied.com 

As opposed to automatic routing of technical support requests originating from the Gage web site, support 

requests received via e-mail or telephone calls are routed manually by our staff. Providing you with high 

quality support may take an average of 2 to 3 days if you do not use the web-based technical support 

system. 

Please note that Technical Support Requests received 

via e-mail or by telephone will take an average of 2 to 3 days to process. 

It is faster to use the web site! 

When calling for support we ask that you have the following information available: 

1. Version and type of your CompuScope SDK and drivers. 

(The version numbers are indicated on the distribution media. Version numbers can also be obtained 

by looking in the appropriate README.TXT files) 

2. Type, version and memory depth of your CompuScope card. 

3. Type and version of your operating system. 

4. Type and speed of your computer and bus. 

5. Any extra hardware peripherals (i.e. CD-ROM, joystick, network card, etc.) 

6. Were you able to reproduce the problem with standalone Gage Software (e.g. GageScope, GageBit, 

etc)?

Gage Products 

For ordering information, see Gage’s product catalog, or visit our web site at 

http://www.gage-applied.com 

CompactPCI Bus Products CompuScope 85GC 8 bit, 5 GS/s Analog Input Card 

CompuScope 82GC 

8 bit, 2 GS/s Analog Input Card 

CompuScope 14100C 

14 bit, 100 MS/s Analog Input Card 




32 bit, 100 MHz Digital Input for CompactPCI Bus 

PCI Bus Products CompuScope 1610 16 bit, 10 MS/s Analog Input Card 

CompuScope 1602 

16 bit, 2.5 MS/s Analog Input Card 















CompuScope 85G 


CompuScope 82G 





32 bit, 100 MHz Digital Input for PCI Bus 

CompuGen CompuGen 1100 12 bit, 80 MS/s Analog Output Card 

CompuGen 3250 

32 bit, 50 MHz Digital Output Card 

Application Software GageScope World's Most Powerful Oscilloscope Software 

GageBit 

Digital Input/Output Software 

CompuGen for Windows 

Arbitrary Waveform Generator Software for Windows 

Software Development Kits 

CompuScope SDK for C/C++ for Windows 

CompuScope LabVIEW SDK for Windows 

CompuScope MATLAB SDK for Windows 

CompuScope LabWindows/CVI SDK 

(for CompactPCI/PXI bus CompuScope cards) 

CompuGen Analog SDK for C/C++ for Windows 

CompuGen Digital SDK for C/C++ for Windows 

CompuGen Analog LabVIEW SDK for Windows 

CompuGen Digital LabVIEW SDK for Windows 

CompuGen Analog MATLAB SDK for Windows 

CompuGen Digital MATLAB SDK for Windows 

Instrument Mainframes Instrument Mainframe 7000 

Instrument Mainframe 2000 

Instrument Mainframe 8000C 

Instrument Mainframes for Housing CompuScope and 

CompuGen Products. 

Instrument Mainframes for Housing CompactPCI/PXI 

CompuScope Products.

CompuScope SDK Manua.. - Egmont Instruments

You also want an ePaper? Increase the reach of your titles

Delete template?

Save as template?