/*	**************************************************************  */
/*
 *	Module HP3458
 *	This module contains I/O functions for the HP3458 multimeter.                 
 *
 *	Zachary Wolf
 *	8/3/98
 */

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

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

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

/*  PRIVATE FUNCTIONS  */
int hp3458_open_dev(int gpib_board_addr, int gpib_dev_addr);
void hp3458_close_dev(int dev_ID);
int hp3458_out(int dev_ID, char* buf);
int hp3458_in(int dev_ID, char* buf);
int hp3458_serial_poll(int dev_ID, int* spoll);
int hp3458_check_dev_open(int dev_ID);
int hp3458_get_errors(int dev_ID);
void hp3458_message(char* msg);
void hp3458_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[HP3458_MAX_NUM_DEV + 1];
static int dev_descr[HP3458_MAX_NUM_DEV + 1];
static int dev_count;

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

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

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

/*	PUBLIC FUNCTIONS  */

/*	**************************************************************  */
/*
 *  hp3458_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:
 *	dev_ID, identifier for future references to the device
 *
 *	Zachary Wolf
 *	11/11/99
 */

void hp3458_init(int gpib_board_addr, int gpib_dev_addr, int* ID)
{
    /* Declare variables */
    int dev_ID;
    int err;
    
    /* Message */
    hp3458_message("");
    hp3458_message("Initializing the HP3458...");

    /* 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);
    	hp3458_error(cmd);
    	return;
    }
    if (gpib_dev_addr < 1 || gpib_dev_addr > 30)
    {
    	Fmt(msg, "%s<gpib_dev_addr = %i, out of range", gpib_dev_addr);
    	hp3458_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	*ID = 1;
    	return;
    #endif
    
    /* Open the hp3458 */
    dev_ID = hp3458_open_dev(gpib_board_addr, gpib_dev_addr);
    if (dev_ID <= 0)
    {
        hp3458_error("Device was not opened");
        return;
    }

    /* Get the HP3458 ID */
    hp3458_out(dev_ID, "ID?");
    err = hp3458_in(dev_ID, cmd);
    if (err != 0)
    {
        hp3458_error("Problem reading ID");
        hp3458_close_dev(dev_ID);
        return;
    }
    hp3458_message(cmd);
    
    /* Leave the HP3458 in a known default state */
    hp3458_out(dev_ID, "PRESET");
    
    /* Check for errors */
    err = hp3458_get_errors(dev_ID);
    if (err != 0)
    {
        hp3458_error("The HP3458 has an error");
        hp3458_close_dev(dev_ID);
        return;
    }

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

/*	**************************************************************  */
/*
 *	hp3458_get_voltage
 *  This function gets the voltage applied to the HP3458.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Output:
 *	voltage, applied voltage (V)
 *
 *	Zachary Wolf
 *	11/11/99
 */

void hp3458_get_voltage(int dev_ID, double* voltage)
{
	/* Declare variables */
	int dev_open;
	int err;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > HP3458_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	hp3458_error(msg);
    	return;
    }
   
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = hp3458_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	hp3458_error("Device not open");
    	return;
    }
    
    /* Preset the HP3458 */
    hp3458_out(dev_ID, "PRESET");
    
    /* Set the A/D integration time */
    hp3458_out(dev_ID, "NPLC 10");
    
    /* Trigger the measurement */
    hp3458_out(dev_ID, "TRIG SGL");

    /* Get the reading */
	hp3458_in(dev_ID, cmd);
	
	/* Extract the voltage */
	err = Scan(cmd, "%s>%f", voltage);
    if (err != 1)
    {
        hp3458_error("Problem getting HP3458 voltage");
    }
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	hp3458_get_frequency
 *  This function gets the frequency of the voltage applied to the
 *	HP3458.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Output:
 *	frequency, frequency of applied voltage (Hz)
 *
 *	Zachary Wolf
 *	11/11/99
 */

void hp3458_get_frequency(int dev_ID, double* frequency)
{
	/* Declare variables */
	int dev_open;
	int err;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > HP3458_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	hp3458_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = hp3458_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	hp3458_error("Device not open");
    	return;
    }
    
    /* Preset the HP3458 */
    hp3458_out(dev_ID, "PRESET");
    
    /* Set the AC bandwidth */
    hp3458_out(dev_ID, "ACBAND 1 20000");
    
    /* Frequency source */
    hp3458_out(dev_ID, "FSOURCE ACV");
    
    /* Tell the meter to measure frequency */
    hp3458_out(dev_ID, "FREQ AUTO");
    
    /* Trigger the measurement */
    hp3458_out(dev_ID, "TRIG SGL");

    /* Get the reading */
	hp3458_in(dev_ID, cmd);
	
	/* Extract the frequency */
	err = Scan(cmd, "%s>%f", frequency);
    if (err != 1)
    {
        hp3458_error("Problem getting HP3458 frequency");
    }
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	hp3458_get_resistance
 *  This function measures the resistance of the device attached
 *	to the HP3458.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Output:
 *	resistance, resistance of the attached device (ohms)
 *
 *	Zachary Wolf
 *	11/12/99
 */

void hp3458_get_resistance(int dev_ID, double* resistance)
{
	/* Declare variables */
	int dev_open;
	int err;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > HP3458_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	hp3458_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = hp3458_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	hp3458_error("Device not open");
    	return;
    }
    
    /* Preset the HP3458 */
    hp3458_out(dev_ID, "PRESET");
    
    /* Set the number of power line cycles to reject noise */
    hp3458_out(dev_ID, "NPLC 10");
    
    /* Tell the meter to measure resistance, autorange, % resolution */
    hp3458_out(dev_ID, "FUNC OHM, AUTO, .001");
    
    /* Trigger the measurement */
    hp3458_out(dev_ID, "TRIG SGL");

    /* Get the reading */
	hp3458_in(dev_ID, cmd);
	
	/* Extract the frequency */
	err = Scan(cmd, "%s>%f", resistance);
    if (err != 1)
    {
        hp3458_error("Problem getting HP3458 resistance");
    }
    
    /* Put the DVM back in a high impedance state */
    hp3458_out(dev_ID, "PRESET");
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	hp3458_get_temperature
 *  This function measures the temperature of an HP thermistor
 *	attached to the HP3458.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Output:
 *	temperature, temperature of the attached thermistor (deg C)
 *
 *	Zachary Wolf
 *	11/12/99
 */

void hp3458_get_temperature(int dev_ID, double* temperature)
{
	/* Declare variables */
	int dev_open;
	int err;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > HP3458_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	hp3458_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = hp3458_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	hp3458_error("Device not open");
    	return;
    }
    
    /* Preset the HP3458 */
    hp3458_out(dev_ID, "PRESET");
    
    /* Set the number of power line cycles to reject noise */
    hp3458_out(dev_ID, "NPLC 10");
    
    /* Tell the meter to measure resistance, autorange, % resolution */
    hp3458_out(dev_ID, "FUNC OHM, AUTO, .01");
    
    /* Set up the math function to convert resistance to temperature */
    hp3458_out(dev_ID, "MATH CTHRM");
    
    /* Trigger the measurement */
    hp3458_out(dev_ID, "TRIG SGL");

    /* Get the reading */
	hp3458_in(dev_ID, cmd);
	
	/* Extract the frequency */
	err = Scan(cmd, "%s>%f", temperature);
    if (err != 1)
    {
        hp3458_error("Problem getting HP3458 temperature");
    }
    
    /* Put the DVM back in a high impedance state */
    hp3458_out(dev_ID, "PRESET");
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	hp3458_setup_timed_voltage_samples
 *	This function sets up to sample the voltage on the HP3458.
 *	The voltage range, measurement integration time, number of samples,
 *	and the time between samples are specified.
 *
 *	Input:
 *	dev_ID, device identifier
 *	v_range, voltage range for the HP3458
 *	num_plc, number of power line cycles to measure the voltage over
 *	num_samples, the number of samples to take
 *	delta_t, the time between samples (sec)
 *
 *	Zachary Wolf
 *	11/12/99
 */

void hp3458_setup_timed_voltage_samples(int dev_ID, double v_range, double num_plc, int num_samples, double delta_t)
{
	/* Declare variables */
	int dev_open;
	int err;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > HP3458_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	hp3458_error(msg);
    	return;
    }
    if (num_samples < 1 || num_samples > 30000)  
    {
    	Fmt(msg, "%s<num_samples = %i, out of range", num_samples);
    	hp3458_error(msg);
    	return;
    }
    if (delta_t < .001 || delta_t > 10)
    {
    	Fmt(msg, "%s<delta_t = %f, out of range", delta_t);
    	hp3458_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = hp3458_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	hp3458_error("Device not open");
    	return;
    }
    
    /* Preset the HP3458 */
    hp3458_out(dev_ID, "PRESET");
    
    /* Turn off autorange */
    hp3458_out(dev_ID, "ARANGE OFF");
    
    /* Turn off the autozero */
    hp3458_out(dev_ID, "AZERO OFF");
    
    /* Turn off the display */
    hp3458_out(dev_ID, "DISP OFF");
    
    /* Turn off math functions */
    hp3458_out(dev_ID, "MATH OFF");
    
    /* Turn on the keyboard lock */
    hp3458_out(dev_ID, "LOCK ON");
    
    /* Set the output format */
    hp3458_out(dev_ID, "OFORMAT ASCII");
     
    /* Set the voltage range */
    Fmt(cmd, "%s<DCV %f", v_range);
    hp3458_out(dev_ID, cmd);
    
    /* Set the A/D integration time */
    Fmt(cmd, "%s<NPLC %f", num_plc);
    hp3458_out(dev_ID, cmd);
    
    /* Set the timer */
    Fmt(cmd, "%s<TIMER %f", delta_t);
    hp3458_out(dev_ID, cmd);
    
    /* Send the readings to the memory */
    Fmt(cmd, "%s<MSIZE %i", num_samples * 4 + 10);
    hp3458_out(dev_ID, cmd);
    hp3458_out(dev_ID, "MEM FIFO");
    hp3458_out(dev_ID, "MFORMAT DINT");
    
    /* Set up the trigger */
    hp3458_out(dev_ID, "TARM AUTO");
    Fmt(cmd, "%s<NRDGS %i, TIMER", num_samples);
    hp3458_out(dev_ID, cmd);
    
    /* Check for errors */
    err = hp3458_get_errors(dev_ID);
    if (err != 0)
    {
        hp3458_error("The HP3458 has an error");
        hp3458_close_dev(dev_ID);
        return;
    }
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	hp3458_trigger_timed_voltage_samples
 *	This function triggers the voltage sampling set up in the previous
 *	function.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Zachary Wolf
 *	11/12/99
 */

void hp3458_trigger_timed_voltage_samples(int dev_ID)
{
	/* Declare variables */
	int dev_open;
	
    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > HP3458_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	hp3458_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = hp3458_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	hp3458_error("Device not open");
    	return;
    }
    
    /* Turn on the input buffer */
    hp3458_out(dev_ID, "INBUF ON");
    
    /* Trigger the readings */
    hp3458_out(dev_ID, "TRIG SGL");
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	hp3458_collect_timed_voltage_samples
 *	This function collects the samples of the voltage on the HP3458
 *	which were set up and triggered by the previous two functions.
 *
 *	Input:
 *	dev_ID, device identifier
 *	num_samples, the number of samples to take
 *
 *	Output:
 *	voltages[0 to num_samp - 1], voltage samples (V)
 *
 *	Zachary Wolf
 *	11/12/99
 */

void hp3458_collect_timed_voltage_samples(int dev_ID, int num_samples, double voltages[])
{
	/* Declare variables */
	int dev_open;
	int err;
	int spoll;
	int i;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > HP3458_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	hp3458_error(msg);
    	return;
    }
    if (num_samples < 1 || num_samples > 30000)  
    {
    	Fmt(msg, "%s<num_samples = %i, out of range", num_samples);
    	hp3458_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = hp3458_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	hp3458_error("Device not open");
    	return;
    }
    
    /* Wait until the readings are complete */
    do
    {
    	hp3458_serial_poll(dev_ID, &spoll);
    	//printf("spoll = %i\n", spoll);
    	Delay(0.5);
    }while ((spoll & 16) == 0);	/* while bit 4 is off */
    
    /* Turn off the input buffer */
    hp3458_out(dev_ID, "INBUF OFF");
    
    /* Check for errors */
    err = hp3458_get_errors(dev_ID);
    if (err != 0)
    {
        hp3458_error("The HP3458 has an error");
        hp3458_close_dev(dev_ID);
        return;
    }

    /* Get the readings */
    for (i=0; i<num_samples; i++)
    {
		hp3458_in(dev_ID, cmd);
		err = Scan(cmd, "%s>%f", &voltages[i]);
    	if (err != 1)
    	{
        	hp3458_error("Problem getting HP3458 voltage");
    	}
    }
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	hp3458_digitize
 *	This function samples the voltage applied to the HP3458.
 *	The number of samples and the time between samples are
 *	specified.
 *	Some parameters are defined locally such as the voltage range.
 *	These should be changed to meet the needs of the job being performed.
 *
 *	Input:
 *	dev_ID, device identifier
 *	num_samples, the number of samples to take
 *	delta_t, the time between samples (sec)
 *
 *	Output:
 *	voltages[0 to num_samp - 1], voltage samples (V)
 *
 *	Zachary Wolf
 *	11/16/99
 */

void hp3458_digitize(int dev_ID, int num_samples, double delta_t, double voltages[])
{
	/* Parameters */
	const double max_input = 10.;				/* Determines voltage range */
	
	/* Declare variables */
	int dev_open;
	int err;
	int spoll;
	int i;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > HP3458_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	hp3458_error(msg);
    	return;
    }
    if (num_samples < 1 || num_samples > 30000)  
    {
    	Fmt(msg, "%s<num_samples = %i, out of range", num_samples);
    	hp3458_error(msg);
    	return;
    }
    if (delta_t < .00006 || delta_t > 1.)
    {
    	Fmt(msg, "%s<delta_t = %f, out of range", delta_t);
    	hp3458_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = hp3458_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	hp3458_error("Device not open");
    	return;
    }
    
    /* Preset the HP3458 */
    hp3458_out(dev_ID, "PRESET");
    
    /* Turn off autorange */
    hp3458_out(dev_ID, "ARANGE OFF");
    
    /* Turn off the autozero */
    hp3458_out(dev_ID, "AZERO OFF");
    
    /* Turn off the display */
    hp3458_out(dev_ID, "DISP OFF");
    
    /* Turn off math functions */
    hp3458_out(dev_ID, "MATH OFF");
    
    /* Turn on the keyboard lock */
    hp3458_out(dev_ID, "LOCK ON");
    
    /* Set the output format */
    hp3458_out(dev_ID, "OFORMAT ASCII");
     
    /* Set the voltage range */
    Fmt(cmd, "%s<DCV %f", max_input);
    hp3458_out(dev_ID, cmd);
    
    /* Set the A/D integration time */
    Fmt(cmd, "%s<APER %f", delta_t - 50.e-6);
    hp3458_out(dev_ID, cmd);
    
    /* Set the timer */
    Fmt(cmd, "%s<TIMER %f", delta_t);
    hp3458_out(dev_ID, cmd);
    
    /* Send the readings to the memory */
    Fmt(cmd, "%s<MSIZE %i", num_samples * 4 + 10);
    hp3458_out(dev_ID, cmd);
    hp3458_out(dev_ID, "MEM FIFO");
    hp3458_out(dev_ID, "MFORMAT DINT");
    
    /* Set up the trigger */
    hp3458_out(dev_ID, "TARM AUTO");
    Fmt(cmd, "%s<NRDGS %i, TIMER", num_samples);
    hp3458_out(dev_ID, cmd);
    
    /* Check for errors */
    err = hp3458_get_errors(dev_ID);
    if (err != 0)
    {
        hp3458_error("The HP3458 has an error");
        hp3458_close_dev(dev_ID);
        return;
    }
    
    /* Trigger the readings */
    hp3458_out(dev_ID, "TRIG SGL");
    
    /* Wait until the readings are complete */
    do
    {
    	hp3458_serial_poll(dev_ID, &spoll);
    	//printf("spoll = %i\n", spoll);
    	Delay(0.5);
    }while ((spoll & 16) == 0);	/* while bit 4 is off */
    
    /* Check for errors */
    err = hp3458_get_errors(dev_ID);
    if (err != 0)
    {
        hp3458_error("The HP3458 has an error");
        hp3458_close_dev(dev_ID);
        return;
    }

    /* Get the readings */
    for (i=0; i<num_samples; i++)
    {
		hp3458_in(dev_ID, cmd);
		err = Scan(cmd, "%s>%f", &voltages[i]);
    	if (err != 1)
    	{
        	hp3458_error("Problem getting HP3458 voltage");
    	}
    }
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	hp3458_exit
 *  This function leaves the HP3458 in a desired state and
 *	closes the device.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Zachary Wolf
 *	7/27/98
 */

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

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > HP3458_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	hp3458_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = hp3458_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	return;		   /* OK, already closed */
    }

    /* Leave the device in the desired state */
    /* Reset the HP3458 to the power on state */
    hp3458_out(dev_ID, "RESET");

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

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

/*	PRIVATE FUNCTIONS  */

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

int hp3458_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);
    	hp3458_error(cmd);
    	return -1;
    }
    if (gpib_dev_addr < 1 || gpib_dev_addr > 30)
    {
    	Fmt(msg, "%s<gpib_dev_addr = %i, out of range", gpib_dev_addr);
    	hp3458_error(msg);
    	return -1;
    }

	/* Initialization */
    dev_ID = 0;

    /* Check to see if the device is already in the device table */
    for (i = 1; i <= HP3458_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 <= HP3458_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)
    {
    	hp3458_error("The device could not be opened");
        return  -1;
    }
    
    /* Open the device */
    /* Do not terminate write with EOI, add CR LF in sending routine */
    /* Terminate read on LF, remove CR LF in read routine */
	descr = ibdev(gpib_board_addr, gpib_dev_addr, 0, T30s, 0, 0x140A);
	if (descr <= 0)
	{
		hp3458_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]);
	if (err & 0x8000)
	{
		hp3458_error("Problem clearing device");
	}
    
    /* Return the device ID */
    return dev_ID;
}

/*	**************************************************************  */
/*
 *	hp3458_close_dev
 *  This function closes the device.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Zachary Wolf
 *	8/3/98
 */

void hp3458_close_dev(int dev_ID)
{
	/* Close the device */
    if (dev_descr[dev_ID] != 0)
    {
        ibonl(dev_descr[dev_ID], 0);
        dev_descr[dev_ID] = 0;
        dev_addr[dev_ID] = 0;
        dev_count--;
    }
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	hp3458_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
 *	7/27/98
 */

int hp3458_out(int dev_ID, char* buf)
{
	/* Declare variables */
	char out_buf[HP3458_MAX_CMD];
	int nbytes;
	int err;
	
	/* Append CR LF to the message */
	Fmt(out_buf, "%s<%s%c%c", buf, 13,10); 
	
	/* Send the message */
	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);
		hp3458_error(msg);
		return -1;
	}
	
	/* Done */
    return 0;
}

/*	**************************************************************  */
/*
 *	hp3458_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
 *	7/27/98
 */

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

/*	**************************************************************  */
/*
 *	hp3458_serial_poll
 *  This function performs a serial poll of the device.
 *	A value of 16 indicates the HP3458 is ready for a command.
 *	A value of 32 indicates an error.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Output:
 *	spoll, contents of the serial poll register
 *	err, 0 if ok, -1 otherwise
 *
 *	Zachary Wolf
 *	8/26/98
 */

int hp3458_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);
	
	/* Check for errors */
	if (err & 0x8000)
	{
		Fmt(msg, "%s<ibsta = %x, problem performing GPIB serial poll", err);
		hp3458_error(msg);
		return -1;
	}
	
	/* Return the result as an integer */
	Scan(&spoll_char, "%c>%i", spoll);
	
	/* Done */
    return 0;
}

/*	**************************************************************  */
/*
 *	hp3458_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 hp3458_check_dev_open(int dev_ID)
{
	/* See if the board descriptor has a positive value */
    if (dev_descr[dev_ID] > 0)
    {
        return  1;	  /* Open */
    }
    else
    {
	    return 0;	  /* Not open */
	}
}

/*	**************************************************************  */
/*
 *	hp3458_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
 *	8/3/98
 */

int hp3458_get_errors(int dev_ID)
{
	/* Declare variables */
    int status;

	/* Get the HP3458 error status */
	hp3458_out(dev_ID, "ERR?");
	hp3458_in(dev_ID, cmd);
	
	/* Extract the status value */
	Scan(cmd, "%s>%i", &status);
    
    /* Alert the operator if there is an error */
    if (status != 0)
    {
    	Fmt(msg, "%s<The HP3458 has an error, HP error code = %i", status);
    	hp3458_error(msg);
        return -1;
    }
    
    /* Done */
    return 0;
}

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

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

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

void hp3458_error(char* message)
{
	/* Declare variables */
	char buf[80];
	
	/* Notify the operator of the error */
	printf("\nHP3458 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);
}