/*	**************************************************************  */
/*
 *	Module HP34970
 *	This module contains I/O functions for the HP34970 multimeter.                 
 *
 *	Zachary Wolf
 *	2/19/03
 */

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

/*  INCLUDES  */
#include "repository.h"
#include "c:\MMCVI\Lib\delay.h"
#include "delay.h"
#include <utility.h>
#include <gpib.h>
#include <formatio.h>
#include <ansi_c.h>
#include "hp34970_sw.h"


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

/*  PRIVATE FUNCTIONS  */
int hp34970_open_dev(int gpib_board_addr, int gpib_dev_addr);
void hp34970_close_dev(int dev_ID);
int hp34970_out(int dev_ID, char* buf);
int hp34970_in(int dev_ID, char* buf);
int hp34970_in_buf(int dev_ID, char* buf);
int hp34970_serial_poll(int dev_ID, int* spoll);
int hp34970_check_dev_open(int dev_ID);
void hp34970_message(char* msg);
void hp34970_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[HP34970_MAX_NUM_DEV + 1];
static int dev_descr[HP34970_MAX_NUM_DEV + 1];
static int dev_count;

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

/*  PRIVATE GLOBAL VARIABLES  */
/*
 *  cmd, buffer for GPIB I/O strings
 *	msg, buffer for messages to Standard I/O
 */
static char cmd[HP34970_MAX_NUM_CHAR];
static char msg[HP34970_MAX_NUM_CHAR];
static char module_name[] = {"hp34970"};

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

/*	PUBLIC FUNCTIONS  */

/*	**************************************************************  */
/*
 *  hp34970_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
 *	2/19/03
 */

void hp34970_init(int gpib_board_addr, int gpib_dev_addr, int* ID)
{
    /* Declare variables */
    int dev_ID;
    int err;
    
    /* Message */
    hp34970_message("");
    hp34970_message("Initializing the HP34970...");

    /* 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);
    	stop_error_msg(module_name, cmd);
    	return;
    }
    if (gpib_dev_addr < 1 || gpib_dev_addr > 30)
    {
    	Fmt(msg, "%s<gpib_dev_addr = %i, out of range", gpib_dev_addr);
    	stop_error_msg(module_name, msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	*ID = 1;
    	return;
    #endif
    
    /* Open the hp34970 */
    dev_ID = hp34970_open_dev(gpib_board_addr, gpib_dev_addr);
    if (dev_ID <= 0)
    {
        stop_error_msg(module_name, "Device was not opened");
        return;
    }
    
    /* Put the HP34970 in a known default state (factory reset) */
    hp34970_out(dev_ID, "*RST");

    /* Get the HP34970 ID */
    hp34970_out(dev_ID, "*IDN?");
    err = hp34970_in(dev_ID, cmd);
    if (err != 0)
    {
        stop_error_msg(module_name, "Problem reading ID");
        hp34970_close_dev(dev_ID);
        return;
    }
    hp34970_message(cmd);
    
    /* Enable status system registers */
    /* Not used at present */
    
    /* Check for errors */
    err = hp34970_get_errors(dev_ID);
    if (err != 0)
    {
        stop_error_msg(module_name, "The HP34970 has an error");
        hp34970_close_dev(dev_ID);
        return;
    }

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

/*	**************************************************************  */
/*
 *	hp34970_preset
 *  This function runs the preset function of the HP34970.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Zachary Wolf
 *	2/19/03
 */

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

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > HP34970_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	hp34970_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = hp34970_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	hp34970_error("Device not open");
    	return;
    }
    
    /* Preset the HP34970 */
    hp34970_out(dev_ID, "SYSTEM:PRESET");
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	hp34970_scan_chan_volt
 *  This function gets the voltages applied to the specified channels.
 *
 *	Input:
 *	dev_ID, device identifier
 *	num_chan, number of channels to measure
 *	chan[0 to num_chan - 1], channel number
 *
 *	Output:
 *	volt[0 to num_chan - 1], voltage measurements from each channel (V)
 *
 *	Zachary Wolf
 *	2/19/03
 */

void hp34970_scan_chan_volt(int dev_ID, int num_chan, int chan[], double volt[])
{
	/* Declare variables */
	int i;
	char meas[HP34970_MAX_NUM_CHAN];

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > HP34970_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	hp34970_error(msg);
    	return;
    }
    if (num_chan < 1 || num_chan > HP34970_MAX_NUM_CHAN)
    {
    	Fmt(msg, "%s<num_chan = %i, out of range", num_chan);
    	hp34970_error(msg);
    	return;
    }
    for (i = 0; i < num_chan; i++)
    {
	    if (chan[i] < 101 || chan[i] >= 400)
	    {
	    	Fmt(msg, "%s<chan[%i] = %i, out of range in hp34970_scan_chan_volt", i, chan[i]);
	    	hp34970_error(msg);
 	   		return;
    	}
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	for (i = 0; i < num_chan; i++) volt[i] = 0.;
    	return;
    #endif
	
	/* Set up to measure voltages */
	for (i = 0; i < num_chan; i++) meas[i] = 'v';
	
	/* Perform the scan */
	hp34970_scan_chan(dev_ID, num_chan, chan, meas, volt);
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	hp34970_get_chan_volt
 *  This function gets the voltage applied to the specified channel.
 *
 *	Input:
 *	dev_ID, device identifier
 *	chan, channel number (0 to HP34970_MAX_NUM_CHAN - 1)
 *
 *	Output:
 *	volt, applied voltage (V)
 *
 *	Zachary Wolf
 *	2/19/03
 */

void hp34970_get_chan_volt(int dev_ID, int chan, double* volt)
{
	/* Declare variables */
	int num_chan;
	int chan_array[HP34970_MAX_NUM_CHAN];
	double volt_array[HP34970_MAX_NUM_CHAN];

    // Check input parameters 
    if (dev_ID < 1 || dev_ID > HP34970_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	hp34970_error(msg);
    	return;
    }
    if (chan < 101 || chan > 400)
    {
    	Fmt(msg, "%s<chan = %i, out of range hp34970_get_chan_volt", chan);
    	hp34970_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	*volt = 1.;
    	return;
    #endif
    
    /* Get the voltage */
	num_chan = 1;
	chan_array[0] = chan;
	hp34970_scan_chan_volt(dev_ID, num_chan, chan_array, volt_array);
	*volt = volt_array[0];
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	hp34970_scan_chan_res
 *  This function measures the resistances connected to the specified channels.
 *
 *	Input:
 *	dev_ID, device identifier
 *	num_chan, number of channels to measure
 *	chan[0 to num_chan - 1], channel number
 *
 *	Output:
 *	res[0 to num_chan - 1], resistance measurements from each channel (ohm)
 *
 *	Zachary Wolf
 *	2/19/03
 */

void hp34970_scan_chan_res(int dev_ID, int num_chan, int chan[], double res[])
{
	/* Declare variables */
	int i;
	char meas[HP34970_MAX_NUM_CHAN];

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > HP34970_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	hp34970_error(msg);
    	return;
    }
    if (num_chan < 1 || num_chan > HP34970_MAX_NUM_CHAN)
    {
    	Fmt(msg, "%s<num_chan = %i, out of range", num_chan);
    	hp34970_error(msg);
    	return;
    }
    for (i = 0; i < num_chan; i++)
    {
	    if (chan[i] < 101 || chan[i] >= 400)
	    {
	    	Fmt(msg, "%s<chan[%i] = %i, out of range in scan_chan_res", i, chan[i]);
	    	hp34970_error(msg);
 	   		return;
    	}
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	for (i = 0; i < num_chan; i++) res[i] = 0.;
    	return;
    #endif
	
	/* Set up to measure resistances */
	for (i = 0; i < num_chan; i++) meas[i] = 'r';
	
	/* Perform the scan */
	hp34970_scan_chan(dev_ID, num_chan, chan, meas, res);
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	hp34970_get_chan_res
 *  This function gets the resistance applied to the specified channel.
 *
 *	Input:
 *	dev_ID, device identifier
 *	chan, channel number (0 to HP34970_MAX_NUM_CHAN - 1)
 *
 *	Output:
 *	res, applied resistance (ohm)
 *
 *	Zachary Wolf
 *	2/19/03
 */

void hp34970_get_chan_res(int dev_ID, int chan, double* res)
{
	/* Declare variables */
	int num_chan;
	int chan_array[HP34970_MAX_NUM_CHAN];
	double res_array[HP34970_MAX_NUM_CHAN];

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > HP34970_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	hp34970_error(msg);
    	return;
    }
    if (chan < 101 || chan > 400)
    {
    	Fmt(msg, "%s<chan = %i, out of range in get_chan_res", chan);
    	hp34970_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	*res = 0.;
    	return;
    #endif
    
    /* Get the resistance */
	num_chan = 1;
	chan_array[0] = chan;
	hp34970_scan_chan_res(dev_ID, num_chan, chan_array, res_array);
	*res = res_array[0];
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	hp34970_scan_chan_4wire_res
 *  This function measures the resistances connected to the specified channels.
 *	It uses 4-wire resistance measurements.
 *
 *	Input:
 *	dev_ID, device identifier
 *	num_chan, number of channels to measure
 *	chan[0 to num_chan - 1], channel number
 *
 *	Output:
 *	res[0 to num_chan - 1], resistance measurements from each channel (ohm)
 *
 *	Zachary Wolf
 *	2/19/03
 */

void hp34970_scan_chan_4wire_res(int dev_ID, int num_chan, int chan[], double res[])
{
	/* Declare variables */
	int i;
	char meas[HP34970_MAX_NUM_CHAN];

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > HP34970_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	hp34970_error(msg);
    	return;
    }
    if (num_chan < 1 || num_chan > HP34970_MAX_NUM_CHAN)
    {
    	Fmt(msg, "%s<num_chan = %i, out of range", num_chan);
    	hp34970_error(msg);
    	return;
    }
    for (i = 0; i < num_chan; i++)
    {
	    if (chan[i] < 101 || chan[i] >= 400)
	    {
	    	Fmt(msg, "%s<chan[%i] = %i, out of range in hp34970_scan_chan_4wire_res", i, chan[i]);
	    	hp34970_error(msg);
 	   		return;
    	}
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	for (i = 0; i < num_chan; i++) res[i] = 0.;
    	return;
    #endif
	
	/* Set up to measure resistances */
	for (i = 0; i < num_chan; i++) meas[i] = '4';
	
	/* Perform the scan */
	hp34970_scan_chan(dev_ID, num_chan, chan, meas, res);
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	hp34970_get_chan_4wire_res
 *  This function gets the resistance applied to the specified channel.
 *	It uses 4-wire resistance measurements.
 *
 *	Input:
 *	dev_ID, device identifier
 *	chan, channel number (0 to HP34970_MAX_NUM_CHAN - 1)
 *
 *	Output:
 *	res, applied resistance (ohm)
 *
 *	Zachary Wolf
 *	2/19/03
 */

void hp34970_get_chan_4wire_res(int dev_ID, int chan, double* res)
{
	/* Declare variables */
	int num_chan;
	int chan_array[HP34970_MAX_NUM_CHAN];
	double res_array[HP34970_MAX_NUM_CHAN];

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > HP34970_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	hp34970_error(msg);
    	return;
    }
    if (chan < 101 || chan > 400)
    {
    	Fmt(msg, "%s<chan = %i, out of range in hp34970_scan_chan_4wire_res", chan);
    	hp34970_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	*res = 0.;
    	return;
    #endif
    
    /* Get the resistance */
	num_chan = 1;
	chan_array[0] = chan;
	hp34970_scan_chan_4wire_res(dev_ID, num_chan, chan_array, res_array);
	*res = res_array[0];
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	hp34970_scan_chan
 *  This function performs the specified measurement on the specified channels.
 *
 *	Input:
 *	dev_ID, device identifier
 *	num_chan, number of channels to measure
 *	chan[0 to num_chan - 1], channel number
 *	meas[0 to num_chan - 1], measurement for each channel ('v' = voltage, 'r' = resistance, 
 *												'4' = 4-wire resistance, 't' - temperature)
 *
 *	Output:
 *	meas_val[0 to num_chan - 1], measured value from each channel (V, ohm, ...)
 *
 *	Zachary Wolf
 *	2/19/03
 */

void hp34970_scan_chan(int dev_ID, int num_chan, int chan[], char meas[], double meas_val[])
{
	/* Declare variables */
	int dev_open;
	int err;
	int i, j, n;
	char scan_list[HP34970_MAX_NUM_CHAR];
	char chan_list[HP34970_MAX_NUM_CHAR];
	char in_buf[HP34970_MAX_IN_BUF];
	char buf[HP34970_MAX_IN_BUF];
	int chan_as_meas[HP34970_MAX_NUM_CHAN];
	double meas_val_as_meas[HP34970_MAX_NUM_CHAN];
	char unit_as_meas[HP34970_MAX_NUM_CHAN][HP34970_MAX_NUM_CHAR];
	char unit[HP34970_MAX_NUM_CHAN][HP34970_MAX_NUM_CHAR];
	char sensor[8];
	char tc_type;
	int rtd_type, therm;
	double rtd_res;
	static char last_meas[HP34970_MAX_NUM_CHAN]="";

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > HP34970_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	hp34970_error(msg);
    	return;
    }
    if (num_chan < 1 || num_chan > HP34970_MAX_NUM_CHAN)
    {
    	Fmt(msg, "%s<num_chan = %i, out of range in hp34970_scan_chan", num_chan);
    	hp34970_error(msg);
    	return;
    }
    for (i = 0; i < num_chan; i++)
    {
	    if (chan[i] < 101 || chan[i] >= 400)
	    {
	    	Fmt(msg, "%s<chan[%i] = %i, out of range in hp34970_scan_chan", i, chan[i]);
	    	hp34970_error(msg);
 	   		return;
    	}
    }
    for (i = 0; i < num_chan; i++)
    {
	    if (meas[i] != 'v' && meas[i] != 'r' && meas[i] != '4' && meas[i] != 't')
	    {
	    	Fmt(msg, "%s<meas[%i] = %c, unknown measurement", i, meas[i]);
	    	hp34970_error(msg);
 	   		return;
    	}
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	for (i = 0; i < num_chan; i++) meas_val[i] = 1.;
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = hp34970_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	hp34970_error("Device not open");
    	return;
    }
    
    /* Preset the HP34970 */
//    hp34970_preset(dev_ID);
    
    /* Make the scan list for everything common to all channels */
    sprintf(scan_list, "(@%i", chan[0]);
    for (i = 1; i < num_chan; i++) sprintf(scan_list, "%s, %i", scan_list, chan[i]);
    sprintf(scan_list, "%s)", scan_list);
    
    /* Give the DMM the scan list */
    Fmt(cmd, "%s<ROUTE:SCAN %s", scan_list);
    hp34970_out(dev_ID, cmd);
     
    /* Set up each channel for the required measurement */
    for (i = 0; i < num_chan; i++)
    {
    	/* Make the channel list */
	    sprintf(chan_list, "(@%i)", chan[i]);
	    /* Do the appropriate setup for each measurement type */
//		if(last_meas[i] != meas[i])  //check if the channel settings need to be changed
    		if (meas[i] == 'v')
    		{
		    	/* Set up the channel for voltage measurements */
		    	Fmt(cmd, "%s<SENSE:FUNCTION \"VOLTAGE:DC\", %s", chan_list);
		    	hp34970_out(dev_ID, cmd);
		    	/* Set the range to autorange */
		    	//Fmt(cmd, "%s<SENSE:VOLTAGE:DC:RANGE:AUTO ON, %s", chan_list);
				Fmt(cmd,"%s<SENSE:VOLTAGE:DC:RANGE:AUTO OFF, %s", chan_list); 
		    	hp34970_out(dev_ID, cmd);
				Fmt(cmd,"%s<SENSE:VOLTAGE:DC:RANGE 10, %s", chan_list); 
		    	hp34970_out(dev_ID, cmd);
		    	/* Set the A/D integration time */
		    	Fmt(cmd, "%s<SENSE:VOLTAGE:DC:NPLC 10, %s", chan_list);
		    	hp34970_out(dev_ID, cmd);
		    	/* Set the input impedance to 10 Mohms */ 
		    	Fmt(cmd, "%s<INPUT:IMPEDANCE:AUTO OFF, %s", chan_list);
		    	hp34970_out(dev_ID, cmd);
		    	/* Turn on offset compensation */ 
		    	Fmt(cmd, "%s<SENSE:ZERO:AUTO ON, %s", chan_list);
		    	hp34970_out(dev_ID, cmd);
			}
    		else if (meas[i] == 'r')
    		{
		    	/* Set up the channel for resistance measurements */
		    	Fmt(cmd, "%s<SENSE:FUNCTION \"RESISTANCE\", %s", chan_list);
		    	hp34970_out(dev_ID, cmd);
		    	/* Set the range to autorange */
		    	Fmt(cmd, "%s<SENSE:RESISTANCE:RANGE:AUTO ON, %s", chan_list);
		    	hp34970_out(dev_ID, cmd);
		    	/* Set the A/D integration time */
		    	Fmt(cmd, "%s<SENSE:RESISTANCE:NPLC 10, %s", chan_list);
		    	hp34970_out(dev_ID, cmd);
		    	/* Turn on offset compensation */ 
		    	Fmt(cmd, "%s<SENSE:RESISTANCE:OCOMPENSATED ON, %s", chan_list);
		    	hp34970_out(dev_ID, cmd);
			}
    		else if (meas[i] == '4')
    		{
		    	/* Set up the channel for 4-wire resistance measurements */
		    	Fmt(cmd, "%s<SENSE:FUNCTION \"FRESISTANCE\", %s", chan_list);
		    	hp34970_out(dev_ID, cmd);
		    	/* Set the range to autorange */
		    	Fmt(cmd, "%s<SENSE:FRESISTANCE:RANGE:AUTO ON, %s", chan_list);
		    	hp34970_out(dev_ID, cmd);
		    	/* Set the A/D integration time */
		    	Fmt(cmd, "%s<SENSE:FRESISTANCE:NPLC 10, %s", chan_list);
		    	hp34970_out(dev_ID, cmd);
		    	/* Turn on offset compensation */ 
		    	Fmt(cmd, "%s<SENSE:FRESISTANCE:OCOMPENSATED ON, %s", chan_list);
		    	hp34970_out(dev_ID, cmd);
		 	}
		 	else if (meas[i] == 't')
		 	{
				/* set temperature measurements*/
    			Fmt(cmd, "%s<SENS:FUNC:TEMP, %s", chan_list);  
				hp34970_out(dev_ID, cmd);
		  
				/* Set units to Celcium */
    			Fmt(cmd, "%s<UNIT:TEMP, %s", chan_list);  
				hp34970_out(dev_ID, cmd);
    
    			/* Set integration time */
    			Fmt(cmd, "%s<SENS:TEMP:NPLS 10, %s", chan_list);  
				hp34970_out(dev_ID, cmd);
    
    			/* Check the temperature sensor type */
    			Fmt(cmd, "%s<SENS:TEMP:TRAN:TYPE? %s", chan_list);  
				hp34970_out(dev_ID, cmd);
				hp34970_in(dev_ID, sensor);
			
    			/* set sensor configuration */
				if(sensor == "TC")
	 			{
	  				/* Check for thermocouple type */
    				Fmt(cmd, "%s<SENS:TEMP:TRAN:TC:TYPE? %s", chan_list);  
					hp34970_out(dev_ID, cmd);
					hp34970_in(dev_ID, &tc_type);
			
					/* set thermocouple type */
    				Fmt(cmd, "%s<SENS:TEMP:TRAN:TC:TYPE %s, %s", tc_type, chan_list);  
					hp34970_out(dev_ID, cmd);
	
					/* Set a internal reference junction temperature */
    				Fmt(cmd, "%s<SENS:TEMP:TRAN:TC:RJUN:TYPE INT, %s", chan_list);  
					hp34970_out(dev_ID, cmd);
	
					/* Enable thermocouple check option */
    				Fmt(cmd, "%s<SENS:TEMP:TRAN:TC:CHEC ON, %s", chan_list);  
					hp34970_out(dev_ID, cmd);
	 			}
	    		else if(sensor == "RTD" || sensor == "FRTD")
	     		{
    				/* select 2-wire or 4-wire measurements */
    				Fmt(cmd, "%s<SENS:TEMP:TRAN:RTD:TYPE? %s", chan_list);  
					hp34970_out(dev_ID, cmd);
					hp34970_in(dev_ID, in_buf);							
					err = Scan(in_buf, "%s>%i", &rtd_type);
					
					/* set RTD type */
    				Fmt(cmd, "%s<SENS:TEMP:TRAN:RTD:TYPE %i, %s", rtd_type, chan_list);  
					hp34970_out(dev_ID, cmd);
				
	 		 	    /* select nominal resistance */
    				Fmt(cmd, "%s<SENS:TEMP:TRAN:RTD:RES:REF? %s", chan_list);  
					hp34970_out(dev_ID, cmd);
					hp34970_in(dev_ID, in_buf);
					err = Scan(in_buf, "%s>%f", &rtd_res);
				
					 /* set nominal resistance */
    				Fmt(cmd, "%s<SENS:TEMP:TRAN:RTD:RES:REF %f, %s", rtd_res, chan_list);  
					hp34970_out(dev_ID, cmd);
		 
	      		}  
		 		else if(sensor == "THER")
		 		{
    				Fmt(cmd, "%s<SENS:TEMP:TRAN:THER:TYPE? %s", chan_list);  
					hp34970_out(dev_ID, cmd);
					hp34970_in(dev_ID, in_buf);
					err = Scan(in_buf, "%s>%i", &therm);
					
		/* set thermistor type */
    				Fmt(cmd, "%s<SENS:TEMP:TRAN:THER:TYPE %i ,%s", therm, chan_list);  
					hp34970_out(dev_ID, cmd);
				}
			}
			else hp34970_error("Unknown measurement requested.");
		last_meas[i] = meas[i]; 
	}
   
    /* No scaling of the measurements */
    Fmt(cmd, "%s<CALCULATE:SCALE:STATE OFF, %s", scan_list);
    hp34970_out(dev_ID, cmd);
   
    /* Trigger on the READ? command */
    hp34970_out(dev_ID, "TRIGGER:SOURCE IMMEDIATE");
   
    /* Trigger the scan list once */
    hp34970_out(dev_ID, "TRIGGER:COUNT 1");
   
    /* No special delay between measurements */
    Fmt(cmd, "%s<ROUTE:CHANNEL:DELAY:AUTO ON, %s", scan_list);
    hp34970_out(dev_ID, cmd);
    
    /* Set the format for reading the measurements */
    hp34970_out(dev_ID, "FORMAT:READING:ALARM OFF");
    hp34970_out(dev_ID, "FORMAT:READING:CHANNEL ON");
    hp34970_out(dev_ID, "FORMAT:READING:TIME OFF");
    hp34970_out(dev_ID, "FORMAT:READING:UNIT ON");

    /* Get the reading */
    hp34970_out(dev_ID, "READ?");
	hp34970_in_buf(dev_ID, in_buf);
	
	/* Extract the measurements */
	strcat(in_buf, ",end");
    for (i = 0; i < num_chan; i++)
    {
		err = Scan(in_buf, "%s>%f %s[t44],%i,%s[t-]", &meas_val_as_meas[i], unit_as_meas[i], &chan_as_meas[i], buf);
	   	if (err != 4)
 	  	{
	        hp34970_error("Problem getting HP34970 measurements");
	   	}
	   	strcpy(in_buf, buf);
	}
   	if (strcmp(in_buf, "end") != 0) hp34970_error("Problem getting HP34970 measurements");
	
	/* Order the measurements according to the input channel array */
   	for (i = 0; i < num_chan; i++)
   	{
   		n = 0;
	   	for (j = 0; j < num_chan; j++)
	   	{
   			if (chan[i] == chan_as_meas[j])
   			{
   				meas_val[i] = meas_val_as_meas[j];
   				strcpy(unit[i], unit_as_meas[j]);
   				n++;
   			}
   		}
   		if (n != 1) hp34970_error("Problem getting HP34970 measurements.");
   	}
   	
   	/* Check the units */
   	for (i = 0; i < num_chan; i++)
   	{
   		if      (meas[i] == 'v') {if (strcmp(unit[i], "VDC") != 0) hp34970_error("Problem getting HP34970 measurements");}
   		else if (meas[i] == 'r') {if (strcmp(unit[i], "OHM") != 0) hp34970_error("Problem getting HP34970 measurements");}
   		else if (meas[i] == '4') {if (strcmp(unit[i], "OHM") != 0) hp34970_error("Problem getting HP34970 measurements");}
		else hp34970_error("Problem getting HP34970 measurements");
	}
    
    /* Check for errors */
    err = hp34970_get_errors(dev_ID);
    if (err != 0)
    {
        hp34970_error("The HP34970 has an error");
    	for (i = 0; i < num_chan; i++) meas_val[i] = 0.;
        return;
    }
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	hp34970_exit
 *  This function leaves the HP34970 in a desired state and
 *	closes the device.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Zachary Wolf
 *	2/19/03
 */

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

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

    /* Leave the device in the desired state */
    /* Reset the HP34970 to the factory reset state */
    hp34970_out(dev_ID, "*RST");

	/* Close the device */
    hp34970_close_dev(dev_ID);
    
    /* Done */
    return;
}
/*	**************************************************************  */    
/*
 *	hp34970_reset_slots
 *  This function resset slots to the power ON state             
 *  for specified device with dev_ID.
 *
 *	Input:
 *  dev_ID - Device ID
 
 *	Scott Anderson
 *	2/8/2008
 */
void hp34970_reset_slots(int dev_ID)
{
	
		// Reset slots to the power ON state 
		hp34970_out(dev_ID, "SYST:CPON ALL");
		
 return;	
}
/*	**************************************************************  */

/*	PRIVATE FUNCTIONS  */

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

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

    // Exit if testing without hardware 
    #ifdef DUMMY_DEVICES
    	return 0;
    #endif
	
	// Initialization 
    dev_ID = 0;

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

/*	**************************************************************  */
/*
 *	hp34970_close_dev
 *  This function closes the device.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Zachary Wolf
 *	2/19/03
 */

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

/*	**************************************************************  */
/*
 *	hp34970_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
 *	2/19/03
 */

int hp34970_out(int dev_ID, char* buf)
{
	/* Declare variables */
	char out_buf[HP34970_MAX_NUM_CHAR];
	int nbytes;
	int err;
	
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return 0;
    #endif
	
	/* Append LF to the message */
	Fmt(out_buf, "%s<%s%c", buf, 10); 
	
	/* Send the message */
	nbytes = StringLength(out_buf);
	err = ibwrt(dev_descr[dev_ID], out_buf, (long)nbytes);
	
	/* Check for errors */
	if (err & 0x8000)
	{
		Fmt(msg, "%s<ibsta = %x, problem sending GPIB command", err);
		hp34970_error(msg);
		return -1;
	}
	
	/* Done */
    return 0;
}

/*	**************************************************************  */
/*
 *	hp34970_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
 *	2/19/03
 */

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

/*	**************************************************************  */
/*
 *	hp34970_in_buf
 *  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
 *	2/19/03
 */

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

/*	**************************************************************  */
/*
 *	hp34970_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
 *	2/19/03
 */

int hp34970_serial_poll(int dev_ID, int* spoll)
{
	/* Declare variables */
	int err;
	char spoll_char;
	
	/* Perform the serial poll */
	err = ibrsp(dev_descr[dev_ID], &spoll_char);
	
	/* Check for errors */
	if (err & 0x8000)
	{
		Fmt(msg, "%s<ibsta = %x, problem performing GPIB serial poll", err);
		hp34970_error(msg);
		return -1;
	}
	
	/* Return the result as an integer */
	Scan(&spoll_char, "%c>%i", spoll);
	
	/* Done */
    return 0;
}

/*	**************************************************************  */
/*
 *	hp34970_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
 *	2/19/03
 */

int hp34970_check_dev_open(int dev_ID)
{
	/* See if the board descriptor has a positive value */
    if (dev_descr[dev_ID] > 0)
    {
        return  1;	  /* Open */
    }
    else
    {
	    return 0;	  /* Not open */
	}
}

/*	**************************************************************  */
/*
 *	hp34970_get_errors
 *  This function obtains errors from the error queue.
 *	The operator is alerted if there is an error.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Output:
 *	err, 0 if no errors, -1 otherwise
 *
 *	Zachary Wolf
 *	2/19/03
 */

int hp34970_get_errors(int dev_ID)
{
	/* Declare variables */
	int err;
	int more_err;
	
	/* Initialize, start of error queue read */
	err = 0;
	get_another:
	more_err = 0;
	
	/* Get the HP34970 error status */
	hp34970_out(dev_ID, "SYSTEM:ERROR?");
	hp34970_in(dev_ID, msg);
    
    /* Alert the operator if there is an error */
    if (strcmp(msg, "+0,\"No error\"") != 0)
    {
    	printf("\nThe HP34970 has an error.\n");
    	printf("%s", msg);
        err = -1;
        more_err = 1;
    }
    
    /* Check to see if there are more errors */
    if (more_err != 0) goto get_another;
    
    /* Done */
    return err;
}

/*	**************************************************************  */
/*
 *	hp34970_message
 *  This function handles messages about the hp34970.
 *
 *	Input:
 *	message, string to display in standard I/O
 *
 *	Zachary Wolf
 *	2/19/03
 */

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

/*	**************************************************************  */
/*
 *	hp34970_error
 *  This function handles error messages for the HP34970.
 *
 *	Input:
 *	message, string to display in standard I/O
 *
 *	Zachary Wolf
 *	2/19/03
 */

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



/*	**************************************************************  */
/*
 *	hp34970_switch_on_off
 *  This function switches ON the HP34970 20 channel Actuator board installed into 200 slot
 *  for specified channels.
 *
 *	Input:
 *  dev_ID - Device ID
 *  ch_num - number of channel to be switched ON
 *  flag = 1 to switch the channel ON, else flag = 0
 
 *	Yurii Levashov
 *	09/30/2004
 */

void hp34970_switch_on_off(int dev_ID, int ch_num, int flag)
{
	/* Declare variables */
	
	int slot_number;
	int dev_ON = 0, err;
	char buf[80];
	char sc_list[HP34970_MAX_NUM_CHAR];
	
	slot_number = HP34970_SWITCH_SLOT;
	ch_num += slot_number;
	
    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > HP34970_MAX_NUM_DEV)
      {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	hp34970_error(msg);
    	return;
      }
    	if (ch_num < 101 || ch_num > 400)
    	{
    		Fmt(msg, "%s<chan = %i, out of range", ch_num);
    		hp34970_error(msg);
    		return;
    	}
    	
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif

	/* Reset the switches into Power On state */
//	Fmt(cmd, "%s<SYSTEM:CPON %d", slot_number);  
//	hp34970_out(dev_ID, cmd);

	/* Make the scan list */
    sprintf(sc_list, "(@%i)", ch_num);

	/* Check status of the channel */
	
	Fmt(cmd, "%s<ROUT:OPEN? %s", sc_list);
	hp34970_out(dev_ID, cmd);
	hp34970_in(dev_ID, buf);
	
	/* Extract the return values */
		err = Scan(buf,"%s>%d", &dev_ON);			 // Reed status of a channel
		 switch(dev_ON) 			      			  
		 {
		      case 0:								 // If the channel is open 
		        if (flag == 0)						 // And needs to be switched ON
		        {
		      	sprintf(buf, "(@%i)", ch_num);   // Make a string for the channel  
				Fmt(cmd, "%s<ROUT:OPEN %s", buf);    // Format a command string
				hp34970_out(dev_ID, cmd);            // Close the channel 
   				}
   				break;
   				
   			   case 1:								 // If the channel is not open 
   			   if (flag == 1)						 // And needs to be switched OFF
		        {
		      	sprintf(buf, "(@%i)", ch_num);   // Make a string for the channel  
				Fmt(cmd, "%s<ROUT:CLOS %s", buf);    // Format a command string
				hp34970_out(dev_ID, cmd);            // Open the channel 
   				}
   				break;
   			   
   		  		default:
   		    	 hp34970_error(" Problem reading channel list");
   		    	 break;
   		    }
 
	/* Check, if work is done */
	hp34970_out(dev_ID, "ROUT:DONE?");
	hp34970_in(dev_ID, buf);
		err = Scan(buf, "%s>%d", &dev_ON);
		 if(dev_ON != 1) hp34970_error(" Problem open the channels");
		 
return;	
}

/*	**************************************************************  */
/*
 *	hp34970_get_chan_res
 *  This function gets the resistance applied to the specified channel.
 *
 *	Input:
 *	dev_ID, device identifier
 *	chan, channel number (0 to HP34970_MAX_NUM_CHAN - 1)
 *
 *	Output:
 *	res, applied resistance (ohm)
 *
 *	Zachary Wolf
 *	2/19/03
 */

void hp34970_get_chan_temp(int dev_ID, int chan, double* temp)
{
	/* Declare variables */
	int num_chan = 1;
	char meas = 't';
	
    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > HP34970_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	hp34970_error(msg);
    	return;
    }
    if (chan < 101 || chan > 400)
    {
    	Fmt(msg, "%s<chan = %i, out of range", chan);
    	hp34970_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	*temp = 0.;
    	return;
    #endif
    
	/* Get the temperature */     
	hp34970_scan_chan(dev_ID, num_chan, &chan, &meas, temp);
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	hp34970_monitor_chan
 *  This function monitors the specified measurement on the specified channel.
 *
 *	Input:
 *	dev_ID, device identifier
 *	chan, channel number
 *	meas, measurement ('v' = voltage, 'r' = resistance, '4' = 4-wire resistance, 't' = temperature, 'f' = frequency, 'p' = period)
 *
 *	Zachary Wolf
 *	6/6/05
 */

void hp34970_monitor_chan(int dev_ID, int chan, char meas)
{
	/* Declare variables */
	int dev_open;
	char scan_list[HP34970_MAX_NUM_CHAR];
	char chan_list[HP34970_MAX_NUM_CHAR];
	int err;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > HP34970_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	hp34970_error(msg);
    	return;
    }
	if (chan < 101 || chan >= 400)
	{
	    Fmt(msg, "%s<chan = %i, out of range", chan);
	    hp34970_error(msg);
 	   	return;
    }
	if (meas != 'v' && meas != 'r' && meas != '4' && meas != 't' && meas != 'f' && meas != 'p')
	{
	    Fmt(msg, "%s<meas = %c, unknown measurement", meas);
	    hp34970_error(msg);
 	   	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = hp34970_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	hp34970_error("Device not open");
    	return;
    }
    
    /* Make the scan list */
    sprintf(scan_list, "(@%i)", chan);
    
    /* Give the DMM the scan list */
    Fmt(cmd, "%s<ROUTE:SCAN %s", scan_list);
    hp34970_out(dev_ID, cmd);
     
    /* Set up the channel for the required measurement */
    /* Make the channel list */
	sprintf(chan_list, "(@%i)", chan);
	/* Do the appropriate setup for each measurement type */
    if (meas == 'v')
    {
		/* Set up the channel for voltage measurements */
		Fmt(cmd, "%s<SENSE:FUNCTION \"VOLTAGE:DC\", %s", chan_list);
		hp34970_out(dev_ID, cmd);
		/* Set the range to autorange */
		Fmt(cmd, "%s<SENSE:VOLTAGE:DC:RANGE:AUTO ON, %s", chan_list);
		hp34970_out(dev_ID, cmd);
		/* Set the A/D integration time */
		Fmt(cmd, "%s<SENSE:VOLTAGE:DC:NPLC 10, %s", chan_list);
		hp34970_out(dev_ID, cmd);
		/* Set the input impedance to 10 Mohms */ 
		Fmt(cmd, "%s<INPUT:IMPEDANCE:AUTO OFF, %s", chan_list);
		hp34970_out(dev_ID, cmd);
		/* Turn on offset compensation */ 
		Fmt(cmd, "%s<SENSE:ZERO:AUTO ON, %s", chan_list);
		hp34970_out(dev_ID, cmd);
	}
    else if (meas == 'r')
    {
		/* Set up the channel for resistance measurements */
		Fmt(cmd, "%s<SENSE:FUNCTION \"RESISTANCE\", %s", chan_list);
		hp34970_out(dev_ID, cmd);
		/* Set the range to autorange */
		Fmt(cmd, "%s<SENSE:RESISTANCE:RANGE:AUTO ON, %s", chan_list);
		hp34970_out(dev_ID, cmd);
		/* Set the A/D integration time */
		Fmt(cmd, "%s<SENSE:RESISTANCE:NPLC 10, %s", chan_list);
		hp34970_out(dev_ID, cmd);
		/* Turn on offset compensation */ 
		Fmt(cmd, "%s<SENSE:RESISTANCE:OCOMPENSATED ON, %s", chan_list);
		hp34970_out(dev_ID, cmd);
	}
    else if (meas == '4')
    {
		/* Set up the channel for 4-wire resistance measurements */
		Fmt(cmd, "%s<SENSE:FUNCTION \"FRESISTANCE\", %s", chan_list);
		hp34970_out(dev_ID, cmd);
		/* Set the range to autorange */
		Fmt(cmd, "%s<SENSE:FRESISTANCE:RANGE:AUTO ON, %s", chan_list);
		hp34970_out(dev_ID, cmd);
	    /* Set the A/D integration time */
	    Fmt(cmd, "%s<SENSE:FRESISTANCE:NPLC 10, %s", chan_list);
	    hp34970_out(dev_ID, cmd);
	    /* Turn on offset compensation */ 
	    Fmt(cmd, "%s<SENSE:FRESISTANCE:OCOMPENSATED ON, %s", chan_list);
	    hp34970_out(dev_ID, cmd);
	}
    else if (meas == 't')
    {
	    /* Set up the channel for temperature measurements */
	    Fmt(cmd, "%s<SENSE:FUNCTION \"TEMPERATURE\", %s", chan_list);
	    hp34970_out(dev_ID, cmd);
	    /* Set the units to C */
	    Fmt(cmd, "%s<UNIT:TEMPERATURE C, %s", chan_list);
	    hp34970_out(dev_ID, cmd);
	    /* Set the transducer type to thermistor */
	    Fmt(cmd, "%s<SENSE:TEMPERATURE:TRANSDUCER:TYPE THERMISTOR, %s", chan_list);
	    hp34970_out(dev_ID, cmd);
	    /* Set the thermistor resistance to 10K */ 
	    Fmt(cmd, "%s<SENSE:TEMPERATURE:TRANSDUCER:THERMISTOR:TYPE 10000, %s", chan_list);
	    hp34970_out(dev_ID, cmd);
	    /* Use 10 PLC for the measurement */
	    Fmt(cmd, "%s<SENSE:TEMPERATURE:NPLC 10, %s", chan_list);
	    hp34970_out(dev_ID, cmd);
	}
   	else if (meas == 'f')
   	{
	    /* Set up the channel for frequency measurements */
	    Fmt(cmd, "%s<SENSE:FUNCTION \"FREQUENCY\", %s", chan_list);
	    hp34970_out(dev_ID, cmd);
	    /* Set the voltage range to auto */
	    Fmt(cmd, "%s<SENSE:FREQUENCY:VOLTAGE:RANGE:AUTO ON, %s", chan_list);
	    hp34970_out(dev_ID, cmd);
	    /* Set the aperture to 0.1 sec */ 
	    Fmt(cmd, "%s<SENSE:FREQUENCY:APERTURE 0.1, %s", chan_list);
	    hp34970_out(dev_ID, cmd);
	    /* Set the frequency lower limit */
	    Fmt(cmd, "%s<SENSE:FREQUENCY:RANGE:LOWER 20, %s", chan_list);
	    hp34970_out(dev_ID, cmd);
	}
   	else if (meas == 'p')
   	{
	    /* Set up the channel for period measurements */
	    Fmt(cmd, "%s<SENSE:FUNCTION \"PERIOD\", %s", chan_list);
	    hp34970_out(dev_ID, cmd);
	    /* Set the voltage range to auto */
	    Fmt(cmd, "%s<SENSE:PERIOD:VOLTAGE:RANGE:AUTO ON, %s", chan_list);
	    hp34970_out(dev_ID, cmd);
	    /* Set the aperture to 1 sec */ 
	    Fmt(cmd, "%s<SENSE:PERIOD:APERTURE 1, %s", chan_list);
	    hp34970_out(dev_ID, cmd);
	}
	else hp34970_error("Unknown measurement requested.");
   
    /* Set up the channel to monitor */
	Fmt(cmd, "%s<ROUTE:MONITOR %s", chan_list);
	hp34970_out(dev_ID, cmd);
   
    /* Monitor the channel */
	Fmt(cmd, "%s<ROUTE:MONITOR:STATE ON");
	hp34970_out(dev_ID, cmd);
    
    /* Check for errors */
    err = hp34970_get_errors(dev_ID);
    if (err != 0)
    {
        hp34970_error("The HP34970 has an error");
        return;
    }
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	hp34970_monitor_off
 *  This function turns off monitoring of a channel.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Zachary Wolf
 *	6/6/05
 */

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

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > HP34970_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	hp34970_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = hp34970_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	hp34970_error("Device not open");
    	return;
    }
   
    /* Stor monitoring a channel */
	Fmt(cmd, "%s<ROUTE:MONITOR:STATE OFF");
	hp34970_out(dev_ID, cmd);
    
    /* Check for errors */
    err = hp34970_get_errors(dev_ID);
    if (err != 0)
    {
        hp34970_error("The HP34970 has an error");
        return;
    }
    
    /* Done */
    return;
}