/*	**************************************************************  */
/*
 *	Module B9900
 *	This module contains I/O functions for the Bell 9900.                 
 *
 *	Zachary Wolf
 *	1/14/00
 */ 

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

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

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

/*  PRIVATE FUNCTIONS  */
int b9900_open_dev(int gpib_board_addr, int gpib_dev_addr);
void b9900_close_dev(int dev_ID);
int b9900_check_dev_open(int dev_ID);
int b9900_out(int dev_ID, char* buf);
int b9900_in(int dev_ID, char* buf);
int b9900_spoll(int dev_ID, int* spoll);
void b9900_wait_until_not_busy(int dev_ID);
void b9900_wait_until_data_ready(int dev_ID);
void b9900_message(char* message);
void b9900_error(char* message);

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

/*  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[B9900_MAX_NUM_DEV + 1];
static int dev_descr[B9900_MAX_NUM_DEV + 1];
static int dev_count;

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

/*  PRIVATE GLOBAL VARIABLES  */
/*
 *  cmd, buffer for GPIB I/O strings
 *  msg, buffer for message strings to Standard I/O
 *	range_settings, port range settings saved for quick access
 */
static char cmd[B9900_MAX_CMD + 1];
static char msg[B9900_MAX_CMD + 1];
static char reply[B9900_MAX_CMD + 1];

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

/*	PUBLIC FUNCTIONS  */

/*	**************************************************************  */
/*
 *  b9900_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
 *	1/14/00
 */

void b9900_init(int gpib_board_addr, int gpib_dev_addr, int* ID)
{
    /* Declare variables */
    int dev_ID;
    int err;
    int i;
    
    /* Message */
    b9900_message("");
    b9900_message("Initializing the B9900...");

    /* 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);
    	b9900_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);
    	b9900_error(msg);
    	return;
    }
    
    /* Exit here if testing without hardware */
    #ifdef DUMMY_DEVICES
    	*ID = 1;
     	return;
    #endif
    
    /* Open the B9900 */
    dev_ID = b9900_open_dev(gpib_board_addr, gpib_dev_addr);
    if (dev_ID <= 0)
    {
        b9900_error("B9900 was not opened");
        return;
    }
    
    /* Set the communications format */
    Fmt(cmd, "%s<CO1%i[w2p0]00", gpib_dev_addr);
    b9900_out(dev_ID, cmd);
    
    /* Leave the Gaussmeter in a known default state */
    b9900_default_setup(dev_ID);

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

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

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

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > B9900_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	b9900_error(msg);
    	return;
    }
    
    /* Exit here if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = b9900_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	b9900_error("Device not open");
    	return;
    }
     
    /* Set up each channel of the Gaussmeter */
    for (channel=1; channel<=B9900_NUM_CHANNELS; channel++)
    {
	    /* Set the measurement mode to DC Tesla */
	    Fmt(cmd, "%s<MO%i[w1]4", channel);
	    b9900_out(dev_ID, cmd);
	    b9900_message(reply);
	    /* Turn off max-hold */
	    Fmt(cmd, "%s<PE%i[w1]1", channel);
	    b9900_out(dev_ID, cmd);
	    b9900_message(reply);
	    /* Set the display format */
	    Fmt(cmd, "%s<DI%i[w1]222", channel);
	    b9900_out(dev_ID, cmd);
	    b9900_message(reply);
	    /* Turn off classifiers */
	    Fmt(cmd, "%s<CL%i[w1]11-000006+29999", channel);
	    b9900_out(dev_ID, cmd);
	    b9900_message(reply);
	    /* Turn off relative mode */
	    Fmt(cmd, "%s<RE%i[w1]110000000", channel);
	    b9900_out(dev_ID, cmd);
	    b9900_message(reply);
	    /* Set the range to a high value */
		b9900_set_range(dev_ID, channel, 5);
    }
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	b9900_set_range
 *  This function sets the range of the Gaussmeter.
 *
 *	Input:
 *	dev_ID, device identifier
 *	channel, channel number (1 to B9900_NUM_CHANNELS)
 *	range, range (1 = 3 G, 2 = 30 G, 3 = 300 G, 4 = 3 kG, 5 = 30 kG, 6 = 300 kG, 7 = 3 MG, 8 = auto range)
 *
 *	Zachary Wolf
 *	1/19/00
 */

void b9900_set_range(int dev_ID, int channel, int range)
{
	/* Declare variables */
	int dev_open;
	int err;

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

    /* Set the range to the requested value */
    Fmt(cmd, "%s<RA%i[w1]%i[w1]", channel, range);
    b9900_out(dev_ID, cmd);
    
    /* Allow a little extra time to finish */
    Delay(2.);
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	b9900_zero
 *  This function zeros the Gaussmeter.
 *
 *	Input:
 *	dev_ID, device identifier
 *	channel, channel number (1 to B9900_NUM_CHANNELS)
 *
 *	Zachary Wolf
 *	1/19/00
 */

void b9900_zero(int dev_ID, int channel)
{
	/* Declare variables */
	int dev_open;

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

    /* Zero the Gaussmeter */
    zero:
    Fmt(cmd, "%s<ZE%i[w1]0", channel);
    b9900_out(dev_ID, cmd);
    
    /* Allow a little extra time to finish */
    Delay(2.);
    
    /* Check that the Gaussmeter zeroed properly */
    Fmt(cmd, "%s<ZE%i[w1]0", channel);
    if (strcmp(reply, cmd) != 0)
    {
    	printf("There was an error zeroing the Bell 9900 Gaussmeter: %s\n", reply);
    	printf("Try again...\n");
    	goto zero;
    }
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	b9900_get_B
 *  This function gets the field measurement from the Gaussmeter.
 *
 *	Input:
 *	dev_ID, device identifier
 *	channel, channel number (1 to B9900_NUM_CHANNELS)
 *
 *	Output:
 *	B, magnetic field strength (T)
 *
 *	Zachary Wolf
 *	1/20/00
 */

void b9900_get_B(int dev_ID, int channel, double* B)
{
	/* Declare variables */
	int dev_open;
	int err;
	int num_scan;
	int chan;
	int range;
	char sign;
	double reading;
	double multiplier;
	int counter = 0;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > B9900_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	b9900_error(msg);
    	return;
    }
    if (channel < 1 || channel > B9900_NUM_CHANNELS)
    {
    	Fmt(msg, "%s<channel = %i, out of range", channel);
    	b9900_error(msg);
    	return;
    }
    
    /* Exit here if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = b9900_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	b9900_error("B9900 not open");
    	return;
    }
    
    /* In case of problems, try again */
    try_again:
    counter++;
    if (counter > 5)	/* Avoid infinite loops */
    {
    	printf("\nProblem reading the Hall probe, returning 0 T and exiting the function.\n");
		*B = 0.;
		return;
	}

    /* Get the field reading from the Gaussmeter */
    Fmt(cmd, "%s<ME%i[w1]00000000", channel);
    b9900_out(dev_ID, cmd);
    
    /* Extract the field information from the reply */
    num_scan = Scan(reply, "%s>ME%i[w1]0%i[w1]%c%f[w5]", &chan, &range, &sign, &reading);
	if (num_scan != 4)
	{
		printf("Problem 1 reading the Gaussmeter, reply = %s, try again...\n", reply);
		goto try_again;
	}
	
	/* Check */
	if (chan != channel)
	{
		printf("Problem 2 reading the Gaussmeter, reply = %s, try again...\n", reply);
		goto try_again;
	}
	
	/* Check the range and determine the multiplier */
	if      (range == 1) multiplier = 1.e-8;
	else if (range == 2) multiplier = 1.e-7;
	else if (range == 3) multiplier = 1.e-6;
	else if (range == 4) multiplier = 1.e-5;
	else if (range == 5) multiplier = 1.e-4;
	else if (range == 6) multiplier = 1.e-3;
	else if (range == 7) multiplier = 1.e-2;
	else
	{
		printf("Problem 3 reading the Gaussmeter, reply = %s, try again...\n", reply);
		goto try_again;
	}
	
	/* Check the sign */
	if (sign != '-' && sign != '+' && sign != ' ' && sign != '~')
	{
		printf("Problem 4 reading the Gaussmeter, reply = %s, try again...\n", reply);
		goto try_again;
	}
	
	/* Check the reading */
	if (reading < 0 || reading > 32767)
	{
		printf("Problem 5 reading the Gaussmeter, reply = %s, try again...\n", reply);
		goto try_again;
	}
	
	/* Determine the field value */
	if (sign == '-') *B = -1. * reading * multiplier;
	else *B = reading * multiplier;
    
    /* Done */
    return;
}  

/*	**************************************************************  */
/*
 *	b9900_exit
 *  This function configures the B9900 for program exit and
 *	closes the device.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Zachary Wolf
 *	1/21/00
 */

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

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

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

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

/*	PRIVATE FUNCTIONS  */

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

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

	/* Initialization */
    dev_ID = 0;

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

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

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

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

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

/*	**************************************************************  */
/*
 *	b9900_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
 *	1/21/00
 */

int b9900_out(int dev_ID, char* buf)
{
	/* Declare variables */
	int nbytes;
	int err;
	char out_buf[B9900_MAX_CMD + 1];
	char expected_reply[B9900_MAX_CMD + 1];
	
	/* Make sure the device is ready for a command */
	b9900_wait_until_not_busy(dev_ID);
	
	/* Begin the command with ESC, end with CR */
	Fmt(out_buf, "%s<%c%s%c", 27, buf, 13);
	
	/* 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);
		b9900_error(msg);
		return -1;
	}
	
	/* Trigger the Gaussmeter to execute the command */
	err = ibtrg(dev_descr[dev_ID]);
	
	/* Check for errors */
	if (err & 0x8000)
	{
		Fmt(msg, "%s<ibsta = %x, problem sending GPIB command", err);
		b9900_error(msg);
		return -1;
	}
	
	/* Get the Gaussmeter's reply */
	b9900_in(dev_ID, reply);
	
	/* Check for errors */
	Fmt(expected_reply, "%s<%s", buf);
	if (strcmp(expected_reply, reply) != 0)
	{
		if      (reply[0] == 'Z' && reply[1] == 'E');	/* OK, probe zero */
		else if (reply[0] == 'R' && reply[1] == 'E');	/* OK, probe relative */
		else if (reply[0] == 'M' && reply[1] == 'E');	/* OK, measure */
		else
		{
			printf("B9900: command sent     = %s\n", expected_reply);
			printf("B9900: Gaussmeter reply = %s\n", reply);
			b9900_error("Command error, B9900 reply is not what was expected.");
			return -1;
		}
	}
	
	/* Done */
    return 0;
}

/*	**************************************************************  */
/*
 *	b9900_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
 *	1/21/00
 */

int b9900_in(int dev_ID, char* buf)
{
	/* Declare variables */
	int err;
	char in_buf[B9900_MAX_CMD];
	
	/* Make sure the device has the data ready */
	b9900_wait_until_data_ready(dev_ID);
	
	/* Read the message */
	err = ibrd(dev_descr[dev_ID], in_buf, B9900_MAX_CMD);
	
	/* Check for errors */
	if (err & 0x8000)
	{
		Fmt(msg, "%s<ibsta = %x, problem receiving GPIB input", err);
		b9900_error(msg);
		return -1;
	}
	
	/* Remove the CR terminator */
	Scan(in_buf, "%s[t13]>%s", buf);
	
	/* Done */
    return 0;
}

/*	**************************************************************  */
/*
 *	b9900_spoll
 *  This function performs a serial poll on the device.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Output:
 *	spoll, integer encoding the serial poll information
 *	err, 0 if ok, -1 otherwise
 *
 *	Zachary Wolf
 *	1/21/00
 */

int b9900_spoll(int dev_ID, int* spoll)
{
	/* Declare variables */
	int err;
	char spoll_byte;
	
	/* Perform the serial poll */
	err = ibrsp(dev_descr[dev_ID], &spoll_byte);
	
	/* Check for errors */
	if (err & 0x8000)
	{
		Fmt(msg, "%s<ibsta = %x, problem performing serial poll", err);
		b9900_error(msg);
		return -1;
	}
	
	/* Put the serial poll information into an integer */
	*spoll = (int) spoll_byte;
	
	/* Done */
    return 0;
}

/*	**************************************************************  */
/*
 *	b9900_wait_until_not_busy
 *  This function performs serial polls on the device until it determines
 *	that the device is ready to receive a command.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Zachary Wolf
 *	1/21/00
 */

void b9900_wait_until_not_busy(int dev_ID)
{
	/* Declare variables */
	int err;
	int spoll = 0;
	int counter = 0;
	enum {TRUE, FALSE} busy;
	
	/* Loop until the device is ready */
	busy = TRUE;
	while (busy == TRUE)
	{
	
		/* Perform a serial poll */
		err = b9900_spoll(dev_ID, &spoll);
		if (err != 0)
		{
			b9900_error("Serial poll error in b9900_wait_until_not_busy");
			return;
		}
		
		/* The device is busy if spoll bit 0 is set */
		if (spoll & 1) busy = TRUE;
		else busy = FALSE;
		
		/* Allow time for the device to get ready */
		Delay(.2);
		
		/* No endless loops */
		counter++;
		//printf("%i\n", counter);
		if (counter > 100) busy = FALSE;
	
	/* End loop until device is ready */
	}
	
	/* Done */
    return;
}

/*	**************************************************************  */
/*
 *	b9900_wait_until_data_ready
 *  This function performs serial polls on the device until it determines
 *	that the device is ready to send its data.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Zachary Wolf
 *	1/21/00
 */

void b9900_wait_until_data_ready(int dev_ID)
{
	/* Declare variables */
	int err;
	int spoll = 0;
	int counter = 0;
	enum {TRUE, FALSE} ready;
	
	/* Loop until the device has its data ready */
	ready = FALSE;
	while (ready == FALSE)
	{
	
		/* Perform a serial poll */
		err = b9900_spoll(dev_ID, &spoll);
		if (err != 0)
		{
			b9900_error("Serial poll error in b9900_wait_until_data_ready");
			return;
		}
		
		/* The data is ready if spoll bit 6 is set */
		if (spoll & 64) ready = TRUE;
		else ready = FALSE;
		
		/* Allow time for the device to get ready */
		Delay(.2);
		
		/* No endless loops */
		counter++;
		//printf("%i\n", counter);
		if (counter > 100) ready = TRUE;
	
	/* End loop until device is ready */
	}
	
	/* Done */
    return;
}

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

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

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

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