agilentcomm.cpp File Reference

Detailed Description

Communication interface for Agilent Oscilloscopes via VXI-11 protocol.

This software enables Ethernet-based communication with Agilent oscilloscopes using the VXI-11 protocol. It supports sending commands, queries, and retrieving responses for both control and data acquisition tasks. The tool facilitates integration into automated testing systems.

Usage

./agilentcomm -ip <scope_ip> -c <command> [-h]

Options

Required	Description
-ip <scope_ip>	Specifies the IP address of the Agilent oscilloscope.
-c <command>	The command or query to send to the oscilloscope.

Optional	Description
-h	Displays help information and usage instructions.

Copyright

• (c) 2002 The University of Chicago, as Operator of Argonne National Laboratory.
• (c) 2002 The Regents of the University of California, as Operator of Los Alamos National Laboratory.

License

This file is distributed under the terms of the Software License Agreement found in the file LICENSE included with this distribution.

Author

Based on software from Steve Sharples of the Univ. of Nottingham. Modified by R. Soliday.

Definition in file agilentcomm.cpp.

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <rpc/rpc.h>
#include <pthread.h>

Go to the source code of this file.

Typedefs
using	Device_Link = long
using	Device_Flags = long
using	Device_ErrorCode = long
using	VXI11_CLIENT = CLIENT
using	VXI11_LINK = Create_LinkResp

Functions
bool	sc (const char *con, const char *var)
int	vxi11_open_device (const char *ip, CLINK *clink)
int	vxi11_open_device (const char *ip, CLINK *clink, const char *device)
int	vxi11_open_device (const char *ip, CLIENT **client, VXI11_LINK **link, const char *device)
int	vxi11_open_link (const char *ip, CLIENT **client, VXI11_LINK **link, const char *device)
int	vxi11_send (CLINK *clink, const char *cmd)
int	vxi11_send (CLINK *clink, const char *cmd, unsigned long len)
int	vxi11_send (CLIENT *client, VXI11_LINK *link, const char *cmd)
int	vxi11_send (CLIENT *client, VXI11_LINK *link, const char *cmd, unsigned long len)
int	vxi11_close_device (const char *ip, CLINK *clink)
int	vxi11_close_device (const char *ip, CLIENT *client, VXI11_LINK *link)
int	vxi11_close_link (const char *ip, CLIENT *client, VXI11_LINK *link)
double	vxi11_obtain_double_value (CLINK *clink, const char *cmd)
double	vxi11_obtain_double_value (CLINK *clink, const char *cmd, unsigned long timeout)
long	vxi11_send_and_receive (CLINK *clink, const char *cmd, char *buf, unsigned long buf_len, unsigned long timeout)
long	vxi11_receive (CLINK *clink, char *buffer, unsigned long len)
long	vxi11_receive (CLIENT *client, VXI11_LINK *link, char *buffer, unsigned long len, unsigned long timeout)
long	vxi11_receive (CLINK *clink, char *buffer, unsigned long len, unsigned long timeout)
long	vxi11_obtain_long_value (CLINK *clink, const char *cmd, unsigned long timeout)
long	vxi11_obtain_long_value (CLINK *clink, const char *cmd)
long	vxi11_receive_data_block (CLINK *clink, char *buffer, unsigned long len, unsigned long timeout)
enum clnt_stat	create_link_1 (Create_LinkParms *argp, Create_LinkResp *clnt_res, CLIENT *clnt)
enum clnt_stat	device_write_1 (Device_WriteParms *argp, Device_WriteResp *clnt_res, CLIENT *clnt)
enum clnt_stat	destroy_link_1 (Device_Link *argp, Device_Error *clnt_res, CLIENT *clnt)
enum clnt_stat	device_read_1 (Device_ReadParms *argp, Device_ReadResp *clnt_res, CLIENT *clnt)
bool_t	xdr_Create_LinkParms (XDR *xdrs, Create_LinkParms *objp)
bool_t	xdr_Create_LinkResp (XDR *xdrs, Create_LinkResp *objp)
bool_t	xdr_Device_ErrorCode (XDR *xdrs, Device_ErrorCode *objp)
bool_t	xdr_Device_Link (XDR *xdrs, Device_Link *objp)
bool_t	xdr_Device_WriteParms (XDR *xdrs, Device_WriteParms *objp)
bool_t	xdr_Device_WriteResp (XDR *xdrs, Device_WriteResp *objp)
bool_t	xdr_Device_Flags (XDR *xdrs, Device_Flags *objp)
bool_t	xdr_Device_Error (XDR *xdrs, Device_Error *objp)
bool_t	xdr_Device_ReadParms (XDR *xdrs, Device_ReadParms *objp)
bool_t	xdr_Device_ReadResp (XDR *xdrs, Device_ReadResp *objp)
int	main (int argc, char **argv)

Typedef Documentation

Device_ErrorCode

typedef long Device_ErrorCode = long

Definition at line 44 of file agilentcomm.cpp.

Device_Flags

typedef long Device_Flags = long

Definition at line 43 of file agilentcomm.cpp.

Device_Link

typedef long Device_Link = long

Definition at line 42 of file agilentcomm.cpp.

VXI11_CLIENT

using VXI11_CLIENT = CLIENT

Definition at line 105 of file agilentcomm.cpp.

VXI11_LINK

using VXI11_LINK = Create_LinkResp

Definition at line 106 of file agilentcomm.cpp.

Function Documentation

create_link_1()

enum clnt_stat create_link_1	(	Create_LinkParms *	argp,
		Create_LinkResp *	clnt_res,
		CLIENT *	clnt )

Definition at line 345 of file agilentcomm.cpp.

                                                                                              {
  return clnt_call(clnt, CREATE_LINK,
                   reinterpret_cast<xdrproc_t>(xdr_Create_LinkParms), reinterpret_cast<caddr_t>(argp),
                   reinterpret_cast<xdrproc_t>(xdr_Create_LinkResp), reinterpret_cast<caddr_t>(clnt_res),
                   TIMEOUT);
}

destroy_link_1()

enum clnt_stat destroy_link_1	(	Device_Link *	argp,
		Device_Error *	clnt_res,
		CLIENT *	clnt )

Definition at line 557 of file agilentcomm.cpp.

                                                                                       {
  return clnt_call(clnt, DESTROY_LINK,
                   reinterpret_cast<xdrproc_t>(xdr_Device_Link), reinterpret_cast<caddr_t>(argp),
                   reinterpret_cast<xdrproc_t>(xdr_Device_Error), reinterpret_cast<caddr_t>(clnt_res),
                   TIMEOUT);
}

device_read_1()

enum clnt_stat device_read_1	(	Device_ReadParms *	argp,
		Device_ReadResp *	clnt_res,
		CLIENT *	clnt )

Definition at line 654 of file agilentcomm.cpp.

                                                                                              {
  return clnt_call(clnt, DEVICE_READ,
                   reinterpret_cast<xdrproc_t>(xdr_Device_ReadParms), reinterpret_cast<caddr_t>(argp),
                   reinterpret_cast<xdrproc_t>(xdr_Device_ReadResp), reinterpret_cast<caddr_t>(clnt_res),
                   TIMEOUT);
}

device_write_1()

enum clnt_stat device_write_1	(	Device_WriteParms *	argp,
		Device_WriteResp *	clnt_res,
		CLIENT *	clnt )

Definition at line 477 of file agilentcomm.cpp.

                                                                                                 {
  return clnt_call(clnt, DEVICE_WRITE,
                   reinterpret_cast<xdrproc_t>(xdr_Device_WriteParms), reinterpret_cast<caddr_t>(argp),
                   reinterpret_cast<xdrproc_t>(xdr_Device_WriteResp), reinterpret_cast<caddr_t>(clnt_res),
                   TIMEOUT);
}

main()

int main	(	int	argc,
		char **	argv )

Definition at line 172 of file agilentcomm.cpp.

                                {
  const char *progname = argv[0];
  const char *serverIP = nullptr;
  char comm[256] = {0};
  long bytes_returned = 0;
  bool got_ip = false;
  bool got_comm = false;
  bool got_help = false;
  int index = 1;
  CLINK *clink = new CLINK{nullptr, nullptr};
  char outputbuf[BUF_LEN] = {0};
 
  // Parse command-line arguments
  while (index < argc) {
    if (sc(argv[index], "-ip") || sc(argv[index], "-ip_address") || sc(argv[index], "-IP")) {
      if (++index < argc) {
        serverIP = argv[index];
        got_ip = true;
      }
    }
 
    if (sc(argv[index], "-command") || sc(argv[index], "-c") || sc(argv[index], "-comm")) {
      if (++index < argc) {
        std::snprintf(comm, sizeof(comm), "%s", argv[index]);
        got_comm = true;
      }
    }
 
    // Handle help option
    if (sc(argv[index], "-h") || sc(argv[index], "-help")) {
      got_help = true;
    }
 
    index++;
  }
 
  // Validate required arguments
  if (!got_ip || !got_comm || got_help) {
    if (!got_ip || !got_comm) {
      std::fprintf(stderr, "Error: Missing required arguments.\n\n");
    }
    std::printf("Usage: %s [OPTIONS]\n\n", progname);
    std::printf("Options:\n");
    std::printf("  -ip, -ip_address, -IP    IP address of scope (e.g., 128.243.74.232)\n");
    std::printf("  -c, -command, -comm      Command or query to send\n");
    std::printf("  -h, -help                Display this help message\n\n");
    std::printf("Documentation:\n");
    std::printf("  http://cp.literature.agilent.com/litweb/pdf/54855-97017.pdf\n");
    delete clink;
    return EXIT_FAILURE;
  }
 
  // Open device
  if (vxi11_open_device(serverIP, clink) != 0) {
    std::fprintf(stderr, "Error: Failed to open device at IP %s.\n", serverIP);
    delete clink;
    return EXIT_FAILURE;
  }
 
  // Send command
  if (vxi11_send(clink, comm) != 0) {
    std::fprintf(stderr, "Error: Failed to send command '%s' to device.\n", comm);
    vxi11_close_device(serverIP, clink);
    delete clink;
    return EXIT_FAILURE;
  }
 
  // Check if it's a query
  if (std::strchr(comm, '?') != nullptr) {
    bytes_returned = vxi11_receive(clink, outputbuf, BUF_LEN);
    vxi11_close_device(serverIP, clink);
 
    if (bytes_returned > 0) {
      std::printf("%s\n", outputbuf);
    } else if (bytes_returned == -VXI11_NULL_READ_RESP) {
      std::fprintf(stderr, "Error: Nothing received after sending scope command '%s'.\n", comm);
      delete clink;
      return EXIT_FAILURE;
    } else {
      std::fprintf(stderr, "Error: Failed to receive response for command '%s'.\n", comm);
      delete clink;
      return EXIT_FAILURE;
    }
  } else {
    vxi11_close_device(serverIP, clink);
  }
 
  delete clink;
  return EXIT_SUCCESS;
}

sc()

bool sc	(	const char *	con,
		const char *	var )

Definition at line 264 of file agilentcomm.cpp.

                                          {
  return std::strcmp(con, var) == 0;
}

vxi11_close_device() [1/2]

int vxi11_close_device	(	const char *	ip,
		CLIENT *	client,
		VXI11_LINK *	link )

Definition at line 536 of file agilentcomm.cpp.

                                                                         {
  int ret = vxi11_close_link(ip, client, link);
  clnt_destroy(client);
  return ret;
}

vxi11_close_device() [2/2]

int vxi11_close_device	(	const char *	ip,
		CLINK *	clink )

Definition at line 510 of file agilentcomm.cpp.

                                                     {
  int ret;
  int device_no = -1;
 
  // Identify the device number based on IP
  for (int l = 0; l < VXI11_MAX_CLIENTS; l++) {
    if (std::strcmp(ip, VXI11_IP_ADDRESS[l]) == 0) {
      device_no = l;
      break;
    }
  }
 
  if (device_no == -1) {
    std::fprintf(stderr, "vxi11_close_device: error: No record of opening device with IP address %s.\n", ip);
    ret = -4;
  } else {
    if (VXI11_LINK_COUNT[device_no] > 1) {
      ret = vxi11_close_link(ip, clink->client, clink->link);
      VXI11_LINK_COUNT[device_no]--;
    } else {
      ret = vxi11_close_device(ip, clink->client, clink->link);
    }
  }
  return ret;
}

vxi11_close_link()

int vxi11_close_link	(	const char *	ip,
		CLIENT *	client,
		VXI11_LINK *	link )

Definition at line 542 of file agilentcomm.cpp.

                                                                       {
  Device_Error dev_error{};
 
  if (destroy_link_1(&link->lid, &dev_error, client) != RPC_SUCCESS) {
#ifdef __APPLE__
    clnt_perror(client, reinterpret_cast<char *>(ip));
#else
    clnt_perror(client, ip);
#endif
    return -1;
  }
 
  return 0;
}

vxi11_obtain_double_value() [1/2]

double vxi11_obtain_double_value	(	CLINK *	clink,
		const char *	cmd )

Definition at line 568 of file agilentcomm.cpp.

                                                                {
  return vxi11_obtain_double_value(clink, cmd, VXI11_READ_TIMEOUT);
}

vxi11_obtain_double_value() [2/2]

double vxi11_obtain_double_value	(	CLINK *	clink,
		const char *	cmd,
		unsigned long	timeout )

Definition at line 572 of file agilentcomm.cpp.

                                                                                       {
  char buf[50] = {0}; // 50=arbitrary length... more than enough for one number in ascii
  if (vxi11_send_and_receive(clink, cmd, buf, sizeof(buf), timeout) != 0) {
    std::fprintf(stderr, "Warning: Failed to obtain double value. Returning 0.0.\n");
    return 0.0;
  }
  return std::strtod(buf, nullptr);
}

vxi11_obtain_long_value() [1/2]

long vxi11_obtain_long_value	(	CLINK *	clink,
		const char *	cmd )

Definition at line 747 of file agilentcomm.cpp.

                                                            {
  return vxi11_obtain_long_value(clink, cmd, VXI11_READ_TIMEOUT);
}

vxi11_obtain_long_value() [2/2]

long vxi11_obtain_long_value	(	CLINK *	clink,
		const char *	cmd,
		unsigned long	timeout )

Definition at line 737 of file agilentcomm.cpp.

                                                                                   {
  char buf[50] = {0}; // 50=arbitrary length... more than enough for one number in ascii
  if (vxi11_send_and_receive(clink, cmd, buf, sizeof(buf), timeout) != 0) {
    std::fprintf(stderr, "Warning: Failed to obtain long value. Returning 0.\n");
    return 0;
  }
  return std::strtol(buf, nullptr, 10);
}

vxi11_open_device() [1/3]

int vxi11_open_device	(	const char *	ip,
		CLIENT **	client,
		VXI11_LINK **	link,
		const char *	device )

Definition at line 273 of file agilentcomm.cpp.

                                                                                              {
#ifdef __APPLE__
  *client = clnt_create(reinterpret_cast<char *>(ip), DEVICE_CORE, DEVICE_CORE_VERSION, "tcp");
#else
  *client = clnt_create(ip, DEVICE_CORE, DEVICE_CORE_VERSION, "tcp");
#endif
 
  if (*client == nullptr) {
#ifdef __APPLE__
    clnt_pcreateerror(reinterpret_cast<char *>(ip));
#else
    clnt_pcreateerror(ip);
#endif
    return -1;
  }
 
  return vxi11_open_link(ip, client, link, device);
}

vxi11_open_device() [2/3]

int vxi11_open_device	(	const char *	ip,
		CLINK *	clink )

Definition at line 268 of file agilentcomm.cpp.

                                                    {
  const char device[] = "inst0";
  return vxi11_open_device(ip, clink, device);
}

vxi11_open_device() [3/3]

int vxi11_open_device	(	const char *	ip,
		CLINK *	clink,
		const char *	device )

Definition at line 292 of file agilentcomm.cpp.

                                                                        {
  int ret;
  int device_no = -1;
 
  for (int l = 0; l < VXI11_MAX_CLIENTS; l++) {
    if (std::strcmp(ip, VXI11_IP_ADDRESS[l]) == 0) {
      device_no = l;
      break;
    }
  }
 
  if (device_no < 0) {
    if (VXI11_DEVICE_NO >= VXI11_MAX_CLIENTS) {
      std::fprintf(stderr, "Error: Maximum of %d clients allowed.\n", VXI11_MAX_CLIENTS);
      ret = -VXI11_MAX_CLIENTS;
    } else {
      ret = vxi11_open_device(ip, &(clink->client), &(clink->link), device);
      std::strncpy(VXI11_IP_ADDRESS[VXI11_DEVICE_NO], ip, sizeof(VXI11_IP_ADDRESS[VXI11_DEVICE_NO]) - 1);
      VXI11_IP_ADDRESS[VXI11_DEVICE_NO][sizeof(VXI11_IP_ADDRESS[VXI11_DEVICE_NO]) - 1] = '\0';
      VXI11_CLIENT_ADDRESS[VXI11_DEVICE_NO] = clink->client;
      VXI11_LINK_COUNT[VXI11_DEVICE_NO] = 1;
      VXI11_DEVICE_NO++;
    }
  } else {
    clink->client = VXI11_CLIENT_ADDRESS[device_no];
    ret = vxi11_open_link(ip, &(clink->client), &(clink->link), device);
    VXI11_LINK_COUNT[device_no]++;
  }
  return ret;
}

vxi11_open_link()

int vxi11_open_link	(	const char *	ip,
		CLIENT **	client,
		VXI11_LINK **	link,
		const char *	device )

Definition at line 323 of file agilentcomm.cpp.

                                                                                            {
  Create_LinkParms link_parms;
 
  // Set link parameters
  link_parms.clientId = reinterpret_cast<long>(*client);
  link_parms.lockDevice = false;
  link_parms.lock_timeout = VXI11_DEFAULT_TIMEOUT;
  link_parms.device = const_cast<char *>(device);
 
  *link = new Create_LinkResp();
 
  if (create_link_1(&link_parms, *link, *client) != RPC_SUCCESS) {
#ifdef __APPLE__
    clnt_perror(*client, reinterpret_cast<char *>(ip));
#else
    clnt_perror(*client, ip);
#endif
    return -2;
  }
  return 0;
}

vxi11_receive() [1/3]

long vxi11_receive	(	CLIENT *	client,
		VXI11_LINK *	link,
		char *	buffer,
		unsigned long	len,
		unsigned long	timeout )

Definition at line 608 of file agilentcomm.cpp.

                                                                                                             {
  Device_ReadParms read_parms;
  Device_ReadResp read_resp{};
  long curr_pos = 0;
 
  read_parms.lid = link->lid;
  read_parms.requestSize = len;
  read_parms.io_timeout = timeout;   // in ms
  read_parms.lock_timeout = timeout; // in ms
  read_parms.flags = 0;
  read_parms.termChar = 0;
 
  while (true) {
    read_resp = Device_ReadResp{};
    read_resp.data.data_val = buffer + curr_pos;
    read_parms.requestSize = len - curr_pos; // Never request more total data than originally specified in len
 
    if (device_read_1(&read_parms, &read_resp, client) != RPC_SUCCESS) {
      return -VXI11_NULL_READ_RESP; // No data to read
    }
    if (read_resp.error != 0) {
      std::fprintf(stderr, "vxi11_user: read error: %ld\n", read_resp.error);
      return -(read_resp.error);
    }
 
    if ((unsigned long)(curr_pos + read_resp.data.data_len) <= len) {
      curr_pos += read_resp.data.data_len;
    }
    if ((read_resp.reason & RCV_END_BIT) || (read_resp.reason & RCV_CHR_BIT)) {
      break;
    } else if ((unsigned long)curr_pos == len) {
      std::fprintf(stderr, "vxi11_user: read error: Buffer too small. Read %ld bytes without hitting terminator.\n", curr_pos);
      return -100;
    }
  }
  return curr_pos; // Actual number of bytes received
}

vxi11_receive() [2/3]

long vxi11_receive	(	CLINK *	clink,
		char *	buffer,
		unsigned long	len )

Definition at line 646 of file agilentcomm.cpp.

                                                                  {
  return vxi11_receive(clink, buffer, len, VXI11_READ_TIMEOUT);
}

vxi11_receive() [3/3]

long vxi11_receive	(	CLINK *	clink,
		char *	buffer,
		unsigned long	len,
		unsigned long	timeout )

Definition at line 650 of file agilentcomm.cpp.

                                                                                         {
  return vxi11_receive(clink->client, clink->link, buffer, len, timeout);
}

vxi11_receive_data_block()

long vxi11_receive_data_block	(	CLINK *	clink,
		char *	buffer,
		unsigned long	len,
		unsigned long	timeout )

Definition at line 751 of file agilentcomm.cpp.

                                                                                                    {
  // Assuming the maximum length of the header is 11 (#9 + 9 digits)
  unsigned long necessary_buffer_size = len + 12;
  char *in_buffer = new char[necessary_buffer_size];
  long ret = vxi11_receive(clink, in_buffer, necessary_buffer_size, timeout);
  if (ret < 0) {
    delete[] in_buffer;
    return ret;
  }
  if (in_buffer[0] != '#') {
    std::fprintf(stderr, "vxi11_user: data block error: Data block does not begin with '#'.\n");
    std::fprintf(stderr, "First 20 characters received were: '");
    for (size_t l = 0; l < 20 && l < (size_t)necessary_buffer_size; l++) {
      std::fprintf(stderr, "%c", in_buffer[l]);
    }
    std::fprintf(stderr, "'\n");
    delete[] in_buffer;
    return -3;
  }
 
  // First, find out how many digits
  int ndigits = 0;
  sscanf(in_buffer, "#%1d", &ndigits);
 
  // Some instruments, if there is a problem acquiring the data, return only "#0"
  if (ndigits > 0) {
    // Convert the next <ndigits> bytes into an unsigned long
    char scan_cmd[20];
    std::snprintf(scan_cmd, sizeof(scan_cmd), "#%%1d%%%dlu", ndigits);
    unsigned long returned_bytes = 0;
    sscanf(in_buffer, scan_cmd, &ndigits, &returned_bytes);
    std::memcpy(buffer, in_buffer + (ndigits + 2), returned_bytes);
    delete[] in_buffer;
    return static_cast<long>(returned_bytes);
  } else {
    delete[] in_buffer;
    return 0;
  }
}

vxi11_send() [1/4]

int vxi11_send	(	CLIENT *	client,
		VXI11_LINK *	link,
		const char *	cmd )

Definition at line 434 of file agilentcomm.cpp.

                                                                  {
  return vxi11_send(client, link, cmd, std::strlen(cmd));
}

vxi11_send() [2/4]

int vxi11_send	(	CLIENT *	client,
		VXI11_LINK *	link,
		const char *	cmd,
		unsigned long	len )

Definition at line 438 of file agilentcomm.cpp.

                                                                                     {
  Device_WriteParms write_parms;
  int bytes_left = static_cast<int>(len);
  char *send_cmd = new char[len];
  std::memcpy(send_cmd, cmd, len);
 
  write_parms.lid = link->lid;
  write_parms.io_timeout = VXI11_DEFAULT_TIMEOUT;
  write_parms.lock_timeout = VXI11_DEFAULT_TIMEOUT;
 
  // We can only write (link->maxRecvSize) bytes at a time
  while (bytes_left > 0) {
    Device_WriteResp write_resp{};
 
    if (static_cast<unsigned int>(bytes_left) <= link->maxRecvSize) {
      write_parms.flags = 8;
      write_parms.data.data_len = bytes_left;
    } else {
      write_parms.flags = 0;
      write_parms.data.data_len = (link->maxRecvSize > 0) ? link->maxRecvSize : 4096;
    }
    write_parms.data.data_val = send_cmd + (len - bytes_left);
 
    if (device_write_1(&write_parms, &write_resp, client) != RPC_SUCCESS) {
      delete[] send_cmd;
      return -VXI11_NULL_WRITE_RESP;
    }
    if (write_resp.error != 0) {
      std::fprintf(stderr, "vxi11_user: write error: %ld\n", write_resp.error);
      delete[] send_cmd;
      return -(write_resp.error);
    }
    bytes_left -= write_resp.size;
  }
 
  delete[] send_cmd;
  return 0;
}

vxi11_send() [3/4]

int vxi11_send	(	CLINK *	clink,
		const char *	cmd )

Definition at line 426 of file agilentcomm.cpp.

                                              {
  return vxi11_send(clink, cmd, std::strlen(cmd));
}

vxi11_send() [4/4]

int vxi11_send	(	CLINK *	clink,
		const char *	cmd,
		unsigned long	len )

Definition at line 430 of file agilentcomm.cpp.

                                                                 {
  return vxi11_send(clink->client, clink->link, cmd, len);
}

vxi11_send_and_receive()

long vxi11_send_and_receive	(	CLINK *	clink,
		const char *	cmd,
		char *	buf,
		unsigned long	buf_len,
		unsigned long	timeout )

Definition at line 581 of file agilentcomm.cpp.

                                                                                                                    {
  int ret;
  long bytes_returned;
  do {
    ret = vxi11_send(clink, cmd);
    if (ret != 0) {
      if (ret != -VXI11_NULL_WRITE_RESP) {
        std::fprintf(stderr, "Error: vxi11_send_and_receive: Could not send command '%s'. Return code: %d.\n", cmd, ret);
        return -1;
      } else {
        std::printf("(Info: VXI11_NULL_WRITE_RESP in vxi11_send_and_receive, resending query)\n");
      }
    }
 
    bytes_returned = vxi11_receive(clink, buf, buf_len, timeout);
    if (bytes_returned <= 0) {
      if (bytes_returned > -VXI11_NULL_READ_RESP) {
        std::fprintf(stderr, "Error: vxi11_send_and_receive: Problem reading reply. Return code: %ld.\n", bytes_returned);
        return -2;
      } else {
        std::printf("(Info: VXI11_NULL_READ_RESP in vxi11_send_and_receive, resending query)\n");
      }
    }
  } while (bytes_returned == -VXI11_NULL_READ_RESP || ret == -VXI11_NULL_WRITE_RESP);
  return 0;
}

xdr_Create_LinkParms()

bool_t xdr_Create_LinkParms	(	XDR *	xdrs,
		Create_LinkParms *	objp )

Definition at line 352 of file agilentcomm.cpp.

                                                               {
#if defined(SOLARIS) && !defined(_LP64)
  long *buf;
#else
  int32_t *buf;
#endif
 
  if (xdrs->x_op == XDR_ENCODE) {
    buf = reinterpret_cast<int32_t *>(XDR_INLINE(xdrs, 3 * BYTES_PER_XDR_UNIT));
    if (buf == nullptr) {
      if (!xdr_long(xdrs, &objp->clientId))
        return FALSE;
      if (!xdr_bool(xdrs, &objp->lockDevice))
        return FALSE;
      if (!xdr_u_long(xdrs, &objp->lock_timeout))
        return FALSE;
    } else {
      IXDR_PUT_INT32(buf, objp->clientId);
      IXDR_PUT_BOOL(buf, objp->lockDevice);
      IXDR_PUT_U_INT32(buf, objp->lock_timeout);
    }
    if (!xdr_string(xdrs, &objp->device, ~0))
      return FALSE;
    return TRUE;
  } else if (xdrs->x_op == XDR_DECODE) {
    buf = reinterpret_cast<int32_t *>(XDR_INLINE(xdrs, 3 * BYTES_PER_XDR_UNIT));
    if (buf == nullptr) {
      if (!xdr_long(xdrs, &objp->clientId))
        return FALSE;
      if (!xdr_bool(xdrs, &objp->lockDevice))
        return FALSE;
      if (!xdr_u_long(xdrs, &objp->lock_timeout))
        return FALSE;
    } else {
      objp->clientId = IXDR_GET_INT32(buf);
      objp->lockDevice = IXDR_GET_BOOL(buf);
      objp->lock_timeout = IXDR_GET_U_INT32(buf);
    }
    if (!xdr_string(xdrs, &objp->device, ~0))
      return FALSE;
    return TRUE;
  }
 
  if (!xdr_long(xdrs, &objp->clientId))
    return FALSE;
  if (!xdr_bool(xdrs, &objp->lockDevice))
    return FALSE;
  if (!xdr_u_long(xdrs, &objp->lock_timeout))
    return FALSE;
  if (!xdr_string(xdrs, &objp->device, ~0))
    return FALSE;
  return TRUE;
}

xdr_Create_LinkResp()

bool_t xdr_Create_LinkResp	(	XDR *	xdrs,
		Create_LinkResp *	objp )

Definition at line 406 of file agilentcomm.cpp.

                                                             {
  if (!xdr_Device_ErrorCode(xdrs, &objp->error))
    return FALSE;
  if (!xdr_Device_Link(xdrs, &objp->lid))
    return FALSE;
  if (!xdr_u_short(xdrs, &objp->abortPort))
    return FALSE;
  if (!xdr_u_long(xdrs, &objp->maxRecvSize))
    return FALSE;
  return TRUE;
}

xdr_Device_Error()

bool_t xdr_Device_Error	(	XDR *	xdrs,
		Device_Error *	objp )

Definition at line 564 of file agilentcomm.cpp.

                                                       {
  return xdr_Device_ErrorCode(xdrs, &objp->error);
}

xdr_Device_ErrorCode()

bool_t xdr_Device_ErrorCode	(	XDR *	xdrs,
		Device_ErrorCode *	objp )

Definition at line 418 of file agilentcomm.cpp.

                                                               {
  return xdr_long(xdrs, objp);
}

xdr_Device_Flags()

bool_t xdr_Device_Flags	(	XDR *	xdrs,
		Device_Flags *	objp )

Definition at line 506 of file agilentcomm.cpp.

                                                       {
  return xdr_long(xdrs, objp);
}

xdr_Device_Link()

bool_t xdr_Device_Link	(	XDR *	xdrs,
		Device_Link *	objp )

Definition at line 422 of file agilentcomm.cpp.

                                                     {
  return xdr_long(xdrs, objp);
}

xdr_Device_ReadParms()

bool_t xdr_Device_ReadParms	(	XDR *	xdrs,
		Device_ReadParms *	objp )

Definition at line 661 of file agilentcomm.cpp.

                                                               {
#if defined(SOLARIS) && !defined(_LP64)
  long *buf;
#else
  int32_t *buf;
#endif
 
  if (xdrs->x_op == XDR_ENCODE) {
    if (!xdr_Device_Link(xdrs, &objp->lid))
      return FALSE;
    buf = reinterpret_cast<int32_t *>(XDR_INLINE(xdrs, 3 * BYTES_PER_XDR_UNIT));
    if (buf == nullptr) {
      if (!xdr_u_long(xdrs, &objp->requestSize))
        return FALSE;
      if (!xdr_u_long(xdrs, &objp->io_timeout))
        return FALSE;
      if (!xdr_u_long(xdrs, &objp->lock_timeout))
        return FALSE;
    } else {
      IXDR_PUT_U_INT32(buf, objp->requestSize);
      IXDR_PUT_U_INT32(buf, objp->io_timeout);
      IXDR_PUT_U_INT32(buf, objp->lock_timeout);
    }
    if (!xdr_Device_Flags(xdrs, &objp->flags))
      return FALSE;
    if (!xdr_char(xdrs, &objp->termChar))
      return FALSE;
    return TRUE;
  } else if (xdrs->x_op == XDR_DECODE) {
    if (!xdr_Device_Link(xdrs, &objp->lid))
      return FALSE;
    buf = reinterpret_cast<int32_t *>(XDR_INLINE(xdrs, 3 * BYTES_PER_XDR_UNIT));
    if (buf == nullptr) {
      if (!xdr_u_long(xdrs, &objp->requestSize))
        return FALSE;
      if (!xdr_u_long(xdrs, &objp->io_timeout))
        return FALSE;
      if (!xdr_u_long(xdrs, &objp->lock_timeout))
        return FALSE;
    } else {
      objp->requestSize = IXDR_GET_U_INT32(buf);
      objp->io_timeout = IXDR_GET_U_INT32(buf);
      objp->lock_timeout = IXDR_GET_U_INT32(buf);
    }
    if (!xdr_Device_Flags(xdrs, &objp->flags))
      return FALSE;
    if (!xdr_char(xdrs, &objp->termChar))
      return FALSE;
    return TRUE;
  }
 
  if (!xdr_Device_Link(xdrs, &objp->lid))
    return FALSE;
  if (!xdr_u_long(xdrs, &objp->requestSize))
    return FALSE;
  if (!xdr_u_long(xdrs, &objp->io_timeout))
    return FALSE;
  if (!xdr_u_long(xdrs, &objp->lock_timeout))
    return FALSE;
  if (!xdr_Device_Flags(xdrs, &objp->flags))
    return FALSE;
  if (!xdr_char(xdrs, &objp->termChar))
    return FALSE;
  return TRUE;
}

xdr_Device_ReadResp()

bool_t xdr_Device_ReadResp	(	XDR *	xdrs,
		Device_ReadResp *	objp )

Definition at line 727 of file agilentcomm.cpp.

                                                             {
  if (!xdr_Device_ErrorCode(xdrs, &objp->error))
    return FALSE;
  if (!xdr_long(xdrs, &objp->reason))
    return FALSE;
  if (!xdr_bytes(xdrs, reinterpret_cast<char **>(&objp->data.data_val), reinterpret_cast<u_int *>(&objp->data.data_len), ~0))
    return FALSE;
  return TRUE;
}

xdr_Device_WriteParms()

bool_t xdr_Device_WriteParms	(	XDR *	xdrs,
		Device_WriteParms *	objp )

Definition at line 484 of file agilentcomm.cpp.

                                                                 {
  if (!xdr_Device_Link(xdrs, &objp->lid))
    return FALSE;
  if (!xdr_u_long(xdrs, &objp->io_timeout))
    return FALSE;
  if (!xdr_u_long(xdrs, &objp->lock_timeout))
    return FALSE;
  if (!xdr_Device_Flags(xdrs, &objp->flags))
    return FALSE;
  if (!xdr_bytes(xdrs, reinterpret_cast<char **>(&objp->data.data_val), reinterpret_cast<u_int *>(&objp->data.data_len), ~0))
    return FALSE;
  return TRUE;
}

xdr_Device_WriteResp()

bool_t xdr_Device_WriteResp	(	XDR *	xdrs,
		Device_WriteResp *	objp )

Definition at line 498 of file agilentcomm.cpp.

                                                               {
  if (!xdr_Device_ErrorCode(xdrs, &objp->error))
    return FALSE;
  if (!xdr_u_long(xdrs, &objp->size))
    return FALSE;
  return TRUE;
}