/*	**************************************************************  */
/*
 *	Module SR830
 *	This module contains I/O functions for the Stanford Research
 *	SR830 lock-in amplifier.                 
 *
 *	Zachary Wolf
 *	7/2/04
 */ 

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

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

/*  PRIVATE FUNCTIONS  */
int sr830_open_dev(int gpib_board_addr, int gpib_dev_addr);
void sr830_close_dev(int dev_ID);
int sr830_check_dev_open(int dev_ID);
int sr830_out(int dev_ID, char* buf);
int sr830_in(int dev_ID, char* buf);
int sr830_spoll(int dev_ID, int* spoll);
void sr830_wait_until_ready_for_command(int dev_ID);
void sr830_wait_until_data_ready(int dev_ID);
void sr830_message(char* msg);
void sr830_error(char* msg);
void sr830_try_to_fix_errors(int dev_ID);
int sr830_get_errors(int dev_ID);

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

/*  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[SR830_MAX_NUM_DEV + 1];
static int dev_descr[SR830_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[SR830_MAX_CMD + 1];
static char msg[SR830_MAX_CMD + 1];

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

/*	PUBLIC FUNCTIONS  */

/*	**************************************************************  */
/*
 *  sr830_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
 *	7/2/04
 */

void sr830_init(int gpib_board_addr, int gpib_dev_addr, int* ID)
{
    /* Declare variables */
    int dev_ID;
    int err;
    int i;
    
    /* Message */
    sr830_message("");
    sr830_message("Initializing the SR830...");

    /* 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);
    	sr830_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);
    	sr830_error(msg);
    	return;
    }
    
    /* Exit here if testing without hardware */
    #ifdef DUMMY_DEVICES
    	*ID = 1;
    	return;
    #endif
    
    /* Open the SR830 */
    dev_ID = sr830_open_dev(gpib_board_addr, gpib_dev_addr);
    if (dev_ID <= 0)
    {
        sr830_error("SR830 was not opened");
        return;
    }
    
    /* Start with the default measurement parameter settings */
    sr830_out(dev_ID, "*RST");
    
    /* Let things settle */
    Delay(2.);
    
    /* Start with low sensitivity and high reserve */
    sr830_out(dev_ID, "SENS26");
    sr830_out(dev_ID, "RMOD0");
    
    /* mmm Set the filter rolloff to 24 dB */
    sr830_out(dev_ID, "OFSL 3");
    
    /* Let things settle */
    Delay(1.);
    
    /* Clear all status registers */
    sr830_out(dev_ID, "*CLS");
    
    /* Have the SR830 direct all output to the GPIB interface */
    sr830_out(dev_ID, "OUTX1");
    
    /* Set the control to remote */
    sr830_out(dev_ID, "LOCL1");
    
    /* Allow the front panel keys to stay in use */
    sr830_out(dev_ID, "OVRM1");
    
    /* Enable the standard event status register, bits 0 2 4 5, 1+4+16+32=53 */
    sr830_out(dev_ID, "*ESE53");
    
    /* Disable SRQs, will check for errors */
    sr830_out(dev_ID, "*SRE0");
    
    /* Enable the error status register */
    sr830_out(dev_ID, "ERRE255");
    
    /* Enable the lock-in status register, bits 0 1 2 3, 1+2+4+8=15 */
    sr830_out(dev_ID, "LIAE15");
    
    /* Change the display from X Y to R Theta */
    sr830_out(dev_ID, "DDEF1,1,0");	/* Set CH1 to trace 1, R */
    sr830_out(dev_ID, "DDEF2,1,0");	/* Set CH2 to trace 1, Theta */
   
    /* Get the SR830 ID */
    sr830_out(dev_ID, "*IDN?");
    err = sr830_in(dev_ID, cmd);
    if (err != 0)
    {
        sr830_error("Problem reading ID");
    }
    sr830_message(cmd);
    
    /* Check for errors */
    err = sr830_get_errors(dev_ID);
    if (err != 0) sr830_error("SR830: The lock-in had an error during the initialization.");

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

/*	**************************************************************  */
/*
 *	sr830_set_ext_ttl_trig
 *  This function sets up the lock-in for external TTL reference.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Zachary Wolf
 *	8/25/04
 */

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

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > SR830_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	sr830_error(msg);
    	return;
    }
    
    /* Exit here if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = sr830_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	sr830_error("Device not open");
    	return;
    }
    
    /* Set up the external TTL trigger */
    sr830_out(dev_ID, "FMOD0");		/* Use an external reference */
    sr830_out(dev_ID, "RSLP1");		/* Trigger on TTL, rising edge */
    Delay(1.);						/* Allow time to settle before clearing unlocked status bit */
    sr830_out(dev_ID, "LIAS?3");	/* Clear the unlocked status bit */
    sr830_in(dev_ID, msg);			/* Clear the unlocked status bit */
    
    /* Check for errors */
    err = sr830_get_errors(dev_ID);
    if (err != 0) sr830_error("SR830: The lock-in had an error during the setup.");
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	sr830_set_ext_sine_trig
 *  This function sets up the lock-in for external sine wave reference.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Zachary Wolf
 *	8/25/04
 */

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

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > SR830_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	sr830_error(msg);
    	return;
    }
    
    /* Exit here if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = sr830_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	sr830_error("Device not open");
    	return;
    }
   
    /* Set up the external sine trigger */
    sr830_out(dev_ID, "FMOD0");		/* Use an external reference */
    sr830_out(dev_ID, "RSLP0");		/* Trigger on external sine wave zero crossing */
    Delay(1.);						/* Allow time to settle before clearing unlocked status bit */
    sr830_out(dev_ID, "LIAS?3");	/* Clear the unlocked status bit */
    sr830_in(dev_ID, msg);			/* Clear the unlocked status bit */
    
    /* Check for errors */
    err = sr830_get_errors(dev_ID);
    if (err != 0) sr830_error("SR830: The lock-in had an error during the setup.");
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	sr830_set_synchronous_filter
 *  This function turns on the synchronous filter, f < 200 Hz.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Zachary Wolf
 *	8/25/04
 */

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

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > SR830_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	sr830_error(msg);
    	return;
    }
    
    /* Exit here if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = sr830_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	sr830_error("Device not open");
    	return;
    }
    
    /* Turn on the synchronous filter */
    sr830_out(dev_ID, "SYNC1");		/* Turn on the synchronous filter, f < 200 Hz */
    Delay(1.);						/* Allow time to settle before clearing the filter overload status bit */
    sr830_out(dev_ID, "LIAS?1");	/* Clear the filter overload status bit */
    sr830_in(dev_ID, msg);			/* Clear the filter overload status bit */
    
    /* Check for errors */
    err = sr830_get_errors(dev_ID);
    if (err != 0) sr830_error("SR830: The lock-in had an error during setting the synchronous filter.");
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	sr830_set_time_constant
 *  This function sets the output filter time constant.
 *	See p. 5-6 of the manual for the time constant codes.
 *	The default is 100 msec.  This should be adequate for most measurements.
 *
 *	Input:
 *	dev_ID, device identifier
 *	code, time constant code (see p. 5-6)
 *
 *	Zachary Wolf
 *	8/25/04
 */

void sr830_set_time_constant(int dev_ID, int code)
{
	/* Declare variables */
	int dev_open;
	int err;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > SR830_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	sr830_error(msg);
    	return;
    }
    if (code < 0 || code > 19)
    {
    	Fmt(msg, "%s<Time constant code = %i, out of range, fixed...", code);
    	sr830_message(msg);
    }
    if (code < 0) code = 0;
    if (code > 19) code = 19;
    
    /* Exit here if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = sr830_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	sr830_error("Device not open");
    	return;
    }
    
    /* Set the time constant */
    Fmt(cmd, "%s<OFLT%i", code);
    sr830_out(dev_ID, cmd);			/* Set the time constant */
    Delay(1.);						/* Allow time to settle before clearing the filter overload status bit */
    sr830_out(dev_ID, "LIAS?1");	/* Clear the filter overload status bit */
    sr830_in(dev_ID, msg);			/* Clear the filter overload status bit */
    
    /* Check for errors */
    err = sr830_get_errors(dev_ID);
    if (err != 0) sr830_error("SR830: The lock-in had an error setting the time constant.");
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	sr830_set_sensitivity
 *  This function sets the input sensitivity.
 *	See p. 5-6 of the manual for the sensitivity codes.
 *
 *	Input:
 *	dev_ID, device identifier
 *	code, input sensitivity code (see p. 5-6)
 *
 *	Zachary Wolf
 *	8/25/04
 */

void sr830_set_sensitivity(int dev_ID, int code)
{
	/* Declare variables */
	int dev_open;
	int err;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > SR830_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	sr830_error(msg);
    	return;
    }
    if (code < 0 || code > 26)
    {
    	Fmt(msg, "%s<Sensitivity code = %i, out of range, fixed...", code);
    	sr830_message(msg);
    }
    if (code < 0) code = 0;
    if (code > 26) code = 26;
    
    /* Exit here if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = sr830_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	sr830_error("Device not open");
    	return;
    }
    
    /* Set the sensitivity */
    Fmt(cmd, "%s<SENS%i", code);
    sr830_out(dev_ID, cmd);
    
    /* Let things settle */
    Delay(1.);
    
    /* Clear the LIA output overload status bit after adjusting the sensitivity */
    sr830_out(dev_ID, "LIAS?2");
    sr830_in(dev_ID, msg);
    
    /* Clear the LIA input/reserve overload status bit after adjusting the sensitivity */
    sr830_out(dev_ID, "LIAS?0");
    sr830_in(dev_ID, msg);
    
    /* Check for errors */
    //err = sr830_get_errors(dev_ID);
    //if (err != 0) sr830_error("SR830: The lock-in had an error setting the sensitivity.");
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	sr830_set_reserve_mode
 *  This function sets the dynamic reserve mode.
 *	See p. 5-6 of the manual for the reserve codes.
 *
 *	Input:
 *	dev_ID, device identifier
 *	code, dynamic reserve mode code (see p. 5-6)
 *
 *	Zachary Wolf
 *	8/25/04
 */

void sr830_set_reserve_mode(int dev_ID, int code)
{
	/* Declare variables */
	int dev_open;
	int err;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > SR830_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	sr830_error(msg);
    	return;
    }
    if (code < 0 || code > 2)
    {
    	Fmt(msg, "%s<Reserve mode code = %i, out of range, fixed...", code);
    	sr830_message(msg);
    }
    if (code < 0) code = 0;
    if (code > 2) code = 2;
    
    /* Exit here if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = sr830_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	sr830_error("Device not open");
    	return;
    }
   
    /* Set the dynamic reserve mode */
    Fmt(cmd, "%s<RMOD%i", code);
    sr830_out(dev_ID, cmd);
    
    /* Check for errors */
    err = sr830_get_errors(dev_ID);
    if (err != 0) sr830_error("SR830: The lock-in had an error setting the reserve.");
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	sr830_set_har_num
 *  This function sets the harmonic number that the lock-in measures.
 *
 *	Input:
 *	dev_ID, device identifier
 *	har_num, harmonic number
 *
 *	Zachary Wolf
 *	8/25/04
 */

void sr830_set_har_num(int dev_ID, int har_num)
{
	/* Declare variables */
	int dev_open;
	int err;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > SR830_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	sr830_error(msg);
    	return;
    }
    if (har_num < 1 || har_num > 30)
    {
    	Fmt(msg, "%s<har_num = %i, out of range", har_num);
    	sr830_error(msg);
    	return;
    }
    
    /* Exit here if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = sr830_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	sr830_error("SR830 not open");
    	return;
    }

    /* Set the harmonic number */
    Fmt(cmd, "%s<HARM%i", har_num);
    sr830_out(dev_ID, cmd);
   
    /* Check for errors */
    err = sr830_get_errors(dev_ID);
    if (err != 0) sr830_error("The SR830 had an error while setting the harmonic number.");
    
    /* Done */
    return;
}

/*	**************************************************************  */			
/*
 *	sr830_set_sine_out
 *  This function sets the sine out amplitude and frequency.
 *
 *	Input:
 *	dev_ID, device identifier
 *	ampl, rms voltage amplitude (Vrms, .004 to 5 Vrms)
 *	freq, voltage frequency (Hz, .001 to 102000 Hz)
 *
 *	Zachary Wolf
 *	8/25/04
 */

void sr830_set_sine_out(int dev_ID, double ampl, double freq)
{
	/* Declare variables */
	int dev_open;
	int err;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > SR830_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	sr830_error(msg);
    	return;
    }
    if (ampl < .004) ampl = .004;
    if (ampl > 5.) ampl = 5.;
    if (freq < .001) freq = .001;
    if (freq > 102000.) freq = 102000.;
    
    /* Exit here if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = sr830_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	sr830_error("SR830 not open");
    	return;
    }

    /* Set the sine wave amplitude */
    Fmt(cmd, "%s<SLVL%f", ampl);
    sr830_out(dev_ID, cmd);

    /* Set the sine wave frequency */
    Fmt(cmd, "%s<FREQ%f", freq);
    sr830_out(dev_ID, cmd);
   
    /* Check for errors */
    err = sr830_get_errors(dev_ID);
    if (err != 0) sr830_error("The SR830 had an error while setting the sine out parameters.");
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	sr830_automeasure
 *  This function performs an automeasure sequence.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Zachary Wolf
 *	8/25/04
 */

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

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > SR830_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	sr830_error(msg);
    	return;
    }
    
    /* Exit here if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = sr830_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	sr830_error("Device not open");
    	return;
    }
    
    /* Initially set the input sensitivity to the highest range (1 V) */
    sr830_out(dev_ID, "SENS26");
    
    /* Set the dynamic reserve to its maximum value */
    sr830_out(dev_ID, "RMOD0");
    
    /* Let things settle */
    Delay(.5);
    
    /* Auto-gain */
    sr830_out(dev_ID, "AGAN");
    
    /* Auto-reserve */
    sr830_out(dev_ID, "ARSV");
    
    /* Let things settle */
    Delay(1.);
    
    /* Clear the LIA output overload status bit after autogain */
    sr830_out(dev_ID, "LIAS?2");
    sr830_in(dev_ID, msg);
    
    /* Clear the LIA input/reserve overload status bit after autoreserve */
    sr830_out(dev_ID, "LIAS?0");
    sr830_in(dev_ID, msg);
    
    /* If there are errors, try to fix them */
    err = sr830_get_errors(dev_ID);
    while (err != 0)
    {
		sr830_try_to_fix_errors(dev_ID);
    	err = sr830_get_errors(dev_ID);
    }
    
    /* Let things settle before collecting the readings */
    Delay(1.);
    
    /* Done */
    return;
}

/*	**************************************************************  */  
/*
 *	sr830_get_freq
 *  This function gets the lock-in's reference frequency.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Output:
 *	freq, reference frequency (Hz)
 *
 *	Zachary Wolf
 *	8/25/04
 */

void sr830_get_freq(int dev_ID, double* freq)
{
	/* Declare variables */
	int dev_open;
	int err;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > SR830_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	sr830_error(msg);
    	return;
    }
    
    /* Exit here if testing without hardware */
    #ifdef DUMMY_DEVICES
    	*freq = 10000.;
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = sr830_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	sr830_error("SR830 not open");
    	return;
    }

    /* Get the frequency */
    do{
    	sr830_out(dev_ID, "FREQ?");
    	sr830_in(dev_ID, msg);
    	Scan(msg, "%s>%f", freq);
    
    	/* Debug */
    	//printf("DEBUG, frequency = %s Hz\n", msg);
    
    	/* Check for errors, if there are errors, try to fix them */
    	err = sr830_get_errors(dev_ID);
    	if (err != 0)
			sr830_try_to_fix_errors(dev_ID);
    }while(err != 0);
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	sr830_get_phase
 *  This function gets the lock-in's phase measurement.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Output:
 *	phase, phase of measured voltage (deg)
 *
 *	Zachary Wolf
 *	8/25/04
 */

void sr830_get_phase(int dev_ID, double* phase)
{
	/* Declare variables */
	int dev_open;
	int err;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > SR830_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	sr830_error(msg);
    	return;
    }
    
    /* Exit here if testing without hardware */
    #ifdef DUMMY_DEVICES
    	*phase = 0.;
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = sr830_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	sr830_error("SR830 not open");
    	return;
    }

    /* Get the phase */
    do{
    	sr830_out(dev_ID, "OUTP?4");
    	sr830_in(dev_ID, msg);
    	Scan(msg, "%s>%f", phase);
    
    	/* Debug */
    	//printf("DEBUG, phase = %s deg\n", msg);
    
    	/* Check for errors, if there are errors, try to fix them */
    	err = sr830_get_errors(dev_ID);
    	if (err != 0)
			sr830_try_to_fix_errors(dev_ID);
    }while(err != 0);
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	sr830_get_vrms
 *  This function gets the lock-in's rms voltage measurement.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Output:
 *	vrms, measured rms voltage (Vrms)
 *
 *	Zachary Wolf
 *	8/25/04
 */

void sr830_get_vrms(int dev_ID, double* vrms)
{
	/* Declare variables */
	int dev_open;
	int err;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > SR830_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	sr830_error(msg);
    	return;
    }
    
    /* Exit here if testing without hardware */
    #ifdef DUMMY_DEVICES
    	*vrms = 0.;
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = sr830_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	sr830_error("SR830 not open");
    	return;
    }

    /* Get the voltage */
    do{
    	sr830_out(dev_ID, "OUTP?3");
    	sr830_in(dev_ID, msg);
    	Scan(msg, "%s>%f", vrms);
    
    	/* Debug */
    	//printf("DEBUG, Vrms = %s V\n", msg);
    
    	/* Check for errors, if there are errors, try to fix them */
    	err = sr830_get_errors(dev_ID);
    	if (err != 0)
			sr830_try_to_fix_errors(dev_ID);
    }while(err != 0);
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	sr830_get_vxrms
 *  This function gets the lock-in's in phase rms voltage measurement.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Output:
 *	vxrms, measured in phase rms voltage (Vrms)
 *
 *	Zachary Wolf
 *	8/25/04
 */

void sr830_get_vxrms(int dev_ID, double* vxrms)
{
	/* Declare variables */
	int dev_open;
	int err;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > SR830_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	sr830_error(msg);
    	return;
    }
    
    /* Exit here if testing without hardware */
    #ifdef DUMMY_DEVICES
    	*vxrms = .5;
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = sr830_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	sr830_error("SR830 not open");
    	return;
    }

    /* Get the voltage */
    do{
    	/* Check for errors, if there are errors, try to fix them */
    	err = sr830_get_errors(dev_ID);
    	if (err != 0)
			sr830_try_to_fix_errors(dev_ID);
			
		sr830_out(dev_ID, "OUTP?1");
    	sr830_in(dev_ID, msg);
    	Scan(msg, "%s>%f", vxrms);
    
    	/* Debug */
    	//printf("DEBUG, Vxrms = %s V\n", msg);
    
    	
    }while(err != 0);
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	sr830_get_vyrms
 *  This function gets the lock-in's out of phase rms voltage measurement.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Output:
 *	vyrms, measured out of phase rms voltage (Vrms)
 *
 *	Zachary Wolf
 *	8/25/04
 */

void sr830_get_vyrms(int dev_ID, double* vyrms)
{
	/* Declare variables */
	int dev_open;
	int err;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > SR830_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	sr830_error(msg);
    	return;
    }
    
    /* Exit here if testing without hardware */
    #ifdef DUMMY_DEVICES
    	*vyrms = 1.e-2 * rand() / RAND_MAX;
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = sr830_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	sr830_error("SR830 not open");
    	return;
    }

    /* Get the voltage */
    do{
    	/* Check for errors, if there are errors, try to fix them */
    	err = sr830_get_errors(dev_ID);
    	if (err != 0)
			sr830_try_to_fix_errors(dev_ID);
			
		sr830_out(dev_ID, "OUTP?2");
    	sr830_in(dev_ID, msg);
    	Scan(msg, "%s>%f", vyrms);
    
    	/* Debug */
    	//printf("DEBUG, Vyrms = %s V\n", msg);
    
    	
    }while(err != 0);  
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	sr830_get_sensitivity
 *  This function gets the lock-in's sensitivity setting.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Output:
 *	sens, sensitivity code, see p. 5-6 of the manual for the code meanings
 *
 *	Zachary Wolf
 *	8/25/04
 */

void sr830_get_sensitivity(int dev_ID, int* sens)
{
	/* Declare variables */
	int dev_open;
	int err;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > SR830_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	sr830_error(msg);
    	return;
    }
    
    /* Exit here if testing without hardware */
    #ifdef DUMMY_DEVICES
    	*sens = -1;
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = sr830_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	sr830_error("SR830 not open");
    	return;
    }

    /* Get the sensitivity code */
    sr830_out(dev_ID, "SENS?");
    sr830_in(dev_ID, msg);
    Scan(msg, "%s>%i", sens);
    
    /* Debug */
    //printf("DEBUG, Sens = %s\n", msg);
    
    /* Check for errors */
    //err = sr830_get_errors(dev_ID);
    //if (err != 0) sr830_error("The SR830 had an error while getting the sensitivity.");
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	sr830_lower_sensitivity
 *  This function lowers the lock-in's sensitivity to avoid an
 *	input overload in a noisy environment.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Zachary Wolf
 *	9/2/05
 */

void sr830_lower_sensitivity(int dev_ID)
{
	/* Declare variables */
	int sens;
	
	/* Get the current sensitivity */
	sr830_get_sensitivity(dev_ID, &sens);
	
	/* Lower the sensitivity */
	sens++;
	
	/* Set the new sensitivity */
	sr830_set_sensitivity(dev_ID, sens);
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	sr830_clear_errors
 *  This function obtains SR830 errors.  All errors are cleared by this function.
 *	It is used after a condition which is expected to cause an error,
 *	such as a change in the reference frequency.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Zachary Wolf
 *	8/25/04
 */

void sr830_clear_errors(int dev_ID)
{
	/* Declare variables */
    int status;
    int num;

	/* Get the serial poll status byte */
    /* See p. 5-21 for the status byte definitions */
	sr830_out(dev_ID, "*STB?");
	sr830_in(dev_ID, cmd);
	num = Scan(cmd, "%s>%i", &status);
    if (num != 1)
    {
        sr830_error("Problem getting the serial poll status byte");
        return;
    }
    if (status & (4 + 8 + 32))
    {
    	if (status & 1);	/* OK, no scan in progress */
    	if (status & 2);	/* OK, no command execution in progress */
    	if (status & 4);	// sr830_message("SR830_ERROR, a bit has been set in the ERR status byte");
    	if (status & 8);	// sr830_message("SR830_ERROR, a bit has been set in the LIA status byte");
    	if (status & 16);	/* OK, data is ready */
    	if (status & 32);	// sr830_message("SR830_ERROR, a bit has been set in the standard status byte");
    	if (status & 64);	/* OK, SRQ has occurred */
    	if (status & 128);	/* OK, unused */
    }

	/* Get the standard event status byte */
    /* See p. 5-22 for the status byte definitions */
	sr830_out(dev_ID, "*ESR?");
	sr830_in(dev_ID, cmd);
	num = Scan(cmd, "%s>%i", &status);
    if (num != 1)
    {
        sr830_error("Problem getting the standard event status byte");
        return;
    }
    if (status & (1 + 4 + 16 + 32))
    {
    	if (status & 1);	// sr830_message("SR830_ERROR, input queue overflow");
    	if (status & 2);	/* OK, unused */
    	if (status & 4);	// sr830_message("SR830_ERROR, output queue overflow");
    	if (status & 8);	/* OK, unused */
    	if (status & 16);	// sr830_message("SR830_ERROR, command did not execute correctly, or parameter out of range");
    	if (status & 32);	// sr830_message("SR830_ERROR, illegal command received");
    	if (status & 64);	/* OK, keypress or know turn */
    	if (status & 128);	/* OK, power-on */
    }

	/* Get the LIA status byte */
    /* See p. 5-20 for the status byte definitions */
	sr830_out(dev_ID, "LIAS?");
	sr830_in(dev_ID, cmd);
	num = Scan(cmd, "%s>%i", &status);
    if (num != 1)
    {
        sr830_error("Problem getting the LIA status byte");
        return;
    }
    if (status & (1 + 2 + 4 + 8))
    {
    	if (status & 1);	// sr830_message("SR830_ERROR, input or reserve overload");
    	if (status & 2);	// sr830_message("SR830_ERROR, filter overload");
    	if (status & 4);	// sr830_message("SR830_ERROR, output overload");
    	if (status & 8);	// sr830_message("SR830_ERROR, reference unlocked");
    	if (status & 16);	/* OK, range switch */
    	if (status & 32);	/* OK, time constant changed */
    	if (status & 64);	/* OK, unit was triggered */
    	if (status & 128);	/* OK, unused */
    }

	/* Get the error status byte */
    /* See p. 5-23 for the status byte definitions */
	sr830_out(dev_ID, "ERRS?");
	sr830_in(dev_ID, cmd);
	num = Scan(cmd, "%s>%i", &status);
    if (num != 1)
    {
        sr830_error("Problem getting the error status byte");
        return;
    }
    if (status & (2 + 4 + 16 + 32 + 64 + 128))
    {
    	if (status & 1);	/* OK, unused */
    	if (status & 2);	// sr830_message("SR830_ERROR, battery backup has failed");
    	if (status & 4);	// sr830_message("SR830_ERROR, RAM memory test failure");
    	if (status & 8);	/* OK, unused */
    	if (status & 16);	// sr830_message("SR830_ERROR, ROM error");
    	if (status & 32);	// sr830_message("SR830_ERROR, GPIB error");
    	if (status & 64);	// sr830_message("SR830_ERROR, DSP error");
    	if (status & 128);	// sr830_message("SR830_ERROR, math error");
    }
       
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	sr830_exit
 *  This function configures the SR830 for program exit and
 *	closes the device.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Zachary Wolf
 *	8/25/04
 */

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

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

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

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

/*	PRIVATE FUNCTIONS  */

/*	**************************************************************  */
/*
 *	sr830_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, device identifier for future references to the device (-1 if there is a problem)
 *
 *	Zachary Wolf
 *	7/2/04
 */

int sr830_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);
    	sr830_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);
    	sr830_error(msg);
    	return -1;
    }

	/* Initialization */
    dev_ID = 0;

    /* Check to see if the device is already in the device table */
    for (i = 1; i <= SR830_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 <= SR830_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)
    {
    	sr830_error("The device could not be opened");
        return  -1;
    }
    
    /* Open the device */
    /* Terminate write with LF */
    /* Terminate read on LF, remove LF in read routine */
	descr = ibdev(gpib_board_addr, gpib_dev_addr, 0, T10s, 0, 0x140A);
	if (descr <= 0)
	{
		sr830_error("The device could not be opened");
		return  -1;
	}
    
    /* Open successful, save results */
    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)
    {
    	sr830_error("Problem clearing device");
    }
    
    /* Return the device ID */
    return dev_ID;
}

/*	**************************************************************  */
/*
 *	sr830_close_dev
 *  This function closes the device.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Zachary Wolf
 *	8/25/04
 */

void sr830_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;
}

/*	**************************************************************  */
/*
 *	sr830_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
 *	8/25/04
 */

int sr830_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 */
	}
}

/*	**************************************************************  */
/*
 *	sr830_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
 *	8/25/04
 */

int sr830_out(int dev_ID, char* buf)
{
	/* Declare variables */
	int nbytes;
	char out_buf[SR830_MAX_CMD];
	int err;
	
	/* Make sure the SR830 is ready for a command */
	sr830_wait_until_ready_for_command(dev_ID);
	
	/* Add LF to the message */
	Fmt(out_buf, "%s<%s%c", buf, 0x0A);
	
	/* 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);
		sr830_error(msg);
		return -1;
	}
    	
    /* Allow time to process command */
    Delay(.2);
	
	/* Done */
    return 0;
}

/*	**************************************************************  */
/*
 *	sr830_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
 *	8/25/04
 */

int sr830_in(int dev_ID, char* buf)
{
	/* Declare variables */
	int err;
	char in_buf[SR830_MAX_CMD];
	
	/* Make sure the data is ready */
	sr830_wait_until_data_ready(dev_ID);
	
	/* Read the message */
	err = ibrd(dev_descr[dev_ID], in_buf, SR830_MAX_CMD);
	
	/* Check for errors */
	if (err & 0x8000)
	{
		Fmt(msg, "%s<ibsta = %x, problem receiving GPIB input", err);
		sr830_error(msg);
		return -1;
	}
	
	/* Remove the LF terminator */
	Scan(in_buf, "%l>%s[t-]", buf);
	
	/* Done */
    return 0;
}

/*	**************************************************************  */
/*
 *	sr830_spoll
 *  This function performs a serial poll on the device.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Output:
 *	spoll, integer encoding the serial poll information
 *	err, 0 if ok, -1 otherwise
 *
 *	Zachary Wolf
 *	8/25/04
 */

int sr830_spoll(int dev_ID, int* spoll)
{
	/* Declare variables */
	int err;
	char spoll_byte;
	
	/* Perform the serial poll */
	err = ibrsp(dev_descr[dev_ID], &spoll_byte);
	
	/* Check for errors */
	if (err & 0x8000)
	{
		Fmt(msg, "%s<ibsta = %x, problem performing serial poll", err);
		sr830_error(msg);
		return -1;
	}
	
	/* Put the serial poll information into an integer */
	*spoll = (int) spoll_byte;
	
	/* Done */
    return 0;
}

/*	**************************************************************  */
/*
 *	sr830_wait_until_ready_for_command
 *  This function periodically performs a serial poll on the device
 *	until it is ready to receive a command. 
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Zachary Wolf
 *	8/25/04
 */

void sr830_wait_until_ready_for_command(int dev_ID)
{
	/* Declare variables */
	int ready = 0;
	int spoll;
	
	/* Loop until the data is ready */
	while (ready == 0)
	{
		/* Perform a serial poll */
		/* The bit definitions are given on p. 5-21 */
		sr830_spoll(dev_ID, &spoll);
	
		/* See if data is ready */
		/* Bit 0 (value 1) means that no scan is in progress */
		/* Bit 1 (value 2) means that no command is in progress */
		if (spoll & (1 + 2)) ready = 1;
    	
    	/* Allow time to get ready for commands */
    	if (ready == 0) Delay(.2);
    }
	
	/* Done */
    return;
}

/*	**************************************************************  */
/*
 *	sr830_wait_until_data_ready
 *  This function periodically performs a serial poll on the device
 *	until it is ready to send data. 
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Zachary Wolf
 *	8/25/04
 */

void sr830_wait_until_data_ready(int dev_ID)
{
	/* Declare variables */
	int ready = 0;
	int spoll;
	
	/* Loop until the data is ready */
	while (ready == 0)
	{
		/* Perform a serial poll */
		/* The bit definitions are given on p. 5-21 */
		sr830_spoll(dev_ID, &spoll);
	
		/* See if data is ready */
		/* Bit 1 (value 2) means that no command is in progress */
		/* Bit 4 (value 16) means that data is ready */
		if (spoll & (2 + 16)) ready = 1;
    	
    	/* Allow time to get data ready */
    	if (ready == 0) Delay(.2);
     }
	
	/* Done */
    return;
}

/*	**************************************************************  */
/*
 *	sr830_get_errors
 *  This function obtains SR830 errors.
 *	The operator is alerted if there is an error.
 *	All errors are cleared by this function.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Output:
 *	error, 0 if no errors, -1 otherwise
 *
 *	Zachary Wolf
 *	8/25/04
 */

int sr830_get_errors(int dev_ID)
{
	/* Declare variables */
    int status;
    int err = 0;
    int num;

	/* Get the serial poll status byte */
    /* Alert the operator if there is an error */
    /* See p. 5-21 for the status byte definitions */
	sr830_out(dev_ID, "*STB?");
	sr830_in(dev_ID, cmd);
	num = Scan(cmd, "%s>%i", &status);
    if (num != 1)
    {
        sr830_error("Problem getting the serial poll status byte");
        return -1;
    }
    if (status & (4 + 8 + 32))
    {
    	err = -1;
    	if (status & 1);	/* OK, no scan in progress */
    	if (status & 2);	/* OK, no command execution in progress */
    	if (status & 4);	// sr830_message("SR830_ERROR, a bit has been set in the ERR status byte");
    	if (status & 8);	// sr830_message("SR830_ERROR, a bit has been set in the LIA status byte");
    	if (status & 16);	/* OK, data is ready */
    	if (status & 32);	// sr830_message("SR830_ERROR, a bit has been set in the standard status byte");
    	if (status & 64);	/* OK, SRQ has occurred */
    	if (status & 128);	/* OK, unused */
    }

	/* Get the standard event status byte */
    /* Alert the operator if there is an error */
    /* See p. 5-22 for the status byte definitions */
	sr830_out(dev_ID, "*ESR?");
	sr830_in(dev_ID, cmd);
	num = Scan(cmd, "%s>%i", &status);
    if (num != 1)
    {
        sr830_error("Problem getting the standard event status byte");
        return -1;
    }
    if (status & (1 + 4 + 16 + 32))
    {
    	err = -1;
    	if (status & 1) sr830_message("SR830_ERROR, input queue overflow");
    	if (status & 2);	/* OK, unused */
    	if (status & 4) sr830_message("SR830_ERROR, output queue overflow");
    	if (status & 8);	/* OK, unused */
    	if (status & 16) sr830_message("SR830_ERROR, command did not execute correctly, or parameter out of range");
    	if (status & 32) sr830_message("SR830_ERROR, illegal command received");
    	if (status & 64);	/* OK, keypress or know turn */
    	if (status & 128);	/* OK, power-on */
    }

	/* Get the LIA status byte */
    /* Alert the operator if there is an error */
    /* See p. 5-20 for the status byte definitions */
	sr830_out(dev_ID, "LIAS?");
	sr830_in(dev_ID, cmd);
	num = Scan(cmd, "%s>%i", &status);
    if (num != 1)
    {
        sr830_error("Problem getting the LIA status byte");
        return -1;
    }
    if (status & (1 + 2 + 4 + 8))
    {
    	err = -1;
    	if (status & 1) sr830_message("SR830_ERROR, input or reserve overload");
    	if (status & 2) sr830_message("SR830_ERROR, filter overload");
    	if (status & 4) sr830_message("SR830_ERROR, output overload");
    	if (status & 8) sr830_message("SR830_ERROR, reference unlocked");
    	if (status & 16);	/* OK, range switch */
    	if (status & 32);	/* OK, time constant changed */
    	if (status & 64);	/* OK, unit was triggered */
    	if (status & 128);	/* OK, unused */
    }

	/* Get the error status byte */
    /* Alert the operator if there is an error */
    /* See p. 5-23 for the status byte definitions */
	sr830_out(dev_ID, "ERRS?");
	sr830_in(dev_ID, cmd);
	num = Scan(cmd, "%s>%i", &status);
    if (num != 1)
    {
        sr830_error("Problem getting the error status byte");
        return -1;
    }
    if (status & (2 + 4 + 16 + 32 + 64 + 128))
    {
    	err = -1;
    	if (status & 1);	/* OK, unused */
    	if (status & 2) sr830_message("SR830_ERROR, battery backup has failed");
    	if (status & 4) sr830_message("SR830_ERROR, RAM memory test failure");
    	if (status & 8);	/* OK, unused */
    	if (status & 16) sr830_message("SR830_ERROR, ROM error");
    	if (status & 32) sr830_message("SR830_ERROR, GPIB error");
    	if (status & 64) sr830_message("SR830_ERROR, DSP error");
    	if (status & 128) sr830_message("SR830_ERROR, math error");
    }
       
    /* Done */
    return err;
}

/*	**************************************************************  */
/*
 *	sr830_try_to_fix_errors
 *  This function obtains SR830 errors.  If possible, errors are fixed.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Zachary Wolf
 *	8/25/04
 */

void sr830_try_to_fix_errors(int dev_ID)
{
	/* Declare variables */
    int status;
    int num;
    int sens;
    
    /* Message */
    sr830_message("Try to fix errors...");
    
    /* Allow time for the register bits to be reset after the get_errors */
    Delay(.5);

	/* Get the serial poll status byte */
	/* This only indicates where any errors are */
    /* See p. 5-21 for the status byte definitions */
	sr830_out(dev_ID, "*STB?");
	sr830_in(dev_ID, cmd);
	num = Scan(cmd, "%s>%i", &status);
    if (num != 1)
    {
        sr830_error("Problem getting the serial poll status byte");
        return;
    }
    if (status & (4 + 8 + 32))
    {
    	if (status & 1);	/* OK, no scan in progress */
    	if (status & 2);	/* OK, no command execution in progress */
    	if (status & 4);	/* ERROR, a bit has been set in the ERR status byte */
    	if (status & 8);	/* ERROR, a bit has been set in the LIA status byte */
    	if (status & 16);	/* OK, data is ready */
    	if (status & 32);	/* ERROR, a bit has been set in the standard status byte */
    	if (status & 64);	/* OK, SRQ has occurred */
    	if (status & 128);	/* OK, unused */
    }

	/* Get the standard event status byte */
    /* These errors can not be fixed */
    /* See p. 5-22 for the status byte definitions */
	sr830_out(dev_ID, "*ESR?");
	sr830_in(dev_ID, cmd);
	num = Scan(cmd, "%s>%i", &status);
    if (num != 1)
    {
        sr830_error("Problem getting the standard event status byte");
        return;
    }
    if (status & (1 + 4 + 16 + 32))
    {
    	if (status & 1);	/* ERROR, input queue overflow */
    	if (status & 2);	/* OK, unused */
    	if (status & 4);	/* ERROR, output queue overflow */
    	if (status & 8);	/* OK, unused */
    	if (status & 16);	/* ERROR, command did not execute correctly, or parameter out of range */
    	if (status & 32);	/* ERROR, illegal command received */
    	if (status & 64);	/* OK, keypress or know turn */
    	if (status & 128);	/* OK, power-on */
    }

	/* Get the LIA status byte */
    /* Some of these errors can be fixed */
    /* See p. 5-23 for the status byte definitions */
	sr830_out(dev_ID, "LIAS?");
	sr830_in(dev_ID, cmd);
	num = Scan(cmd, "%s>%i", &status);
    if (num != 1)
    {
        sr830_error("Problem getting the LIA status byte");
        return;
    }
    if (status & (1 + 2 + 4 + 8))
    {
    	if (status & 1)	/* ERROR, input or reserve overload */
    	{
	    	printf("Fixing input or reserve overload...\n");
	    	sr830_get_sensitivity(dev_ID, &sens);
	    	sens = sens + 2;	/* Increasing sensitivity code decreases sensitivity */
	    	sr830_set_sensitivity(dev_ID, sens);
	    	Delay(2.);
    	}
    	if (status & 2)	/* ERROR, filter overload */
    	{
	    	printf("Fixing filter overload...\n");
	    	sr830_get_sensitivity(dev_ID, &sens);
	    	sens = sens + 2;	/* Increasing sensitivity code decreases sensitivity */
	    	sr830_set_sensitivity(dev_ID, sens);
	    	Delay(2.);
    	}
    	if (status & 4)	/* ERROR, output overload */
    	{
	    	printf("Fixing output overload...\n");
	    	sr830_get_sensitivity(dev_ID, &sens);
	    	sens = sens + 2;	/* Increasing sensitivity code decreases sensitivity */
	    	sr830_set_sensitivity(dev_ID, sens);
	    	Delay(2.);								   
    	}
    	if (status & 8);	/* ERROR, reference unlocked */
    	if (status & 16);	/* OK, range switch */
    	if (status & 32);	/* OK, time constant changed */
    	if (status & 64);	/* OK, unit was triggered */
    	if (status & 128);	/* OK, unused */
    }

	/* Get the error status byte */
    /* These errors can not be fixed */
    /* See p. 5-23 for the status byte definitions */
	sr830_out(dev_ID, "ERRS?");
	sr830_in(dev_ID, cmd);
	num = Scan(cmd, "%s>%i", &status);
    if (num != 1)
    {
        sr830_error("Problem getting the error status byte");
        return;
    }
    if (status & (1 + 2 + 4 + 8 + 16 + 32 + 64 + 128))
    {
    	if (status & 1);	/* OK, unused */
    	if (status & 2);	/* ERROR, battery backup has failed */
    	if (status & 4);	/* ERROR, RAM memory test failure */
    	if (status & 8);	/* OK, unused */
    	if (status & 16);	/* ERROR, ROM error */
    	if (status & 32);	/* ERROR, GPIB error */
    	if (status & 64);	/* ERROR, DSP error */
    	if (status & 128);	/* ERROR, math error */
    }
       
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	sr830_message
 *  This function handles messages about the SR830.
 *
 *	Input:
 *	message, string to display in standard I/O
 *
 *	Zachary Wolf
 *	8/25/04
 */

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

/*	**************************************************************  */
/*
 *	sr830_error
 *  This function handles error messages for the SR830.
 *
 *	Input:
 *	message, string to display in standard I/O
 *
 *	Zachary Wolf
 *	8/25/04
 */

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