/*	**************************************************************  */
/*
 *	Module MF10D
 *	This module contains I/O functions for the Walker fluxmeter
 *	model MF-10D.
 *
 *	Zachary Wolf
 *	12/14/05
 */ 

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

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

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

/*  PRIVATE FUNCTIONS  */
int mf10d_open_dev(int gpib_board_addr, int gpib_dev_addr);
void mf10d_close_dev(int dev_ID);
int mf10d_check_dev_open(int dev_ID);
int mf10d_out(int dev_ID, char* buf);
int mf10d_in(int dev_ID, char* buf);
void mf10d_message(char* msg);
void mf10d_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[MF10D_MAX_NUM_DEV + 1];
static int dev_descr[MF10D_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[MF10D_MAX_CMD + 1];
static char msg[MF10D_MAX_CMD + 1];

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

/*	PUBLIC FUNCTIONS  */

/*	**************************************************************  */
/*
 *  mf10d_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
 *	12/14/05
 */

void mf10d_init(int gpib_board_addr, int gpib_dev_addr, int* ID)
{
    /* Declare variables */
    int dev_ID;
    int err;
    int i;
    
    /* Message */
    mf10d_message("");
    mf10d_message("Initializing the MF10D...");

    /* 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);
    	mf10d_error(msg);
    	return;
    }
    if (gpib_dev_addr < 1 || gpib_dev_addr > 30)
    {
    	Fmt(msg, "%s<gpib_dev_addr = %i, out of range", gpib_dev_addr);
    	mf10d_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	*ID = 1;
    	return;
    #endif
    
    /* Open the MF10D */
    dev_ID = mf10d_open_dev(gpib_board_addr, gpib_dev_addr);
    if (dev_ID <= 0)
    {
        mf10d_error("Device was not opened");
        return;
    }

    /* Reset the fluxmeter */
    mf10d_out(dev_ID, ":set:reset");
    mf10d_in(dev_ID, msg);
    if (strcmp(msg, "Illegal parameter string") == 0)	/* Happens when first power on */
    {
    	mf10d_out(dev_ID, ":set:reset");
    	mf10d_in(dev_ID, msg);
    }
    if (strcmp(msg, "Integrator reset") != 0) mf10d_error("Reset error");

    /* Set the units to milliWeber-turns */
    mf10d_out(dev_ID, ":set:units:mWts");
    mf10d_in(dev_ID, msg);
    if (strcmp(msg, "units set to mWeber-turns") != 0) mf10d_error("Units error");

    /* Set the display to normal */
    mf10d_out(dev_ID, ":set:dis:NORM");
    mf10d_in(dev_ID, msg);
    if (strcmp(msg, "display set to NORMAL") != 0) mf10d_error("Display error");

    /* Set the mode to DC, default */
    mf10d_out(dev_ID, ":set:mode:DC");
    mf10d_in(dev_ID, msg);
    if (strcmp(msg, "mode set to DC") != 0) mf10d_error("Mode error");
    
    /* Set the gain to 1, default */
    mf10d_out(dev_ID, ":set:mult:1");
    mf10d_in(dev_ID, msg);
    if (strcmp(msg, "multiplier set to 1") != 0) mf10d_error("Gain error");

    /* Enable the keypad */
    mf10d_out(dev_ID, ":keypad:enable");
    mf10d_in(dev_ID, msg);
    if (strcmp(msg, "keypad enabled") != 0) mf10d_error("Keypad enable error");

    /* Turn off alarms */
    mf10d_out(dev_ID, ":set:alarm:off");
    mf10d_in(dev_ID, msg);
    if (strcmp(msg, "alarm off") != 0) mf10d_error("Alarm off error");

    /* Print the ID information */
    mf10d_out(dev_ID, "*IDN?");
    mf10d_in(dev_ID, msg);
    mf10d_message(msg);

    /* Print the status information */
    mf10d_out(dev_ID, ":status");
    mf10d_in(dev_ID, msg);
    mf10d_message(msg);

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

/*	**************************************************************  */
/*
 *	mf10d_set_mode
 *  This function sets the mode of the fluxmeter for either DC
 *	or AC measurements.
 *
 *	Input:
 *	dev_ID, device identifier
 *	mode, fluxmeter mode ("DC" or "AC")
 *
 *	Zachary Wolf
 *	12/14/05
 */

void mf10d_set_mode(int dev_ID, char mode[])
{
	/* Declare variables */
	int dev_open;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > MF10D_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	mf10d_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = mf10d_check_dev_open(dev_ID);
    if (dev_open == 0)
    {
    	mf10d_error("Instrument not open");
    	return;
    }
    
    /* Set the mode */
    if ((strcmp(mode, "DC") == 0) || (strcmp(mode, "dc") == 0))
    {
    	mf10d_out(dev_ID, ":set:mode:DC");
    	mf10d_in(dev_ID, msg);
    	if (strcmp(msg, "mode set to DC") != 0) mf10d_error("Mode error");
    }
    else if ((strcmp(mode, "AC") == 0) || (strcmp(mode, "ac") == 0))
    {
    	mf10d_out(dev_ID, ":set:mode:AC");
    	mf10d_in(dev_ID, msg);
    	if (strcmp(msg, "mode set to AC") != 0) mf10d_error("Mode error");
    }
    else
    {
    	mf10d_error("Unrecognized mode");
    }
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	mf10d_set_gain
 *  This function sets the gain of the fluxmeter input amplifier.
 *
 *	Input:
 *	dev_ID, device identifier
 *	gain, amplifier gain (1, 10, or 100)
 *
 *	Zachary Wolf
 *	12/14/05
 */

void mf10d_set_gain(int dev_ID, int gain)
{
	/* Declare variables */
	int dev_open;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > MF10D_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	mf10d_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = mf10d_check_dev_open(dev_ID);
    if (dev_open == 0)
    {
    	mf10d_error("Instrument not open");
    	return;
    }
    
    /* Set the gain */
    if (gain == 1)
    {
    	mf10d_out(dev_ID, ":set:mult:1");
    	mf10d_in(dev_ID, msg);
    	if (strcmp(msg, "multiplier set to 1") != 0) mf10d_error("Gain error");
    }
    else if (gain == 10)
    {
    	mf10d_out(dev_ID, ":set:mult:10");
    	mf10d_in(dev_ID, msg);
    	if (strcmp(msg, "multiplier set to 10") != 0) mf10d_error("Gain error");
    }
    else if (gain == 100)
    {
    	mf10d_out(dev_ID, ":set:mult:100");
    	mf10d_in(dev_ID, msg);
    	if (strcmp(msg, "multiplier set to 100") != 0) mf10d_error("Gain error");
    }
    else
    {
    	mf10d_error("Unrecognized gain");
    }
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	mf10d_auto_null
 *  This function zeros input offset voltages.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Zachary Wolf
 *	12/14/05
 */

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

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > MF10D_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	mf10d_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = mf10d_check_dev_open(dev_ID);
    if (dev_open == 0)
    {
    	mf10d_error("Instrument not open");
    	return;
    }
    
    /* Message */
    printf("\nBeginning the auto null cycle...\n");
    printf("Please be patient, this can take a while.");
    
    /* Perform the auto null */
    mf10d_out(dev_ID, ":set:null:auto");
    mf10d_in(dev_ID, msg);
    if (strcmp(msg, "Nulling Complete") != 0) mf10d_error("Auto null error");
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	mf10d_start_vt_meas
 *  This function sets up the fluxmeter for an integrated voltage
 *	measurement.  At the end, it resets the fluxmeter and the
 *	integration begins.
 *
 *	Input:
 *	dev_ID, device identifier
 *	gain, amplifier gain (1, 10, or 100)
 *
 *	Zachary Wolf
 *	12/14/05
 */

void mf10d_start_vt_meas(int dev_ID, int gain)
{
	/* Declare variables */
	int dev_open;

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

    /* Set the units to milliWeber-turns */
    mf10d_out(dev_ID, ":set:units:mWts");
    mf10d_in(dev_ID, msg);
    if (strcmp(msg, "units set to mWeber-turns") != 0) mf10d_error("Units error");

    /* Set the mode to DC */
    mf10d_out(dev_ID, ":set:mode:DC");
    mf10d_in(dev_ID, msg);
    if (strcmp(msg, "mode set to DC") != 0) mf10d_error("Mode error");
    
    /* Set the gain */
	mf10d_set_gain(dev_ID, gain);

    /* Reset the fluxmeter */
    mf10d_out(dev_ID, ":set:reset");
    mf10d_in(dev_ID, msg);
    if (strcmp(msg, "Integrator reset") != 0) mf10d_error("Reset error");
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	mf10d_get_vt
 *  This function gets an integrated voltage measurement from the
 *	fluxmeter.
 *	The measurement should begin with a call to mf10d_start_vt_meas.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Output:
 *	vt, integrated voltage (Vs)
 *
 *	Zachary Wolf
 *	12/14/05
 */

void mf10d_get_vt(int dev_ID, double* vt)
{
	/* Declare variables */
	int dev_open;
	char sign;
	double value;
	char units[10];
	int num_scan;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > MF10D_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	mf10d_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = mf10d_check_dev_open(dev_ID);
    if (dev_open == 0)
    {
    	mf10d_error("Instrument not open");
    	return;
    }
    
    /* Get the measured value */
    mf10d_out(dev_ID, ":measure:field");
    mf10d_in(dev_ID, msg);
    num_scan = Scan(msg, "%s>%c%f %s", &sign, &value, units);
    if (num_scan != 3) mf10d_error("Error reading measurement");
    if (strcmp(units, "mWebts") != 0) mf10d_error("Error reading measurement, units wrong");
    
    /* Return the measured value in Vs */
    *vt = value;
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	mf10d_start_vt_peak_meas
 *  This function sets up the fluxmeter for a peak integrated voltage
 *	measurement.  At the end, it resets the fluxmeter and the
 *	integration begins.
 *
 *	Input:
 *	dev_ID, device identifier
 *	gain, amplifier gain (1, 10, or 100)
 *
 *	Zachary Wolf
 *	12/14/05
 */

void mf10d_start_vt_peak_meas(int dev_ID, int gain)
{
	/* Declare variables */
	int dev_open;

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

    /* Set the units to milliWeber-turns */
    mf10d_out(dev_ID, ":set:units:mWts");
    mf10d_in(dev_ID, msg);
    if (strcmp(msg, "units set to mWeber-turns") != 0) mf10d_error("Units error");

    /* Display peak value */
    mf10d_out(dev_ID, ":set:dis:PEAK");
    mf10d_in(dev_ID, msg);
    if (strcmp(msg, "display set to PEAK") != 0) mf10d_error("Display error");

    /* Set the mode to DC */
    mf10d_out(dev_ID, ":set:mode:DC");
    mf10d_in(dev_ID, msg);
    if (strcmp(msg, "mode set to DC") != 0) mf10d_error("Mode error");
    
    /* Set the gain */
	mf10d_set_gain(dev_ID, gain);

    /* Reset the fluxmeter */
    mf10d_out(dev_ID, ":set:reset");
    mf10d_in(dev_ID, msg);
    if (strcmp(msg, "Integrator reset") != 0) mf10d_error("Reset error");

    /* Reset the peak hold */
    mf10d_out(dev_ID, ":set:peak:reset");
    mf10d_in(dev_ID, msg);
    if (strcmp(msg, "peak detector reset") != 0) mf10d_error("Peak reset error");
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	mf10d_get_vt_peak
 *  This function gets a peak integrated voltage measurement from the
 *	fluxmeter.
 *	The measurement should begin with a call to mf10d_start_vt_peak_meas.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Output:
 *	vt_peak, peak integrated voltage (Vs)
 *
 *	Zachary Wolf
 *	12/14/05
 */

void mf10d_get_vt_peak(int dev_ID, double* vt_peak)
{
	/* Declare variables */
	int dev_open;
	double value;
	char units[10];
	int num_scan;

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > MF10D_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	mf10d_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = mf10d_check_dev_open(dev_ID);
    if (dev_open == 0)
    {
    	mf10d_error("Instrument not open");
    	return;
    }
    
    /* Get the measured value */
    mf10d_out(dev_ID, ":get:peakvalue");
    mf10d_in(dev_ID, msg);
    num_scan = Scan(msg, "%s>Peak value is: %f %s", &value, units);
    if (num_scan != 2) mf10d_error("Error reading peak measurement");
    if (strcmp(units, "uWt's") != 0) mf10d_error("Error reading peak measurement, units wrong");
    
    /* Return the measured peak value in Vs */
    *vt_peak = value;
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	mf10d_exit
 *  This function puts the MF10D in the desired state for exit
 *	and closes the device.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Zachary Wolf
 *	12/14/05
 */

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

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > MF10D_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	mf10d_error(msg);
    	return;
    }
    
    /* Exit if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = mf10d_check_dev_open(dev_ID);
    if (dev_open == 0)
    {
    	return;		 /* OK, already closed */
    }
    
    /* Set the gain of the MF10D to 1 */
    mf10d_out(dev_ID, "SGA,*,1");

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

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

/*	PRIVATE FUNCTIONS  */

/*	**************************************************************  */
/*
 *	mf10d_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
 *	12/14/05
 */

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

	/* Initialization */
    dev_ID = 0;

    /* Check to see if the device is already in the device table */
    for (i = 1; i <= MF10D_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 <= MF10D_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)
    {
    	mf10d_error("The device could not be opened");
        return  -1;
    }
    
    /* 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)
	{
		mf10d_error("The device could not be opened");
		return  -1;
	}
    
    /* Open successful, update device table */
    dev_addr[dev_ID] = gpib_dev_addr;
    dev_descr[dev_ID] = descr;
    dev_count++;
    
    /* Return the device dev_ID */
    return dev_ID;
}

/*	**************************************************************  */
/*
 *	mf10d_close_dev
 *  This function closes the device and removes it from the GPIB
 *	device table.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Zachary Wolf
 *	9/2/98
 */

void mf10d_close_dev(int dev_ID)
{
	/* Close the device */
    if (dev_descr[dev_ID] != 0)
    {
        /*ibloc(dev_descr[dev_ID]);*/		 /* Local control plus reset */
        /*ibonl(dev_descr[dev_ID], 0);*/
        dev_descr[dev_ID] = 0;
        dev_addr[dev_ID] = 0;
        dev_count--;
    }
    
    /* Done */
    return;
}

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

/*	**************************************************************  */
/*
 *	mf10d_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
 *	12/14/05
 */

int mf10d_out(int dev_ID, char* buf)
{
	/* Declare variables */
	char out_buf[MF10D_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);
		mf10d_error(msg);
		return -1;
	}
	
	/* Done */
    return 0;
}

/*	**************************************************************  */
/*
 *	mf10d_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
 *	12/14/05
 */

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

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

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

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

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