横河500接口函数

3.3 Available Functions (1)

int TmcInitialize( int wire, char* adr, int* id ); (1)

int TmcDeviceClear( int id ); (4)

int TmcSend( int id, char* msg ); (5)

int TmcSendByLength( int id, char* msg, int len ); (5)

int TmcSendSetup( int id ); (6)

int TmcSendOnly( int id, char* msg, int len, int end ); (7)

int TmcReceive( int id, char* buff, int blen, int* rlen ); (7)

int TmcReceiveSetup( int id ); (8)

int TmcReceiveOnly( int id, char* buff, int blen, int* rlen ); (9)

int TmcReceiveBlockHeader( int id, int* length ); (10)

int TmcReceiveBlockData( int id, char* buff, int blen, int* rlen, int* end ); (11)

int TmcCheckEnd( int id ); (12)

int TmcSetRen( int id, int flag ); (13)

int TmcGetLastError( int id ); (13)

int TmcSetTerm( int id, int eos, int eot ); (14)

int TmcSetTimeout( int id, int tmo ); (15)

int TmcFinish( int id ); (16)

int TmcSearchDevices( int wire, DEVICELIST* list, int max, int* num, char* option); (16)

int TmcEncodeSerialNumber(char* encode, size_t len, char* src); (17)

int TmcDecodeSerialNumber(char* decode, size_t len, char* src); (18)

int TmcWaitSRQ( int id, char* stsbyte, int tout); (19)

int TmcAbortWaitSRQ( int id); (19)

int TmcSetCallback(int id, Hndlr func, ULONG p1,ULONG p2); (20)

int TmcResetCallback(int id); (21)

typedef void SRQCALLBACK(int id, UCHAR stb, ULONG p1,ULONG p2); (21)

3.3 Available Functions

---------------------------------------------------------------------------------------------------------------

intTmcInitialize( int wire, char* adr, int* id );

Purpose: Initializes and opens a connection to the specified device

Parameters: intwire connection types

char* adr the address of the connection

int* id special device ID used by other functions

Return value: 0 = OK, 1 = ERROR

Details:

Description of Parameters

int wire

Set this parameter to the type of connection through which the device will be

controlled.

The settings for each type of interface are shown below.

GPIB: wire = TM_CTL_GPIB(1)

RS232: wire = TM_CTL_RS232(2)

USB: wire = TM_CTL_USB(3)

Ethernet: wire = TM_CTL_ETHER(4)

USBTMC(DL9000): wire = TM_CTL_USBTMC(5)

EthernetUDP: wire = TM_CTL_ETHERUDP(6)

USBTMC(excluding DL9000): wire = TM_CTL_ETHERUDP(7)

VXI-11: wire = TM_CTL_VXI11(8)

char* adr

Use a character string to set this parameter to the GPIB address or RS-232

settings of the device to be controlled.

The following shows how the settings for each interface.

GPIB: adr = "1"-"30" (the GPIB address value of the device)

RS232: adr = "port number, baud rate number, bit specification, handshaking number"

port number 1 = COM1

2 = COM2

3 = COM3

baud rate number 0 = 1200

1 = 2400

2 = 4800

3 = 9600

4 = 19200

5 = 38400

6 = 57600

bit specifications 0 = 8 bits, no parity, 1 stop bit

1 = 7 bits, even parity, 1 stop bit

2 = 7 bits, odd parity, 1 stop bit

handshaking number 0 = NO-NO

1 = XON-XON

2= CTS-RTS

USB: adr = "1"-"127" (the unique USB ID for the device)

Ethernet: adr = "server name, user name, password"

sever name The server name or IP address of the DL

user name The user name

password The password

When the user name is anonymous,

a password is not required.

(A delimiting comma "," is required.)

USBTMC(DL9000): adr = "serial number"

Serial number The instrument serial number

USBTMC(GS200 and GS820): adr = "serial number"

Serial number The instrument serial number

USBTMC(GS610): adr = "serial number" + "C"

Serial number The instrument serial number

USBTMC (other than the DL9000 and GS series): adr = the number

encoded by TmcEncodeSerialNumber using "serial number"

Serial number The instrument serial number

VXI-11: adr = "IP address"

int* id

Allocates the device ID passed to each function after initialization to the

storagebuffer.

If initialization succeeds and a connection is opened, an integer equal to

orgreaterthan 0 is returned for the ID.

If initialization succeeds, the return value is 0. If a connection could not be

opened,the return value is 1.

Regardless of the type of connection, the settings below take effect if

initializationis successful.

- Terminator: LF (LF or EOI for GPIB)

- Timeout: 30 seconds

Example:

GPIB address 1:

int id;

int ret = TmcInitialize( TM_CTL_GPIB, "1", &id );

RS232 COM1,57600,8-NO-1,CTS-RTS:

int id;

ret = TmcInitialize( TM_CTL_RS232, "1,6,0,2", &id );

USB ID 1:

int id;

int ret = TmcInitialize( TM_CTL_USB, "1", &id );

Ethernet IP = 11.22.33.44, User name = anonymous

int id;

int ret = TmcInitialize( TM_CTL_ETHER, "11.22.33.44,anonymous,", &id );

Ethernet IP = 11.22.33.44, User name = yokogawa, Password = abcdefgh int id;

int ret = TmcInitialize( TM_CTL_ETHE, "11.22.33.44,yokogawa,abcdefgh",

&id );

USBTMC (DL9000) serial number = 27E000001

int id;

int ret = TmcInitialize( TM_CTL_USBTMC, "27E000001", &id );

USBTMC (GS200 and GS820) serial number = 27E000001

int id;

int ret = TmcInitialize( TM_CTL_USBTMC2, "27E000001", &id );

USBTMC (GS610) serial number = 27E000001

int id;

int ret = TmcInitialize( TM_CTL_USBTMC2, "27E000001C", &id );

USBTMC (other than the DL9000 and GS series) serial number = 27E000001

' When using the device list

int id;

int ret;

DEVICELIST list[127];

intnum;

ret = TmcSearchDevices(TM_CTL_USBTMC2,list,127,&num,NULL);

ret = TmcInitialize( TM_CTL_USBTMC2, list[0].adr, &id );

' When specifying the serial number directly

int id;

char encode[256];

int ret;

ret = TmcEncodeSerialNumber(encode,256,"27E000001");

ret = TmcInitialize( TM_CTL_USBTMC2, encode, &id );

VXI-11 IP=11.22.33.44

int id;

int ret = TmcInitialize( TM_CTL_VXI11, "11.22.33.44", &id );

---------------------------------------------------------------------------------------------------------------

intTmcDeviceClear( int id );

Purpose: Executes a selected device clear(SDC). This is a GPIB-specific command.

Parameters: int id device ID

Return value: 0 = OK, 1 = ERROR

Details:

Description of Parameters

int id

Set this parameter to the ID of the device for which the device clear will be executed.

This function is specific to GPIB devices, and doesn't affect devices using other

interfaces.

This function is specific to GPIB and USBTMC (other than the DL9000) devices, and doesn't affect devices using other interfaces.

With USBTMC (other than the DL9000), a USBTMC standard InitiateClear is issued.

If the InitiateClear succeeds, ClearFeature is issued and execution ends.

If the device clear succeeds, the return value is 0. However, if it is executed on non-GPIB or USBTMC (other than the DL9000) devices, the value is always 0.

If device clear succeeds, the return value is 0.

However, if it is executed on non-GPIB devices, the value is always 0.

Example:

int ret = TmcDeviceClear( id );

---------------------------------------------------------------------------------------------------------------

intTmcSend( int id, char* msg );

Purpose: Sends a message to a device.

Parameters: intid device ID

char* msg message character string

Return value: 0 = OK, 1 = ERROR

Details:

Description of Parameters

int id

Set this parameter to the ID of the device to which the message will be sent.

char* msg

For this parameter, enter the character string for the message itself.

Sends an ASCII character string to the device specified by the ID.

When sending binary data, use "TmcSendByLength".

Also, when dividing up a message to be sent, use "TmcSendSetup" and "TmcSendOnly".

Example:

int ret = TmcSend( id, "START" );

---------------------------------------------------------------------------------------------------------------

intTmcSendByLength( int id, char* msg, intlen );

Purpose: Sends a message of the specified number of bytes to a device.

Parameters: int id device ID

char* msg message character string

intlen the length in bytes to be sent

Return value: 0 = OK, 1 = ERROR

Details:

Description of Parameters

int id

Set this parameter to the ID of the device to which the message will be sent.

char* msg

For this parameter, enter the message itself.

intlen

Set this parameter to the number of bytes to be sent in the message.

Sends a message to the device specified by the ID.

You can send a message even if it includes binary data.

When dividing up a message to be sent, use "TmcSendSetup" and "TmcSendOnly".

Example:

int ret = TmcSendByLength( id, "START", 5 );

---------------------------------------------------------------------------------------------------------------

intTmcSendSetup( int id );

Purpose: Prepares the PC to send a message to a device.

Parameters: intid device ID

Return value: 0 = OK, 1 = ERROR

Details:

Description of Parameters

int id

Set this parameter to the ID of the device to which the PC should prepare to send a

message.

Prepares to send a message to the device specified by the ID.

When sending a single message over several transmissions, executes only once prior to the

transmission.

Use "TmcSendOnly" for the actual transmission.

Example:

int ret = TmcSendSetup( id );

---------------------------------------------------------------------------------------------------------------

intTmcSendOnly( int id, char* msg, intlen, int end );

Purpose: Sends a message of the specified number of bytes to a device.

Parameters: int id device ID

char* msg message character string

intlen the length in bytes to be sent

int end end flag

Return value: 0 = OK, 1 = ERROR

Details:

Description of Parameters

int id

Set this parameter to the ID of the device to which the message will be sent.

char* msg

For this parameter, enter the message itself.

intlen

Set this parameter to the number of bytes to be sent in the message.

int end

Set this parameter to indicate whether the current transmission is the final

transmission.

The value is 1 at the end of transmission, or 0 if transmission is to continue.

Sends a message to the device specified by the ID.

You can send a message even if it includes binary data.

If the end flag was set to 1, a terminator is sent at the end of the message.

Therefore while the end flag is 0, the device side considers the message to be in a series.

Examples:

int ret;

ret = TmcSendSetup( id );

ret = TmcSendOnly( id, "STA", 3, 0 );

ret = TmcSendOnly( id, "RT", 2, 1 );

---------------------------------------------------------------------------------------------------------------

intTmcReceive( int id, char* buff, intblen, int* rlen );

Purpose: Receives a message from a device.

Parameters: int id device ID

char* buff buffer for received data

intblen size of the buffer (in bytes)

intrlen the actual number of bytes received

Return value: 0 = OK, 1 = ERROR

Details:

Description of Parameters

int id

Set this parameter to the ID of the device from which the message will be received.

char* buff

Set this parameter to create a buffer that will store the message.

intblen

Set this parameter to the maximum number of bytes in the message that may be

received (normally the number of bytes in the buffer).

int* rlen

Returns the actual number of bytes received.

Receives a message from the device specified by the ID. Receives data up to the terminator

when one is detected, or the number of bytes specified by blen if no terminator is detected.

When using YOKOGAWA digital oscilloscopes, use "TmcReceiveBlockHeader" and

"TmcReceiveBlockData" to receive message data such as "WAVeform:SEND?" and "IMAGe:SEND?".

Examples:

char buff[10000];

int length;

int ret = TmcReceive( id, buff, 10000, &length );

---------------------------------------------------------------------------------------------------------------

intTmcReceiveSetup( int id );

Purpose: Prepares the PC to receive a message from a device.

Parameters: intid device ID

Return value: 0 = OK, 1 = ERROR

Details:

Description of Parameters

int id

Set this parameter to the ID of the device from which the PC will receive the

message.

Executes in order to prepare to receive from the device large amounts of data that has

been divided up into multiple transmissions.

Use "TmcReceiveOnly" for the actual receiving of data.

Example:

int ret = TmcReceiveSetup( id );

---------------------------------------------------------------------------------------------------------------

intTmcReceiveOnly( int id, char* buff, intblen, int* rlen );

Purpose: Receives a message (after preparation) from a device.

Parameters: int id device ID

char* buff buffer for received data

intblen size of the buffer (in bytes)

intrlen the actual number of bytes received

Return value: 0 = OK, 1 = ERROR

Details:

Description of Parameters

int id

Set this parameter to the ID of the device from which the message will be received.

char* buff

Set this parameter to create a buffer that will store the message.

intblen

Set this parameter to the maximum number of bytes in the message that may be

received (normally the number of bytes in the buffer).

int* rlen

Returns the actual number of bytes received.

Used when receiving large amounts of data that has been divided up.

After preparing for reception using "TmcReceiveSetup", receives the message from the

device specified by the ID.

Receives data up to the terminator when one is detected, or the number of bytes

specified

byblen if no terminator is detected.

Examples:

int ret;

char buff [1000];

int length;

ret = TmcReceiveSetup( id );

ret = TmcReceiveOnly( id, buff, 1000, &length );

ret = TmcReceiveOnly( id, buff, 1000, &length );

ret = TmcReceiveOnly( id, buff, 1000, &length );

---------------------------------------------------------------------------------------------------------------

intTmcReceiveBlockHeader( int id, int* length );

Purpose: Receives the header portion of the Block Data sent from the device, and returns

the number of bytes after the header.

Parameters: int id device ID

int* length the number of bytes in the Block Data

Return value: 0 = OK, 1 = ERROR

Details:

Description of Parameters

int id

Set this parameter to the ID of the device from which Block Data will be received.

int* length

Returns the number of bytes in the Block Data.

This is the first command to be used before receiving Block Data.

The number of bytes in the data after the header is returned as the length, so that

number plus 1 (for the terminator) is assigned to "TmcReceiveBlockData" and then the

data is received.

Examples:

int length;

int ret = TmcReceiveBlockHeader( id, &length );

---------------------------------------------------------------------------------------------------------------

intTmcReceiveBlockData( int id, char* buff, intblen, int* rlen, int* end );

Purpose: Receives the data portion of the Block Data sent from a device.

Parameters: int id device ID

char* buff buffer for received data

intblen size of the buffer (in bytes)

intrlen the actual number of bytes received

int* end end flag

Return value: 0 = OK, 1 = ERROR

Details:

Description of Parameters

int id

Set this parameter to the ID of the device from which the message will be received.

char* buff

Set this parameter to create a buffer that will store the message.

intblen

Set this parameter to the maximum number of bytes in the message that may be

received (normally the number of bytes in the buffer).

int* rlen

Returns the actual number of bytes received.

int* end

Returns whether all of the number of bytes of data returned by

"TmcReceiveBlockHeader" are finished being received.

The value is 1 at the end of reception, or 0 if reception is to continue.

Used when receiving block data (messages starting with a #).

After preparing for reception using "TmcReceiveBlockHeader", the message is received

from the device specified by the ID.

Receives data up to the terminator when one is detected, or the number of bytes specified

byblen if no terminator is detected.

Example:

int ret;

int length;

int len;

char buff [1000];

int flag;

ret = TmcReceiveBlockHeader( id, &length );

if( length < 1 ) {

return;

}

length += 1;

flag = 0;

while( flag == 0 ) {

ret = TmcReceiveBlockData( id, buf, 1000, &len, &flag );

}

---------------------------------------------------------------------------------------------------------------

intTmcCheckEnd( int id );

Purpose: Returns whether the message from the device is finished.

Can be used with the GPIB, USB, Ethernet, USBTMC, and VXI-11 interfaces.

Parameters: intid device ID

Return value: 1 = message to continue, 0 = message complete

Details:

Description of Parameters

int id

Set this parameter to the ID of the device from which the message to be checked

for completion will be received.

When receiving a message that has been divided up into a series of messages, all of the

message is received using "TmcReveiveOnly", and the function returns the value indicating

whether reception is complete.

Example:

int ret = TmcCheckEnd( id );

if( ret == 0 ) {

/* end of reception */

}

else {

/* reception continuing */

}

---------------------------------------------------------------------------------------------------------------

intTmcSetRen( int id, int flag );

Purpose: Places a device in remote or local mode. Use with non-GPIB interfaces is limited to

YOKOGAWA instruments.

Parameters: int id device ID

int flag remote (1)/local (0)

Return value: 0 = OK, 1 = ERROR

Details:

Description of Parameters

int id

Set this parameter to the ID of the device that will be placed in remote or

local mode.

int flag

Send 1 for remote, and 0 for local mode.

Depending on the type of interface, there are some differences in the way this command

is used.

For GPIB, the REN line is set to TRUE or FALSE.

Even after the parameter is entered, the device isn't actually placed in the mode until

messages are sent to that device.

With GPIB, the remote/local function cannot be applied separately to different devices.

When using RS232, USB or Ethernet with YOKOGAWA 488.2 compliant devices, only devices

that support COMMunications groups as messages can utilize this function.

In this case, the function can be applied separately to different devices.

In the USBTMC, remote / local switch is realized by control transfer.

Example:

int ret = TmcSetRen( id, 1 );

---------------------------------------------------------------------------------------------------------------

intTmcGetLastError( int id );

Purpose: Returns the number of the last error that occurred.

Parameters: intid device ID

Return value: Error number

Details:

Description of Parameters

int id

Set this parameter to the ID of the device from which an error number will

be acquired.

Returns the number of the last error that occurred on that device.

If the return value from any of the functions is non-zero (including the initialization function), this function can be used to acquire the actual error number. Example:

int ret = TmcSend( id, "START" );

if( ret != 0 ) {

int err = TmcGetLastError( id );

}

--------------------------------------------------------------------------------------------------------------- intTmcSetTerm( int id, inteos, inteot );

Purpose: Sets the terminator for sending or receiving a message.

Parameters: int id device ID

inteos terminator

inteot EOI

Return value: 0 = OK, 1 = ERROR

Details:

Description of Parameters

int id

Set this parameter to the ID of the device for the terminator.

inteos

Set this parameter to the terminator itself. The settings are shown below.

eos = 0 : CR+LF

= 1 : CR

= 2 : LF

= 3 : EOI (GPIB), or not (RS232, USB, Ethernet)

When the interface is GPIB and eos is 3, eot determines whether EOI is used.

inteot

Set this parameter to determine whether EOI can be used for the terminator.

This is a GPIB-specific command.

Sets the terminator. In general, you can use the following settings for any interface when carrying out communications with YOKOGAWA products.

int ret = TmcSetTerm( id, 2, 1 ); /* eos = LF, eot = TRUE */

When sending or receiving binary data with the setting eos = LF, if LF code is

included

in the binary code, the transmission concludes when the LF code is encountered.

However, when receiving block data using a YOKOGAWA product, if you use

"TmcReceiveBlockHeader" and "TmcReceivceBlockData", there's no need to switch the

terminator.

This function not supported with USBTMC on instruments other than the DL9000. It is not necessary to use the function.

Example:

int ret = TmcSetTerm( id, 2, 1 );

---------------------------------------------------------------------------------------------------------------

intTmcSetTimeout( int id, inttmo );

Purpose: Sets the timeout time for communications.

Parameters: int id device ID

inttmo timeout time (100-6553600 ms)

Return value: 0 = OK, 1 = ERROR

Details:

Description of Parameters

int id

Set this parameter to the ID of the device on which timeout will be set.

inttmo

Set this parameter to the timeout time in units of 100 ms.

When tmo = 0

GPIB: Timeout unlimited

Other: No timeout

Sets the timeout time for communications. Generally you should set the timeout time

to 30 seconds when using YOKOGAWA products. (Even if you lengthen the timeout time,

performance will not be affected.

Example:

int ret = TmcSetTimeout( id, 300 ); /* 30s */

---------------------------------------------------------------------------------------------------------------

intTmcFinish( int id );

Purpose: Closes the connection to a device.

Parameters: intid device ID

Return value: 0 = OK, 1 = ERROR

Details:

Description of Parameters

int id

Set this parameter to the ID of the device whose connection will be closed.

Closes connections opened with "TmcInitialize" (initialization function).

You must execute this function when concluding communications.

Example:

int ret = TmcFinish( id );

---------------------------------------------------------------------------------------------------------------

intTmcSearchDevices( int wire, DEVICELIST* list, int max, int* num, char* option);

Purpose: Returns a list of devices connected to the specified wire.

Parameters: int wire Wire type

DEVICELIST* list Pointer to the array containing the strings indicating the found devices

int max Number of arrays of strings indicating the found devices

int* num Number of found devices

char* option Required parameters for each devices

Return value: 0 = OK, 1 = ERROR

Details:

Description of parameters

int wire

Specifies the type of wire to which the device to be controlled is connected.

The settings for each interface are as follows:

GPIB : Not supported

RS232 : Not supported

USB : Not supported

Ethernet : Not supported

USBTMC(DL9000) : Not supported

EthernetUDP : Not supported

USBTMC (other than the DL9000): wire = TM_CTL_USBTMC2(7)

VXI-11 : wire = TM_CTL_VXI11(8)

DEVICELIST* list

typedef struct _Devicelist

{

char adr[ADRMAXLEN];(ADRMAXLEN= 64)

} DEVICELIST;

GPIB, RS232, USB, Ethernet, and USBTMC (DL9000) are undefined.

For USBTMC, the encoded serial number is returned.

For VXI-11, the IP address is returned.

int max

Number of arrays of the above structure prepared by the user.

int* num

Number of devices acquired

char* option

VXI-11: IP address to be masked, in the form of a string

USBTMC: Not required

Other: Undefined

Example:

int ret;

DEVICELIST list[127];

int num;

ret = TmcSearchDevices(7,list,127,&num,NULL); // USBTMC (other than the DL9000)

--------------------------------------------------------------------------------

intTmcEncodeSerialNumber(char* encode, size_tlen, char* src);

Purpose: Converts the name plate serial number to a USB internal serial number.

Parameters: char* encode The converted USB internal serial number

size_tlen Size of the encode buffer (no. of bytes)

char* src Serial number printed on the name plate

Return value: 0 = OK

Details:

Description of parameters

char* encode

Pointer to the buffer in which the converted USB internal serial number is stored

size_tlen

Size of the above buffer

char* src

Pointer to the buffer to which the serial number of the instrument printed on the name plate is written.

Example:

char encode[256];

int ret;

// Converts the name plate serial number to a USB internal serial number.

ret = TmcEncodeSerialNumber(encode,256,"12W929658");

ret = TmcInitialize(TM_CTL_USBTMC2, encode, &id);

--------------------------------------------------------------------------------

intTmcDecodeSerialNumber(char* decode, size_tlen, char* src);

Purpose: Converts the name plate serial number to a USB internal serial number.

Parameters: char* encode Serial number printed on the name plate

size_tlen Size of the encode buffer (no. of bytes)

char* src The converted USB internal serial number

Return value: 0 = OK, 1 = ERROR

Details:

Description of parameters

char* decode

Pointer to the buffer to which the serial number of the instrument printed on the name plate is written.

size_tlen

Size of the above buffer

char* src

Pointer to the buffer in which the converted USB internal serial number is stored

Example:

char encode[256];

// Converts the USB internal serial number to the name plate serial number.

ret = TmcDecodeSerialNumber(decode,256,"313257393239363538");

// decode = "12W929658"

-------------------------------------------------------------------------------- intTmcWaitSRQ( int id, char* stsbyte, int tout);

Purpose: Receives the SRQ of the device of the specified ID

Parameters: int id Device value

char* stsbyte Pointer to the status byte storage buffer

int tout Timeout value (in 100 msec units)

Return value: 0 = OK, 1 = ERROR

Details:

Description of parameters

int id

Sets the ID of the device that receives the SRQ.

char* stsbyte

Sets the SRQ attributes.

int tout

Timeout value set in 100 msec units.

Example:

int ret

int sts;

// Waits for the SRQ with a timeout value of 10 seconds

ret = TmcWaitSRQ(id, &sts, 100);

--------------------------------------------------------------------------------

intTmcAbortWaitSRQ( int id);

Purpose: Clears the wait state of the SRQ wait function of the specified device. Parameters: int id Device value

Return value: 0 = OK, 1 = ERROR

Details:

Description of parameters

Specifies the ID of the device on which to clear the wait state of the SRQ wait function.

Example:

int ret = TmcAbortWaitSRQ(id);

--------------------------------------------------------------------------------

intTmcSetCallback(int id, Hndlrfunc, ULONG p1,ULONG p2);

Purpose: Registers the call back routine when an SRQ occurs.

Parameters: int id Device value

Hndlrfunc Pointer to the call back function

unsigned long p1 long first parameter

unsigned long p2 long second parameter

Return value: 0 = OK, 1 = ERROR

Details:

Description of parameters

int id

Sets the device ID of the device that sets the call back function.

Hndlrfunc

typedef void(*Hndlr)(int, UCHAR, ULONG, ULONG);

Sets the pointer to the call back function called when an SRQ occurs.

Unsigned long p1

First parameter passed to the call back function

Unsigned long p2

Second parameter passed to the call back function

Example:

void func1(intid,UCHARstb,ULONG p1,ULONG p2)

{

printf("SRQ occurred id=%d stb=0x%x p1=%d p2=%d\n",

id,stb,p1,p2);

}