/*	**************************************************************  */
/*
 *	Module HP33220
 *	This module contains I/O functions for the HP33220 function
 *	generator.                 
 *
 *	Zachary Wolf
 *	8/26/04
 */

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

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

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

/*  PRIVATE FUNCTIONS  */
int hp33220_open_dev(int gpib_board_addr, int gpib_dev_addr);
void hp33220_close_dev(int dev_ID);
int hp33220_out(int dev_ID, char* buf);
int hp33220_in(int dev_ID, char* buf);
int hp33220_serial_poll(int dev_ID, int* spoll);
int hp33220_check_dev_open(int dev_ID);
int hp33220_get_errors(int dev_ID);
void hp33220_message(char* msg);
void hp33220_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[HP33220_MAX_NUM_DEV + 1];
static int dev_descr[HP33220_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[HP33220_MAX_CMD + 1];
static char msg[HP33220_MAX_CMD + 1];

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

/*	PUBLIC FUNCTIONS  */

/*	**************************************************************  */
/*
 *  hp33220_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
 *	8/26/04
 */

void hp33220_init(int gpib_board_addr, int gpib_dev_addr, int* ID)
{
    /* Declare variables */
    int dev_ID;
    int err;
    
    /* Message */
    hp33220_message("");
    hp33220_message("Initializing the HP33220...");

    /* 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);
    	hp33220_error(msg);
    	return;
    }
    if (gpib_dev_addr < 1 || gpib_dev_addr > 30)
    {
    	Fmt(msg, "%s<gpib_dev_addr = %i, out of range", gpib_dev_addr);
    	hp33220_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	*ID = 1;
    	return;
    #endif
    
    /* Open the hp33220 */
    dev_ID = hp33220_open_dev(gpib_board_addr, gpib_dev_addr);
    if (dev_ID <= 0)
    {
        hp33220_error("Device was not opened");
        return;
    }
    
    /* Clear the status registor */
    hp33220_out(dev_ID, "*CLS");
    
    /* Turn off service requests */
    hp33220_out(dev_ID, "*SRE 0");
    
    /* Leave the HP33220 in a known default state */
    hp33220_out(dev_ID, "*RST");

    /* Get the HP33220 ID */
    hp33220_out(dev_ID, "*IDN?");
    err = hp33220_in(dev_ID, cmd);
    if (err != 0)
    {
        hp33220_error("Problem reading ID");
        hp33220_close_dev(dev_ID);
        return;
    }
    hp33220_message(cmd);

    /* Check for errors */
    err = hp33220_get_errors(dev_ID);
    if (err != 0)
    {
        hp33220_error("The HP33220 has an error");
        hp33220_close_dev(dev_ID);
        return;
    }

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

/*	**************************************************************  */
/*
 *	hp33220_output_sine
 *  This function makes the HP33220 output a sine wave.  The amplitude
 *	and frequency must be specified.  The function assumes a
 *	high load impedance.  The user must account for the source impedance
 *	when driving low impedance loads.
 *
 *	Input:
 *	dev_ID, device identifier
 *	ampl, voltage amplitude zero to peak (V)
 *	freq, sine wave frequency (Hz)
 *
 *	Zachary Wolf
 *	11/9/04
 */

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

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > HP33220_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	hp33220_error(msg);
    	return;
    }
    if (ampl < 0.002 || ampl > 10.)
    {
    	Fmt(msg, "%s<hp33220_output_sine: ampl = %f V, out of range, adjusted...", ampl);
    	hp33220_message(msg);
    	if (ampl < 0.002) ampl = 0.002;
    	if (ampl > 10.) ampl = 10.;
    }
    if (freq < 1.e-6 || freq > 2.e7)
    {
    	Fmt(msg, "%s<hp33220_output_sine: freq = %f, out of range, adjusted...", freq);
    	hp33220_message(msg);
    	if (freq < 1.e-6) freq = 1.e-6;
    	if (freq > 2.e7) freq = 2.e7;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = hp33220_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	hp33220_error("Device not open");
    	return;
    }
    
    /* Reset the HP33220 so it is in a known state */
    hp33220_out(dev_ID, "*RST");
    
    /* Set the load to high impedance */
    //hp33220_out(dev_ID, "OUTP:LOAD INF");
    /* Set the load mmm*/
    hp33220_set_load(dev_ID, HP33220_GEN_LOAD);
    
    /* No DC offset */
    hp33220_out(dev_ID, "VOLT:OFFS 0.");
    
    /* Set the function to sine wave */
    hp33220_out(dev_ID, "FUNC SIN");
    
    /* Set the amplitude */
    hp33220_out(dev_ID, "VOLT:UNIT VPP");
    Fmt(cmd, "%s<VOLT %f", 2 * ampl);
    hp33220_out(dev_ID, cmd);
    
    /* Set the frequency */
    Fmt(cmd, "%s<FREQ %f", freq);
    hp33220_out(dev_ID, cmd);
    
    /* Turn on the output */
    hp33220_out(dev_ID, "OUTP ON");
    
    /* Turn on the sync output */
    hp33220_out(dev_ID, "OUTP:SYNC ON");
    
    /* Keep the normal phase relative to the sync output */
    hp33220_out(dev_ID, "OUTP:POL NORM");

    /* Check for errors */
    err = hp33220_get_errors(dev_ID);
    if (err != 0)
    {
        hp33220_error("The HP33220 has an error");
        return;
    }
   
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	hp33220_output_square
 *  This function makes the HP33220 output a square wave.  The amplitude,
 *	frequency, and duty cycle must be specified.  The function assumes a
 *	high load impedance.  The user must account for the source impedance
 *	when driving low impedance loads.
 *
 *	Input:
 *	dev_ID, device identifier
 *	ampl, voltage amplitude zero to peak (V)
 *	freq, square wave frequency (Hz)
 *	duty_cycle, duty cycle (20 to 80%)
 *
 *	Zachary Wolf
 *	11/9/04
 */

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

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > HP33220_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	hp33220_error(msg);
    	return;
    }
    if (ampl < 0.002 || ampl > 10.)
    {
    	Fmt(msg, "%s<hp33220_output_square: ampl = %f V, out of range, adjusted...", ampl);
    	hp33220_message(msg);
    	if (ampl < 0.002) ampl = 0.002;
    	if (ampl > 10.) ampl = 10.;
    }
    if (freq < 1.e-6 || freq > 2.e7)
    {
    	Fmt(msg, "%s<hp33220_output_square: freq = %f, out of range, adjusted...", freq);
    	hp33220_message(msg);
    	if (freq < 1.e-6) freq = 1.e-6;
    	if (freq > 2.e7) freq = 2.e7;
    }
    if (duty_cycle < 20 || duty_cycle > 80)
    {
    	Fmt(msg, "%s<hp33220_output_square: duty_cycle = %f, out of range, adjusted...", duty_cycle);
    	hp33220_message(msg);
    	if (duty_cycle < 20) duty_cycle = 20;
    	if (duty_cycle > 80) duty_cycle = 80;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = hp33220_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	hp33220_error("Device not open");
    	return;
    }
    
    /* Reset the HP33220 so it is in a known state */
    hp33220_out(dev_ID, "*RST");
    
    /* Set the load to high impedance */
    //hp33220_out(dev_ID, "OUTP:LOAD INF");
    /* Set the load mmm*/
    hp33220_set_load(dev_ID, HP33220_GEN_LOAD);
    
    /* No DC offset */
    hp33220_out(dev_ID, "VOLT:OFFS 0.");
    
    /* Set the function to square wave */
    hp33220_out(dev_ID, "FUNC SQU");
    
    /* Set the amplitude */
    hp33220_out(dev_ID, "VOLT:UNIT VPP");
    Fmt(cmd, "%s<VOLT %f", 2 * ampl);
    hp33220_out(dev_ID, cmd);
    
    /* Set the frequency */
    Fmt(cmd, "%s<FREQ %f", freq);
    hp33220_out(dev_ID, cmd);
    
    /* Set the duty cycle */
    Fmt(cmd, "%s<FUNC:SQU:DCYCLE %f", duty_cycle);
    hp33220_out(dev_ID, cmd);
    
    /* Turn on the output */
    hp33220_out(dev_ID, "OUTP ON");
    
    /* Turn on the sync output */
    hp33220_out(dev_ID, "OUTP:SYNC ON");
    
    /* Keep the normal phase relative to the sync output */
    hp33220_out(dev_ID, "OUTP:POL NORM");

    /* Check for errors */
    err = hp33220_get_errors(dev_ID);
    if (err != 0)
    {
        hp33220_error("The HP33220 has an error");
        return;
    }
   
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	hp33220_output_ramp
 *  This function makes the HP33220 output a ramp waveform.  The amplitude,
 *	frequency, and symmetry must be specified.  The function assumes a
 *	high load impedance.  The user must account for the source impedance
 *	when driving low impedance loads.
 *
 *	Input:
 *	dev_ID, device identifier
 *	ampl, voltage amplitude zero to peak (V)
 *	freq, ramp wave frequency (Hz)
 *	symm, symmetry, the amount of time the ramp is rising (0 to 100%)
 *
 *	Zachary Wolf
 *	11/9/04
 */

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

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > HP33220_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	hp33220_error(msg);
    	return;
    }
    if (ampl < 0.002 || ampl > 10.)
    {
    	Fmt(msg, "%s<hp33220_output_ramp: ampl = %f V, out of range, adjusted...", ampl);
    	hp33220_message(msg);
    	if (ampl < 0.002) ampl = 0.002;
    	if (ampl > 10.) ampl = 10.;
    }
    if (freq < 1.e-6 || freq > 2.e5)
    {
    	Fmt(msg, "%s<hp33220_output_ramp: freq = %f, out of range, adjusted...", freq);
    	hp33220_message(msg);
    	if (freq < 1.e-6) freq = 1.e-6;
    	if (freq > 2.e5) freq = 2.e5;
    }
    if (symm < 0 || symm > 100)
    {
    	Fmt(msg, "%s<hp33220_output_ramp: symm = %f, out of range, adjusted...", symm);
    	hp33220_message(msg);
    	if (symm < 0) symm = 0.;
    	if (symm > 100) symm = 100.;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = hp33220_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	hp33220_error("Device not open");
    	return;
    }
    
    /* Reset the HP33220 so it is in a known state */
    hp33220_out(dev_ID, "*RST");
    
    /* Set the load to high impedance */
    //hp33220_out(dev_ID, "OUTP:LOAD INF");
    /* Set the load mmm*/
    hp33220_set_load(dev_ID, HP33220_GEN_LOAD);
    
    /* No DC offset */
    hp33220_out(dev_ID, "VOLT:OFFS 0.");
    
    /* Set the function to ramp wave */
    hp33220_out(dev_ID, "FUNC RAMP");
    
    /* Set the amplitude */
    hp33220_out(dev_ID, "VOLT:UNIT VPP");
    Fmt(cmd, "%s<VOLT %f", 2 * ampl);
    hp33220_out(dev_ID, cmd);
    
    /* Set the frequency */
    Fmt(cmd, "%s<FREQ %f", freq);
    hp33220_out(dev_ID, cmd);
    
    /* Set the symmetry */
    Fmt(cmd, "%s<FUNC:RAMP:SYMM %f", symm);
    hp33220_out(dev_ID, cmd);
    
    /* Turn on the output */
    hp33220_out(dev_ID, "OUTP ON");
    
    /* Turn on the sync output */
    hp33220_out(dev_ID, "OUTP:SYNC ON");
    
    /* Keep the normal phase relative to the sync output */
    hp33220_out(dev_ID, "OUTP:POL NORM");

    /* Check for errors */
    err = hp33220_get_errors(dev_ID);
    if (err != 0)
    {
        hp33220_error("The HP33220 has an error");
        return;
    }
   
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	hp33220_output_pulse
 *  This function makes the HP33220 output a pulse waveform.  The amplitude,
 *	period, pulse width, rise and fall times must be specified.  The function assumes a
 *	high load impedance.  The user must account for the source impedance
 *	when driving low impedance loads.
 *
 *	Input:
 *	dev_ID, device identifier
 *	ampl, voltage amplitude zero to peak (V)
 *	period, time between pulses (sec)
 *	width, pulse width between 50% points (sec)
 *	edge_time, rise and fall time 10% to 90% (sec)
 *
 *	Zachary Wolf
 *	11/9/04
 */

void hp33220_output_pulse(int dev_ID, double ampl, double period, double width, double edge_time)
{
	/* Declare variables */
	int dev_open;
	int err;

    /* Check input parameters */
    /* Note: these are rough checks */
    /* The device will adjust incorrect values, but will give an error message */
    if (dev_ID < 1 || dev_ID > HP33220_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	hp33220_error(msg);
    	return;
    }
    if (ampl < 0.002 || ampl > 10.)
    {
    	Fmt(msg, "%s<hp33220_output_pulse: ampl = %f V, out of range, adjusted...", ampl);
    	hp33220_message(msg);
    	if (ampl < 0.002) ampl = 0.002;
    	if (ampl > 10.) ampl = 10.;
    }
    if (period < 2.e-7 || period > 2.e3)
    {
    	Fmt(msg, "%s<hp33220_output_pulse: period = %f, out of range, adjusted...", period);
    	hp33220_message(msg);
    	if (period < 2.e-7) period = 2.e-7;
    	if (period > 2.e3) period = 2.e3;
    }
    if (width < 2.e-8 || width > 2.e3)
    {
    	Fmt(msg, "%s<hp33220_output_pulse: width = %f, out of range, adjusted...", width);
    	hp33220_message(msg);
    	if (width < 2.e-8) width = 2.e-8;
    	if (width > 2.e3) width = 2.e3;
    }
    if (edge_time < 5.e-9 || edge_time > 1.e-7)
    {
    	Fmt(msg, "%s<hp33220_output_pulse: edge_time = %f, out of range, adjusted...", edge_time);
    	hp33220_message(msg);
    	if (edge_time < 5.e-9) edge_time = 5.e-9;
    	if (edge_time > 1.e-7) edge_time = 1.e-7;
    }
    if (period < width + 1.6 * edge_time)
    {
    	Fmt(msg, "%s<hp33220_output_pulse: period too short for width, adjusted...");
    	hp33220_message(msg);
    	period = width + 1.6 * edge_time;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = hp33220_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	hp33220_error("Device not open");
    	return;
    }
    
    /* Reset the HP33220 so it is in a known state */
    hp33220_out(dev_ID, "*RST");
    
    /* Set the load to high impedance */
    //hp33220_out(dev_ID, "OUTP:LOAD INF");
    /* Set the load mmm*/
    hp33220_set_load(dev_ID, HP33220_GEN_LOAD);
    
    /* No DC offset */
    hp33220_out(dev_ID, "VOLT:OFFS 0.");
    
    /* Set the function to pulse */
    hp33220_out(dev_ID, "FUNC PULSE");
    
    /* Set the amplitude */
    hp33220_out(dev_ID, "VOLT:UNIT VPP");
    Fmt(cmd, "%s<VOLT %f", 2 * ampl);
    hp33220_out(dev_ID, cmd);
    
    /* Set the period */
    Fmt(cmd, "%s<PULSE:PERIOD %f", period);
    hp33220_out(dev_ID, cmd);
    
    /* Set the pulse width */
    Fmt(cmd, "%s<FUNC:PULSE:WIDTH %f", width);
    hp33220_out(dev_ID, cmd);
    
    /* Keep the pulse width constant if the period is varied */
    hp33220_out(dev_ID, "FUNC:PULSE:HOLD WIDTH");
    
    /* Set the rise and fall times */
    Fmt(cmd, "%s<FUNC:PULSE:TRANSITION %f", edge_time);
    hp33220_out(dev_ID, cmd);
    
    /* Turn on the output */
    hp33220_out(dev_ID, "OUTP ON");
    
    /* Turn on the sync output */
    hp33220_out(dev_ID, "OUTP:SYNC ON");
    
    /* Keep the normal phase relative to the sync output */
    hp33220_out(dev_ID, "OUTP:POL NORM");

    /* Check for errors */
    err = hp33220_get_errors(dev_ID);
    if (err != 0)
    {
        hp33220_error("The HP33220 has an error");
        return;
    }
   
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	hp33220_output_on
 *  This function turns on the output of the hp33220 function generator.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Michael Levashov
 *	06/13/2007
 */

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

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > HP33220_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	hp33220_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = hp33220_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	hp33220_error("Device not open");
    	return;
    }
    
    /* Send the command */
    Fmt(msg, "OUTPUT ON");
    hp33220_out(dev_ID, msg);
    
    return;
}
    

/*	**************************************************************  */
/*
 *	hp33220_output_off
 *  This function turns off the output of the hp33220 function generator.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Michael Levashov
 *	06/13/2007
 */

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

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > HP33220_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	hp33220_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = hp33220_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	hp33220_error("Device not open");
    	return;
    }
    
    /* Send the command */
    Fmt(msg, "OUTPUT OFF");
    hp33220_out(dev_ID, msg);
    
    return;
}

/*	**************************************************************  */
/*
 *	hp33220_set_ampl
 *  This function sets the amplitude of the output.  The waveform,
 *	frequcncy, etc. must have been set previously.  The function assumes a
 *	high load impedance.  The user must account for the source impedance
 *	when driving low impedance loads.
 *
 *	Input:
 *	dev_ID, device identifier
 *	ampl, voltage amplitude zero to peak (V)
 *
 *	Zachary Wolf
 *	11/9/04
 */

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

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > HP33220_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	hp33220_error(msg);
    	return;
    }
    if (ampl < 0.001 || ampl > 10.)
    {
    	Fmt(msg, "%s<hp33220_set_ampl: ampl = %f V, out of range, adjusted...", ampl);
    	hp33220_message(msg);
    	if (ampl < 0.002) ampl = 0.002;
    	if (ampl > 10.) ampl = 10.;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = hp33220_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	hp33220_error("Device not open");
    	return;
    }
    
    /* Set the amplitude */
    hp33220_out(dev_ID, "VOLT:UNIT VPP");
    Fmt(cmd, "%s<VOLT %f", 2 * ampl);
    hp33220_out(dev_ID, cmd);

    /* Check for errors */
    err = hp33220_get_errors(dev_ID);
    if (err != 0)
    {
        hp33220_error("The HP33220 has an error");
        return;
    }
   
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	hp33220_set_freq
 *  This function sets the frequency of the output.  The waveform,
 *	amplitude, etc. must have been set previously.
 *
 *	Input:
 *	dev_ID, device identifier
 *	freq, output frequency (Hz)
 *
 *	Zachary Wolf
 *	11/9/04
 */

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

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > HP33220_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	hp33220_error(msg);
    	return;
    }
    if (freq < 1.e-6 || freq > 2.e7)
    {
    	Fmt(msg, "%s<hp33220_set_freq: freq = %f, out of range, adjusted...", freq);
    	hp33220_message(msg);
    	if (freq < 1.e-6) freq = 1.e-6;
    	if (freq > 2.e7) freq = 2.e7;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = hp33220_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	hp33220_error("Device not open");
    	return;
    }
    
    /* Set the frequency */
    Fmt(cmd, "%s<FREQ %f", freq);
    hp33220_out(dev_ID, cmd);

    /* Check for errors */
    err = hp33220_get_errors(dev_ID);
    if (err != 0)
    {
        hp33220_error("The HP33220 has an error");
        return;
    }
   
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	hp33220_set_dc_offset
 *  This function sets the DC offset of the output.  The waveform,
 *	amplitude, etc. must have been set previously.
 *
 *	Input:
 *	dev_ID, device identifier
 *	dc_offset, output dc_offset (V)
 *
 *	Zachary Wolf
 *	11/9/04
 */

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

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > HP33220_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	hp33220_error(msg);
    	return;
    }
    hp33220_out(dev_ID, "VOLT:UNIT VPP");	/* Need amplitude to get allowed range */
    hp33220_out(dev_ID, "VOLT?");			/* Output cannot exceed +-10 V */
    hp33220_in(dev_ID, msg);
    Scan(msg, "%s>%f", &ampl);
    ampl = ampl / 2.;
    if (dc_offset - ampl < -10. || dc_offset + ampl > 10.)
    {
    	Fmt(msg, "%s<hp33220_set_dc_offset: dc_offset = %f V, out of range, adjusted...", dc_offset);
    	hp33220_message(msg);
    	if (dc_offset - ampl < -10.) dc_offset = -10. + ampl;
    	if (dc_offset + ampl > 10.) dc_offset = 10. - ampl;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = hp33220_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	hp33220_error("Device not open");
    	return;
    }
    
    /* Set the dc_offset */
    Fmt(cmd, "%s<VOLT:OFFS %f", dc_offset);
    hp33220_out(dev_ID, cmd);

    /* Check for errors */
    err = hp33220_get_errors(dev_ID);
    if (err != 0)
    {
        hp33220_error("The HP33220 has an error");
        return;
    }
   
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	hp33220_set_pulse_period
 *  This function sets the period of pulse waveforms.  The pulse waveform,
 *	amplitude, etc. must have been set previously.
 *
 *	Input:
 *	dev_ID, device identifier
 *	period, output period (sec)
 *
 *	Zachary Wolf
 *	11/9/04
 */

void hp33220_set_pulse_period(int dev_ID, double period)	
{
	/* Declare variables */
	int dev_open;
	int err;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > HP33220_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	hp33220_error(msg);
    	return;
    }
    if (period < 2.e-7 || period > 2.e3)
    {
    	Fmt(msg, "%s<hp33220_set_pulse_period: period = %f, out of range, adjusted...", period);
    	hp33220_message(msg);
    	if (period < 2.e-7) period = 2.e-7;
    	if (period > 2.e3) period = 2.e3;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = hp33220_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	hp33220_error("Device not open");
    	return;
    }
    
    /* Set the period */
    Fmt(cmd, "%s<PULSE:PERIOD %f", period);
    hp33220_out(dev_ID, cmd);

    /* Check for errors */
    err = hp33220_get_errors(dev_ID);
    if (err != 0)
    {
        hp33220_error("The HP33220 has an error");
        return;
    }
   
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	hp33220_set_delta_freq
 *  This function increments the frequency of the output.
 *
 *	Input:
 *	dev_ID, device identifier
 *	delta_freq, frequency change of the output (Hz)
 *
 *	Zachary Wolf
 *	11/9/04
 */

void hp33220_set_delta_freq(int dev_ID, double delta_freq)
{
	/* Declare variables */
	double freq;
	double new_freq;
	
	/* Get the current frequency */
	hp33220_get_freq(dev_ID, &freq);
	
	/* Increment the frequency */
	new_freq = freq + delta_freq;
	
	/* Set the new frequency */
	hp33220_set_freq(dev_ID, new_freq);
	
   
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	hp33220_get_ampl
 *  This function gets the amplitude of the output.  The function assumes a
 *	high load impedance.  The user must account for the source impedance
 *	when driving low impedance loads.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Output:
 *	ampl, voltage amplitude zero to peak (V)
 *
 *	Zachary Wolf
 *	11/9/04
 */

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

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > HP33220_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	hp33220_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = hp33220_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	hp33220_error("Device not open");
    	return;
    }
    
    /* Get the amplitude */
    hp33220_out(dev_ID, "VOLT?");
    hp33220_in(dev_ID, msg);
    Scan(msg, "%s>%f", ampl);
    
    /* Convert from Vpp to V0p */
    *ampl = *ampl / 2.;

    /* Check for errors */
    err = hp33220_get_errors(dev_ID);
    if (err != 0)
    {
        hp33220_error("The HP33220 has an error");
        return;
    }
   
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	hp33220_get_freq
 *  This function gets the frequency of the output.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Output:
 *	freq, frequency of the output voltage (Hz)
 *
 *	Zachary Wolf
 *	11/9/04
 */

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

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > HP33220_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	hp33220_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = hp33220_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	hp33220_error("Device not open");
    	return;
    }
    
    /* Get the amplitude */
    hp33220_out(dev_ID, "FREQ?");
    hp33220_in(dev_ID, msg);
    Scan(msg, "%s>%f", freq);

    /* Check for errors */
    err = hp33220_get_errors(dev_ID);
    if (err != 0)
    {
        hp33220_error("The HP33220 has an error");
        return;
    }
   
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	hp33220_get_dc_offset
 *  This function gets the DC offset of the output.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Output:
 *	offset, DC offset of the output voltage (V)
 *
 *	Zachary Wolf
 *	11/9/04
 */

void hp33220_get_dc_offset(int dev_ID, double* offset)
{													 
	/* Declare variables */
	int dev_open;
	int err;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > HP33220_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	hp33220_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = hp33220_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	hp33220_error("Device not open");
    	return;
    }
    
    /* Get the DC offset */
    hp33220_out(dev_ID, "VOLTAGE:OFFSET?");
    hp33220_in(dev_ID, msg);
    Scan(msg, "%s>%f", offset);

    /* Check for errors */
    err = hp33220_get_errors(dev_ID);
    if (err != 0)
    {
        hp33220_error("The HP33220 has an error");
        return;
    }
   
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	hp33220_exit
 *  This function leaves the HP33220 in a desired state and
 *	closes the device.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Zachary Wolf
 *	7/27/98
 */

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

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

    /* Leave the device in the desired state */
    /* Reset the HP33220 to the power on state */
    //hp33220_out(dev_ID, "*RST");

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

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

/*	PRIVATE FUNCTIONS  */

/*	**************************************************************  */
/*
 *	hp33220_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
 *	8/26/04
 */

int hp33220_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);
    	hp33220_error(msg);
    	return -1;
    }
    if (gpib_dev_addr < 1 || gpib_dev_addr > 30)
    {
    	Fmt(msg, "%s<gpib_dev_addr = %i, out of range", gpib_dev_addr);
    	hp33220_error(msg);
    	return -1;
    }

	/* Initialization */
    dev_ID = 0;

    /* Check to see if the device is already in the device table */
    for (i = 1; i <= HP33220_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 <= HP33220_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)
    {
    	hp33220_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, T10s, 0, 0x140A);
	if (descr <= 0)
	{
		hp33220_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)
	//{
	//	hp33220_error("Problem clearing device");
	//}
    
    /* Return the device ID */
    return dev_ID;
}

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

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

/*	**************************************************************  */
/*
 *	hp33220_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
 *	7/27/98
 */

int hp33220_out(int dev_ID, char* buf)
{
	/* Declare variables */
	char out_buf[HP33220_MAX_CMD];
	int nbytes;
	int err;
	
	/* 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);
		hp33220_error(msg);
		return -1;
	}
	
	/* Done */
    return 0;
}

/*	**************************************************************  */
/*
 *	hp33220_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
 *	7/27/98
 */

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

/*	**************************************************************  */
/*
 *	hp33220_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
 *	11/8/04
 */

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

/*	**************************************************************  */
/*
 *	hp33220_check_dev_open
 *  This function checks to see if the specified device is open.
 *	If the device has been opened, a 1 is returned, 0 otherwise.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Output:
 *	status, 1 if device is open, 0 otherwise
 *
 *	Zachary Wolf
 *	7/27/98
 */

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

/*	**************************************************************  */
/*
 *	hp33220_get_errors
 *  This function obtains device errors.
 *	The operator is alerted if there is an error.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Output:
 *	err, 0 if no errors, -1 otherwise
 *
 *	Zachary Wolf
 *	8/26/04
 */

int hp33220_get_errors(int dev_ID)
{
	/* Declare variables */
    int status;
    int err;
    int disp_err;
    
    /* Initialization */
    err = 0;
    disp_err = 0;

	/* Get the HP33220 status byte */
	hp33220_out(dev_ID, "*STB?");
	hp33220_in(dev_ID, cmd);
	
	/* Extract the status value */
	Scan(cmd, "%s>%i", &status);
    
    /* Alert the operator if there is an error */
    if ((status & 4) != 0)
    {
    	Fmt(msg, "%s<The HP33220 has an error, status byte = %i", status);
    	hp33220_message(msg);
        err = -1;
        disp_err = -1;
    }
    
    /* Display the contents of the error queue */
    while (disp_err != 0)
    {
		hp33220_out(dev_ID, "SYST:ERR?");
		hp33220_in(dev_ID, cmd);
		if (strstr(cmd, "+0,\"No error\"") == NULL) hp33220_message(cmd);
		else disp_err = 0;
			
	}
    
    /* Done */
    return err;
}

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

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

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

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


/* ***************************************************************** */
/*
 * hp33220_set_load	   
 * Sets the load on the output, so that the output voltage is correctly displayed
 *
 * Input:
 * dev_ID, device identifier
 * load, the value to set in the device.  A number less than 1 indicates High impedence.
 *
 * Michael Levashov
 * 06/30/06
 */
 
void hp33220_set_load(int dev_ID,double load)
{
	char buf[20];
	
	if(load<1)
		hp33220_out(dev_ID, "OUTPUT:LOAD INF");
	else if(load<=10000)
	{
		Fmt(buf,"%s<%s%f[p3]","OUTPUT:LOAD ",load);
		hp33220_out(dev_ID, buf);
	}
	else
		hp33220_error("Generator load out of range.\n");
}