/*	**************************************************************  */
/*
 *	Module PDI5025
 *	This module contains I/O functions for the Metrolab precision
 *	digital integrator model 5025.                 
 *
 *	Zachary Wolf
 *	8/29/98
 */ 

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

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

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

/*  PRIVATE FUNCTIONS  */
int pdi5025_open_dev(int gpib_board_addr, int gpib_dev_addr);
void pdi5025_close_dev(int dev_ID);
int pdi5025_check_dev_open(int dev_ID);
int pdi5025_out(int dev_ID, char* buf);
int pdi5025_in(int dev_ID, char* buf);
int pdi5025_in_block(int dev_ID, int num_samp, double vt[]);
int pdi5025_get_errors(int dev_ID);
void pdi5025_get_status(int dev_ID, int reg, char* status);
int pdi5025_hold_until_end_of_run_and_data_ready(int dev_ID);
void pdi5025_hold_until_data_ready(int dev_ID);
void pdi5025_hold_until_end_of_run(int dev_ID);
int pdi5025_serial_poll(int dev_ID, int* spoll);
void pdi5025_message(char* msg);
void pdi5025_error(char* msg);
void pdi5025_generate_samples(char rot_dir, int num_samp_per_rev,
	int num_samp, double vt[]);

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

/*  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[PDI5025_MAX_NUM_DEV + 1];
static int dev_descr[PDI5025_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[PDI5025_MAX_CMD + 1];
static char msg[PDI5025_MAX_CMD + 1];
static int num_encoder_pulse_per_rev;

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

/*	PUBLIC FUNCTIONS  */

/*	**************************************************************  */
/*
 *  pdi5025_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
 *	8/29/98
 */

void pdi5025_init(int gpib_board_addr, int gpib_dev_addr, int* ID)
{
    /* Declare variables */
    int dev_ID;
    int err;
    int i;
    
    /* Message */
    pdi5025_message("");
    pdi5025_message("Initializing the PDI5025...");

    /* 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);
    	pdi5025_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);
    	pdi5025_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	*ID = 1;
    	return;
    #endif
    
    /* Open the PDI5025 */
    dev_ID = pdi5025_open_dev(gpib_board_addr, gpib_dev_addr);
    if (dev_ID <= 0)
    {
        pdi5025_error("Device was not opened");
        return;
    }

    /* Put the PDI in an idle state */
    pdi5025_out(dev_ID, "BRK");
    
    /* Read status 1 and 2 to clear the registers */
    pdi5025_get_status(dev_ID, 1, cmd);
    pdi5025_get_status(dev_ID, 2, cmd);
    
    /* Set the gain to the lowest value */
    pdi5025_out(dev_ID, "SGA,*,1");
    
    /* Turn off interrupts */
    pdi5025_out(dev_ID, "MSK,1,00");
    pdi5025_out(dev_ID, "MSK,2,00");
    
    /* Check for errors */
    pdi5025_get_errors(dev_ID);
    
    /* Talk to the PDI5025 */
    pdi5025_out(dev_ID, "VER");
	err = pdi5025_in(dev_ID, cmd);
    if (err != 0)
    {
        pdi5025_error("Problem reading dev_ID");
        pdi5025_close_dev(dev_ID);
        return;
    }
    pdi5025_message(cmd);
    
    /* Print the status register's contents */
    for (i = 1; i <= 7; i++)
    {
    	pdi5025_get_status(dev_ID, i, cmd);
    	pdi5025_message(cmd);
    }

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

/*	**************************************************************  */
/*
 *	pdi5025_get_VT_timer
 *  This function takes n integrated voltage readings spaced t seconds
 *	apart and returns the values.
 *
 *	Input:
 *	dev_ID, device identifier
 *	chan, integrator channel, A or B
 *	gain, input amplifier gain, 1, 2, 5, 10, 20, 50, 100, 200, 500, 1000
 *	delta_t_samp, time between integrated voltage samples (sec)
 *	num_samp, number of integrated voltage samples
 *
 *	Output:
 *	vt[0 to n], vt[0] = 0, vt[1 to n] = n measured integrated voltage samples
 *
 *	Zachary Wolf
 *	8/29/98
 */

void pdi5025_get_VT_timer(int dev_ID, char chan, int gain,
		double delta_t_samp, int num_samp, double vt[])
{
	/* Declare variables */
	int dev_open;
	int err;
	int delta_t_samp_ms;
	int i;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > PDI5025_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	pdi5025_error(msg);
    	return;
    }
    if (chan != 'A' && chan != 'B')
    {
    	Fmt(msg, "%s<chan = %c, must be A or B", chan);
    	pdi5025_error(msg);
    	return;
    }
    if (gain != 1 && gain != 2 && gain != 5 &&
    	gain != 10 && gain != 20 && gain != 50 &&
    	gain != 100 && gain != 200 && gain != 500 &&
    	gain != 1000)
    {
    	Fmt(msg, "%s<gain = %i, not allowed", gain);
    	pdi5025_error(msg);
    	return;
    }
    if (delta_t_samp < .001 || delta_t_samp > 30.)
    {
    	Fmt(msg, "%s<delta_t_samp = %f, out of range", delta_t_samp);
    	pdi5025_error(msg);
    	return;
    }
    if (num_samp < 1 || num_samp > 5000)
    {
    	Fmt(msg, "%s<num_samp = %i, out of range", num_samp);
    	pdi5025_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = pdi5025_check_dev_open(dev_ID);
    if (dev_open == 0)
    {
    	pdi5025_error("Instrument not open");
    	return;
    }
    
    /* Select the integrator channel */
    Fmt(cmd, "%s<CHA,%c", chan);
    //pdi5025_out(dev_ID, cmd);
    
    /* Set the gain */
    Fmt(cmd, "%s<SGA,%i", gain);
    pdi5025_out(dev_ID, cmd);
    
    /* Set the PDI5025 for cululated data storage */
    pdi5025_out(dev_ID, "CUM,1,S");
    
    /* Use block data transfer mode */
    pdi5025_out(dev_ID, "IMD,0");
    
    /* Use the internal timer for triggers */
    pdi5025_out(dev_ID, "TRS,T");
    
    /* Set the time between integrated voltage samples */
    delta_t_samp_ms = (int)(delta_t_samp * 1000.);
    Fmt(cmd, "%s<TRI,+,0/%i,%i", num_samp, delta_t_samp_ms);
    pdi5025_out(dev_ID, cmd);
    
    /* Check for errors */
	err = pdi5025_get_errors(dev_ID);
    if (err != 0)
    {
        pdi5025_error("Problem with PDI5025");
        return;
    }
    
    /* Start the measurement */
    pdi5025_out(dev_ID, "RUN");
    
    /* Wait until the measurement is finished and the PDI is done processing the data */
	err = pdi5025_hold_until_end_of_run_and_data_ready(dev_ID);
    if (err != 0)
    {
        for (i = 0; i <= num_samp; i++) vt[i] = 0.;
        return;
    }
    
    /* Read the measurements */
	err = pdi5025_in_block(dev_ID, num_samp, vt);
    if (err != 0)
    {
        pdi5025_error("Problem getting VT samples");
        for (i = 0; i <= num_samp; i++) vt[i] = 0.;
        return;
    }
    
    /* Check for errors */
	err = pdi5025_get_errors(dev_ID);
    if (err != 0)
    {
        pdi5025_error("Problem with PDI5025");
        for (i = 0; i <= num_samp; i++) vt[i] = 0.;
        return;
    }
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	pdi5025_get_VT_timer_start
 *  This function begins the sampling of n integrated voltage readings
 *	spaced t seconds apart.
 *
 *	Input:
 *	dev_ID, device identifier
 *	chan, integrator channel, A or B
 *	gain, input amplifier gain, 1, 2, 5, 10, 20, 50, 100, 200, 500, 1000
 *	delta_t_samp, time between integrated voltage samples (sec)
 *	num_samp, number of integrated voltage samples
 *
 *	Zachary Wolf
 *	8/27/99
 */

void pdi5025_get_VT_timer_start(int dev_ID, char chan, int gain,
		double delta_t_samp, int num_samp)
{
	/* Declare variables */
	int dev_open;
	int err;
	int delta_t_samp_ms;
	int i;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > PDI5025_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	pdi5025_error(msg);
    	return;
    }
    if (chan != 'A' && chan != 'B')
    {
    	Fmt(msg, "%s<chan = %c, must be A or B", chan);
    	pdi5025_error(msg);
    	return;
    }
    if (gain != 1 && gain != 2 && gain != 5 &&
    	gain != 10 && gain != 20 && gain != 50 &&
    	gain != 100 && gain != 200 && gain != 500 &&
    	gain != 1000)
    {
    	Fmt(msg, "%s<gain = %i, not allowed", gain);
    	pdi5025_error(msg);
    	return;
    }
    if (delta_t_samp < .001 || delta_t_samp > 30.)
    {
    	Fmt(msg, "%s<delta_t_samp = %f, out of range", delta_t_samp);
    	pdi5025_error(msg);
    	return;
    }
    if (num_samp < 1 || num_samp > 5000)
    {
    	Fmt(msg, "%s<num_samp = %i, out of range", num_samp);
    	pdi5025_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = pdi5025_check_dev_open(dev_ID);
    if (dev_open == 0)
    {
    	pdi5025_error("Instrument not open");
    	return;
    }
    
    /* Select the integrator channel */
    Fmt(cmd, "%s<CHA,%c", chan);
    //pdi5025_out(dev_ID, cmd);
    
    /* Set the gain */
    Fmt(cmd, "%s<SGA,%i", gain);
    pdi5025_out(dev_ID, cmd);
    
    /* Set the PDI5025 for cululated data storage */
    pdi5025_out(dev_ID, "CUM,1,S");
    
    /* Use block data transfer mode */
    pdi5025_out(dev_ID, "IMD,0");
    
    /* Use the internal timer for triggers */
    pdi5025_out(dev_ID, "TRS,T");
    
    /* Set the time between integrated voltage samples */
    delta_t_samp_ms = (int)(delta_t_samp * 1000.);
    Fmt(cmd, "%s<TRI,+,0/%i,%i", num_samp, delta_t_samp_ms);
    pdi5025_out(dev_ID, cmd);
    
    /* Check for errors */
	err = pdi5025_get_errors(dev_ID);
    if (err != 0)
    {
        pdi5025_error("Problem with PDI5025");
        return;
    }
    
    /* Start the measurement */
    pdi5025_out(dev_ID, "RUN");
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	pdi5025_get_VT_timer_finish
 *  This function returns n integrated voltage readings spaced t seconds
 *	apart.
 *
 *	Input:
 *	dev_ID, device identifier
 *	num_samp, number of integrated voltage samples
 *
 *	Output:
 *	vt[0 to n], vt[0] = 0, vt[1 to n] = n measured integrated voltage samples
 *
 *	Zachary Wolf
 *	8/29/98
 */

void pdi5025_get_VT_timer_finish(int dev_ID, int num_samp, double vt[])
{
	/* Declare variables */
	int dev_open;
	int err;
	int i;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > PDI5025_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	pdi5025_error(msg);
    	return;
    }
    if (num_samp < 1 || num_samp > 5000)
    {
    	Fmt(msg, "%s<num_samp = %i, out of range", num_samp);
    	pdi5025_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	for (i = 0; i <= num_samp; i++) vt[i] = (double) i / (double) num_samp;
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = pdi5025_check_dev_open(dev_ID);
    if (dev_open == 0)
    {
    	pdi5025_error("Instrument not open");
    	return;
    }
    
    /* Wait until the measurement is finished and the PDI is done processing the data */
	err = pdi5025_hold_until_end_of_run_and_data_ready(dev_ID);
    if (err != 0)
    {
        for (i = 0; i <= num_samp; i++) vt[i] = 0.;
        return;
    }
    
    /* Read the measurements */
	err = pdi5025_in_block(dev_ID, num_samp, vt);
    if (err != 0)
    {
        pdi5025_error("Problem getting VT samples");
        for (i = 0; i <= num_samp; i++) vt[i] = 0.;
        return;
    }
    
    /* Check for errors */
	err = pdi5025_get_errors(dev_ID);
    if (err != 0)
    {
        pdi5025_error("Problem with PDI5025");
        for (i = 0; i <= num_samp; i++) vt[i] = 0.;
        return;
    }
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	pdi5025_set_rotary_encoder_trigger
 *  This function sets up the PDI5025 to be triggered by a rotary encoder. 
 *
 *	Input:
 *	dev_ID, device identifier
 *	num_encoder_pulse_per_rev_in, number of encoder pulses per revolution
 *
 *	Zachary Wolf
 *	3/2/00
 */

void pdi5025_set_rotary_encoder_trigger(int dev_ID, int num_encoder_pulse_per_rev_in)
{
	/* Declare variables */
	int dev_open;

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

    /* Save the number of encoder pulses per revolution for future use */
    num_encoder_pulse_per_rev = num_encoder_pulse_per_rev_in;
   
    /* Encoder setup */
    Fmt(cmd, "%s<TRS,E,%i", num_encoder_pulse_per_rev);
    pdi5025_out(dev_ID, cmd);
    
    /* Check for errors */
    pdi5025_get_errors(dev_ID);
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	pdi5025_get_VT_rotary_encoder
 *  This function takes n integrated voltage readings triggered by
 *	a rotary encoder.
 *
 *	Input:
 *	dev_ID, device identifier
 *	chan, integrator channel, A or B
 *	gain, input amplifier gain, 1, 2, 5, 10, 20, 50, 100, 200, 500, 1000
 *	rot_dir, rotation direction, + or -
 *	num_samp_per_rev, number of integrated voltage samples per revolution
 *	num_samp, number of integrated voltage samples
 *
 *	Output:
 *	vt[0 to n], vt[0] = 0, vt[1 to n] = n measured integrated voltage samples
 *
 *	Zachary Wolf
 *	9/3/98
 */

void pdi5025_get_VT_rotary_encoder(int dev_ID, char chan, int gain, char rot_dir,
	int num_samp_per_rev, int num_samp, double vt[])
{
	/* Declare variables */
	int dev_open;
	int err;
	int i;

    /* Check input parameters */
    if (num_encoder_pulse_per_rev == 0)
    {
    	pdi5025_message("pdi_get_VT_encoder, no encoder present");
    	return;
    }
    if (dev_ID < 1 || dev_ID > PDI5025_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	pdi5025_error(msg);
    	return;
    }
    if (chan != 'A' && chan != 'B')
    {
    	Fmt(msg, "%s<chan = %c, must be A or B", chan);
    	pdi5025_error(msg);
    	return;
    }
    if (gain != 1 && gain != 2 && gain != 5 &&
    	gain != 10 && gain != 20 && gain != 50 &&
    	gain != 100 && gain != 200 && gain != 500 &&
    	gain != 1000)
    {
    	Fmt(msg, "%s<gain = %i, not allowed", gain);
    	pdi5025_error(msg);
    	return;
    }
    if (rot_dir != '+' && rot_dir != '-')
    {
    	Fmt(msg, "%s<rot_dir = %c, must be + or -", rot_dir);
    	pdi5025_error(msg);
    	return;
    }
    if (num_samp_per_rev < 1 || num_samp_per_rev > num_encoder_pulse_per_rev)
    {
    	Fmt(msg, "%s<num_samp_per_rev = %i, out of range", num_samp_per_rev);
    	pdi5025_error(msg);
    	return;
    }
    if (num_samp < 1 || num_samp > 5000)
    {
    	Fmt(msg, "%s<num_samp = %i, out of range", num_samp);
    	pdi5025_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	pdi5025_generate_samples(rot_dir, num_samp_per_rev, num_samp, vt);
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = pdi5025_check_dev_open(dev_ID);
    if (dev_open == 0)
    {
    	pdi5025_error("Instrument not open");
    	return;
    }
    
    /* Select the integrator channel */
    Fmt(cmd, "%s<CHA,%c", chan);
    //pdi5025_out(dev_ID, cmd);
    
    /* Set the gain */
    Fmt(cmd, "%s<SGA,%i", gain);
    pdi5025_out(dev_ID, cmd);
    
    /* Set the PDI5025 for cululated data storage */
    pdi5025_out(dev_ID, "CUM,1,S");
    
    /* Use block data transfer mode */
    pdi5025_out(dev_ID, "IMD,0");
    
    /* Set up the integration intervals */
    Fmt(cmd, "%s<TRI,%c,0/%i,%i", rot_dir, num_samp, 4 * num_encoder_pulse_per_rev / num_samp_per_rev);
    pdi5025_out(dev_ID, cmd);
    
    /* Check for errors */
	err = pdi5025_get_errors(dev_ID);
    if (err != 0)
    {
        pdi5025_error("Problem with PDI5025");
        for (i = 0; i <= num_samp; i++) vt[i] = 0.;
        return;
    }
    
    /* Start the measurement */
    pdi5025_out(dev_ID, "RUN");
    
    /* Wait until the measurement is finished and the PDI is done processing the data */
	err = pdi5025_hold_until_end_of_run_and_data_ready(dev_ID);
    if (err != 0)
    {
        for (i = 0; i <= num_samp; i++) vt[i] = 0.;
        return;
    }
    
    /* Read the measurements */
	err = pdi5025_in_block(dev_ID, num_samp, vt);
    if (err != 0)
    {
        pdi5025_error("Problem getting VT samples");
        for (i = 0; i <= num_samp; i++) vt[i] = 0.;
        return;
    }
    
    /* Check for errors */
	err = pdi5025_get_errors(dev_ID);
    if (err != 0)
    {
        pdi5025_error("Problem with PDI5025");
        for (i = 0; i <= num_samp; i++) vt[i] = 0.;
		return;
    }
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	pdi5025_set_linear_encoder_trigger
 *  This function sets up the PDI5025 to be triggered by a linear encoder. 
 *
 *	Input:
 *	dev_ID, device identifier
 *	index, 1 if the encoder has an index that you wish to use, 0 otherwise
 *
 *	Zachary Wolf
 *	3/2/00
 */

void pdi5025_set_linear_encoder_trigger(int dev_ID, int index)
{
	/* Declare variables */
	int dev_open;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > PDI5025_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	pdi5025_error(msg);
    	return;
    }
    if (index < 0 || index > 1)
    {
    	Fmt(msg, "%s<index = %i, out of range", index);
    	pdi5025_error(msg);
    	return;
    }
     
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = pdi5025_check_dev_open(dev_ID);
    if (dev_open == 0)
    {
    	pdi5025_error("Instrument not open");
    	return;
    }
    
	/* Encoder setup */
    if (index == 0) pdi5025_out(dev_ID, "TRS,E");		/* Encoder without index */
    if (index == 1) pdi5025_out(dev_ID, "TRS,E,S");		/* Encoder with index */
    
    /* Check for errors */
    pdi5025_get_errors(dev_ID);
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	pdi5025_get_VT_linear_encoder
 *  This function takes n integrated voltage readings triggered by
 *	a linear encoder.
 *
 *	Input:
 *	dev_ID, device identifier
 *	chan, integrator channel, A or B
 *	gain, input amplifier gain, 1, 2, 5, 10, 20, 50, 100, 200, 500, 1000
 *	dir, direction, + or -
 *	enc_start_pulse, encoder pulse number (+ or -) relative to zero where the samples start
 *	num_enc_pulse_btwn_samp, number of encoder pulses between VT samples
 *	num_samp, number of integrated voltage samples
 *
 *	Output:
 *	vt[0 to n], vt[0] = 0, vt[1 to n] = n measured integrated voltage samples
 *
 *	Zachary Wolf
 *	3/2/00
 */

void pdi5025_get_VT_linear_encoder(int dev_ID, char chan, int gain, char dir,
	long int enc_start_pulse, int enc_num_pulse_btwn_samp, int num_samp, double vt[])
{
	/* Declare variables */
	int dev_open;
	int err;
	int i;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > PDI5025_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	pdi5025_error(msg);
    	return;
    }
    if (chan != 'A' && chan != 'B')
    {
    	Fmt(msg, "%s<chan = %c, must be A or B", chan);
    	pdi5025_error(msg);
    	return;
    }
    if (gain != 1 && gain != 2 && gain != 5 &&
    	gain != 10 && gain != 20 && gain != 50 &&
    	gain != 100 && gain != 200 && gain != 500 &&
    	gain != 1000)
    {
    	Fmt(msg, "%s<gain = %i, not allowed", gain);
    	pdi5025_error(msg);
    	return;
    }
    if (dir != '+' && dir != '-')
    {
    	Fmt(msg, "%s<dir = %c, must be + or -", dir);
    	pdi5025_error(msg);
    	return;
    }
    if (enc_start_pulse < -8388608 || enc_start_pulse > 8388608)
    {
    	Fmt(msg, "%s<enc_start_pulse = %li, out of range", enc_start_pulse);
    	pdi5025_error(msg);
    	return;
    }
    if (enc_num_pulse_btwn_samp < 1 || enc_num_pulse_btwn_samp > 10000)
    {
    	Fmt(msg, "%s<enc_num_pulse_btwn_samp = %i, out of range", enc_num_pulse_btwn_samp);
    	pdi5025_error(msg);
    	return;
    }
    if (num_samp < 1 || num_samp > 5000)
    {
    	Fmt(msg, "%s<num_samp = %i, out of range", num_samp);
    	pdi5025_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = pdi5025_check_dev_open(dev_ID);
    if (dev_open == 0)
    {
    	pdi5025_error("Instrument not open");
    	return;
    }
    
    /* Select the integrator channel */
    Fmt(cmd, "%s<CHA,%c", chan);
    //pdi5025_out(dev_ID, cmd);
    
    /* Set the gain */
    Fmt(cmd, "%s<SGA,%i", gain);
    pdi5025_out(dev_ID, cmd);
    
    /* Set the PDI5025 for cululated data storage */
    pdi5025_out(dev_ID, "CUM,1,S");
    
    /* Use block data transfer mode */
    pdi5025_out(dev_ID, "IMD,0");
														  
    /* Set up the integration intervals */
    Fmt(cmd, "%s<TRI,%c,%i/%i,%i", dir, 4 * enc_start_pulse, num_samp, 4 * enc_num_pulse_btwn_samp);
    pdi5025_out(dev_ID, cmd);
    
    /* Check for errors */
	err = pdi5025_get_errors(dev_ID);
    if (err != 0)
    {
        pdi5025_error("Problem with PDI5025");
        for (i = 0; i <= num_samp; i++) vt[i] = 0.;
        return;
    }
    
    /* Start the measurement */
    pdi5025_out(dev_ID, "RUN");
    
    /* Wait until the measurement is finished and the PDI is done processing the data */
	err = pdi5025_hold_until_end_of_run_and_data_ready(dev_ID);
    if (err != 0)
    {
        for (i = 0; i <= num_samp; i++) vt[i] = 0.;
        return;
    }
    
    /* Read the measurements */
	err = pdi5025_in_block(dev_ID, num_samp, vt);
    if (err != 0)
    {
        pdi5025_error("Problem getting VT samples");
        for (i = 0; i <= num_samp; i++) vt[i] = 0.;
        return;
    }
    
    /* Check for errors */
	err = pdi5025_get_errors(dev_ID);
    if (err != 0)
    {
        pdi5025_error("Problem with PDI5025");
        for (i = 0; i <= num_samp; i++) vt[i] = 0.;
		return;
    }
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	pdi5025_get_VT_linear_encoder_start
 *  This function starts taking n integrated voltage readings triggered by
 *	a linear encoder.
 *
 *	Input:
 *	dev_ID, device identifier
 *	chan, integrator channel, A or B
 *	gain, input amplifier gain, 1, 2, 5, 10, 20, 50, 100, 200, 500, 1000
 *	dir, direction, + or -
 *	enc_start_pulse, encoder pulse number (+ or -) relative to zero where the samples start
 *	num_enc_pulse_btwn_samp, number of encoder pulses between VT samples
 *	num_samp, number of integrated voltage samples
 *
 *	Zachary Wolf
 *	3/2/00
 */

void pdi5025_get_VT_linear_encoder_start(int dev_ID, char chan, int gain, char dir,
	long int enc_start_pulse, int enc_num_pulse_btwn_samp, int num_samp)
{
	/* Declare variables */
	int dev_open;
	int err;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > PDI5025_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	pdi5025_error(msg);
    	return;
    }
    if (chan != 'A' && chan != 'B')
    {
    	Fmt(msg, "%s<chan = %c, must be A or B", chan);
    	pdi5025_error(msg);
    	return;
    }
    if (gain != 1 && gain != 2 && gain != 5 &&
    	gain != 10 && gain != 20 && gain != 50 &&
    	gain != 100 && gain != 200 && gain != 500 &&
    	gain != 1000)
    {
    	Fmt(msg, "%s<gain = %i, not allowed", gain);
    	pdi5025_error(msg);
    	return;
    }
    if (dir != '+' && dir != '-')
    {
    	Fmt(msg, "%s<dir = %c, must be + or -", dir);
    	pdi5025_error(msg);
    	return;
    }
    if (enc_start_pulse < -8388608 || enc_start_pulse > 8388608)
    {
    	Fmt(msg, "%s<enc_start_pulse = %li, out of range", enc_start_pulse);
    	pdi5025_error(msg);
    	return;
    }
    if (enc_num_pulse_btwn_samp < 1 || enc_num_pulse_btwn_samp > 10000)
    {
    	Fmt(msg, "%s<enc_num_pulse_btwn_samp = %i, out of range", enc_num_pulse_btwn_samp);
    	pdi5025_error(msg);
    	return;
    }
    if (num_samp < 1 || num_samp > 5000)
    {
    	Fmt(msg, "%s<num_samp = %i, out of range", num_samp);
    	pdi5025_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = pdi5025_check_dev_open(dev_ID);
    if (dev_open == 0)
    {
    	pdi5025_error("Instrument not open");
    	return;
    }
    
    /* Select the integrator channel */
    Fmt(cmd, "%s<CHA,%c", chan);
    //pdi5025_out(dev_ID, cmd);
    
    /* Set the gain */
    Fmt(cmd, "%s<SGA,%i", gain);
    pdi5025_out(dev_ID, cmd);
    
    /* Set the PDI5025 for cululated data storage */
    pdi5025_out(dev_ID, "CUM,1,S");
    
    /* Use block data transfer mode */
    pdi5025_out(dev_ID, "IMD,0");
														  
    /* Set up the integration intervals */
    Fmt(cmd, "%s<TRI,%c,%i/%i,%i", dir, 4 * enc_start_pulse, num_samp, 4 * enc_num_pulse_btwn_samp);
    pdi5025_out(dev_ID, cmd);
    
    /* Check for errors */
	err = pdi5025_get_errors(dev_ID);
    if (err != 0)
    {
        pdi5025_error("Problem with PDI5025");
        return;
    }
    
    /* Start the measurement */
    pdi5025_out(dev_ID, "RUN");
   
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	pdi5025_get_VT_linear_encoder_finish
 *  This function collects n integrated voltage readings triggered by
 *	a linear encoder.
 *
 *	Input:
 *	dev_ID, device identifier
 *	num_samp, number of integrated voltage samples
 *
 *	Output:
 *	vt[0 to n], vt[0] = 0, vt[1 to n] = n measured integrated voltage samples
 *
 *	Zachary Wolf
 *	3/2/00
 */

void pdi5025_get_VT_linear_encoder_finish(int dev_ID, int num_samp, double vt[])
{
	/* Declare variables */
	int dev_open;
	int err;
	int i;
	double x;
	static int num_call = 0;
	double temp[5000];

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > PDI5025_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	pdi5025_error(msg);
    	return;
    }
    if (num_samp < 1 || num_samp > 5000)
    {
    	Fmt(msg, "%s<num_samp = %i, out of range", num_samp);
    	pdi5025_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	num_call++;
		for (i = 0; i <= num_samp; i++)
		{
			x = (i - num_samp/2.) / (num_samp/2.);
			x = x * .05;
			//vt[i] = x + pow(x, 2) + pow(x, 3);
			vt[i] = x;
		}
		for (i = num_samp; i >= 0; i--) vt[i] = vt[i] - vt[0];
		if (fmod((double)num_call, 2.) < .2)
		{
			for (i = 0; i <= num_samp; i++) temp[i] = vt[i];
			for (i = 0; i <= num_samp; i++) vt[i] = temp[num_samp - i]; 
			for (i = num_samp; i >= 0; i--) vt[i] = vt[i] - vt[0];
		}
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = pdi5025_check_dev_open(dev_ID);
    if (dev_open == 0)
    {
    	pdi5025_error("Instrument not open");
    	return;
    }
    
    /* Wait until the measurement is finished and the PDI is done processing the data */
	err = pdi5025_hold_until_end_of_run_and_data_ready(dev_ID);
    if (err != 0)
    {
        for (i = 0; i <= num_samp; i++) vt[i] = 0.;
        return;
    }
    
    /* Read the measurements */
	err = pdi5025_in_block(dev_ID, num_samp, vt);
    if (err != 0)
    {
        pdi5025_error("Problem getting VT samples");
        for (i = 0; i <= num_samp; i++) vt[i] = 0.;
        return;
    }
    
    /* Check for errors */
	err = pdi5025_get_errors(dev_ID);
    if (err != 0)
    {
        pdi5025_error("Problem with PDI5025");
        for (i = 0; i <= num_samp; i++) vt[i] = 0.;
		return;
    }
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	pdi5025_locate_index
 *  This function has the PDI5025 locate the encoder index pulse.
 *	The motor must be turning the encoder for this function to work.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Output:
 *	index, 1 if found index pulse, 0 otherwise
 *
 *	Zachary Wolf
 *	9/3/98
 */

int pdi5025_locate_index(int dev_ID)
{
	/* Declare variables */
	int dev_open;
    char status[PDI5025_MAX_CMD];
    enum {TRUE, FALSE} have_index;
    int num_tries = 0;
    int index;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > PDI5025_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	pdi5025_error(msg);
    	return 0;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return 1;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = pdi5025_check_dev_open(dev_ID);
    if (dev_open == 0)
    {
    	pdi5025_error("Instrument not open");
    	return 0;
    }
    
    /* Find the index pulse */
    pdi5025_out(dev_ID, "IND,+");
    
    /* Loop until the index if found */
    /* Check for errors in the status word */
    index = 0;
    have_index = FALSE;
    while (have_index == FALSE)
    {
    	pdi5025_get_status(dev_ID, 1, status);
    	if (status[7] == '1')		/* Register 1, bit 0, position 7, synchro */
    	{
    		have_index = TRUE;		/* Found index */
    		index = 1;
    	}
    	else
    	{
    		have_index = FALSE;		/* Have not found index */
    		Delay(.5);
    	}
    	if (status[2] == '1')		/* Register 1, bit 5, position 2, command error */
	    {
	    	pdi5025_error("Command error");
	    }
	    if (status[3] == '1')		/* Register 1, bit 4, position 3, overrange error */
	    {
	    	pdi5025_error("Overrange error");
	    }
	    num_tries++;
	    if (num_tries > 30) pdi5025_error("Having trouble finding index pulse");
    }
    
    /* Done */
    return index;
}

/*	**************************************************************  */
/*
 *	pdi5025_set_gain
 *  This function sets the gain of the integrator.
 *
 *	Input:
 *	dev_ID, device identifier
 *	chan, integrator channel, A or B
 *	gain, input amplifier gain, 1, 2, 5, 10, 20, 50, 100, 200, 500, 1000
 *
 *	Zachary Wolf
 *	9/3/98
 */

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

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > PDI5025_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	pdi5025_error(msg);
    	return;
    }
    if (chan != 'A' && chan != 'B')
    {
    	Fmt(msg, "%s<chan = %c, must be A or B", chan);
    	pdi5025_error(msg);
    	return;
    }
    if (gain != 1 && gain != 2 && gain != 5 &&
    	gain != 10 && gain != 20 && gain != 50 &&
    	gain != 100 && gain != 200 && gain != 500 &&
    	gain != 1000)
    {
    	Fmt(msg, "%s<gain = %i, not allowed", gain);
    	pdi5025_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = pdi5025_check_dev_open(dev_ID);
    if (dev_open == 0)
    {
    	pdi5025_error("Instrument not open");
    	return;
    }
    
    /* Select the integrator channel */
    Fmt(cmd, "%s<CHA,%c", chan);
    //pdi5025_out(dev_ID, cmd);
    
    /* Set the gain */
    Fmt(cmd, "%s<SGA,%i", gain);
    pdi5025_out(dev_ID, cmd);
    
    /* Check for errors */
	err = pdi5025_get_errors(dev_ID);
    if (err != 0)
    {
        pdi5025_error("Problem with PDI5025");
        return;
    }
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	pdi5025_zero_encoder_counter
 *  This function zeros the encoder pulse counter. 
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Zachary Wolf
 *	3/8/00
 */

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

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > PDI5025_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	pdi5025_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = pdi5025_check_dev_open(dev_ID);
    if (dev_open == 0)
    {
    	pdi5025_error("Instrument not open");
    	return;
    }
    
	/* Zero the encoder counter */
    pdi5025_out(dev_ID, "ZCT");
    
    /* Check for errors */
    pdi5025_get_errors(dev_ID);
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	pdi5025_get_encoder_count
 *  This function reads the encoder pulse counter. 
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Output:
 *	count, encoder pulse count, the PDI factor of 4 is taken out
 *
 *	Zachary Wolf
 *	3/8/00
 */

void pdi5025_get_encoder_count(int dev_ID, long int* count)
{
	/* Declare variables */
	int dev_open;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > PDI5025_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	pdi5025_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = pdi5025_check_dev_open(dev_ID);
    if (dev_open == 0)
    {
    	pdi5025_error("Instrument not open");
    	return;
    }
    
	/* Get the encoder count */
    pdi5025_out(dev_ID, "RCT");
    pdi5025_in(dev_ID, msg);
    Scan(msg, "%s>%i", count);
    *count = *count / 4;
    
    /* Check for errors */
    pdi5025_get_errors(dev_ID);
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	pdi5025_exit
 *  This function puts the PDI5025 in the desired state for exit
 *	and closes the device.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Zachary Wolf
 *	8/23/98
 */

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

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > PDI5025_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	pdi5025_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = pdi5025_check_dev_open(dev_ID);
    if (dev_open == 0)
    {
    	return;		 /* OK, already closed */
    }
    
    /* Set the gain of the PDI5025 to 1 */
    pdi5025_out(dev_ID, "SGA,*,1");

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

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

/*	PRIVATE FUNCTIONS  */

/*	**************************************************************  */
/*
 *	pdi5025_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
 *	8/23/98
 */

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

	/* Initialization */
    dev_ID = 0;

    /* Check to see if the device is already in the device table */
    for (i = 1; i <= PDI5025_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 <= PDI5025_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)
    {
    	pdi5025_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)
	{
		pdi5025_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)
    {
    	pdi5025_error("Problem clearing device");
    }
    
    /* Always perform GPIB addressing before read and write */
    err = ibconfig(dev_descr[dev_ID], IbcREADDR, 1);
    if (err & 0x8000)
    {
        pdi5025_error("Problem setting readdressing option");
    }
    
    /* Return the device dev_ID */
    return dev_ID;
}

/*	**************************************************************  */
/*
 *	pdi5025_close_dev
 *  This function closes the device and removes it from the GPIB
 *	device table.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Zachary Wolf
 *	9/2/98
 */

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

/*	**************************************************************  */
/*
 *	pdi5025_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 pdi5025_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 */
	}
}

/*	**************************************************************  */
/*
 *	pdi5025_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/29/98
 */

int pdi5025_out(int dev_ID, char* buf)
{
	/* Declare variables */
	char out_buf[PDI5025_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);
		pdi5025_error(msg);
		return -1;
	}
	
	/* Done */
    return 0;
}

/*	**************************************************************  */
/*
 *	pdi5025_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/23/98
 */

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

/*	**************************************************************  */
/*
 *	pdi5025_in_block
 *  This function reads a block of data from the integrator and puts
 *	the measured values in an array.
 *
 *	Input:
 *	dev_ID, device identifier
 *	num_samp, number of samples expected (error if we don't get this number)
 *
 *	Output:
 *	vt[], array of integrated voltage samples
 *	err, 0 if ok, -1 otherwise
 *
 *	Zachary Wolf
 *	8/23/98
 */

int pdi5025_in_block(int dev_ID, int num_samp, double vt[])
{
	/* Declare variables */
	int err;
	char in_buf[60000];		  /* Accept up to 5000 samples * 12 (10 + CR LF) bytes per sample */
	char samp_buf[20];
	int samp_index, buf_index;
	char in_char;
	int num_scan;
	double vt_val;
	char vt_chan;

	/* Temporarily set the end-of-string character to ctrl-Z (ASCII 26 or 1A hex) */
	err = ibeos(dev_descr[dev_ID], 0x141A);
	if (err & 0x8000)
	{
		Fmt(msg, "%s<ibsta = %x, problem receiving GPIB input", err);
		pdi5025_error(msg);
		return -1;
	}

	/* Read the data block */
	err = ibrd(dev_descr[dev_ID], in_buf, 60000);
	if (err & 0x8000)
	{
		Fmt(msg, "%s<ibsta = %x, problem receiving GPIB input", err);
		pdi5025_error(msg);
		return -1;
	}

	/* Reset the end-of-string character to LF (ASCII 10 or 0A hex) */
	err = ibeos(dev_descr[dev_ID], 0x140A);
	if (err & 0x8000)
	{
		Fmt(msg, "%s<ibsta = %x, problem receiving GPIB input", err);
		pdi5025_error(msg);
		return -1;
	}
	
	/* Fill the data array */
	samp_index = 0;
	buf_index = 0;
	num_scan = 0;
	vt[0] = 0;		/* Integral begins at 0 */
	while (1)		/* Loop over characters until ctrl-Z, then break */
	{
		in_char = in_buf[buf_index];		/* Go through input buffer */
		buf_index++;
		if (in_char == 26) break;			/* While exit on ctrl-Z */
		samp_buf[samp_index] = in_char;		/* Put each sample by itself in a buffer */
		samp_index++;
		if (samp_index > 18)				/* Protection */
		{
			pdi5025_error("pdi5025_in_block, data buffer format error");
			return -1;
		}
		if (in_char == 10)					/* Sample ends on LF */
		{
			samp_buf[samp_index] = 0;		/* Null terminate string */
	    	Scan(samp_buf, "%s[t13t00]>%f %c", &vt_val, &vt_chan);	/* Read to CR, extract vt value */
	    	num_scan++;						/* Sample number read so far, starts at 1 */
	    	vt[num_scan] = vt_val * 1.e-8;	/* Scale vt value, put in array */
	    	samp_index = 0;					/* Prepare for next sample */
	    }
	}
	
	/* Check the number of samples */
	if (num_scan != num_samp)
	{
		pdi5025_error("pdi5025_in_block, got wrong number of samples");
		return -1;
	}
	
	/* Done */
    return 0;
}

/*	**************************************************************  */
/*
 *	pdi5025_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/29/98
 */

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

	/* Register 1 */
    pdi5025_get_status(dev_ID, 1, status);
    
    /* Register 1, bit 5, position 2, command error */
    if (status[2] == '1')
    {
    	pdi5025_error("Command error");
    	err = -1;
    }
    
    /* Register 1, bit 4, position 3, overrange error */
    if (status[3] == '1')
    {
    	pdi5025_error("Overrange error");
    	err = -1;
    }

	/* Register 2 */
    pdi5025_get_status(dev_ID, 2, status);
    
    /* Register 2, bit 3, position 4, autotest failed */
    if (status[4] == '1')
    {
    	pdi5025_error("Autotest failed");
    	err = -1;
    }
    
    /* Register 2, bit 2, position 5, encoder count error */
    if (status[5] == '1')
    {
    	pdi5025_error("Encoder count error");
    	err = -1;
    }
    
    /* Register 2, bit 1, position 6, data buffer full */
    if (status[6] == '1')
    {
    	pdi5025_error("Data buffer full");
    	err = -1;
    }
    
    /* Register 2, bit 0, position 7, trigger too fast */
    if (status[7] == '1')
    {
    	pdi5025_error("Trigger too fast error");
    	err = -1;
    }

	/* Register 4 */
    pdi5025_get_status(dev_ID, 4, status);
    
    /* Register 4, bit 5, position 2, bit 4, position 3,
                   bit 1, position 6, bit 0, position 7, overrange error */
    if (status[2] == '1' || status[3] == '1' ||
        status[6] == '1' || status[7] == '1')
    {
    	pdi5025_error("Overrange error");
    	err = -1;
    }

	/* Register 5 */
    pdi5025_get_status(dev_ID, 5, status);
    
    /* Register 5, bits 0 to 4 indicate errors */
    if (status[3] == '1' || status[4] == '1' ||
        status[5] == '1' || status[6] == '1' || status[7] == '1')
    {
    	Fmt(msg, "%s<Register 5 error: %s", status);
    	pdi5025_error(msg);
    	err = -1;
    }

	/* Register 6 */
    pdi5025_get_status(dev_ID, 6, status);
    
    /* Register 6, bits 0 to 4 indicate errors */
    if (status[3] == '1' || status[4] == '1' ||
        status[5] == '1' || status[6] == '1' || status[7] == '1')
    {
    	Fmt(msg, "%s<Register 6 error: %s", status);
    	pdi5025_error(msg);
    	err = -1;
    }

    /* Done */
    return err;
}

/*	**************************************************************  */
/*
 *	pdi5025_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
 *	8/26/98
 */

int pdi5025_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);
		pdi5025_error(msg);
		return -1;
	}
	
	/* Return the result as an integer */
	Scan(&spoll_char, "%c>%i", spoll);

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

/*	**************************************************************  */
/*
 *	pdi5025_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
 *	8/31/98
 */

void pdi5025_get_status(int dev_ID, int reg, char* status)
{
	/* Declare variables */
	char status_cmd[PDI5025_MAX_CMD];
	
	/* Check the input parameters */
	if (reg < 1 || reg > 7)
	{
		Fmt(status_cmd, "%s<reg = %i, value out of range", reg);
		pdi5025_error(status_cmd);
		return;
	}
	
	/* Get the status register contents */
	Fmt(status_cmd, "%s<STB,%i", reg);
	pdi5025_out(dev_ID, status_cmd);
	pdi5025_in(dev_ID, status);
	
	/* Debug */
	/* printf("%i  %s\n", reg, status); */
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	pdi5025_hold_until_end_of_run_and_data_ready
 *  This function reads status register 1 in a loop until both the
 *	end of run bit and data ready bit are set.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Output:
 *	err, 0 if ok, 1 if there is a problem
 *
 *	Zachary Wolf
 *	9/18/98
 */

int pdi5025_hold_until_end_of_run_and_data_ready(int dev_ID)
{
	/* Declare variables */
    char status[PDI5025_MAX_CMD];
    enum {TRUE, FALSE} run_ended, data_ready;
    int counter;
    
    /* Loop until the run is ended and the data is ready */
    /* Check for errors in the status word */
    counter = 0;
    run_ended = FALSE;
    data_ready = FALSE;
    while (run_ended == FALSE || data_ready == FALSE)
    {
    	pdi5025_get_status(dev_ID, 1, status);
    	if (status[4] == '1')		/* Register 1, bit 3, position 4, end of run */
    	{
    		run_ended = TRUE;
    	}
    	if (status[5] == '1')		/* Register 1, bit 2, position 5, data ready */
    	{
    		data_ready = TRUE;
    	}
    	if (status[2] == '1')		/* Register 1, bit 5, position 2, command error */
	    {
	    	pdi5025_error("Command error");
	    }
	    if (status[3] == '1')		/* Register 1, bit 4, position 3, overrange error */
	    {
	    	pdi5025_error("Overrange error");
	    }
	    if (run_ended == FALSE || data_ready == FALSE) Delay(.2);
	    counter++;
	    if (counter >= 500) return 1;	/* Assume problem after 100 seconds */ 
    }
    
    /* Done */
    return 0;
}

/*	**************************************************************  */
/*
 *	pdi5025_hold_until_data_ready
 *  This function reads status register 1 in a loop until the
 *	data ready bit is set.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Zachary Wolf
 *	8/31/98
 */

void pdi5025_hold_until_data_ready(int dev_ID)
{
	/* Declare variables */
    char status[PDI5025_MAX_CMD];
    enum {TRUE, FALSE} busy;
    
    /* Loop while busy */
    /* Check for errors in the status word */
    busy = TRUE;
    while (busy == TRUE)
    {
    	pdi5025_get_status(dev_ID, 1, status);
    	if (status[5] == '1')
    	{
    		busy = FALSE;			/* Data ready */
    	}
    	else
    	{
    		busy = TRUE;			/* Data not ready */
    		Delay(.1);
    	}
    	if (status[2] == '1')		/* Register 1, bit 5, position 2, command error */
	    {
	    	pdi5025_error("Command error");
	    }
	    if (status[3] == '1')		/* Register 1, bit 4, position 3, overrange error */
	    {
	    	pdi5025_error("Overrange error");
	    }
    }
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	pdi5025_hold_until_end_of_run
 *  This function reads status register 1 in a loop until the
 *	end of run bit is set.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Zachary Wolf
 *	9/1/98
 */

void pdi5025_hold_until_end_of_run(int dev_ID)
{
	/* Declare variables */
    char status[PDI5025_MAX_CMD];
    enum {TRUE, FALSE} busy;
    
    /* Loop while busy */
    /* Check for errors in the status word */
    busy = TRUE;
    while (busy == TRUE)
    {
    	pdi5025_get_status(dev_ID, 1, status);
    	if (status[4] == '1')
    	{
    		busy = FALSE;			/* End of run */
    	}
    	else
    	{
    		busy = TRUE;			/* Run not finished */
    		Delay(.5);
    	}
    	if (status[2] == '1')		/* Register 1, bit 5, position 2, command error */
	    {
	    	pdi5025_error("Command error");
	    }
	    if (status[3] == '1')		/* Register 1, bit 4, position 3, overrange error */
	    {
	    	pdi5025_error("Overrange error");
	    }
    }
    
    /* Done */
    return;
}

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

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

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

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

/*	**************************************************************  */
/*
 *	pdi5025_generate_samples
 *  This function generates integrated voltage samples to use while
 *	debugging software.
 *
 *	Input:
 *	rot_dir, rotation direction, + or -
 *	num_samp_per_rev, number of integrated voltage samples per revolution
 *	num_samp, number of integrated voltage samples
 *
 *	Output:
 *	vt[0 to n], vt[0] = 0, vt[1 to n] = n measured integrated voltage samples
 *
 *	Zachary Wolf
 *	9/3/98
 */

void pdi5025_generate_samples(char rot_dir, int num_samp_per_rev,
	int num_samp, double vt[])
{
	/* Declare variables */
	int i;
	double pi = 3.1415927;
	double ramp_ampl;
	double* rev_vt;
	
	/* Message */
	//pdi5025_message("Generating fake data for testing...");
	
	/* Generate samples */
	/*
	vt(t) = A_n * [cos(nwt + phi_n) - cos(phi_n)] , subtract constant so vt starts at 0
	fft_n = A_n * e^(j phi_n)
	*/
	vt[0] = 0.;
	for (i = 1; i <= num_samp; i++)
	{
		vt[i] = 0.;
		vt[i] = vt[i] + 1. * (1. / 1.) * (cos(1. * 2. * 3.141593 * i / num_samp_per_rev - 1. * (-1. * pi / 1. - pi/18.) - pi / 2.) - cos( - 1. * (-1. * pi / 1. - pi/18.) - pi / 2.));
		vt[i] = vt[i] + .2 * (1. / 2.) * (cos(2. * 2. * 3.141593 * i / num_samp_per_rev - 2. * (-1. * pi / 2. - pi/18.) - pi / 2.) - cos( - 2. * (-1. * pi / 2. - pi/18.) - pi / 2.));
		vt[i] = vt[i] + .3 * (1. / 3.) * (cos(3. * 2. * 3.141593 * i / num_samp_per_rev - 3. * (-1. * pi / 3. - pi/18.) - pi / 2.) - cos( - 3. * (-1. * pi / 3. - pi/18.) - pi / 2.));
		vt[i] = vt[i] + .4 * (1. / 4.) * (cos(4. * 2. * 3.141593 * i / num_samp_per_rev - 4. * (-1. * pi / 4. - pi/18.) - pi / 2.) - cos( - 4. * (-1. * pi / 4. - pi/18.) - pi / 2.));
	}
	
	/* Reverse the vt array if the rotation direction is negative */
	if (rot_dir == '-')
	{
		rev_vt = malloc((num_samp + 1) * sizeof(double));
		for (i = 0; i <= num_samp; i++) rev_vt[i] = vt[num_samp - i];
		for (i = 0; i <= num_samp; i++) vt[i] = rev_vt[i];
		free(rev_vt);
	}
	
	/* Set parameters */
	//ramp_ampl = .5;
	
	/* Add a ramp for integrator offset */
	//for (i = 0; i <= num_samp; i++)
	//{
	//	vt[i] = vt[i] + i * ramp_ampl / num_samp;
	//}
	
	/* Add a bad point to test data-check function */
	/* vt[10] = 5.; */
	
	/* Done */
	return;
}