/*	**************************************************************  */
/*
 *	Module CM2100
 *	This module contains I/O functions for the Compumotor model
 *	2100 indexer.                 
 *
 *	Zachary Wolf
 *	8/24/98
 */ 

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

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

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

/*  PRIVATE FUNCTIONS  */
int cm2100_open_dev(int gpib_board_addr, int gpib_dev_addr);
void cm2100_close_dev(int dev_ID);
int cm2100_out(int dev_ID, char *buf);
int cm2100_in(int dev_ID, char* buf);
int cm2100_check_dev_open(int dev_ID);
int cm2100_read_error_status(int dev_ID);
void cm2100_hold_until_move_complete(int dev_ID);
void cm2100_hold_until_ready_to_reply(int dev_ID);
int cm2100_serial_poll(int dev_ID, int* spoll);
void cm2100_message(char* msg);
void cm2100_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[CM2100_MAX_NUM_DEV + 1];
static int dev_descr[CM2100_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[CM2100_MAX_CMD + 1];
static char msg[CM2100_MAX_CMD + 1];
static long int cm2100_num_steps_per_rev;

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

/*	PUBLIC FUNCTIONS  */

/*	**************************************************************  */
/*
 *  cm2100_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
 *	8/24/98
 */

void cm2100_init(int gpib_board_addr, int gpib_dev_addr, int* ID)
{
    /* Declare variables */
    int dev_ID;
    int err;
    
    /* Message */
    cm2100_message("");
    cm2100_message("Initializing the CM2100...");

    /* 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);
    	cm2100_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);
    	cm2100_error(msg);
    	return;
    }
    
    /* Parameter initialization */
    cm2100_num_steps_per_rev = CM2100_NUM_STEPS_PER_REV;
    
    /* Exit here if testing without hardware */
    #ifdef DUMMY_DEVICES
    	*ID = 1;
    	return;
    #endif
    
    /* Open the CM2100 */
    dev_ID = cm2100_open_dev(gpib_board_addr, gpib_dev_addr);
    if (dev_ID <= 0)
    {
        cm2100_error("Device was not opened");
        return;
    }
    
    /* Enable the communications interface */
    cm2100_out(dev_ID, "E");
    
    /* Energize the drive */
    cm2100_out(dev_ID, "ST1");
    
    /* Set the present position to zero */
    cm2100_out(dev_ID, "X0");
    
    /* Get a response from the CM2100 */
    cm2100_out(dev_ID, "R");
    cm2100_hold_until_ready_to_reply(dev_ID);
    err = cm2100_in(dev_ID, cmd);
    if (err != 0)
    {
        cm2100_error("Problem reading dev_ID");
        cm2100_close_dev(dev_ID);
        return;
    }
    cm2100_message(cmd);

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

/*	**************************************************************  */
/*
 *	cm2100_set_num_steps_per_rev
 *  This function sets the cm2100_num_steps_per_rev parameter.
 *
 *	Input:
 *	num_steps_per_rev, parameter value
 *
 *	Zachary Wolf
 *	3/6/01
 */

void cm2100_set_num_steps_per_rev(long num_steps_per_rev)
{
	/* Set the parameter value */
	cm2100_num_steps_per_rev = num_steps_per_rev;
	
	/* Done */
	return;
}

/*	**************************************************************  */
/*
 *	cm2100_rel_move
 *  This function moves the motor the specified number of revolutions
 *	with the specified acceleration and velocity.
 *
 *	Input:
 *	dev_ID, device identifier
 *	acc, acceleration (rev/sec/sec)
 *	vel, velocity (rev/sec)
 *	dis, distance (rev), can be + or -
 *
 *	Zachary Wolf
 *	8/24/98
 */

void cm2100_rel_move(int dev_ID, double acc, double vel, double dis)
{
	/* Declare variables */
	int err;
	int dev_open;
	long int dis_steps;
	long int steps_taken;
	
	/* Convert distance in revolutions to distance in steps */
	dis_steps = dis * cm2100_num_steps_per_rev;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > CM2100_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	cm2100_error(msg);
    	return;
    }
    if (acc < 0.1 || acc > 990.)
    {
    	Fmt(msg, "%s<acc = %f, out of range, will be adjusted", acc);
    	cm2100_error(msg);
    	if (acc < 0.1) acc = 0.1; else acc = 990.;
    }
    if (vel < 0.1 || vel > 99.)
    {
    	Fmt(msg, "%s<vel = %f, out of range, will be adjusted", vel);
    	cm2100_error(msg);
    	if (vel < 0.1) vel = 0.1; else vel = 99.;
    }
    if (labs(dis_steps) > 99999999)
    {
    	Fmt(msg, "%s<dis_steps = %i, out of range", dis_steps);
    	cm2100_error(msg);
    	return;
    }
    if (labs(dis_steps) == 0) return;
    
    /* Exit here if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = cm2100_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	cm2100_error("Device not open");
    	return;
    }
    
    /* Set normal mode to move to a given position */
    cm2100_out(dev_ID, "MN");
    
    /* Set the acceleration */
    Fmt(cmd, "%s<A%f[p2]", acc);
    cm2100_out(dev_ID, cmd);
    
    /* Set the velocity */
    Fmt(cmd, "%s<V%f[p3]", vel);
    cm2100_out(dev_ID, cmd);
    
    /* Set the distance */
    Fmt(cmd, "%s<D%i", dis_steps);
    cm2100_out(dev_ID, cmd);
    
    /* Move */
    cm2100_out(dev_ID, "G");
    cm2100_hold_until_move_complete(dev_ID); 
    
    /* Ask how many steps were taken */
    cm2100_out(dev_ID, "P");
    cm2100_hold_until_ready_to_reply(dev_ID); 
    cm2100_in(dev_ID, cmd);
    Scan(cmd, "%s>%i", &steps_taken);
    
    /* Make sure the proper number of steps were taken */
    if (steps_taken != dis_steps)
    {
    	cm2100_error("The wrong number of steps were taken");
    	return;
    }
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	cm2100_start_rel_move
 *  This function starts a move of the motor.  It moves the
 *	specified number of revolutions with the specified acceleration
 *	and velocity.
 *
 *	Input:
 *	dev_ID, device identifier
 *	acc, acceleration (rev/sec/sec)
 *	vel, velocity (rev/sec)
 *	dis, distance (rev), can be + or -
 *
 *	Zachary Wolf
 *	8/26/98
 */

void cm2100_start_rel_move(int dev_ID, double acc, double vel, double dis)
{
	/* Declare variables */
	int err;
	int dev_open;
	long int dis_steps;
	
	/* Convert distance in revolutions to distance in steps */
	dis_steps = dis * cm2100_num_steps_per_rev;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > CM2100_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	cm2100_error(msg);
    	return;
    }
    if (acc < 0.1 || acc > 990.)
    {
    	Fmt(msg, "%s<acc = %f, out of range, will be adjusted", acc);
    	cm2100_error(msg);
    	if (acc < 0.1) acc = 0.1; else acc = 990.;
    }
    if (vel < 0.1 || vel > 99.)
    {
    	Fmt(msg, "%s<vel = %f, out of range, will be adjusted", vel);
    	cm2100_error(msg);
    	if (vel < 0.1) vel = 0.1; else vel = 99.;
    }
    if (labs(dis_steps) > 99999999)
    {
    	Fmt(msg, "%s<dis_steps = %i, out of range", dis_steps);
    	cm2100_error(msg);
    	return;
    }
    
    /* Exit here if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = cm2100_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	cm2100_error("Device not open");
    	return;
    }
    
    /* Set normal mode to move to a given position */
    cm2100_out(dev_ID, "MN");
    
    /* Set the acceleration */
    Fmt(cmd, "%s<A%f[p2]", acc);
    cm2100_out(dev_ID, cmd);
    
    /* Set the velocity */
    Fmt(cmd, "%s<V%f[p3]", vel);
    cm2100_out(dev_ID, cmd);
    
    /* Set the distance */
    Fmt(cmd, "%s<D%i", dis_steps);
    cm2100_out(dev_ID, cmd);
    
    /* Move */
    cm2100_out(dev_ID, "G");	            /* Do not hold while moving */
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	cm2100_end_rel_move
 *  This function checks that a move started by cm2100_start_rel_move
 *	has finished and performed properly.
 *
 *	Input:
 *	dev_ID, device identifier
 *	dis, distance (rev), can be + or -
 *
 *	Zachary Wolf
 *	8/26/98
 */

void cm2100_end_rel_move(int dev_ID, double dis)
{
	/* Declare variables */
	int err;
	int dev_open;
	long int dis_steps;
	long int steps_taken;
	
	/* Convert distance in revolutions to distance in steps */
	dis_steps = dis * cm2100_num_steps_per_rev;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > CM2100_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	cm2100_error(msg);
    	return;
    }
    if (labs(dis_steps) > 99999999)
    {
    	Fmt(msg, "%s<dis_steps = %i, out of range", dis_steps);
    	cm2100_error(msg);
    	return;
    }
    
    /* Exit here if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = cm2100_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	cm2100_error("Device not open");
    	return;
    }
    
    /* Wait until the move is finished */
    cm2100_hold_until_move_complete(dev_ID);
    
    /* Ask how many steps were taken */
    cm2100_out(dev_ID, "P");
    cm2100_hold_until_ready_to_reply(dev_ID);  
    cm2100_in(dev_ID, cmd);
    Scan(cmd, "%s>%i", &steps_taken);
    
    /* Make sure the proper number of steps were taken */
    if (steps_taken != dis_steps)
    {
    	cm2100_error("The wrong number of steps were taken");
    	return;
    }
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	cm2100_get_abs_position
 *  This function gets the number of revolutions from zero that
 *	the motor is currently at.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Output:
 *	pos, position (rev), can be + or -
 *
 *	Zachary Wolf
 *	8/26/98
 */

void cm2100_get_abs_position(int dev_ID, double* pos)
{
	/* Declare variables */
	int err;
	int dev_open;
	long int pos_steps;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > CM2100_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	cm2100_error(msg);
    	return;
    }
    
    /* Exit here if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = cm2100_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	cm2100_error("Device not open");
    	return;
    }
   
    /* Ask for the current position */
    cm2100_out(dev_ID, "X1");
    cm2100_hold_until_ready_to_reply(dev_ID); 
    cm2100_in(dev_ID, cmd);
    Scan(cmd, "%s>%i", &pos_steps);
	
	/* Convert the position in steps to position in revolutions */
	*pos = (double) pos_steps / (double) cm2100_num_steps_per_rev;
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	cm2100_zero
 *  This function sets the indexer position counter to zero.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Zachary Wolf
 *	8/25/98
 */

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

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

    /* Zero the position counter */
    cm2100_out(dev_ID, "X0");
    
    /* Check for errors */
    err = cm2100_read_error_status(dev_ID);
    if (err != 0)
    {
        cm2100_error("The device has an error");
        cm2100_close_dev(dev_ID);
        return;
    }
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	cm2100_exit
 *  This function prepares the CM2100 for shutdown and closes
 *	the device.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Zachary Wolf
 *	8/23/98
 */

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

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > CM2100_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	cm2100_error(msg);
    	return;
    }
    
    /* Exit here if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = cm2100_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	return;		 /* OK, already closed */
    }
    
    /* Leave the CM2100 in the desired state */
    /* De-energize the drive */
    cm2100_out(dev_ID, "ST0");

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

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

/*	PRIVATE FUNCTIONS  */

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

    /* Check to see if the device is already in the device table */
    for (i = 1; i <= CM2100_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 <= CM2100_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)
    {
    	cm2100_error("The device could not be opened");
        return  -1;
    }
    
	/* Open the device */
    /* Terminate write with EOI, CR is added in the send routine */
    /* Terminate read on CR, remove CR in read routine */
	descr = ibdev(gpib_board_addr, gpib_dev_addr, 0, T10s, 1, 0x140D);
	if (descr <= 0)
	{
		cm2100_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 CM2100 to clear */
    if (err & 0x8000)
    {
    	cm2100_error("Problem clearing device");
    }
    
    /* Return the device ID */
    return dev_ID;
}

/*	**************************************************************  */
/*
 *	cm2100_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 cm2100_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;
}


/*	**************************************************************  */
/*
 *	cm2100_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 cm2100_out(int dev_ID, char* buf)
{
	/* Declare variables */
	char out_buf[CM2100_MAX_CMD];
	int nbytes;
	int err;
	
	/* Add a carriage return to the command */
	Fmt(out_buf, "%s<%s%c", buf, 13);
	
	/* 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);
		cm2100_error(msg);
		return -1;
	}
	
	/* Done */
    return 0;
}

/*	**************************************************************  */
/*
 *	cm2100_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 cm2100_in(int dev_ID, char* buf)
{
	/* Declare variables */
	int err;
	char in_buf[CM2100_MAX_CMD];
	
	/* Read the message */
	err = ibrd(dev_descr[dev_ID], in_buf, CM2100_MAX_CMD);
	
	/* Check for errors */
	if (err & 0x8000)
	{
		Fmt(msg, "%s<ibsta = %x, problem receiving GPIB input", err);
		cm2100_error(msg);
		return -1;
	}
	
	/* Remove the CR terminator */
	Scan(in_buf, "%s[t13]>%s[t-]", buf);
	
	/* Done */
    return 0;
}

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

/*	**************************************************************  */
/*
 *	cm2100_read_error_status
 *  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/3/98
 */

int cm2100_read_error_status(int dev_ID)
{
	/* Declare variables */
    int spoll;

	/* Perform a serial poll */
    cm2100_serial_poll(dev_ID, &spoll);
	
	/* Check for problems */
    if ((spoll & 4) == 4)
    {
        cm2100_error("Limit reached");
        return -1;
    }
    if ((spoll & 128) == 128)
    {
        cm2100_error("Motor stall");
        return -1;
    }
    
    /* Done */
    return 0;
}

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

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

/*	**************************************************************  */
/*
 *	cm2100_hold_until_move_complete
 *  This function serial polls the device in a loop until the
 *	move complete bit is set.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Zachary Wolf
 *	8/26/98
 */

void cm2100_hold_until_move_complete(int dev_ID)
{
	/* Declare variables */
    int spoll;
    enum {TRUE, FALSE} busy;
    
    /* Loop while busy */
    busy = TRUE;
    while (busy == TRUE)
    {
    	cm2100_serial_poll(dev_ID, &spoll);
    	if ((spoll & 1) == 1)
    	{
    		busy = FALSE;		/* Move complete */
    	}
    	else
    	{
    		busy = TRUE;		/* Still moving */
    		Delay(.5);
    	}
    }
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	cm2100_hold_until_ready_to_reply
 *  This function serial polls the device in a loop until the
 *	ready to reply bit is set.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Zachary Wolf
 *	8/26/98
 */

void cm2100_hold_until_ready_to_reply(int dev_ID)
{
	/* Declare variables */
    int spoll;
    enum {TRUE, FALSE} busy;
    
    /* Loop while busy */
    busy = TRUE;
    while (busy == TRUE)
    {
    	cm2100_serial_poll(dev_ID, &spoll);
    	if ((spoll & 8) == 8)    
    	{
    		busy = FALSE;		   /* Ready to reply */
    	}
    	else
    	{
    		busy = TRUE;           /* Not ready to reply */
    		Delay(.1);
    	}
    }
    
    /* Done */
    return;
}

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

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

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

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