/*	**************************************************************  */
/*
 *	Module TDS754D
 *	This module contains I/O functions for the Tektronix TDS754D
 *	oscilloscope.
 *
 *	Zachary Wolf
 *	5/18/01
 */ 

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

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

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

/*  PRIVATE FUNCTIONS  */
int tds754d_open_dev(int gpib_board_addr, int gpib_dev_addr);
void tds754d_close_dev(int dev_ID);
int tds754d_out(int dev_ID, char* buf);
int tds754d_in(int dev_ID, char* buf);
int tds754d_in_waveform(int dev_ID, char* buf);
int tds754d_check_device_open(int dev_ID);
int tds754d_get_errors(int dev_ID);
void tds754d_message(char* msg);
void tds754d_error(char* msg);

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

/*	PRIVATE DEVICE TABLE  */
/*
 *	This table allows several devices of the same type to be
 *	used in the system.
 *  dev_addr, contains the GPIB addresses of opened devices
 *  dev_descr, contains the device descriptors of opened devices
 *  dev_count, contains the number of devices open of this type
 */
static int dev_addr[TDS754D_MAX_NUM_DEV + 1];
static int dev_descr[TDS754D_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[TDS754D_MAX_CMD + 1];
static char msg[TDS754D_MAX_CMD + 1];

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

/*	PUBLIC FUNCTIONS  */

/*	**************************************************************  */
/*
 *  tds754d_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 conected 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
 *	5/18/01
 */

void tds754d_init(int gpib_board_addr, int gpib_dev_addr, int* ID)
{
    /* Declare variables */
    int dev_ID;
    int err;
    
    /* Message */
    tds754d_message("");
    tds754d_message("Initializing the TDS754D...");

    /* 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);
    	tds754d_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);
    	tds754d_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	*ID = 1;
    	return;
    #endif
    
    /* Open the TDS754D */
    dev_ID = tds754d_open_dev(gpib_board_addr, gpib_dev_addr);
    if (dev_ID <= 0)
    {
        tds754d_error("Device was not opened");
        return;
    }
    
    /* Allow all bits of the device event status enable register */
    tds754d_out(dev_ID, "DESE 255");
    
    /* Don't use service requests */
    tds754d_out(dev_ID, "*ESE 0");
    tds754d_out(dev_ID, "*SRE 0");
    
    /* Get the ID */
    tds754d_out(dev_ID, "*IDN?");
    err = tds754d_in(dev_ID, cmd);
    if (err != 0)
    {
        tds754d_error("Problem reading ID");
        tds754d_close_dev(dev_ID);
        return;
    }
    tds754d_message(cmd);
    
    /* Check for errors */
    err = tds754d_get_errors(dev_ID);
    if (err != 0)
    {
        tds754d_error("The device has an error");
        tds754d_close_dev(dev_ID);
        return;
    }

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

/*	**************************************************************  */
/*
 *	tds754d_factory_setup
 *  This function sets up the oscilloscope with the factory
 *	initialization settings.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Zachary Wolf
 *	5/25/01
 */

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

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > TDS754D_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	tds754d_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = tds754d_check_device_open(dev_ID);
    if (dev_open != 1)
    {
    	tds754d_error("Device not open");
    	return;
    }
    
    /* Set the scope to its factory settings */
    tds754d_out(dev_ID, "FACTORY");
    
    /* Check for errors */
    err = tds754d_get_errors(dev_ID);
    if (err != 0)
    {
        tds754d_error("The device has an error");
        tds754d_close_dev(dev_ID);
        return;
    }
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	tds754d_set_vert_scale
 *  This function sets the scale factor of the specified channel.
 *
 *	Input:
 *	dev_ID, device identifier
 *	chan, channel number (1 to 4) to get the waveform from
 *	scale, scale factor (V/div)
 *
 *	Zachary Wolf
 *	5/25/01
 */

void tds754d_set_vert_scale(int dev_ID, int chan, double scale)
{
	/* Declare variables */
	int dev_open;
	int err;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > TDS754D_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	tds754d_error(msg);
    	return;
    }
    if (chan < 1 || chan > 4)
    {
    	Fmt(msg, "%s<chan = %i, out of range", chan);
    	tds754d_error(msg);
    	return;
    }
    if (scale < .001 || scale > 10.)
    {
    	Fmt(msg, "%s<scale = %f, out of range", scale);
    	tds754d_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = tds754d_check_device_open(dev_ID);
    if (dev_open != 1)
    {
    	tds754d_error("Device not open");
    	return;
    }
    
    /* Set the scale factor of the specified channel */
    Fmt(cmd, "%s<CH%i:SCALE %f", chan, scale);
    tds754d_out(dev_ID, cmd);
    
    /* Check for errors */
    err = tds754d_get_errors(dev_ID);
    if (err != 0)
    {
        tds754d_error("The device has an error");
        tds754d_close_dev(dev_ID);
        return;
    }
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	tds754d_set_vert_position
 *  This function sets the display position of the specified channel.
 *
 *	Input:
 *	dev_ID, device identifier
 *	chan, channel number (1 to 4) to get the waveform from
 *	position, position of the waveform from the center graticule (div)
 *
 *	Zachary Wolf
 *	5/25/01
 */

void tds754d_set_vert_position(int dev_ID, int chan, double position)
{
	/* Declare variables */
	int dev_open;
	int err;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > TDS754D_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	tds754d_error(msg);
    	return;
    }
    if (chan < 1 || chan > 4)
    {
    	Fmt(msg, "%s<chan = %i, out of range", chan);
    	tds754d_error(msg);
    	return;
    }
    if (position < -5. || position > 5.)
    {
    	Fmt(msg, "%s<position = %f, out of range", position);
    	tds754d_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = tds754d_check_device_open(dev_ID);
    if (dev_open != 1)
    {
    	tds754d_error("Device not open");
    	return;
    }
    
    /* Set the display position of the specified channel */
    Fmt(cmd, "%s<CH%i:POSITION %f", chan, position);
    tds754d_out(dev_ID, cmd);
    
    /* Check for errors */
    err = tds754d_get_errors(dev_ID);
    if (err != 0)
    {
        tds754d_error("The device has an error");
        tds754d_close_dev(dev_ID);
        return;
    }
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	tds754d_set_vert_coupling
 *  This function sets the coupling of the specified channel.
 *
 *	Input:
 *	dev_ID, device identifier
 *	chan, channel number (1 to 4) to get the waveform from
 *	coupling, channel coupling (AC, DC, or GND)
 *
 *	Zachary Wolf
 *	11/28/01
 */

void tds754d_set_vert_coupling(int dev_ID, int chan, enum vert_coupling_enum coupling)
{
	/* Declare variables */
	int dev_open;
	int err;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > TDS754D_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	tds754d_error(msg);
    	return;
    }
    if (chan < 1 || chan > 4)
    {
    	Fmt(msg, "%s<chan = %i, out of range", chan);
    	tds754d_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = tds754d_check_device_open(dev_ID);
    if (dev_open != 1)
    {
    	tds754d_error("Device not open");
    	return;
    }
    
    /* Set the coupling of the specified channel */
    if      (coupling == AC)
    	Fmt(cmd, "%s<CH%i:COUPLING AC", chan);
    else if (coupling == DC)
    	Fmt(cmd, "%s<CH%i:COUPLING DC", chan);
    else if (coupling == GND)
    	Fmt(cmd, "%s<CH%i:COUPLING GND", chan);
    else
    {
        tds754d_error("A parameter value has an error");
        tds754d_close_dev(dev_ID);
        return;
    }
    tds754d_out(dev_ID, cmd);
    
    /* Check for errors */
    err = tds754d_get_errors(dev_ID);
    if (err != 0)
    {
        tds754d_error("The device has an error");
        tds754d_close_dev(dev_ID);
        return;
    }
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	tds754d_set_vert_chan_select
 *  This function turns a channel on or off.  If it is turned on,
 *	it is the selected waveform.
 *
 *	Input:
 *	dev_ID, device identifier
 *	chan, channel number (1 to 4) to get the waveform from
 *	select, channel select status (ON or OFF)
 *
 *	Zachary Wolf
 *	11/28/01
 */

void tds754d_set_vert_chan_select(int dev_ID, int chan, enum vert_select_enum select)
{
	/* Declare variables */
	int dev_open;
	int err;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > TDS754D_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	tds754d_error(msg);
    	return;
    }
    if (chan < 1 || chan > 4)
    {
    	Fmt(msg, "%s<chan = %i, out of range", chan);
    	tds754d_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = tds754d_check_device_open(dev_ID);
    if (dev_open != 1)
    {
    	tds754d_error("Device not open");
    	return;
    }
    
    /* Set the select status of the specified channel */
    if      (select == ON)
    	Fmt(cmd, "%s<SELECT:CH%i ON", chan);
    else if (select == OFF)
    	Fmt(cmd, "%s<SELECT:CH%i OFF", chan);
    else
    {
        tds754d_error("A parameter value has an error");
        tds754d_close_dev(dev_ID);
        return;
    }
    tds754d_out(dev_ID, cmd);
    
    /* Check for errors */
    err = tds754d_get_errors(dev_ID);
    if (err != 0)
    {
        tds754d_error("The device has an error");
        tds754d_close_dev(dev_ID);
        return;
    }
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	tds754d_set_horiz_scale
 *  This function sets the horizontal scale factor (time per division).
 *	The tds754d chooses the closest scale factor in a 1-2-5 sequence.
 *	"In extended-acquisition-length mode, no matter what value you set,
 *	the oscilloscope will only use the closest real-time,
 *	non-interpolated value."  (From the manual.  You don't get the
 *	value requested unless you use a record length of 500.)
 *
 *	Input:
 *	dev_ID, device identifier
 *	scale, scale factor (sec/div)
 *
 *	Zachary Wolf
 *	11/28/01
 */

void tds754d_set_horiz_scale(int dev_ID, double scale)
{
	/* Declare variables */
	int dev_open;
	int err;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > TDS754D_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	tds754d_error(msg);
    	return;
    }
    if (scale < 500.e-12 || scale > 10.)
    {
    	Fmt(msg, "%s<scale = %f, out of range", scale);
    	tds754d_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = tds754d_check_device_open(dev_ID);
    if (dev_open != 1)
    {
    	tds754d_error("Device not open");
    	return;
    }
    
    /* Set the horizontal scale factor */
    Fmt(cmd, "%s<HORIZONTAL:MAIN:SCALE %f", scale);
    tds754d_out(dev_ID, cmd);
    
    /* Check for errors */
    err = tds754d_get_errors(dev_ID);
    if (err != 0)
    {
        tds754d_error("The device has an error");
        tds754d_close_dev(dev_ID);
        return;
    }
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	tds754d_set_horiz_record_length
 *  This function sets the horizontal record length.
 *
 *	Input:
 *	dev_ID, device identifier
 *	record_length, the number of data points aquired for each record
 *
 *	Zachary Wolf
 *	11/28/01
 */

void tds754d_set_horiz_record_length(int dev_ID, long int record_length)
{
	/* Declare variables */
	int dev_open;
	int err;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > TDS754D_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	tds754d_error(msg);
    	return;
    }
    if (record_length != 500  && record_length != 1000 &&
    	record_length != 2500 && record_length != 5000 &&
    	record_length != 15000 && record_length != 50000 &&
    	record_length != 75000 && record_length != 100000)
    {
    	Fmt(msg, "%s<record_length = %i, out of range", record_length);
    	tds754d_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = tds754d_check_device_open(dev_ID);
    if (dev_open != 1)
    {
    	tds754d_error("Device not open");
    	return;
    }
    
    /* Set the horizontal record length */
    Fmt(cmd, "%s<HORIZONTAL:RECORDLENGTH %i", record_length);
    tds754d_out(dev_ID, cmd);
    
    /* Check for errors */
    err = tds754d_get_errors(dev_ID);
    if (err != 0)
    {
        tds754d_error("The device has an error");
        tds754d_close_dev(dev_ID);
        return;
    }
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	tds754d_set_horiz_trigger_position
 *  This function sets the trigger position in the data record.
 *
 *	Input:
 *	dev_ID, device identifier
 *	trigger_position, position in the record where the trigger occurs (0 to 100%)
 *
 *	Zachary Wolf
 *	11/28/01
 */

void tds754d_set_horiz_trigger_position(int dev_ID, int trigger_position)
{
	/* Declare variables */
	int dev_open;
	int err;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > TDS754D_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	tds754d_error(msg);
    	return;
    }
    if (trigger_position < 0  || trigger_position > 100)
    {
    	Fmt(msg, "%s<trigger_position = %i, out of range", trigger_position);
    	tds754d_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = tds754d_check_device_open(dev_ID);
    if (dev_open != 1)
    {
    	tds754d_error("Device not open");
    	return;
    }
    
    /* Set the horizontal trigger position */
    Fmt(cmd, "%s<HORIZONTAL:TRIGGER:POSITION %i", trigger_position);
    tds754d_out(dev_ID, cmd);
    
    /* Check for errors */
    err = tds754d_get_errors(dev_ID);
    if (err != 0)
    {
        tds754d_error("The device has an error");
        tds754d_close_dev(dev_ID);
        return;
    }
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	tds754d_set_horiz_fit_to_screen
 *  This function allows the entire waveform to be viewed on the screen.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Zachary Wolf
 *	6/19/02
 */

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

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > TDS754D_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	tds754d_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = tds754d_check_device_open(dev_ID);
    if (dev_open != 1)
    {
    	tds754d_error("Device not open");
    	return;
    }
    
    /* Turn on the fit to screen function */
    tds754d_out(dev_ID, "HORIZONTAL:FITTOSCREEN ON");
    
    /* Check for errors */
    err = tds754d_get_errors(dev_ID);
    if (err != 0)
    {
        tds754d_error("The device has an error");
        tds754d_close_dev(dev_ID);
        return;
    }
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	tds754d_set_trig_mode
 *  This function sets the trigger mode to either normal or auto.
 *
 *	Input:
 *	dev_ID, device identifier
 *	mode, trigger mode (AUTO or NORM)
 *
 *	Zachary Wolf
 *	11/28/01
 */

void tds754d_set_trig_mode(int dev_ID, enum trig_mode_enum mode)
{
	/* Declare variables */
	int dev_open;
	int err;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > TDS754D_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	tds754d_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = tds754d_check_device_open(dev_ID);
    if (dev_open != 1)
    {
    	tds754d_error("Device not open");
    	return;
    }
    
    /* Set the trigger mode */
    if      (mode == AUTO)
    	Fmt(cmd, "%s<TRIGGER:MAIN:MODE AUTO");
    else if (mode == NORM)
    	Fmt(cmd, "%s<TRIGGER:MAIN:MODE NORM");
    else
    {
        tds754d_error("A parameter value has an error");
        tds754d_close_dev(dev_ID);
        return;
    }
    tds754d_out(dev_ID, cmd);
    
    /* Check for errors */
    err = tds754d_get_errors(dev_ID);
    if (err != 0)
    {
        tds754d_error("The device has an error");
        tds754d_close_dev(dev_ID);
        return;
    }
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	tds754d_set_trig_edge
 *  This function makes the oscilloscope use edge triggering.  Parameters
 *	set the details of the triggering.
 *
 *	Input:
 *	dev_ID, device identifier
 *	source, trigger source (CH1, CH2, CH3, CH4, LINE, AUX)
 *	coupling, trigger coupling (TAC, TDC, HFREJ, LFREJ, NOISEREJ)
 *	slope, slope of the edge (FALL, RISE)
 *
 *	Zachary Wolf
 *	11/28/01
 */

void tds754d_set_trig_edge(int dev_ID, enum trig_source_enum source, enum trig_coupling_enum coupling, enum trig_slope_enum slope)
{
	/* Declare variables */
	int dev_open;
	int err;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > TDS754D_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	tds754d_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = tds754d_check_device_open(dev_ID);
    if (dev_open != 1)
    {
    	tds754d_error("Device not open");
    	return;
    }
    
    /* Set the trigger source */
    if      (source == CH1)
    	Fmt(cmd, "%s<TRIGGER:MAIN:EDGE:SOURCE CH1");
    else if (source == CH2)
    	Fmt(cmd, "%s<TRIGGER:MAIN:EDGE:SOURCE CH2");
    else if (source == CH3)
    	Fmt(cmd, "%s<TRIGGER:MAIN:EDGE:SOURCE CH3");
    else if (source == CH4)
    	Fmt(cmd, "%s<TRIGGER:MAIN:EDGE:SOURCE CH4");
    else if (source == LINE)
    	Fmt(cmd, "%s<TRIGGER:MAIN:EDGE:SOURCE LINE");
    else if (source == AUX)
    	Fmt(cmd, "%s<TRIGGER:MAIN:EDGE:SOURCE AUX");
    else
    {
        tds754d_error("A parameter value has an error");
        tds754d_close_dev(dev_ID);
        return;
    }
    tds754d_out(dev_ID, cmd);
    
    /* Set the trigger coupling */
    if      (coupling == TAC)
    	Fmt(cmd, "%s<TRIGGER:MAIN:EDGE:COUPLING AC");
    else if (coupling == TDC)
    	Fmt(cmd, "%s<TRIGGER:MAIN:EDGE:COUPLING DC");
    else if (coupling == HFREJ)
    	Fmt(cmd, "%s<TRIGGER:MAIN:EDGE:COUPLING HFREJ");
    else if (coupling == LFREJ)
    	Fmt(cmd, "%s<TRIGGER:MAIN:EDGE:COUPLING LFREJ");
    else if (coupling == NOISEREJ)
    	Fmt(cmd, "%s<TRIGGER:MAIN:EDGE:COUPLING NOISEREJ");
    else
    {
        tds754d_error("A parameter value an error");
        tds754d_close_dev(dev_ID);
        return;
    }
    tds754d_out(dev_ID, cmd);
    
    /* Set the trigger slope */
    if      (slope == FALL)
    	Fmt(cmd, "%s<TRIGGER:MAIN:EDGE:SLOPE FALL");
    else if (slope == RISE)
    	Fmt(cmd, "%s<TRIGGER:MAIN:EDGE:SLOPE RISE");
    else
    {
        tds754d_error("A parameter value an error");
        tds754d_close_dev(dev_ID);
        return;
    }
    tds754d_out(dev_ID, cmd);
    
    /* Check for errors */
    err = tds754d_get_errors(dev_ID);
    if (err != 0)
    {
        tds754d_error("The device has an error");
        tds754d_close_dev(dev_ID);
        return;
    }
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	tds754d_set_trig_holdoff
 *  This function sets the holdoff parameters of the trigger.
 *
 *	Input:
 *	dev_ID, device identifier
 *	holdoff_by, trigger holdoff by (TIME, DEFAULT)
 *	holdoff_time, holdoff time (sec), used only if trigger holdoff by TIME
 *
 *	Zachary Wolf
 *	11/28/01
 */

void tds754d_set_trig_holdoff(int dev_ID, enum trig_holdoff_by_enum by, double holdoff_time)
{
	/* Declare variables */
	int dev_open;
	int err;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > TDS754D_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	tds754d_error(msg);
    	return;
    }
    if (holdoff_time < 250.e-9  || holdoff_time > 12.)
    {
    	Fmt(msg, "%s<holdoff_time = %f, out of range", holdoff_time);
    	tds754d_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = tds754d_check_device_open(dev_ID);
    if (dev_open != 1)
    {
    	tds754d_error("Device not open");
    	return;
    }
    
    /* Set the trigger holdoff by */
    if      (by == TIME)
    {
    	Fmt(cmd, "%s<TRIGGER:MAIN:HOLDOFF:BY TIME");
    	tds754d_out(dev_ID, cmd);
    	Fmt(cmd, "%s<TRIGGER:MAIN:HOLDOFF:TIME %f", holdoff_time);
    	tds754d_out(dev_ID, cmd);
    }
    else if (by == DEFAULT)
    {
    	Fmt(cmd, "%s<TRIGGER:MAIN:HOLDOFF:BY DEFAULT");
    	tds754d_out(dev_ID, cmd);
    }
    else
    {
        tds754d_error("A parameter value has an error");
        tds754d_close_dev(dev_ID);
        return;
    }
    
    /* Check for errors */
    err = tds754d_get_errors(dev_ID);
    if (err != 0)
    {
        tds754d_error("The device has an error");
        tds754d_close_dev(dev_ID);
        return;
    }
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	tds754d_set_trig_level
 *  This function sets the trigger level.
 *
 *	Input:
 *	dev_ID, device identifier
 *	trigger_level, trigger level (V)
 *
 *	Zachary Wolf
 *	11/28/01
 */

void tds754d_set_trig_level(int dev_ID, double trigger_level)
{
	/* Declare variables */
	int dev_open;
	int err;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > TDS754D_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	tds754d_error(msg);
    	return;
    }
    if (trigger_level < -10.  || trigger_level > 10.)
    {
    	Fmt(msg, "%s<trigger_level = %f, out of range", trigger_level);
    	tds754d_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = tds754d_check_device_open(dev_ID);
    if (dev_open != 1)
    {
    	tds754d_error("Device not open");
    	return;
    }
    
    /* Set the trigger level */
    Fmt(cmd, "%s<TRIGGER:MAIN:LEVEL %f", trigger_level);
    tds754d_out(dev_ID, cmd);
    
    /* Check for errors */
    err = tds754d_get_errors(dev_ID);
    if (err != 0)
    {
        tds754d_error("The device has an error");
        tds754d_close_dev(dev_ID);
        return;
    }
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	tds754d_set_acq_mode
 *  This function sets the acquisition mode of the oscilloscope
 *
 *	Input:
 *	dev_ID, device identifier
 *	mode, acquisition mode (SAMPLE, PEAKDETECT, HIRES, AVERAGE, ENVELOPE)
 *
 *	Zachary Wolf
 *	11/28/01
 */

void tds754d_set_acq_mode(int dev_ID, enum acq_mode_enum mode)
{
	/* Declare variables */
	int dev_open;
	int err;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > TDS754D_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	tds754d_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = tds754d_check_device_open(dev_ID);
    if (dev_open != 1)
    {
    	tds754d_error("Device not open");
    	return;
    }
    
    /* Set the acquisition mode */
    if      (mode == SAMPLE)
    	Fmt(cmd, "%s<ACQUIRE:MODE SAMPLE");
    else if (mode == PEAKDETECT)
    	Fmt(cmd, "%s<ACQUIRE:MODE PEAKDETECT");
    else if (mode == HIRES)
    	Fmt(cmd, "%s<ACQUIRE:MODE HIRES");
    else if (mode == AVERAGE)
    	Fmt(cmd, "%s<ACQUIRE:MODE AVERAGE");
    else if (mode == ENVELOPE)
    	Fmt(cmd, "%s<ACQUIRE:MODE ENVELOPE");
    else
    {
        tds754d_error("A parameter value has an error");
        tds754d_close_dev(dev_ID);
        return;
    }
    tds754d_out(dev_ID, cmd);
    
    /* In average and envelope modes, set default values */
    if (mode == AVERAGE)
	    tds754d_out(dev_ID, "ACQUIRE:NUMAVG 10");
    if (mode == ENVELOPE)
	    tds754d_out(dev_ID, "ACQUIRE:NUMENV 10");
    
    /* Check for errors */
    err = tds754d_get_errors(dev_ID);
    if (err != 0)
    {
        tds754d_error("The device has an error");
        tds754d_close_dev(dev_ID);
        return;
    }
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	tds754d_set_acq_num_ave
 *  This function sets the number of acquisitions for averaging
 *	when the acquisition mode is set to averaging.
 *
 *	Input:
 *	dev_ID, device identifier
 *	num_ave, number of acquisitions for averaging (2 to 10000)
 *
 *	Zachary Wolf
 *	11/28/01
 */

void tds754d_set_acq_num_ave(int dev_ID, int num_ave)
{
	/* Declare variables */
	int dev_open;
	int err;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > TDS754D_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	tds754d_error(msg);
    	return;
    }
    if (num_ave < 2  || num_ave > 10000)
    {
    	Fmt(msg, "%s<num_ave = %i, out of range", num_ave);
    	tds754d_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = tds754d_check_device_open(dev_ID);
    if (dev_open != 1)
    {
    	tds754d_error("Device not open");
    	return;
    }
    
    /* Set the number of acquisitions for averaging */
    Fmt(cmd, "%s<ACQUIRE:NUMAVG %i", num_ave);
    tds754d_out(dev_ID, cmd);
    
    /* Check for errors */
    err = tds754d_get_errors(dev_ID);
    if (err != 0)
    {
        tds754d_error("The device has an error");
        tds754d_close_dev(dev_ID);
        return;
    }
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	tds754d_get_waveform
 *  This function gets a waveform from the oscilloscope.
 *
 *	Input:
 *	dev_ID, device identifier
 *	chan, channel number (1 to 4) to get the waveform from
 *
 *	Output:
 *	num_samp, number of samples in the waveform
 *	t[0 to num_pts - 1], time of each sample relative to the trigger (sec)
 *	v[0 to num_pts - 1], voltage value of each sample (V)
 *
 *	Zachary Wolf
 *	5/21/01
 */

void tds754d_get_waveform(int dev_ID, int chan, long int* num_samp, double t[], double v[])
{
	/* Declare variables */
	int dev_open;
	int err;
	long int rec_len;
	char data_string[TDS754D_MAX_WAVEFORM];
	long int num_pts;
	int num_scan;
	double y_off, y_mult;
	double x_incr;
	long int pt_off;
	int i;
	int chan_rtn;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > TDS754D_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	tds754d_error(msg);
    	return;
    }
    if (chan < 1 || chan > 4)
    {
    	Fmt(msg, "%s<chan = %i, out of range", chan);
    	tds754d_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = tds754d_check_device_open(dev_ID);
    if (dev_open != 1)
    {
    	tds754d_error("Device not open");
    	return;
    }
     
    /* Get the record length of the waveform */
    tds754d_out(dev_ID, "HORIZONTAL:RECORDLENGTH?");
    tds754d_in(dev_ID, msg);
    num_scan = Scan(msg, "%s[x]>:HOR:RECO %i", &rec_len);
    if (num_scan != 1) tds754d_error("tds754d_get_waveform: Problem reading rec_len");
    
    /* Setup to read the waveform */
    Fmt(cmd, "%s<DATA:SOURCE CH%i", chan);
    tds754d_out(dev_ID, cmd);
    tds754d_out(dev_ID, "DATA:ENCDG ASCII");
    tds754d_out(dev_ID, "DATA:WIDTH 1");
    tds754d_out(dev_ID, "DATA:START 1");
    Fmt(cmd, "%s<DATA:STOP %i", rec_len);
    tds754d_out(dev_ID, cmd);
    
    /* Get the waveform */
    tds754d_out(dev_ID, "CURVE?");
    tds754d_in_waveform(dev_ID, data_string);
     
    /* Get the number of points in the waveform */
    Fmt(cmd, "%s<WFMPRE:CH%i:NR_PT?", chan);
    tds754d_out(dev_ID, cmd);
    tds754d_in(dev_ID, msg);
    num_scan = Scan(msg, "%s[x]>:WFMP:CH%i[w1]:NR_P %i", &chan_rtn, &num_pts);
    if (num_scan != 2) tds754d_error("tds754d_get_waveform: Problem reading num_pts");
    if (chan_rtn != chan) tds754d_error("tds754d_get_waveform: Problem reading num_pts");
    
    /* Extract the raw voltage values */
    num_scan = Scan(data_string, "%s[x]>:CURV %*f[x]", num_pts, v);
    if (num_scan != 1) tds754d_error("tds754d_get_waveform: problem reading raw v");
    
    /* Get the Y offset value */
    Fmt(cmd, "%s<WFMPRE:CH%i:YOFF?", chan);
    tds754d_out(dev_ID, cmd);
    tds754d_in(dev_ID, msg);
    num_scan = Scan(msg, "%s[x]>:WFMP:CH%i[w1]:YOF %f", &chan_rtn, &y_off);
    if (num_scan != 2) tds754d_error("tds754d_get_waveform: Problem reading y_off");
    if (chan_rtn != chan) tds754d_error("tds754d_get_waveform: Problem reading y_off");
    
    /* Get the Y multiplier value */
    Fmt(cmd, "%s<WFMPRE:CH%i:YMULT?", chan);
    tds754d_out(dev_ID, cmd);
    tds754d_in(dev_ID, msg);
    num_scan = Scan(msg, "%s[x]>:WFMP:CH%i[w1]:YMU %f", &chan_rtn, &y_mult);
    if (num_scan != 2) tds754d_error("tds754d_get_waveform: Problem reading y_mult");
    if (chan_rtn != chan) tds754d_error("tds754d_get_waveform: Problem reading y_mult");
    
    /* Get the X increment value */
    Fmt(cmd, "%s<WFMPRE:CH%i:XINCR?", chan);
    tds754d_out(dev_ID, cmd);
    tds754d_in(dev_ID, msg);
    num_scan = Scan(msg, "%s[x]>:WFMP:CH%i[w1]:XIN %f", &chan_rtn, &x_incr);
    if (num_scan != 2) tds754d_error("tds754d_get_waveform: Problem reading x_incr");
    if (chan_rtn != chan) tds754d_error("tds754d_get_waveform: Problem reading x_incr");
    
    /* Get the X trigger point */
    Fmt(cmd, "%s<WFMPRE:CH%i:PT_OFF?", chan);
    tds754d_out(dev_ID, cmd);
    tds754d_in(dev_ID, msg);
    num_scan = Scan(msg, "%s[x]>:WFMP:CH%i[w1]:PT_O %i", &chan_rtn, &pt_off);
    if (num_scan != 2) tds754d_error("tds754d_get_waveform: Problem reading pt_off");
    if (chan_rtn != chan) tds754d_error("tds754d_get_waveform: Problem reading pt_off");
    
    /* Return the number of samples in the waveform */
    *num_samp = num_pts;
    
    /* Calculate the time of each sample */
    for (i = 0; i < num_pts; i++) t[i] = (i - pt_off) * x_incr;
    
    /* Calculate the voltage of each sample */
    for (i = 0; i < num_pts; i++) v[i] = (v[i] - y_off) * y_mult;
    
    /* Check for errors */
    err = tds754d_get_errors(dev_ID);
    if (err != 0)
    {
        tds754d_error("The device has an error");
        tds754d_close_dev(dev_ID);
        return;
    }
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	tds754d_exit
 *  This function puts the TDS754D in a desired state and closes the device.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Zachary Wolf
 *	5/18/01
 */

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

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > TDS754D_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	tds754d_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = tds754d_check_device_open(dev_ID);
    if (dev_open != 1)
    {
    	return;		 /* OK, already closed */
    }
    
    /* Put the TDS754D in the appropriate state for program exit */

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

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

/*	PRIVATE FUNCTIONS  */

/*	**************************************************************  */
/*
 *	tds754d_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
 *	5/18/01
 */

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

	/* Initialization */
    dev_ID = 0;

    /* Check to see if the device is already in the device table */
    for (i = 1; i <= TDS754D_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 <= TDS754D_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)
    {
    	tds754d_error("The device could not be opened");
        return  -1;
    }
    
	/* Open the device */
    /* Terminate write with LF EOI, add LF in write routine */
    /* Terminate read on LF, remove LF in read routine */
	descr = ibdev(gpib_board_addr, gpib_dev_addr, 0, T10s, 1, 0x140A);
	if (descr <= 0)
	{
		tds754d_error("The device could not be opened");
		return  -1;
	}
   
    /* Open successful, save parameters in device table */
    dev_addr[dev_ID] = gpib_dev_addr;
    dev_descr[dev_ID] = descr;
    dev_count++;
    
    /* Clear the device */
	err = ibclr(dev_descr[dev_ID]);
	if (err & 0x8000)
	{
		tds754d_error("Problem clearing device");
    }
    
    /* Return the device ID */
    return dev_ID;
}

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

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


/*	**************************************************************  */
/*
 *	tds754d_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
 *	5/18/01
 */

int tds754d_out(int dev_ID, char* buf)
{
	/* Declare variables */
	int nbytes;
	int err;
	char out_buf[TDS754D_MAX_CMD];
	
	/* Send the message */
	Fmt(out_buf, "%s<%s%c", buf, 10);
	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);
		tds754d_error(msg);
		return -1;
	}
	
	/* Done */
    return 0;
}

/*	**************************************************************  */
/*
 *	tds754d_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
 *	5/18/01
 */

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

/*	**************************************************************  */
/*
 *	tds754d_in_waveform
 *  This function reads a data waveform 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
 *	5/18/01
 */

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

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

/*	**************************************************************  */
/*
 *	tds754d_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
 *	5/23/01
 */

int tds754d_get_errors(int dev_ID)
{
	/* Declare variables */
    int status;
    int num_scan;

	/* Get the standard event status register value */
	tds754d_out(dev_ID, "*ESR?");
	tds754d_in(dev_ID, msg);
	
	/* Extract the status value */
	num_scan = Scan(msg, "%s>%i", &status);
    if (num_scan != 1)
    {
        tds754d_error("Problem getting error status");
        return -1;
    }
    
    /* Alert the operator if there is an error */
    /* Error if any of bits 5, 4, 3, 2 are set: 00111100 = 60 */
    if ((status & 60) != 0)
    {
		tds754d_out(dev_ID, "ALLEV?");
		tds754d_in(dev_ID, msg);
		tds754d_message("\nTDS754D Error:");
		tds754d_message(msg);
		Fmt(msg, "%s<TDS754D error code = %i", status);
    	tds754d_error(msg);
        return -1;
    }
    
    /* Done */
    return 0;
}

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

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

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

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