/*	**************************************************************  */
/*
 *	Module PM500
 *	This module contains I/O functions for the Newport model
 *	PM500 controller.                 
 *
 *	Zachary Wolf
 *	2/1/01
 */ 

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

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

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

/*  PRIVATE FUNCTIONS  */
int pm500_open_dev(int gpib_board_addr, int gpib_dev_addr);
void pm500_close_dev(int dev_ID);
int pm500_out(int dev_ID, char *buf);
int pm500_in(int dev_ID, char* buf);
int pm500_check_dev_open(int dev_ID);
int pm500_check_errors(int dev_ID);
int pm500_serial_poll(int dev_ID, int* spoll);
void pm500_hold_until_move_complete(int dev_ID, char axis);
void pm500_message(char* msg);
void pm500_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[PM500_MAX_NUM_DEV + 1];
static int dev_descr[PM500_MAX_NUM_DEV + 1];
static int dev_count;

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

/*  PRIVATE GLOBAL VARIABLES  */
/*
 *  cmd, buffer for GPIB I/O strings
 *  msg, buffer for message strings to Standard I/O
 */
static char cmd[PM500_MAX_CMD + 1];
static char msg[PM500_MAX_CMD + 1];

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

/*	PUBLIC FUNCTIONS  */

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

void pm500_init(int gpib_board_addr, int gpib_dev_addr, int* ID)
{
    /* Declare variables */
    int dev_ID;
    int err;
    
    /* Message */
    pm500_message("");
    pm500_message("Initializing the PM500...");

    /* 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);
    	pm500_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);
    	pm500_error(msg);
    	return;
    }
    
    /* Exit here if testing without hardware */
    #ifdef DUMMY_DEVICES
    	*ID = 1;
    	return;
    #endif
    
    /* Open the PM500 */
    dev_ID = pm500_open_dev(gpib_board_addr, gpib_dev_addr);
    if (dev_ID <= 0)
    {
        pm500_error("Device was not opened");
        return;
    }
    
    /* Restart the system */
    //pm500_out(dev_ID, "RSTART");
    //Delay(1.);
    
    /* Set the communication options to CR LF EOI */
    pm500_out(dev_ID, "ENAINT $606");
    Delay(.3);
    
    /* Talk to the PM500 */
    pm500_out(dev_ID, "VN ?");
    err = pm500_in(dev_ID, cmd);
    if (err != 0)
    {
        pm500_error("Problem reading dev_ID");
        pm500_close_dev(dev_ID);
        return;
    }
    pm500_message(cmd);
    
    /* Set the direction sign for each exis */
    pm500_out(dev_ID, "ASIGN-1");
    pm500_out(dev_ID, "BSIGN-1");
    pm500_out(dev_ID, "XSIGN-1");
    pm500_out(dev_ID, "YSIGN-1");
    
    /* System specific initialization */
    if (PM500_SYSTEM_NUM == 1)	/* SLAC system */
    {
   		pm500_out(dev_ID, "AHSLOPE .02");
    	pm500_out(dev_ID, "BHSLOPE .02");
    	pm500_out(dev_ID, "XHSLOPE .02");
    	pm500_out(dev_ID, "YHSLOPE .02");
     	//pm500_out(dev_ID, "XHSLOPE ?");
    	//err = pm500_in(dev_ID, cmd);
    	//pm500_message(cmd);
    }
    if (PM500_SYSTEM_NUM == 2)	/* SSC system */
    {
    }
    
    /* Move the stages to their fiducials (the zero position) */
	pm500_rel_stage_move(dev_ID, 'A', .1, .05, .001);
	pm500_rel_stage_move(dev_ID, 'B', .1, .05, .001);
	pm500_rel_stage_move(dev_ID, 'X', .1, .05, .001);
	pm500_rel_stage_move(dev_ID, 'Y', .1, .05, .001);
    pm500_move_to_fiducial(dev_ID, 'A');
    pm500_move_to_fiducial(dev_ID, 'B');
    pm500_move_to_fiducial(dev_ID, 'X');
    pm500_move_to_fiducial(dev_ID, 'Y');
    
    /* Perform an autocalibration on each axis */
    //pm500_autocal(dev_ID, 'A');
    //pm500_autocal(dev_ID, 'B');
    //pm500_autocal(dev_ID, 'X');
    //pm500_autocal(dev_ID, 'Y');
    
    /* Check for errors */
	pm500_check_errors(dev_ID);

	/* Return the ID number */
    *ID = dev_ID;
    
    /* Done */
    return;
}
								 
/*	**************************************************************  */
/*
 *	pm500_autocal
 *  This function performs a self calibration on the specified axis.
 *
 *	Input:
 *	dev_ID, device identifier
 *	axis, axis to move (A, B, X, or Y)
 *
 *	Zachary Wolf
 *	5/14/01
 */

void pm500_autocal(int dev_ID, char axis)
{
	/* Declare variables */
	int err;
	int dev_open;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > PM500_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	pm500_error(msg);
    	return;
    }
    if (axis != 'A' && axis != 'B' && axis != 'X' && axis != 'Y')
    {
    	Fmt(msg, "%s<axis = %c, out of range (A, B, X, or Y)", axis);
    	pm500_error(msg);
    }
    
    /* Exit here if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = pm500_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	pm500_error("Device not open");
    	return;
    }
    
    /* Message */
    printf("PM500 is performing a calibration on axis %c...\n", axis);
    
    /* Perform the calibration */
	Fmt(cmd, "%s<%cAZ", axis);
    pm500_out(dev_ID, cmd);
   
    /* Wait unil the calibration is complete */
    pm500_hold_until_move_complete(dev_ID, axis);
    
    /* Check for errors */
	pm500_check_errors(dev_ID);
    
    /* Done */
    return;
}
								 
/*	**************************************************************  */
/*
 *	pm500_move_to_fiducial
 *  This function moves the specified axis to its fiducial point (center
 *	of the stage).
 *
 *	Input:
 *	dev_ID, device identifier
 *	axis, axis to move (A, B, X, or Y)
 *
 *	Zachary Wolf
 *	5/15/01
 */

void pm500_move_to_fiducial(int dev_ID, char axis)
{
	/* Declare variables */
	int err;
	int dev_open;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > PM500_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	pm500_error(msg);
    	return;
    }
    if (axis != 'A' && axis != 'B' && axis != 'X' && axis != 'Y')
    {
    	Fmt(msg, "%s<axis = %c, out of range (A, B, X, or Y)", axis);
    	pm500_error(msg);
    }
    
    /* Exit here if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = pm500_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	pm500_error("Device not open");
    	return;
    }
    
    /* Message */
    printf("Moving axis %c to its fiducial...\n", axis);
    
    /* Move the stage */
	Fmt(cmd, "%s<%cF0", axis);
    pm500_out(dev_ID, cmd);
   
    /* Wait unil the move is complete */
    pm500_hold_until_move_complete(dev_ID, axis);
    
    /* Check for errors */
	pm500_check_errors(dev_ID);
    
    /* Done */
    return;
}
								 
/*	**************************************************************  */
/*
 *	pm500_rel_stage_move
 *  This function moves a stage a given distance relative to
 *	its present position.  The acceleration and velocity are specified.
 *
 *	Input:
 *	dev_ID, device identifier
 *	axis, axis to move (A, B, X, or Y)
 *	acc, acceleration (m/sec/sec)
 *	vel, velocity (m/sec)
 *	dis, distance (m), can be + or -
 *
 *	Zachary Wolf
 *	2/5/01
 */

void pm500_rel_stage_move(int dev_ID, char axis, double acc, double vel, double dis)
{
	/* Declare variables */
	int err;
	int dev_open;
	double ini_pos, fin_pos;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > PM500_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	pm500_error(msg);
    	return;
    }
    if (axis != 'A' && axis != 'B' && axis != 'X' && axis != 'Y')
    {
    	Fmt(msg, "%s<axis = %c, out of range (A, B, X, or Y)", axis);
    	pm500_error(msg);
    }
    if (acc <= 0.)
    {
    	Fmt(msg, "%s<acc = %f, out of range, must be positive", acc);
    	pm500_error(msg);
    }
    if (vel <= 0.)
    {
    	Fmt(msg, "%s<vel = %f, out of range, must be positive", vel);
    	pm500_error(msg);
    }
    
    /* Exit here if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = pm500_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	pm500_error("Device not open");
    	return;
    }
    
    /* Get the initial motor position before the move */
	pm500_get_pos(dev_ID, axis, &ini_pos);
    
    /* Set the acceleration, required units mm/sec/sec */
	Fmt(cmd, "%s<%cACCEL%f", axis, acc * 1000.);
    pm500_out(dev_ID, cmd);
    
    /* Set the deceleration, required units mm/sec/sec */
	Fmt(cmd, "%s<%cDECEL%f", axis, acc * 1000.);
    pm500_out(dev_ID, cmd);
    
    /* Set the velocity, required units mm/sec */
	Fmt(cmd, "%s<%cV%f", axis, vel * 1000.);
    pm500_out(dev_ID, cmd);
    
    /* Move the stage, required units microns */
    Fmt(cmd, "%s<%cGR%f", axis, dis * 1.e6);
    pm500_out(dev_ID, cmd);
   
    /* Wait unil the move is complete */
    Delay(fabs(dis)/vel + 2*vel/acc);
    pm500_hold_until_move_complete(dev_ID, axis);
    
    /* Check for errors */
	pm500_check_errors(dev_ID);
    
    /* Get the motor position after the move */
	pm500_get_pos(dev_ID, axis, &fin_pos);
	
	/* Check the move */
	if (fabs(fin_pos - ini_pos - dis) > 2.e-6)
		pm500_error("pm500_rel_stage_move: the stage did not move the proper amount");
    
    /* Done */
    return;
}
								 
/*	**************************************************************  */
/*
 *	pm500_rel_2_stage_move
 *  This function moves two stages a given distance relative to
 *	their present position.  The acceleration and velocity are specified.
 *
 *	Input:
 *	dev_ID, device identifier
 *	axis1, axis 1 (A, B, X, or Y)
 *	axis2, axis 2 (A, B, X, or Y)
 *	acc, acceleration (m/sec/sec)
 *	vel, velocity (m/sec)
 *	dis, distance (m), can be + or -
 *
 *	Zachary Wolf
 *	2/5/01
 */

void pm500_rel_2_stage_move(int dev_ID, char axis1, char axis2, double acc, double vel, double dis)
{
	/* Declare variables */
	int err;
	int dev_open;
	double ini_pos1, fin_pos1;
	double ini_pos2, fin_pos2;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > PM500_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	pm500_error(msg);
    	return;
    }
    if (axis1 != 'A' && axis1 != 'B' && axis1 != 'X' && axis1 != 'Y')
    {
    	Fmt(msg, "%s<axis1 = %c, out of range (A, B, X, or Y)", axis1);
    	pm500_error(msg);
    }
    if (axis2 != 'A' && axis2 != 'B' && axis2 != 'X' && axis2 != 'Y')
    {
    	Fmt(msg, "%s<axis2 = %c, out of range (A, B, X, or Y)", axis2);
    	pm500_error(msg);
    }
    if (acc <= 0.)
    {
    	Fmt(msg, "%s<acc = %f, out of range, must be positive", acc);
    	pm500_error(msg);
    }
    if (vel <= 0.)
    {
    	Fmt(msg, "%s<vel = %f, out of range, must be positive", vel);
    	pm500_error(msg);
    }
    
    /* Exit here if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = pm500_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	pm500_error("Device not open");
    	return;
    }
    
    /* Get the initial motor position before the move */
	pm500_get_pos(dev_ID, axis1, &ini_pos1);
	pm500_get_pos(dev_ID, axis2, &ini_pos2);
    
    /* Set the acceleration, required units mm/sec/sec */
	Fmt(cmd, "%s<%cACCEL%f", axis1, acc * 1000.);
    pm500_out(dev_ID, cmd);
	Fmt(cmd, "%s<%cACCEL%f", axis2, acc * 1000.);
    pm500_out(dev_ID, cmd);
    
    /* Set the deceleration, required units mm/sec/sec */
	Fmt(cmd, "%s<%cDECEL%f", axis1, acc * 1000.);
    pm500_out(dev_ID, cmd);
	Fmt(cmd, "%s<%cDECEL%f", axis2, acc * 1000.);
    pm500_out(dev_ID, cmd);
    
    /* Set the velocity, required units mm/sec */
	Fmt(cmd, "%s<%cV%f", axis1, vel * 1000.);
    pm500_out(dev_ID, cmd);
	Fmt(cmd, "%s<%cV%f", axis2, vel * 1000.);
    pm500_out(dev_ID, cmd);
    
    /* Move the stage, required units microns */
    Fmt(cmd, "%s<%cGR%f", axis1, dis * 1.e6);
    pm500_out(dev_ID, cmd);
    Fmt(cmd, "%s<%cGR%f", axis2, dis * 1.e6);
    pm500_out(dev_ID, cmd);
   
    /* Wait unil the move is complete */
    Delay(fabs(dis)/vel + 2*vel/acc);
    pm500_hold_until_move_complete(dev_ID, axis1);
    pm500_hold_until_move_complete(dev_ID, axis2);
    
    /* Check for errors */
	pm500_check_errors(dev_ID);
    
    /* Get the motor position after the move */
	pm500_get_pos(dev_ID, axis1, &fin_pos1);
	pm500_get_pos(dev_ID, axis2, &fin_pos2);
	
	/* Check the move */
	if (fabs(fin_pos1 - ini_pos1 - dis) > 2.e-6)
		pm500_error("pm500_rel_stage_move: the stage did not move the proper amount");
	if (fabs(fin_pos2 - ini_pos2 - dis) > 2.e-6)
		pm500_error("pm500_rel_stage_move: the stage did not move the proper amount");
    
    /* Done */
    return;
}
								 
/*	**************************************************************  */
/*
 *	pm500_rel_2_indep_stage_move
 *  This function moves two stages given distances relative to
 *	their present positions.  The acceleration and velocity are specified.
 *
 *	Input:
 *	dev_ID, device identifier
 *	axis1, axis 1 (A, B, X, or Y)
 *	axis2, axis 2 (A, B, X, or Y)
 *	acc, acceleration (m/sec/sec)
 *	vel, velocity (m/sec)
 *	dis1, stage 1 distance (m), can be + or -
 *	dis2, stage 2 distance (m), can be + or -
 *
 *	Zachary Wolf
 *	2/5/01
 */

void pm500_rel_2_indep_stage_move(int dev_ID, char axis1, char axis2, double acc, double vel, double dis1, double dis2)
{
	/* Declare variables */
	int err;
	int dev_open;
	double ini_pos1, fin_pos1;
	double ini_pos2, fin_pos2;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > PM500_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	pm500_error(msg);
    	return;
    }
    if (axis1 != 'A' && axis1 != 'B' && axis1 != 'X' && axis1 != 'Y')
    {
    	Fmt(msg, "%s<axis1 = %c, out of range (A, B, X, or Y)", axis1);
    	pm500_error(msg);
    }
    if (axis2 != 'A' && axis2 != 'B' && axis2 != 'X' && axis2 != 'Y')
    {
    	Fmt(msg, "%s<axis2 = %c, out of range (A, B, X, or Y)", axis2);
    	pm500_error(msg);
    }
    if (acc <= 0.)
    {
    	Fmt(msg, "%s<acc = %f, out of range, must be positive", acc);
    	pm500_error(msg);
    }
    if (vel <= 0.)
    {
    	Fmt(msg, "%s<vel = %f, out of range, must be positive", vel);
    	pm500_error(msg);
    }
    
    /* Exit here if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = pm500_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	pm500_error("Device not open");
    	return;
    }
    
    /* Get the initial motor positions before the move */
	pm500_get_pos(dev_ID, axis1, &ini_pos1);
	pm500_get_pos(dev_ID, axis2, &ini_pos2);
    
    /* Set the acceleration, required units mm/sec/sec */
	Fmt(cmd, "%s<%cACCEL%f", axis1, acc * 1000.);
    pm500_out(dev_ID, cmd);
	Fmt(cmd, "%s<%cACCEL%f", axis2, acc * 1000.);
    pm500_out(dev_ID, cmd);
    
    /* Set the deceleration, required units mm/sec/sec */
	Fmt(cmd, "%s<%cDECEL%f", axis1, acc * 1000.);
    pm500_out(dev_ID, cmd);
	Fmt(cmd, "%s<%cDECEL%f", axis2, acc * 1000.);
    pm500_out(dev_ID, cmd);
    
    /* Set the velocity, required units mm/sec */
	Fmt(cmd, "%s<%cV%f", axis1, vel * 1000.);
    pm500_out(dev_ID, cmd);
	Fmt(cmd, "%s<%cV%f", axis2, vel * 1000.);
    pm500_out(dev_ID, cmd);
    
    /* Move the stages, required units microns */
    Fmt(cmd, "%s<%cGR%f", axis1, dis1 * 1.e6);
    pm500_out(dev_ID, cmd);
    Fmt(cmd, "%s<%cGR%f", axis2, dis2 * 1.e6);
    pm500_out(dev_ID, cmd);
   
    /* Wait unil the move is complete */
    Delay(fabs(dis1)/vel + 2*vel/acc);
    pm500_hold_until_move_complete(dev_ID, axis1);
    pm500_hold_until_move_complete(dev_ID, axis2);
    
    /* Check for errors */
	pm500_check_errors(dev_ID);
    
    /* Get the motor position after the move */
	pm500_get_pos(dev_ID, axis1, &fin_pos1);
	pm500_get_pos(dev_ID, axis2, &fin_pos2);
	
	/* Check the move */
	if (fabs(fin_pos1 - ini_pos1 - dis1) > 2.e-6)
		pm500_error("pm500_rel_stage_move: the stage did not move the proper amount");
	if (fabs(fin_pos2 - ini_pos2 - dis2) > 2.e-6)
		pm500_error("pm500_rel_stage_move: the stage did not move the proper amount");
    
    /* Done */
    return;
}
								 
/*	**************************************************************  */
/*
 *	pm500_abs_stage_move
 *  This function moves a stage to a specified position.
 *	The acceleration and velocity are specified.
 *
 *	Input:
 *	dev_ID, device identifier
 *	axis, axis to move (A, B, X, or Y)
 *	acc, acceleration (m/sec/sec)
 *	vel, velocity (m/sec)
 *	pos, position (m), can be + or -
 *
 *	Zachary Wolf
 *	5/14/01
 */

void pm500_abs_stage_move(int dev_ID, char axis, double acc, double vel, double pos)
{
	/* Declare variables */
	int err;
	int dev_open;
	double fin_pos;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > PM500_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	pm500_error(msg);
    	return;
    }
    if (axis != 'A' && axis != 'B' && axis != 'X' && axis != 'Y')
    {
    	Fmt(msg, "%s<axis = %c, out of range (A, B, X, or Y)", axis);
    	pm500_error(msg);
    }
    if (acc <= 0.)
    {
    	Fmt(msg, "%s<acc = %f, out of range, must be positive", acc);
    	pm500_error(msg);
    }
    if (vel <= 0.)
    {
    	Fmt(msg, "%s<vel = %f, out of range, must be positive", vel);
    	pm500_error(msg);
    }
    
    /* Exit here if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = pm500_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	pm500_error("Device not open");
    	return;
    }
    
    /* Set the acceleration, required units mm/sec/sec */
	Fmt(cmd, "%s<%cACCEL%f", axis, acc * 1000.);
    pm500_out(dev_ID, cmd);
    
    /* Set the deceleration, required units mm/sec/sec */
	Fmt(cmd, "%s<%cDECEL%f", axis, acc * 1000.);
    pm500_out(dev_ID, cmd);
    
    /* Set the velocity, required units mm/sec */
	Fmt(cmd, "%s<%cV%f", axis, vel * 1000.);
    pm500_out(dev_ID, cmd);
    
    /* Move the stage, required units microns */
    Fmt(cmd, "%s<%cG%f", axis, pos * 1.e6);
    pm500_out(dev_ID, cmd);
   
    /* Wait unil the move is complete */
    pm500_hold_until_move_complete(dev_ID, axis);
    
    /* Check for errors */
	pm500_check_errors(dev_ID);
    
    /* Get the motor position after the move */
	pm500_get_pos(dev_ID, axis, &fin_pos);
	
	/* Check the move */
	if (fabs(fin_pos - pos) > 2.e-6)
		pm500_error("pm500_abs_stage_move: the stage did not move the proper amount");
    
    /* Done */
    return;
}
								 
/*	**************************************************************  */
/*
 *	pm500_abs_2_stage_move
 *  This function moves two stages to a specified position.
 *	The acceleration and velocity are specified.
 *
 *	Input:
 *	dev_ID, device identifier
 *	axis1, axis 1 (A, B, X, or Y)
 *	axis2, axis 2 (A, B, X, or Y)
 *	acc, acceleration (m/sec/sec)
 *	vel, velocity (m/sec)
 *	pos, position (m), can be + or -	 
 *
 *	Zachary Wolf
 *	5/16/01
 */

void pm500_abs_2_stage_move(int dev_ID, char axis1, char axis2, double acc, double vel, double pos)
{
	/* Declare variables */
	int err;
	int dev_open;
	double fin_pos1, fin_pos2;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > PM500_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	pm500_error(msg);
    	return;
    }
    if (axis1 != 'A' && axis1 != 'B' && axis1 != 'X' && axis1 != 'Y')
    {
    	Fmt(msg, "%s<axis1 = %c, out of range (A, B, X, or Y)", axis1);
    	pm500_error(msg);
    }
    if (axis2 != 'A' && axis2 != 'B' && axis2 != 'X' && axis2 != 'Y')
    {
    	Fmt(msg, "%s<axis2 = %c, out of range (A, B, X, or Y)", axis2);
    	pm500_error(msg);
    }
    if (acc <= 0.)
    {
    	Fmt(msg, "%s<acc = %f, out of range, must be positive", acc);
    	pm500_error(msg);
    }
    if (vel <= 0.)
    {
    	Fmt(msg, "%s<vel = %f, out of range, must be positive", vel);
    	pm500_error(msg);
    }
    
    /* Exit here if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = pm500_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	pm500_error("Device not open");
    	return;
    }
    
    /* Set the acceleration, required units mm/sec/sec */
	Fmt(cmd, "%s<%cACCEL%f", axis1, acc * 1000.);
    pm500_out(dev_ID, cmd);
	Fmt(cmd, "%s<%cACCEL%f", axis2, acc * 1000.);
    pm500_out(dev_ID, cmd);
    
    /* Set the deceleration, required units mm/sec/sec */
	Fmt(cmd, "%s<%cDECEL%f", axis1, acc * 1000.);
    pm500_out(dev_ID, cmd);
	Fmt(cmd, "%s<%cDECEL%f", axis2, acc * 1000.);
    pm500_out(dev_ID, cmd);
    
    /* Set the velocity, required units mm/sec */
	Fmt(cmd, "%s<%cV%f", axis1, vel * 1000.);
    pm500_out(dev_ID, cmd);
	Fmt(cmd, "%s<%cV%f", axis2, vel * 1000.);
    pm500_out(dev_ID, cmd);
    
    /* Move the stage, required units microns */
    Fmt(cmd, "%s<%cG%f", axis1, pos * 1.e6);
    pm500_out(dev_ID, cmd);
    Fmt(cmd, "%s<%cG%f", axis2, pos * 1.e6);
    pm500_out(dev_ID, cmd);
   
    /* Wait unil the move is complete */
    pm500_hold_until_move_complete(dev_ID, axis1);
    pm500_hold_until_move_complete(dev_ID, axis2);
    
    /* Check for errors */
	pm500_check_errors(dev_ID);
    
    /* Get the motor position after the move */
	pm500_get_pos(dev_ID, axis1, &fin_pos1);
	pm500_get_pos(dev_ID, axis2, &fin_pos2);
	
	/* Check the move */
	if (fabs(fin_pos1 - pos) > 2.e-6)
		pm500_error("pm500_abs_2_stage_move: the stage did not move the proper amount");
	if (fabs(fin_pos2 - pos) > 2.e-6)
		pm500_error("pm500_abs_2_stage_move: the stage did not move the proper amount");
    
    /* Done */
    return;
}
								 
/*	**************************************************************  */
/*
 *	pm500_abs_2_indep_stage_move
 *  This function moves two stages to their specified positions.
 *	The acceleration and velocity are specified.
 *
 *	Input:
 *	dev_ID, device identifier
 *	axis1, axis 1 (A, B, X, or Y)
 *	axis2, axis 2 (A, B, X, or Y)
 *	acc, acceleration (m/sec/sec)
 *	vel, velocity (m/sec)
 *	pos1, stage 1 position (m), can be + or -	 
 *	pos2, stage 2 position (m), can be + or -	 
 *
 *	Zachary Wolf
 *	5/16/01
 */

void pm500_abs_2_indep_stage_move(int dev_ID, char axis1, char axis2, double acc, double vel, double pos1, double pos2)
{
	/* Declare variables */
	int err;
	int dev_open;
	double fin_pos1, fin_pos2;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > PM500_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	pm500_error(msg);
    	return;
    }
    if (axis1 != 'A' && axis1 != 'B' && axis1 != 'X' && axis1 != 'Y')
    {
    	Fmt(msg, "%s<axis1 = %c, out of range (A, B, X, or Y)", axis1);
    	pm500_error(msg);
    }
    if (axis2 != 'A' && axis2 != 'B' && axis2 != 'X' && axis2 != 'Y')
    {
    	Fmt(msg, "%s<axis2 = %c, out of range (A, B, X, or Y)", axis2);
    	pm500_error(msg);
    }
    if (acc <= 0.)
    {
    	Fmt(msg, "%s<acc = %f, out of range, must be positive", acc);
    	pm500_error(msg);
    }
    if (vel <= 0.)
    {
    	Fmt(msg, "%s<vel = %f, out of range, must be positive", vel);
    	pm500_error(msg);
    }
    
    /* Exit here if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = pm500_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	pm500_error("Device not open");
    	return;
    }
    
    /* Set the acceleration, required units mm/sec/sec */
	Fmt(cmd, "%s<%cACCEL%f", axis1, acc * 1000.);
    pm500_out(dev_ID, cmd);
	Fmt(cmd, "%s<%cACCEL%f", axis2, acc * 1000.);
    pm500_out(dev_ID, cmd);
    
    /* Set the deceleration, required units mm/sec/sec */
	Fmt(cmd, "%s<%cDECEL%f", axis1, acc * 1000.);
    pm500_out(dev_ID, cmd);
	Fmt(cmd, "%s<%cDECEL%f", axis2, acc * 1000.);
    pm500_out(dev_ID, cmd);
    
    /* Set the velocity, required units mm/sec */
	Fmt(cmd, "%s<%cV%f", axis1, vel * 1000.);
    pm500_out(dev_ID, cmd);
	Fmt(cmd, "%s<%cV%f", axis2, vel * 1000.);
    pm500_out(dev_ID, cmd);
    
    /* Move the stages, required units microns */
    Fmt(cmd, "%s<%cG%f", axis1, pos1 * 1.e6);
    pm500_out(dev_ID, cmd);
    Fmt(cmd, "%s<%cG%f", axis2, pos2 * 1.e6);
    pm500_out(dev_ID, cmd);
   
    /* Wait unil the move is complete */
    pm500_hold_until_move_complete(dev_ID, axis1);
    pm500_hold_until_move_complete(dev_ID, axis2);
    
    /* Check for errors */
	pm500_check_errors(dev_ID);
    
    /* Get the motor position after the move */
	pm500_get_pos(dev_ID, axis1, &fin_pos1);
	pm500_get_pos(dev_ID, axis2, &fin_pos2);
	
	/* Check the move */
	if (fabs(fin_pos1 - pos1) > 2.e-6)
		pm500_error("pm500_abs_2_stage_move: the stage did not move the proper amount");
	if (fabs(fin_pos2 - pos2) > 2.e-6)
		pm500_error("pm500_abs_2_stage_move: the stage did not move the proper amount");
    
    /* Done */
    return;
}
								 
/*	**************************************************************  */
/*
 *	pm500_zero
 *  This function zeros the specified axis.
 *
 *	Input:
 *	dev_ID, device identifier
 *	axis, axis to move (A, B, X, or Y)
 *
 *	Zachary Wolf
 *	5/14/01
 */

void pm500_zero(int dev_ID, char axis)
{
	/* Declare variables */
	int err;
	int dev_open;
	double fin_pos;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > PM500_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	pm500_error(msg);
    	return;
    }
    if (axis != 'A' && axis != 'B' && axis != 'X' && axis != 'Y')
    {
    	Fmt(msg, "%s<axis = %c, out of range (A, B, X, or Y)", axis);
    	pm500_error(msg);
    }
    
    /* Exit here if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = pm500_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	pm500_error("Device not open");
    	return;
    }
    
    /* Zero the stage */
	Fmt(cmd, "%s<%cC", axis);
    pm500_out(dev_ID, cmd);
    
    /* Check for errors */
	pm500_check_errors(dev_ID);
    
    /* Get the stage position after the move */
	pm500_get_pos(dev_ID, axis, &fin_pos);
	
	/* Check the move */
	if (fabs(fin_pos) > 1.)
		pm500_error("pm500_zero: the stage did not zero properly");
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	pm500_get_acc
 *  This function gets the acceleration of the specified axis.
 *
 *	Input:
 *	dev_ID, device identifier
 *	axis, system axis (A, B, X, or Y)
 *
 *	Output:
 *	acc, stage acceleration (m/sec/sec)
 *
 *	Zachary Wolf
 *	5/15/01
 */

void pm500_get_acc(int dev_ID, char axis, double* acc)
{
	/* Declare variables */
	int err;
	int dev_open;
	int num_scan;
	char id, status;
	double acc_mm_sec_sec;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > PM500_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	pm500_error(msg);
    	return;
    }
    if (axis != 'A' && axis != 'B' && axis != 'X' && axis != 'Y')
    {
    	Fmt(msg, "%s<axis = %c, out of range (A, B, X, or Y)", axis);
    	pm500_error(msg);
    }
    
    /* Exit here if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = pm500_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	pm500_error("Device not open");
    	return;
    }
    
    /* Get the acceleration information */
	Fmt(cmd, "%s<%cACCEL?", axis);
    pm500_out(dev_ID, cmd);
    pm500_in(dev_ID, msg);
    
    /* Extract the acceleration */
    num_scan = Scan(msg, "%s>%c%c%f", &id, &status, &acc_mm_sec_sec);
    if (num_scan != 3) pm500_error("Problem reading acceleration.");
    if (id != axis) pm500_error("Problem reading acceleration.");
    *acc = acc_mm_sec_sec / 1000.;
    
    /* Check for errors */
	pm500_check_errors(dev_ID);
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	pm500_get_dcl
 *  This function gets the deceleration of the specified axis.
 *
 *	Input:
 *	dev_ID, device identifier
 *	axis, system axis (A, B, X, or Y)
 *
 *	Output:
 *	dcl, stage deceleration (m/sec/sec)
 *
 *	Zachary Wolf
 *	5/15/01
 */

void pm500_get_dcl(int dev_ID, char axis, double* dcl)
{
	/* Declare variables */
	int err;
	int dev_open;
	int num_scan;
	char id, status;
	double dcl_mm_sec_sec;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > PM500_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	pm500_error(msg);
    	return;
    }
    if (axis != 'A' && axis != 'B' && axis != 'X' && axis != 'Y')
    {
    	Fmt(msg, "%s<axis = %c, out of range (A, B, X, or Y)", axis);
    	pm500_error(msg);
    }
    
    /* Exit here if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = pm500_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	pm500_error("Device not open");
    	return;
    }
    
    /* Get the deceleration information */
	Fmt(cmd, "%s<%cDECEL?", axis);
    pm500_out(dev_ID, cmd);
    pm500_in(dev_ID, msg);
    
    /* Extract the deceleration */
    num_scan = Scan(msg, "%s>%c%c%f", &id, &status, &dcl_mm_sec_sec);
    if (num_scan != 3) pm500_error("Problem reading deceleration.");
    if (id != axis) pm500_error("Problem reading deceleration.");
    *dcl = dcl_mm_sec_sec / 1000.;
    
    /* Check for errors */
	pm500_check_errors(dev_ID);
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	pm500_get_vel
 *  This function gets the velocity of the specified axis.
 *
 *	Input:
 *	dev_ID, device identifier
 *	axis, system axis (A, B, X, or Y)
 *
 *	Output:
 *	vel, stage velocity (m/sec)
 *
 *	Zachary Wolf
 *	5/15/01
 */

void pm500_get_vel(int dev_ID, char axis, double* vel)
{
	/* Declare variables */
	int err;
	int dev_open;
	int num_scan;
	char id, status;
	double vel_mm_sec;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > PM500_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	pm500_error(msg);
    	return;
    }
    if (axis != 'A' && axis != 'B' && axis != 'X' && axis != 'Y')
    {
    	Fmt(msg, "%s<axis = %c, out of range (A, B, X, or Y)", axis);
    	pm500_error(msg);
    }
    
    /* Exit here if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = pm500_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	pm500_error("Device not open");
    	return;
    }
    
    /* Get the velocity information */
	Fmt(cmd, "%s<%cV?", axis);
    pm500_out(dev_ID, cmd);
    pm500_in(dev_ID, msg);
    
    /* Extract the velocity */
    num_scan = Scan(msg, "%s>%c%c%f", &id, &status, &vel_mm_sec);
    if (num_scan != 3) pm500_error("Problem reading velocity.");
    if (id != axis) pm500_error("Problem reading velocity.");
    *vel = vel_mm_sec / 1000.;
    
    /* Check for errors */
	pm500_check_errors(dev_ID);
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	pm500_get_pos
 *  This function gets the position of the specified axis.
 *
 *	Input:
 *	dev_ID, device identifier
 *	axis, system axis (A, B, X, or Y)
 *
 *	Output:
 *	pos, stage position (m)
 *
 *	Zachary Wolf
 *	5/15/01
 */

void pm500_get_pos(int dev_ID, char axis, double* pos)
{
	/* Declare variables */
	int err;
	int dev_open;
	int num_scan;
	char id, status;
	double pos_mum;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > PM500_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	pm500_error(msg);
    	return;
    }
    if (axis != 'A' && axis != 'B' && axis != 'X' && axis != 'Y')
    {
    	Fmt(msg, "%s<axis = %c, out of range (A, B, X, or Y)", axis);
    	pm500_error(msg);
    }
    
    /* Exit here if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = pm500_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	pm500_error("Device not open");
    	return;
    }
    
    /* Get the position information */
	Fmt(cmd, "%s<%cR", axis);
    pm500_out(dev_ID, cmd);
    pm500_in(dev_ID, msg);
    
    /* Extract the position */
    num_scan = Scan(msg, "%s>%c%c%f", &id, &status, &pos_mum);
    if (num_scan != 3) pm500_error("Problem reading position.");
    if (id != axis) pm500_error("Problem reading position.");
    if (status != 'D') pm500_error("Problem reading position.");
    *pos = pos_mum / 1.e6;
    
    /* Check for errors */
	pm500_check_errors(dev_ID);
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	pm500_get_status
 *  This function gets the status of the specified axis.
 *
 *	Input:
 *	dev_ID, device identifier
 *	axis, system axis (A, B, X, or Y)
 *
 *	Output:
 *	status, stage status
 *
 *	Zachary Wolf
 *	5/15/01
 */

void pm500_get_status(int dev_ID, char axis, char* status)
{
	/* Declare variables */
	int err;
	int dev_open;
	int num_scan;
	char id;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > PM500_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	pm500_error(msg);
    	return;
    }
    if (axis != 'A' && axis != 'B' && axis != 'X' && axis != 'Y')
    {
    	Fmt(msg, "%s<axis = %c, out of range (A, B, X, or Y)", axis);
    	pm500_error(msg);
    }
    
    /* Exit here if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = pm500_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	pm500_error("Device not open");
    	return;
    }
    
    /* Get the status information */
	Fmt(cmd, "%s<%cSTAT", axis);
    pm500_out(dev_ID, cmd);
    pm500_in(dev_ID, msg);
    
    /* Extract the status */
    num_scan = Scan(msg, "%s>%c%c", &id, status);
    if (num_scan != 2) pm500_error("Problem reading status.");
    if (id != axis) pm500_error("Problem reading status.");
    
    /* Check for errors */
	pm500_check_errors(dev_ID);
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	pm500_set_acc
 *  This function sets the acceleration of the specified axis.
 *
 *	Input:
 *	dev_ID, device identifier
 *	axis, system axis (A, B, X, or Y)
 *
 *	Output:
 *	acc, stage acceleration (m/sec/sec)
 *
 *	Zachary Wolf
 *	5/15/01
 */

void pm500_set_acc(int dev_ID, char axis, double acc)
{
	/* Declare variables */
	int err;
	int dev_open;
	double acc_mm_sec_sec;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > PM500_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	pm500_error(msg);
    	return;
    }
    if (axis != 'A' && axis != 'B' && axis != 'X' && axis != 'Y')
    {
    	Fmt(msg, "%s<axis = %c, out of range (A, B, X, or Y)", axis);
    	pm500_error(msg);
    }
    
    /* Exit here if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = pm500_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	pm500_error("Device not open");
    	return;
    }
    
    /* Set the acceleration */
    acc_mm_sec_sec = acc * 1000.;
	Fmt(cmd, "%s<%cACCEL%f", axis, acc_mm_sec_sec);
    pm500_out(dev_ID, cmd);
    
    /* Check for errors */
	pm500_check_errors(dev_ID);
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	pm500_set_dcl
 *  This function sets the deceleration of the specified axis.
 *
 *	Input:
 *	dev_ID, device identifier
 *	axis, system axis (A, B, X, or Y)
 *
 *	Output:
 *	dcl, stage deceleration (m/sec/sec)
 *
 *	Zachary Wolf
 *	5/15/01
 */

void pm500_set_dcl(int dev_ID, char axis, double dcl)
{
	/* Declare variables */
	int err;
	int dev_open;
	double dcl_mm_sec_sec;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > PM500_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	pm500_error(msg);
    	return;
    }
    if (axis != 'A' && axis != 'B' && axis != 'X' && axis != 'Y')
    {
    	Fmt(msg, "%s<axis = %c, out of range (A, B, X, or Y)", axis);
    	pm500_error(msg);
    }
    
    /* Exit here if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = pm500_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	pm500_error("Device not open");
    	return;
    }
    
    /* Set the deceleration */
    dcl_mm_sec_sec = dcl * 1000.;
	Fmt(cmd, "%s<%cDECEL%f", axis, dcl_mm_sec_sec);
    pm500_out(dev_ID, cmd);
    
    /* Check for errors */
	pm500_check_errors(dev_ID);
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	pm500_set_vel
 *  This function sets the velocity of the specified axis.
 *
 *	Input:
 *	dev_ID, device identifier
 *	axis, system axis (A, B, X, or Y)
 *
 *	Output:
 *	vel, stage velocity (m/sec)
 *
 *	Zachary Wolf
 *	5/15/01
 */

void pm500_set_vel(int dev_ID, char axis, double vel)
{
	/* Declare variables */
	int err;
	int dev_open;
	double vel_mm_sec;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > PM500_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	pm500_error(msg);
    	return;
    }
    if (axis != 'A' && axis != 'B' && axis != 'X' && axis != 'Y')
    {
    	Fmt(msg, "%s<axis = %c, out of range (A, B, X, or Y)", axis);
    	pm500_error(msg);
    }
    
    /* Exit here if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = pm500_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	pm500_error("Device not open");
    	return;
    }
    
    /* Set the velocity */
    vel_mm_sec = vel * 1000.;
	Fmt(cmd, "%s<%cV%f", axis, vel_mm_sec);
    pm500_out(dev_ID, cmd);
    
    /* Check for errors */
	pm500_check_errors(dev_ID);
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	pm500_exit
 *  This function prepares the PM500 for shutdown and closes
 *	the device.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Zachary Wolf
 *	8/3/99
 */

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

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > PM500_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	pm500_error(msg);
    	return;
    }
    
    /* Exit here if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = pm500_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	return;		 /* OK, already closed */
    }
    
    /* Leave the PM500 in the desired state */
    /* Nothing needs to be done */

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

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

/*	PRIVATE FUNCTIONS  */

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

int pm500_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);
    	pm500_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);
    	pm500_error(msg);
    	return -1;
    }
    
    /* Initialization */
    dev_ID = 0;

    /* Check to see if the device is already in the device table */
    for (i = 1; i <= PM500_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 <= PM500_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)
    {
    	pm500_error("The device could not be opened");
        return  -1;
    }
    
    /* Clear the interface */
    err = ibsic(gpib_board_addr);
    if (err & 0x8000)
    {
    	pm500_error("Problem clearing GPIB interface");
    }
    
	/* Open the device */
    /* Terminate write without EOI, CR LF is added in the send routine */
    /* Terminate read on LF, remove CR LF in read routine */
	descr = ibdev(gpib_board_addr, gpib_dev_addr, 0, T10s, 0, 0x140A);
	if (descr <= 0)
	{
		pm500_error("The device could not be opened");
		return  -1;
	}
    
    /* Open successful, store results in the device table */
    dev_addr[dev_ID] = gpib_dev_addr;
    dev_descr[dev_ID] = descr;
    dev_count++;
    
    /* Clear the device */
    //err = ibclr(dev_descr[dev_ID]);
    //Delay(.5);        /* Wait for the PM500 to clear */
    //if (err & 0x8000)
    //{
    //	pm500_error("Problem clearing device");
    //}
    
    /* Return the device ID */
    return dev_ID;
}

/*	**************************************************************  */
/*
 *	pm500_close_dev
 *  This function closes the device by removing it from the GPIB
 *	device table.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Zachary Wolf
 *	8/3/98
 */

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


/*	**************************************************************  */
/*
 *	pm500_out
 *  This function writes a buffer of data to the device.
 *
 *	Input:
 *	dev_ID, device identifier
 *	buf, null terminated string, the contents up to \0 are sent
 *
 *	Output:
 *	err, 0 if ok, -1 otherwise
 *
 *	Zachary Wolf
 *	8/23/98
 */

int pm500_out(int dev_ID, char* buf)
{
	/* Declare variables */
	char out_buf[PM500_MAX_CMD];
	int nbytes;
	int err;
	
	/* Add CR LF to the command */
	Fmt(out_buf, "%s<%s%c%c", buf, 13, 10);
	
	/* Send the command */
	nbytes = StringLength(out_buf);
	err = ibwrt(dev_descr[dev_ID], out_buf, (long)nbytes);
	
	/* Check for errors */
	if (err & 0x8000)
	{
		Fmt(msg, "%s<ibsta = %x, problem sending GPIB command", err);
		pm500_error(msg);
		return -1;
	}
	
	/* Done */
    return 0;
}

/*	**************************************************************  */
/*
 *	pm500_in
 *  This function reads a buffer of data from the device.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Output:
 *	buf, null terminated string, the contents from the device
 *	err, 0 if ok, -1 otherwise
 *
 *	Zachary Wolf
 *	8/23/98
 */

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

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

/*	**************************************************************  */
/*
 *	pm500_check_errors
 *  This function checks for device errors.
 *	The operator is alerted if there is an error.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Output:
 *	err, 0 if no errors, -1 otherwise
 *
 *	Zachary Wolf
 *	5/14/01
 */

int pm500_check_errors(int dev_ID)
{
	/* Declare variables */
	char err_reg[PM500_MAX_CMD + 1];
	long int err_val;
	int num_scan;

	/* Get the contents of the error register */
    pm500_out(dev_ID, "ESTAT ?");	 
    pm500_in(dev_ID, err_reg);
    num_scan = Scan(err_reg, "%s>%c[d]%c[d]$%i", &err_val);
    if (num_scan != 3) pm500_error("Problem reading error register.");
    //printf("Error Register Contents = %s\n", err_reg);	/* Debug */
	
	/* Exit here if there are no errors */
    if (err_val == 0) return 0;
    
    /* Write a message about the error */
    printf("\nPM500 ERROR, error register contents = %s\n", err_reg);
    
    /* If it was an execute error, print the execute error status */
    if (err_val & 4194304 == 4194304)
    {
    	pm500_out(dev_ID, "EESTAT ?");	 
    	pm500_in(dev_ID, err_reg);
    	printf("\nPM500 ERROR, execute error register contents = %s\n", err_reg);
    }
    
    /* See if the operator wants to continue */
    pm500_error("pm500_check_errors found errors");
    	
    /* Done */
    return -1;
}

/*	**************************************************************  */
/*
 *	pm500_serial_poll
 *  This function performs a serial poll of the device.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Output:
 *	spoll, contents of the serial poll register
 *	err, 0 if ok, -1 otherwise
 *
 *	Zachary Wolf
 *	8/26/98
 */

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

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

/*	**************************************************************  */
/*
 *	pm500_hold_until_move_complete
 *  This function loops until all axes have stopped moving.
 *
 *	Input:
 *	dev_ID, device identifier
 *	axis, axis to check (A, B, X, or Y)
 *
 *	Zachary Wolf
 *	5/15/01
 */

void pm500_hold_until_move_complete(int dev_ID, char axis)
{
	/* Declare variables */
	char status[PM500_MAX_CMD + 1];
    enum {TRUE, FALSE} moving;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > PM500_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	pm500_error(msg);
    	return;
    }
    if (axis != 'A' && axis != 'B' && axis != 'X' && axis != 'Y')
    {
    	Fmt(msg, "%s<axis = %c, out of range (A, B, X, or Y)", axis);
    	pm500_error(msg);
    }
    
    /* Loop while moving */
    moving = TRUE;
    while (moving == TRUE)
    {
		Fmt(cmd, "%s<%cSTAT", axis);
    	pm500_out(dev_ID, cmd);
    	pm500_in(dev_ID, status);
    	//printf("moving status: %s\n", status);
    	if (status[0] != axis) pm500_error("error in reading device status, status[0] != axis");
    	if (status[1] == 'E') pm500_error("error in reading device status, status[1] = E");
    	if (status[1] == 'D')
    	{
    		moving = FALSE;		/* Move complete */
    	}
    	else
    	{
    		moving = TRUE;		/* Still moving */
    		Delay(1.);
    	}
    }
    
    /* Done */
    return;
}

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

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

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

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