/*	**************************************************************  */
/*
 *	Module DAC488HR
 *	This module contains I/O functions for the IOtech DAC488HR.                 
 *
 *	Zachary Wolf
 *	12/20/99
 */ 

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

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

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

/*  PRIVATE FUNCTIONS  */
int dac488hr_open_dev(int gpib_board_addr, int gpib_dev_addr);
void dac488hr_close_dev(int dev_ID);
int dac488hr_out(int dev_ID, char* buf);
int dac488hr_in(int dev_ID, char* buf);
int dac488hr_check_dev_open(int dev_ID);
int dac488hr_get_errors(int dev_ID);
void dac488hr_message(char* msg);
void dac488hr_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[DAC488HR_MAX_NUM_DEV + 1];
static int dev_descr[DAC488HR_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
 *	range_settings, port range settings saved for quick access
 */
static char cmd[DAC488HR_MAX_CMD + 1];
static char msg[DAC488HR_MAX_CMD + 1];
static int range_settings[DAC488HR_NUM_PORTS + 1];

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

/*	PUBLIC FUNCTIONS  */

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

void dac488hr_init(int gpib_board_addr, int gpib_dev_addr, int* ID)
{
    /* Declare variables */
    int dev_ID;
    int err;
    int i;
    
    /* Message */
    dac488hr_message("");
    dac488hr_message("Initializing the DAC488HR...");

    /* 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);
    	dac488hr_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);
    	dac488hr_error(msg);
    	return;
    }
    
    /* Exit here if testing without hardware */
    #ifdef DUMMY_DEVICES
    	*ID = 1;
    	for (i=1; i<=DAC488HR_NUM_PORTS; i++) range_settings[i] = 4;
    	return;
    #endif
    
    /* Open the DAC488HR */
    dev_ID = dac488hr_open_dev(gpib_board_addr, gpib_dev_addr);
    if (dev_ID <= 0)
    {
        dac488hr_error("DAC488HR was not opened");
        return;
    }
    
    /* Get the DAC ID */
    dac488hr_out(dev_ID, "U9 X");
    err = dac488hr_in(dev_ID, cmd);
    if (err != 0)
    {
        dac488hr_error("Problem reading ID");
    }
    dac488hr_message(cmd);
    
    /* Leave the DAC in a known default state */
    dac488hr_default_setup(dev_ID);

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

/*	**************************************************************  */
/*
 *	dac488hr_default_setup
 *  This function sets up the DAC in a default state.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Zachary Wolf
 *	12/20/99
 */

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

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > DAC488HR_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	dac488hr_error(msg);
    	return;
    }
    
    /* Exit here if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = dac488hr_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	dac488hr_error("Device not open");
    	return;
    }
    
    /* Set up each channel of the DAC */
    for (i=1; i<=DAC488HR_NUM_PORTS; i++)
    {
    	/* Set the output port to #i */
    	/* Set the voltage range to +-10 V */
    	/* Set the output data format to signed volts */
    	/* Set the initial voltage value to 0 */
   	 	Fmt(cmd, "%s<P%i[w1] R4 F0 V0 X", i);
    	dac488hr_out(dev_ID, cmd);
    	range_settings[i] = 4;
    }
    
    /* Check for DAC errors */
    err = dac488hr_get_errors(dev_ID);
    if (err != 0)
    {
        dac488hr_error("The DAC has an error");
        dac488hr_close_dev(dev_ID);
        return;
    }
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	dac488hr_set_port_range
 *  This function sets the output voltage range of the specified
 *	port.
 *
 *	Input:
 *	dev_ID, device identifier
 *	port, port number (1 to DAC488HR_NUM_PORTS)
 *	range, DAC range (0 = 0 V, 1 = +-1 V, 2 = +-2 V, 3 = +-5 V, 4 = +-10 V, 5 = +1 V, 6 = +2 V, 7 = +5 V, 8 = +10 V)
 *
 *	Zachary Wolf
 *	12/20/99
 */

void dac488hr_set_port_range(int dev_ID, int port, int range)
{
	/* Declare variables */
	int dev_open;
	int err;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > DAC488HR_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	dac488hr_error(msg);
    	return;
    }
    if (port < 1 || port > DAC488HR_NUM_PORTS)
    {
    	Fmt(msg, "%s<port = %i, out of range", port);
    	dac488hr_error(msg);
    	return;
    }
    if (range < 0 || range > 8)
    {
    	Fmt(msg, "%s<range = %i, out of range", range);
    	dac488hr_error(msg);
    	return;
    }
    
    /* Exit here if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = dac488hr_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	dac488hr_error("DAC488HR not open");
    	return;
    }

    /* Set the range to the requested value */
    Fmt(cmd, "%s<P%i[w1] R%i[w1] X", port, range);
    dac488hr_out(dev_ID, cmd);
    
    /* Check for errors */
    err = dac488hr_get_errors(dev_ID);
    if (err != 0)
    {
        dac488hr_error("The DAC has an error");
        dac488hr_close_dev(dev_ID);
        return;
    }
    
    /* Save the range setting for future checks */
    range_settings[port] = range;
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	dac488hr_set_port_voltage
 *  This function sets the output voltage of the specified port.
 *
 *	Input:
 *	dev_ID, device identifier
 *	port, port number (1 to DAC488HR_NUM_PORTS)
 *	voltage, desired voltage (Volts), must be within range
 *
 *	Zachary Wolf
 *	12/20/99
 */

void dac488hr_set_port_voltage(int dev_ID, int port, double voltage)
{
	/* Declare variables */
	int err;
	int dev_open;
	double low_volt_range[9] = {0., -1., -2., -5., -10., 0., 0., 0., 0.};
	double high_volt_range[9] = {0., 1., 2., 5., 10., 1., 2., 5., 10.};

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > DAC488HR_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	dac488hr_error(msg);
    	return;
    }
    if (port < 1 || port > DAC488HR_NUM_PORTS)
    {
    	Fmt(msg, "%s<port = %i, out of range", port);
    	dac488hr_error(msg);
    	return;
    }
    if (voltage < low_volt_range[range_settings[port]] ||
    	voltage > high_volt_range[range_settings[port]])
    {
    	Fmt(msg, "%s<voltage = %f, outside of DAC range setting", voltage);
    	dac488hr_error(msg);
    	return;
    }
    
    /* Exit here if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = dac488hr_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	dac488hr_error("Device not open");
    	return;
    }

    /* Set the voltage to the requested value */
    Fmt(cmd, "%s<P%i[w1] V%f[w9p5] X", port, voltage);
    dac488hr_out(dev_ID, cmd);
    
    /* Check for errors */
    err = dac488hr_get_errors(dev_ID);
    if (err != 0)
    {
        dac488hr_error("The DAC has an error");
        dac488hr_close_dev(dev_ID);
        return;
    }
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	dac488hr_set_digital_output
 *  This function sets the digital output lines to states determined
 *  by the input parameter.
 *
 *	Input:
 *	dev_ID, device identifier
 *	config, integer (0 to 255) giving the states of the 8 lines
 *
 *	Zachary Wolf
 *	12/20/99
 */

void dac488hr_set_digital_output(int dev_ID, int config)
{
	/* Declare variables */
	int dev_open;
	int err;

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

    /* Set the digital output lines to the requested value */
    Fmt(cmd, "%s<D%i X", config);
    dac488hr_out(dev_ID, cmd);
    
    /* Check for errors */
    err = dac488hr_get_errors(dev_ID);
    if (err != 0)
    {
        dac488hr_error("The DAC has an error");
        dac488hr_close_dev(dev_ID);
        return;
    }
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	dac488hr_get_port_voltage
 *  This function gets the output voltage of the specified port.
 *
 *	Input:
 *	dev_ID, device identifier
 *	port, port number (1 to DAC488HR_NUM_PORTS)
 *
 *	Output:
 *	voltage, port voltage (V)
 *
 *	Zachary Wolf
 *	12/20/99
 */

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

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > DAC488HR_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	dac488hr_error(msg);
    	return;
    }
    if (port < 1 || port > DAC488HR_NUM_PORTS)
    {
    	Fmt(msg, "%s<port = %i, out of range", port);
    	dac488hr_error(msg);
    	return;
    }
    
    /* Exit here if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = dac488hr_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	dac488hr_error("DAC488HR not open");
    	return;
    }

    /* Request the voltage of the desired port */
    Fmt(cmd, "%s<P%i[w1] X V? X", port);
    dac488hr_out(dev_ID, cmd);
    dac488hr_in(dev_ID, cmd);
	
	/* Extract the voltage */
	err = Scan(cmd, "%s>V%f", voltage);
    if (err != 1)
    {
        dac488hr_error("Problem getting DAC voltage");
    }
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	dac488hr_get_digital_output
 *  This function gets the digital output configuration.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Output:
 *	config, integer (0 to 255) giving the states of the 8 lines
 *
 *	Zachary Wolf
 *	12/20/99
 */

void dac488hr_get_digital_output(int dev_ID, int* config)
{
	/* Declare variables */
	int dev_open;
	int err;

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

    /* Request the digital output configuration */
    dac488hr_out(dev_ID, "D? X");
    dac488hr_in(dev_ID, cmd);
	
	/* Extract the voltage */
	err = Scan(cmd, "%s>D%i", config);
    if (err != 1)
    {
        dac488hr_error("Problem getting digital output configuration");
    }
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	dac488hr_exit
 *  This function configures the DAC488HR for program exit and
 *	closes the device.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Zachary Wolf
 *	12/20/99
 */

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

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > DAC488HR_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	dac488hr_error(msg);
    	return;
    }
    
    /* Exit here if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = dac488hr_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	return;		 /* OK, already closed */
    }
    
    /* Set all port voltages to 0 V */
    for (port = 1; port <= DAC488HR_NUM_PORTS; port++)
    	dac488hr_set_port_voltage(dev_ID, port, 0.);

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

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

/*	PRIVATE FUNCTIONS  */

/*	**************************************************************  */
/*
 *	dac488hr_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
 *	12/20/99
 */

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

	/* Initialization */
    dev_ID = 0;

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

/*	**************************************************************  */
/*
 *	dac488hr_close_dev
 *  This function closes the device.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Zachary Wolf
 *	12/20/99
 */

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


/*	**************************************************************  */
/*
 *	dac488hr_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
 *	12/20/99
 */

int dac488hr_out(int dev_ID, char* buf)
{
	/* Declare variables */
	int nbytes;
	int err;
	
	/* Send the message */
	nbytes = StringLength(buf);
	err = ibwrt(dev_descr[dev_ID], buf, (long)nbytes);
	
	/* Check for errors */
	if (err & 0x8000)
	{
		Fmt(msg, "%s<ibsta = %x, problem sending GPIB command", err);
		dac488hr_error(msg);
		return -1;
	}
	
	/* Done */
    return 0;
}

/*	**************************************************************  */
/*
 *	dac488hr_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
 *	12/20/99
 */

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

/*	**************************************************************  */
/*
 *	dac488hr_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
 *	12/20/99
 */

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

/*	**************************************************************  */
/*
 *	dac488hr_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
 *	12/20/99
 */

int dac488hr_get_errors(int dev_ID)
{
	/* Declare variables */
    int status;
    int err;

	/* Get the DAC error status */
	dac488hr_out(dev_ID, "E? X");
	dac488hr_in(dev_ID, cmd);
	
	/* Extract the status value */
	err = Scan(cmd, "%s>E%i", &status);
    if (err != 1)
    {
        dac488hr_error("Problem getting error status");
        return -1;
    }
    
    /* Alert the operator if there is an error */
    if (status != 0)
    {
		Fmt(msg, "%s<DAC488HR error code = %i", status);
    	dac488hr_error(msg);
        return -1;
    }
    
    /* Done */
    return 0;
}

/*	**************************************************************  */
/*
 *	dac488hr_message
 *  This function handles messages about the DAC488HR.
 *
 *	Input:
 *	message, string to display in standard I/O
 *
 *	Zachary Wolf
 *	12/20/99
 */

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

/*	**************************************************************  */
/*
 *	dac488hr_error
 *  This function handles error messages for the DAC488HR.
 *
 *	Input:
 *	message, string to display in standard I/O
 *
 *	Zachary Wolf
 *	12/20/99
 */

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