/*	**************************************************************  */
/*
 *	Module PT2025
 *	This module contains I/O functions for the Metrolab precision
 *	teslameter model 2025.                 
 *
 *	Zachary Wolf
 *	1/8/03
 */ 

/*	**************************************************************  */

/*	INCLUDES  */
#include <utility.h>
#include <gpib.h>
#include <formatio.h>
#include <ansi_c.h>
#include <analysis.h>
#include "pt2025.h"

/*	**************************************************************  */

/*  PRIVATE FUNCTIONS  */
int pt2025_open_dev(int gpib_board_addr, int gpib_dev_addr);
void pt2025_close_dev(int dev_ID);
int pt2025_check_dev_open(int dev_ID);
int pt2025_out(int dev_ID, char* buf);
int pt2025_in(int dev_ID, char* buf);
int pt2025_get_errors(int dev_ID);
void pt2025_get_status(int dev_ID, int reg, char* status);
void pt2025_calc_status_val(char status[], int* status_val);
int pt2025_serial_poll(int dev_ID, int* spoll);
void pt2025_message(char* msg);
void pt2025_error(char* msg);

/*	**************************************************************  */

/*  PRIVATE DEVICE TABLE  */
/*
 *	This table allows several devices of the same type to be
 *	used in the system.
 *  dev_addr, contains the GPIB addresses of opened devices
 *  dev_descr, contains the device descriptors of opened devices
 *  dev_count, contains the number of devices open of this type
 */
static int dev_addr[PT2025_MAX_NUM_DEV + 1];
static int dev_descr[PT2025_MAX_NUM_DEV + 1];
static int dev_count;

/*	**************************************************************  */

/*  PRIVATE GLOBAL VARIABLES  */
/*
 *  cmd, buffer for GPIB I/O strings
 *  msg, buffer for message strings to Standard I/O
 */
static char cmd[PT2025_MAX_CMD + 1];
static char msg[PT2025_MAX_CMD + 1];

/*	**************************************************************  */

/*	PUBLIC FUNCTIONS  */

/*	**************************************************************  */
/*
 *  pt2025_init
 *  This function opens the device, queries for ID, and
 *  initializes the device to a known state.
 *
 *	Input:
 *	gpib_board_addr, address of the GPIB board the device is connected to (0, 1, ...)
 *	gpib_dev_addr, GPIB address of the device (1 to 30, 0 is reserved)
 *
 *	Output:
 *	ID, identifier for future references to the device
 *
 *	Zachary Wolf
 *	1/8/03
 */

void pt2025_init(int gpib_board_addr, int gpib_dev_addr, int* ID)
{
    /* Declare variables */
    int dev_ID;
    int i;
	char status[PT2025_MAX_CMD];
	int status_val;
	char buf[80];
    
    /* Message */
    pt2025_message("");
    pt2025_message("Initializing the PT2025...");

    /* Check input parameters */
    if (gpib_board_addr < 0 || gpib_board_addr > 10)
    {
    	Fmt(msg, "%s<gpib_board_addr = %i, out of range", gpib_board_addr);
    	pt2025_error(msg);
    	return;
    }
    if (gpib_dev_addr < 1 || gpib_dev_addr > 30)
    {
    	Fmt(msg, "%s<gpib_dev_addr = %i, out of range", gpib_dev_addr);
    	pt2025_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	*ID = 1;
    	return;
    #endif
    
    /* Open the PT2025 */
    dev_ID = pt2025_open_dev(gpib_board_addr, gpib_dev_addr);
    if (dev_ID <= 0)
    {
        pt2025_error("Device was not opened");
        return;
    }

    /* Set up the service request mask, no service requests */
    pt2025_out(dev_ID, "M00");
    
    /* Put the device into auto mode (scan +-5% of the coarse setting) */
    pt2025_out(dev_ID, "A1");
    
    /* Set the units to Tesla */
    pt2025_out(dev_ID, "D1");
    
    /* Set the field direction to + */
    pt2025_out(dev_ID, "F1");
    
    /* Use only one multiplexer channel when in search mode */
    pt2025_out(dev_ID, "X1");
    
    /* Set the multiplexer channel to A */
    pt2025_out(dev_ID, "PA");
    
    /* Check for errors */
    pt2025_get_errors(dev_ID);
    
    /* Print the status register's contents */
    for (i = 1; i <= 4; i++)
    {
    	pt2025_get_status(dev_ID, i, status);
		pt2025_calc_status_val(status, &status_val);
    	printf("%s, %i\n", status, status_val);
    }
    
    /* Set the fine adjust potentiometer to 5.0 */
    printf("\nPlease set the PT2025 fine adjust potentiometer to 5.0.\n");
    printf("Press ENTER when done.\n");
	fgets(buf, 80, stdin);

	/* Return the ID number */
    *ID = dev_ID;
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	pt2025_get_reading
 *  This function gets a reading from the teslameter.  This
 *	includes locked status and units information.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Output:
 *	lock_status, locked status of the teslameter ('L', 'N', 'S', or 'W')
 *	meas_val, measured value (T or MHz)
 *	units, units of the reading ('T' for Tesla or 'F' for frequency in MHz)
 *
 *	Zachary Wolf
 *	1/8/03
 */

void pt2025_get_reading(int dev_ID, char* lock_status, double* meas_val, char* units)
{
	/* Declare variables */
	int dev_open;
	int num_scan;
	int err;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > PT2025_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	pt2025_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = pt2025_check_dev_open(dev_ID);
    if (dev_open == 0)
    {
    	pt2025_error("Instrument not open");
    	return;
    }
    
    /* Get the reading */
    pt2025_in(dev_ID, msg);
    
    /* Extract all the pieces */
    num_scan = Scan(msg, "%s>%c%f%c", lock_status, meas_val, units);
    if (num_scan != 3)
    {
    	pt2025_message("Unable to extract field value");
    	*lock_status = 'X';
    	*meas_val = 0.;
    	*units = 'X';
    }
    
    /* Check for errors */
	err = pt2025_get_errors(dev_ID);
    if (err != 0)
    {
        pt2025_error("Problem with PT2025");
        return;
    }
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	pt2025_get_b
 *  This function gets a field reading from the teslameter.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Output:
 *	b, field reading (T)
 *
 *	Zachary Wolf
 *	1/8/03
 */

void pt2025_get_b(int dev_ID, double* b)
{
	/* Declare variables */
	int dev_open;
	int err;
	char lock_status, units;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > PT2025_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	pt2025_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	*b = 0.;
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = pt2025_check_dev_open(dev_ID);
    if (dev_open == 0)
    {
    	pt2025_error("Instrument not open");
    	return;
    }

	/* Get the reading */
	pt2025_get_reading(dev_ID, &lock_status, b, &units);
    
	/* Check the units */
	if (units != 'T')
	{
	    pt2025_message("Wrong units returned in field reading, returning 0.");
	 	*b = 0.;
	 	return;
	}
    
	/* Check that the NMR was locked */
	if (lock_status != 'L')
	{
	    pt2025_message("The NMR is not locked, returning 0.");
	 	*b = 0.;
	 	return;
	}
    
    /* Check for errors */
	err = pt2025_get_errors(dev_ID);
    if (err != 0)
    {
        pt2025_error("Problem with PT2025");
        *b = 0.;
        return;
    }
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	pt2025_get_b_ave
 *  This function gets a field reading from the teslameter.
 *	It takes multiple readings and returns the average and
 *	rms variation.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Output:
 *	b_ave, average of the field readings (T)
 *	b_rms, rms variation of the field readings (T)
 *
 *	Zachary Wolf
 *	1/8/03
 */

void pt2025_get_b_ave(int dev_ID, double* b_ave, double* b_rms)
{
	/* Declare variables */
	int dev_open;
	int err;
	int status;
	int num_meas = PT2025_NUM_READINGS_IN_B_MEAS;
	double b_meas[PT2025_NUM_READINGS_IN_B_MEAS];
	int i;
	char lock_status, units;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > PT2025_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	pt2025_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = pt2025_check_dev_open(dev_ID);
    if (dev_open == 0)
    {
    	pt2025_error("Instrument not open");
    	return;
    }
    
    /* Take a number of readings */
    for (i = 0; i < num_meas; i++)
    {

	    /* Get the reading */
		pt2025_get_reading(dev_ID, &lock_status, &b_meas[i], &units);
    
	    /* Check the units */
	    if (units != 'T')
	    {
	    	pt2025_message("Wrong units returned in field reading, returning 0.");
	 	   	*b_ave = 0.;
	 	   	*b_rms = 0.;
	 	   	return;
	    }
    
	    /* Check that the NMR was locked */
	    if (lock_status != 'L')
	    {
	    	pt2025_message("The NMR is not locked, returning 0.");
	 	   	*b_ave = 0.;
	 	   	*b_rms = 0.;
	 	   	return;
	    }
	    
	    /* Add a small delay before the next reading */
	    Delay(.1);
	    
	/* End loop over readings */
	}
	
	/* Find the average and rms variation of the field readings */
	status = StdDev(b_meas, num_meas, b_ave, b_rms);
	if (status != 0)
	{
		pt2025_error("Problem computing mean and rms of NMR readings.");
	 	*b_ave = 0.;
	 	*b_rms = 0.;
		return;
	}
    
    /* Check for errors */
	err = pt2025_get_errors(dev_ID);
    if (err != 0)
    {
        pt2025_error("Problem with PT2025");
	 	*b_ave = 0.;
	 	*b_rms = 0.;
        return;
    }
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	pt2025_set_mode_manual
 *  This function sets the operating mode to manual.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Zachary Wolf
 *	1/8/03
 */

void pt2025_set_mode_manual(int dev_ID)
{
	/* Declare variables */
	int dev_open;
	int err;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > PT2025_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	pt2025_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = pt2025_check_dev_open(dev_ID);
    if (dev_open == 0)
    {
    	pt2025_error("Instrument not open");
    	return;
    }
    
    /* Set the operating mode to manual */
    pt2025_out(dev_ID, "A0");
    
    /* Check for errors */
	err = pt2025_get_errors(dev_ID);
    if (err != 0)
    {
        pt2025_error("Problem with PT2025");
        return;
    }
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	pt2025_set_mode_auto
 *  This function sets the operating mode to auto.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Zachary Wolf
 *	1/8/03
 */

void pt2025_set_mode_auto(int dev_ID)
{
	/* Declare variables */
	int dev_open;
	int err;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > PT2025_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	pt2025_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = pt2025_check_dev_open(dev_ID);
    if (dev_open == 0)
    {
    	pt2025_error("Instrument not open");
    	return;
    }
    
    /* Set the operating mode to auto */
    pt2025_out(dev_ID, "A1");
    
    /* Check for errors */
	err = pt2025_get_errors(dev_ID);
    if (err != 0)
    {
        pt2025_error("Problem with PT2025");
        return;
    }
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	pt2025_set_mode_search
 *  This function searches the range of the probe for the NMR signal.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Zachary Wolf
 *	1/8/03
 */

void pt2025_set_mode_search(int dev_ID)
{
	/* Declare variables */
	int dev_open;
	int err;
	char buf[80];

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > PT2025_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	pt2025_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = pt2025_check_dev_open(dev_ID);
    if (dev_open == 0)
    {
    	pt2025_error("Instrument not open");
    	return;
    }
    
    /* Set the search time to the middle of the range */
    pt2025_out(dev_ID, "O3");
    
    /* Search over the entire probe range */
    pt2025_out(dev_ID, "H");
    
    /* Message */
    printf("\nThe PT2025 is searching for the field value.\n");
    printf("Press ENTER when the NMR has locked onto the field value.\n");
	fgets(buf, 80, stdin);
    
    /* End the search */
    pt2025_out(dev_ID, "Q");
    
    /* Check for errors */
	err = pt2025_get_errors(dev_ID);
    if (err != 0)
    {
        pt2025_error("Problem with PT2025");
        return;
    }
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	pt2025_set_mux_chan
 *  This function sets the multiplexer channel to the specified value.
 *
 *	Input:
 *	dev_ID, device identifier
 *	chan, desired multiplexer channel (A, B, ..., H)
 *
 *	Zachary Wolf
 *	1/8/03
 */

void pt2025_set_mux_chan(int dev_ID, char chan)
{
	/* Declare variables */
	int dev_open;
	int err;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > PT2025_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	pt2025_error(msg);
    	return;
    }
    if (chan != 'A' && chan != 'B' && chan != 'C' && chan != 'D' && chan != 'E' && chan != 'F' && chan != 'G' && chan != 'H')
    {
    	Fmt(msg, "%s<chan = %c, out of range", chan);
    	pt2025_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = pt2025_check_dev_open(dev_ID);
    if (dev_open == 0)
    {
    	pt2025_error("Instrument not open");
    	return;
    }
    
    /* Set the multiplexer channel */
    Fmt(cmd, "%s<P%c", chan);
    pt2025_out(dev_ID, cmd);
    
    /* Check for errors */
	err = pt2025_get_errors(dev_ID);
    if (err != 0)
    {
        pt2025_error("Problem with PT2025");
        return;
    }
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	pt2025_set_field_dir
 *  This function sets the field direction.
 *
 *	Input:
 *	dev_ID, device identifier
 *	dir, field direction (+ or -)
 *
 *	Zachary Wolf
 *	1/8/03
 */

void pt2025_set_field_dir(int dev_ID, char dir)
{
	/* Declare variables */
	int dev_open;
	int err;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > PT2025_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	pt2025_error(msg);
    	return;
    }
    if (dir != '+' && dir != '-')
    {
    	Fmt(msg, "%s<dir = %c, out of range", dir);
    	pt2025_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = pt2025_check_dev_open(dev_ID);
    if (dev_open == 0)
    {
    	pt2025_error("Instrument not open");
    	return;
    }
    
    /* Set the field direction */
    Fmt(cmd, "%s<F%c", dir);
    pt2025_out(dev_ID, cmd);
    
    /* Check for errors */
	err = pt2025_get_errors(dev_ID);
    if (err != 0)
    {
        pt2025_error("Problem with PT2025");
        return;
    }
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	pt2025_set_manual_coarse
 *  This function sets the oscillator frequency to the appropriate value
 *	for the specified probe number and nominal field value.
 *	The teslameter is set to manual mode.
 *
 *	Input:
 *	dev_ID, device identifier
 *	probe_num, probe number (1 to 8)
 *	b_nom, nominal field strength to set the coarse adjust to (T)
 *
 *	Zachary Wolf
 *	1/8/03
 */

void pt2025_set_manual_coarse(int dev_ID, int probe_num, double b_nom)
{
	/* Declare variables */
	int dev_open;
	int err;
	double f_min, f_max;
	double b_min, b_max;
	double divider;
	int dac_min, dac_max;
	double slope;
	int dac_val;
	double meas_val;
	char lock_status, units;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > PT2025_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	pt2025_error(msg);
    	return;
    }
    if (probe_num < 1 || probe_num > 8)
    {
    	Fmt(msg, "%s<probe_num = %i, out of range", probe_num);
    	pt2025_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = pt2025_check_dev_open(dev_ID);
    if (dev_open == 0)
    {
    	pt2025_error("Instrument not open");
    	return;
    }
    
    /* Determine the frequency divider from the probe number */
    if      (probe_num == 1) divider = 16.;
    else if (probe_num == 2) divider = 8.;
    else if (probe_num == 3) divider = 4.;
    else if (probe_num == 4) divider = 2.;
    else if (probe_num == 5) divider = 1.;
    else if (probe_num == 6) divider = 4.;
    else if (probe_num == 7) divider = 2.;
    else if (probe_num == 8) divider = 1.;
    else pt2025_error("Unknown probe number");
    
    /* Determine the frequency range for the probe */
    f_min = 30. / divider;
    f_max = 90. / divider;
    
    /* Determine the field range for the probe */
    if (probe_num <= 5)	/* H-1 probe type */
    {
	    b_min = .70 / divider;
	    b_max = 2.1 / divider;
	}
	else				/* H-2 probe type */
    {
	    b_min = 6. / divider;
	    b_max = 13.7 / divider;
	}
    
    /* Determine the DAC range */
    dac_min = 0;
    dac_max = 4095;
    
    /* Check to make sure b_nom is in the probe range */
    if (b_nom < b_min || b_nom > b_max)
    {
    	Fmt(msg, "%s<probe_num = %i, b_nom = %f T, field out of probe range", probe_num, b_nom);
    	pt2025_error(msg);
    	return;
    }
    
    /* Calculate the DAC value assuming a linear relationship */
    slope = (dac_max - dac_min) / (b_max - b_min);
    dac_val = dac_min + slope * (b_nom - b_min);
    
    /* Set the DAC value */
    Fmt(cmd, "%s<C%i", dac_val);
    pt2025_out(dev_ID, cmd);
    
    /* Let things settle */
    Delay(2.);
    
    /* Do a correction */
    /* Set the operating mode to manual */
	pt2025_set_mode_manual(dev_ID);
	Delay(1.);
    
    /* Get the field value corresponding to the DAC setting */
    /* The fine adjust potentiometer must be set to 5.0 */
	pt2025_get_reading(dev_ID, &lock_status, &meas_val, &units);
    
	/* Check the units */
	if (units != 'T') return;
    
    /* Find a correction to the DAC setting */
    dac_val = dac_val + slope * (b_nom - meas_val);
    
    /* Set the new DAC value */
    Fmt(cmd, "%s<C%i", dac_val);
    pt2025_out(dev_ID, cmd);
    
    /* Let things settle */
    Delay(2.);
    
    /* Do another correction */
    /* Get the field value corresponding to the DAC setting */
    /* The fine adjust potentiometer must be set to 5.0 */
	pt2025_get_reading(dev_ID, &lock_status, &meas_val, &units);
    
	/* Check the units */
	if (units != 'T') return;
    
    /* Find a correction to the DAC setting */
    dac_val = dac_val + slope * (b_nom - meas_val);
    
    /* Set the new DAC value */
    Fmt(cmd, "%s<C%i", dac_val);
    pt2025_out(dev_ID, cmd);
    
    /* Let things settle */
    Delay(2.);
    
    /* Check for errors */
	err = pt2025_get_errors(dev_ID);
    if (err != 0)
    {
        pt2025_error("Problem with PT2025");
        return;
    }
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	pt2025_exit
 *  This function puts the PT2025 in the desired state for exit
 *	and closes the device.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Zachary Wolf
 *	1/8/03
 */

void pt2025_exit(int dev_ID)
{
	/* Declare variables */
	int dev_open;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > PT2025_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	pt2025_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = pt2025_check_dev_open(dev_ID);
    if (dev_open == 0)
    {
    	return;		 /* OK, already closed */
    }
    
    /* Nothing needs to be done to the device */

	/* Close the device */
    pt2025_close_dev(dev_ID);
    
    /* Done */
    return;
}

/*	**************************************************************  */

/*	PRIVATE FUNCTIONS  */

/*	**************************************************************  */
/*
 *	pt2025_open_dev
 *  This function opens the device and returns an identifier for
 *	future references to the device.
 *
 *	Input:
 *	gpib_board_addr, address of the GPIB board the device is connected to
 *	gpib_dev_addr, GPIB address of the device (1 to 30, 0 is reserved)
 *
 *	Output:
 *	dev_ID, identifier for future references to the	device (-1 if there is a problem)
 *
 *	Zachary Wolf
 *	1/8/03
 */

int pt2025_open_dev(int gpib_board_addr, int gpib_dev_addr)
{
	/* Declare variables */
    int i;
    int dev_ID;
    int descr;
    int err;

    /* Check input parameters */
    if (gpib_board_addr < 0 || gpib_board_addr > 10)
    {
    	Fmt(msg, "%s<gpib_board_addr = %i, out of range", gpib_board_addr);
    	pt2025_error(msg);
    	return -1;
    }
    if (gpib_dev_addr < 1 || gpib_dev_addr > 30)
    {
    	Fmt(msg, "%s<gpib_dev_addr = %i, out of range", gpib_dev_addr);
    	pt2025_error(msg);
    	return -1;
    }

	/* Initialization */
    dev_ID = 0;

    /* Check to see if the device is already in the device table */
    for (i = 1; i <= PT2025_MAX_NUM_DEV; i++)
    {
        if (dev_addr[i] == gpib_dev_addr)
        {
            dev_ID = i;
            return dev_ID;
        }
    }
    
    /* Find an ID for the device */
	for (i = 1; i <= PT2025_MAX_NUM_DEV; i++)
    {
		if (dev_addr[i] == 0)
		{
			dev_ID = i;
			break;
		}
	}
     
    /* If an entry could not be opened in the device table, return an error */
    if (dev_ID <= 0)
    {
    	pt2025_error("The device could not be opened");
        return  -1;
    }
    
    /* Open the device */
    /* Terminate write with EOI, CR LF is added in the send routine */
    /* Terminate read on LF, remove CR LF in read routine */
	descr = ibdev(gpib_board_addr, gpib_dev_addr, 0, T10s, 1, 0x140A);
	if (descr <= 0)
	{
		pt2025_error("The device could not be opened");
		return  -1;
	}
    
    /* Open successful, update device table */
    dev_addr[dev_ID] = gpib_dev_addr;
    dev_descr[dev_ID] = descr;
    dev_count++;
    
    /* Clear the device */
    err = ibclr(dev_descr[dev_ID]);
    Delay(2.);               /* Wait for the device to clear */
    if (err & 0x8000)
    {
    	pt2025_error("Problem clearing device");
    }
    
    /* Always perform GPIB addressing before read and write */
    err = ibconfig(dev_descr[dev_ID], IbcREADDR, 1);
    if (err & 0x8000)
    {
        pt2025_error("Problem setting readdressing option");
    }
    
    /* Return the device dev_ID */
    return dev_ID;
}

/*	**************************************************************  */
/*
 *	pt2025_close_dev
 *  This function closes the device and removes it from the GPIB
 *	device table.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Zachary Wolf
 *	1/8/03
 */

void pt2025_close_dev(int dev_ID)
{
	/* Close the device */
    if (dev_descr[dev_ID] != 0)
    {
        /*ibloc(dev_descr[dev_ID]);*/		 /* Local control plus reset */
        /*ibonl(dev_descr[dev_ID], 0);*/
        dev_descr[dev_ID] = 0;
        dev_addr[dev_ID] = 0;
        dev_count--;
    }
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	pt2025_check_dev_open
 *  This function checks to see if the specified device is open.
 *	If the device has been opened, a 1 is returned, 0 otherwise.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Output:
 *	status, 1 if device is open, 0 otherwise
 *
 *	Zachary Wolf
 *	7/27/98
 */

int pt2025_check_dev_open(int dev_ID)
{
	/* See if the device descriptor has a positive value */
    if (dev_descr[dev_ID] > 0)
    {
        return 1;	   /* Open */
    }
    else
    {
	    return 0;	   /* Not open */
	}
}

/*	**************************************************************  */
/*
 *	pt2025_out
 *  This function writes a buffer of data to the device.
 *
 *	Input:
 *	dev_ID, device identifier
 *	buf, null terminated string, the contents up to \0 are sent
 *
 *	Output:
 *	err, 0 if ok, -1 otherwise
 *
 *	Zachary Wolf
 *	1/8/03
 */

int pt2025_out(int dev_ID, char* buf)
{
	/* Declare variables */
	char out_buf[PT2025_MAX_CMD];
	int nbytes;
	int err;
	
	/* Add CR LF to the command */
	Fmt(out_buf, "%s<%s%c%c", buf, 13, 10);
	
	/* Send the command */
	nbytes = StringLength(out_buf);
	err = ibwrt(dev_descr[dev_ID], out_buf, (long)nbytes);
	
	/* Check for errors */
	if (err & 0x8000)
	{
		Fmt(msg, "%s<ibsta = %x, problem sending GPIB command", err);
		pt2025_error(msg);
		return -1;
	}
	
	/* Allow time for the command to be processed */
	Delay(.5);
	
	/* Done */
    return 0;
}

/*	**************************************************************  */
/*
 *	pt2025_in
 *  This function reads a buffer of data from the device.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Output:
 *	buf, null terminated string, the contents from the device
 *	err, 0 if ok, -1 otherwise
 *
 *	Zachary Wolf
 *	1/8/03
 */

int pt2025_in(int dev_ID, char* buf)
{
	/* Declare variables */
	int err;
	char in_buf[PT2025_MAX_CMD];
	
	/* Read the message */
	err = ibrd(dev_descr[dev_ID], in_buf, PT2025_MAX_CMD);
	
	/* Check for errors */
	if (err & 0x8000)
	{
		Fmt(msg, "%s<ibsta = %x, problem receiving GPIB input", err);
		pt2025_error(msg);
		return -1;
	}
	
	/* Remove the CR LF terminator */
	Scan(in_buf, "%s[t13t00]>%s[t-]", buf);
	
	/* Done */
    return 0;
}

/*	**************************************************************  */
/*
 *	pt2025_get_errors
 *  This function obtains device errors.
 *	The operator is alerted if there is an error.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Output:
 *	err, 0 if no errors, -1 otherwise
 *
 *	Zachary Wolf
 *	1/8/03
 */

int pt2025_get_errors(int dev_ID)
{
	/* Declare variables */
    char status[PT2025_MAX_CMD];
    int status_val;
    int err;
    
    /* Default return value, no error */
    err = 0;

	/* Register 1 */
    pt2025_get_status(dev_ID, 1, status);
	pt2025_calc_status_val(status, &status_val);
    
    /* Register 1, bit 2, value 4, syntax error */
    if ((status_val & 4) == 4)
    {
    	pt2025_error("Syntax error");
    	err = -1;
    }
    
    /* Register 1, bit 3, value 8, hard error */
    if ((status_val & 8) == 8)
    {
    	pt2025_error("Hard error");
    	err = -1;
    }

	/* Register 2 */
	/* No error bits */

	/* Register 3 */
	/* No error bits */

	/* Register 4 */
	/* No error bits */

    /* Done */
    return err;
}

/*	**************************************************************  */
/*
 *	pt2025_serial_poll
 *  This function performs a serial poll of the device.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Output:
 *	spoll, contents of the serial poll register
 *	err, 0 if ok, -1 otherwise
 *
 *	Zachary Wolf
 *	1/8/03
 */

int pt2025_serial_poll(int dev_ID, int* spoll)
{
	/* Declare variables */
	int err;
	char spoll_char;
	
	/* Perform the serial poll */
	err = ibrsp(dev_descr[dev_ID], &spoll_char);
	if (err & 0x8000)
	{
		Fmt(msg, "%s<ibsta = %x, problem performing GPIB serial poll", err);
		pt2025_error(msg);
		return -1;
	}
	
	/* Return the result as an integer */
	Scan(&spoll_char, "%c>%i", spoll);

	/* Debug */
	/* printf("%c %i\n", spoll_char, *spoll); */
	
	/* Done */
    return 0;
}

/*	**************************************************************  */
/*
 *	pt2025_get_status
 *  This function gets the contents of a status register.
 *
 *	Input:
 *	dev_ID, device identifier
 *	reg, register number
 *
 *	Output:
 *	status, contents of the status register
 *
 *	Zachary Wolf
 *	1/8/03
 */

void pt2025_get_status(int dev_ID, int reg, char* status)
{
	/* Declare variables */
	char status_cmd[PT2025_MAX_CMD];
	
	/* Check the input parameters */
	if (reg < 1 || reg > 4)
	{
		Fmt(status_cmd, "%s<reg = %i, value out of range", reg);
		pt2025_error(status_cmd);
		return;
	}
	
	/* Get the status register contents */
	Fmt(status_cmd, "%s<S%i", reg);
	pt2025_out(dev_ID, status_cmd);
	pt2025_in(dev_ID, status);
	
	/* Debug */
	/* printf("%i  %s\n", reg, status); */
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	pt2025_calc_status_val
 *  This function gets the contents of a status register.
 *
 *	Input:
 *	status, contents of the status register
 *
 *	Output:
 *	status_val, integer representation of the status register
 *
 *	Zachary Wolf
 *	1/8/03
 */

void pt2025_calc_status_val(char status[], int* status_val)
{
	/* Calculate the integer representation of the status register contents */
	Scan(status, "%s>S%x", status_val);
	
	/* Debug */
	/* printf("status = %s, value = %i\n", status, *status_val); */
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	pt2025_message
 *  This function handles messages about the PT2025.
 *
 *	Input:
 *	message, string to display in standard I/O
 *
 *	Zachary Wolf
 *	8/3/98
 */

void pt2025_message(char* message)
{
	/* Print the message */
	printf("%s\n", message);
	
	/* Done */
	return;
}

/*	**************************************************************  */
/*
 *	pt2025_error
 *  This function handles error messages for the PT2025.
 *
 *	Input:
 *	message, string to display in standard I/O
 *
 *	Zachary Wolf
 *	8/3/98
 */

void pt2025_error(char* message)
{
	/* Declare variables */
	char buf[80];
	
	/* Notify the operator of the error */
	printf("\nPT2025 ERROR: %s\n", message);
	Beep();
	Delay(.5);
	Beep();
	
	/* Terminate the program if the operator desires */
	printf("Press ENTER to continue.\nPress any key then ENTER to terminate program.\n");
	fgets(buf, 80, stdin);
	if (buf[0] == '\n') return;
	else exit(0);
}