/*	**************************************************************  */
/*
 *	Module EV-16P
 *	This module contains I/O functions for the Mitutoyo EV Counter
 *
 *	Yurii Levashov
 *	01/07/2005
 */ 

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

/*	INCLUDES  */
#include <utility.h>
#include <rs232.h>
#include <formatio.h>
#include <ansi_c.h>
#include "ev16p.h"
#include <userint.h>
//#include "ev16p_ui.h"


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

/*  PRIVATE DEVICE TABLE  */
/*
 *	This table allows several devices of the same type to be
 *	used in the system.
 *	dev_addr, contains the rs232 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[EV16P_MAX_NUM_DEV + 1];
static int dev_descr[EV16P_MAX_NUM_DEV + 1];
static int dev_count;

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

/*  PRIVATE GLOBAL VARIABLES  */
/*
 *  cmd, buffer for RS232 I/O strings
 *  msg, buffer for message strings to Standard I/O
 */
static int com_port;
char cmd[EV16P_MAX_CMD + 1];
char msg[EV16P_MAX_CMD + 1];

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

/*	PUBLIC FUNCTIONS  */

/* 	ev16p_error_handling
 *
 *  This function inform operator about error and error codes 
 *  Returns 0 - OK; -1 - Error
 *
 *	Yurii Levashov
 *	01/07/2005
*/
 int ev16p_error_handling(int err, char descr[])
 {
   char msg[200];
   
	Fmt(msg, "%s<Error in %s. Check error code # %i. Continue?", descr, err); 
	err = ConfirmPopup ("ERROR", msg);
	 if (err == 0)  return -1;     
	 
  return 0;
  }

/*	**************************************************************  */
/*
 *  ev16p_init
 *  This function opens the device, queries for ID, and
 *  initializes the device to a known state.
 *
 *	Input:
 *	rs232_com_port (1-32)
 *	rs232_dev_addr  (00-99) (00 is reserved)
 *
 *	Output:
 *	ID, identifier for future references to the device
 *
 *	Yurii Levashov
 *	01/07/2005
 */

void ev16p_init(int rs232_com_port, int rs232_dev_addr, int* ID)
{
    /* Declare variables */
    int dev_ID;
    int err;
    int i;
    
    /* Check input parameters */
    if(rs232_com_port < 1 || rs232_com_port > 32)
     {
        err = ev16p_error_handling(rs232_com_port, "RS232_COM_PORT");
    	   if(err != 0) return;
     }	   
    if(rs232_dev_addr < 0 || rs232_dev_addr > 99)
     {
       err = ev16p_error_handling(rs232_dev_addr, "RS232_DEV_ADDR");
    	   if(err != 0) return; 
     }	  
    // Exit here if testing without hardware 
    #ifdef DUMMY_DEVICES
    	*ID = 1;
    	return;
    #endif
    
    /* Save the com port number */
    com_port = rs232_com_port;
    
    /* Open Device */
    dev_ID = ev16p_open_dev(rs232_dev_addr); 
    
    /* Open RS232 communications */
	err = OpenComConfig (com_port, "", 9600, 0, 7, 2, 512, 512);
		if (err != 0) err = ev16p_error_handling(err, "OpenCom");
			if(err != 0) return; 
	err = FlushInQ(com_port);
		if (err != 0) err = ev16p_error_handling(err, "FlushInQ");
			if(err != 0) return; 
	err = FlushOutQ(com_port);
		if (err != 0) err = ev16p_error_handling(err, "FlushOutQ");
			if(err != 0) return;
			
    /* Clear Errors */
	ev16p_clear_err(dev_ID);

    /* Check HOLD status of each used gage */
    for(i = 1; i <= EV16P_NUM_GAGES; i++)
    	{
    		Fmt(cmd,"%s<CK0%i[w1]",i);
    		ev16p_out(dev_ID, cmd);
    		Delay(.5);
    		ev16p_in(dev_ID, msg);	  // Get responce
			Scan(msg,"%s>%s[w4]%i[w1]", cmd, &err);
				if(err == 1) 
				{
				 err = ConfirmPopup ("Warning",
									 "Counter is not in HOLD state. RS232 commands are not effective. Would you like to set I/O to RS232?");
				 
					if(err == 1) MessagePopup ("Change HOLD Mode",
											   "HOLD mode should be changed manually, p.3-7");
				}
				 else if(err != 0) 
				 {
				   err = ev16p_error_handling(err, "Problem with Hold Mode");
				   return;
				 }
		}
		
	/* Return the ID number */
    *ID = dev_ID;
    
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	ev16p_zero
 *  This function sets the gages readings to zero.
 *
 *	Input:
 *	dev_ID, device identifier
 *  number of gage to be zeroed. For all gage = 0
 *
 *	Yurii Levashov
 *	01/07/2005
 */

void ev16p_zero(int dev_ID, int gage)
{
	/* Declare variables */
	int err, i;
	int dev_open;
	int num_gages = EV16P_NUM_GAGES;
	
    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > EV16P_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	  err = ev16p_error_handling(dev_ID, msg);
			if(err != 0) return; 
    }
    
    if (gage < 0 || gage > 6)
    {
    	Fmt(msg, "%s<Gage = %i, out of range", dev_ID);
    	  err = ev16p_error_handling(dev_ID, msg);
			if(err != 0) return; 
    }
    
    /* Exit here if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = ev16p_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	  err = ev16p_error_handling(err, "EV-16P is not open");
			if(err != 0) return; 
    }
	if(gage == 0) num_gages = 1;   // for one gage
	
    /* Zero the gage readings */
    for(i = 1; i <= num_gages; i++)
    {
    	Fmt(cmd,"%s<CR0%i[w1]",i);
    	ev16p_out(dev_ID, cmd);  // zero gage readings
    	Delay(.5);
    	ev16p_in(dev_ID, msg);	   // Get responce
    	Fmt(cmd,"%s<CH0%i[w1]",i);
	 	if(strcmp (msg, cmd) != 0) err = ev16p_error_handling(err, "Zero gages");
	}
	
    /* Done */
    return;
}
/*	**************************************************************  */
/*
 *	ev16p_read
 *  This function reads the gages .
 *
 *	Input:
 *	dev_ID, device identifier
 *  number of gage. For all gage = 0
 *
 *	Yurii Levashov
 *	01/07/2005
 */

double ev16p_read(int dev_ID, int gage)
{
	/* Declare variables */
	int err, i, n = 0;
	int dev_open;
//	int num_gages = EV16P_NUM_GAGES;
//	char test[5];
	double /*readings[EV16P_NUM_GAGES] = {0},*/ result;
	int count = 0;
	
    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > EV16P_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	  err = ev16p_error_handling(dev_ID, msg);
			if(err != 0) return 0; 
    }
    
    if (gage < 0 || gage > 6)
    {
    	Fmt(msg, "%s<Gage = %i, out of range", dev_ID);
    	  err = ev16p_error_handling(dev_ID, msg);
			if(err != 0) return 0; 
    }
    
    /* Exit here if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return 0;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = ev16p_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	  err = ev16p_error_handling(err, "EV-16P is not open");
			if(err != 0) return 0; 
    }
//	if(gage != 0) num_gages = 1;   // for one gage
	
    // Read the gage
//    for(i = 1; i <= num_gages; i++)
//    {
      do
       {
    	 Fmt(cmd,"%s<GA0%i[w1]",gage);
    	 ev16p_out(dev_ID, cmd);  			// zero gage readings
    	 ev16p_in(dev_ID, msg);	   			// Get responce
//    	Fmt(cmd,"%s<GN0%i[w1]",gage);
    	 n = Scan(msg,"%s[i5]>%f", &result);	// readings + i - 1);
	 	 if(n == 1) return result;
	 	}
	   while(count++ < 1);
	   
	   return(ev16p_error_handling(err, "Reading gages"));
	 	
//	}
	   	  // output data on GUI 
/*	  switch(gage)
	  {
	   case 1:
	   err = SetCtrlAttribute (PANEL, PANEL_GAGE1_OUT, ATTR_CTRL_VAL, dum/1000.);
	   break;
	   case 2:
	   err = SetCtrlAttribute (PANEL, PANEL_GAGE2_OUT, ATTR_CTRL_VAL, readings[1]);
	   break;
	   case 3:
	   err = SetCtrlAttribute (PANEL, PANEL_GAGE3_OUT, ATTR_CTRL_VAL, readings[2]);
	   break;
	   case 4:
	   err = SetCtrlAttribute (PANEL, PANEL_GAGE4_OUT, ATTR_CTRL_VAL, readings[3]);
	   break;
	   default:
	   err = SetCtrlAttribute (PANEL, PANEL_GAGE1_OUT, ATTR_CTRL_VAL, readings[0]);
	   err = SetCtrlAttribute (PANEL, PANEL_GAGE2_OUT, ATTR_CTRL_VAL, readings[1]);
	   err = SetCtrlAttribute (PANEL, PANEL_GAGE3_OUT, ATTR_CTRL_VAL, readings[2]);
	   err = SetCtrlAttribute (PANEL, PANEL_GAGE4_OUT, ATTR_CTRL_VAL, readings[3]);
	   }  */
    /* Done */
//    return e;
}
/*	**************************************************************  */
/*
 *	ev16p_preset
 *  This function presets the gages readings.
 *
 *	Input:
 *	dev_ID, device identifier
 *  number of gage to be preset. For all gages = 0
 *
 *	Yurii Levashov
 *	01/07/2005
 */

void ev16p_preset(int dev_ID, int gage, double readings[])
{
	/* Declare variables */
	int err, i;
	int dev_open;
	int num_gages = EV16P_NUM_GAGES;
	char sign = '+';
	double number;
	
    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > EV16P_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	  err = ev16p_error_handling(dev_ID, msg);
			if(err != 0) return; 
    }
    
    if (gage < 0 || gage > 6)
    {
    	Fmt(msg, "%s<Gage = %i, out of range", dev_ID);
    	  err = ev16p_error_handling(dev_ID, msg);
			if(err != 0) return; 
    }
    
    /* Exit here if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = ev16p_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	  err = ev16p_error_handling(err, "EV-16P is not open");
			if(err != 0) return; 
    }
	if(gage != 0) num_gages = 1;   // for one gage
	
    /* preset the gage readings */
    for(i = 1; i <= num_gages; i++)
    {
    	/* make a command */
    	number = readings[i-1] * 1000.;
    	if(number < 0) 
    	{
    	 sign = '-';
    	 number = - number;
    	 }
    	Fmt(msg,"%s<000%f[p4]", number);
    	Fmt(cmd,"%s<CP0%i[w1], %c%s[w9]", i, sign, msg);
    	
    	/* send command */
    	ev16p_out(dev_ID, cmd);  
    	Delay(.5);
    	ev16p_in(dev_ID, msg);	   // Get responce
    	Fmt(cmd,"%s<CH0%i[w1]",i);
	 	if(strcmp(msg, cmd) != 0) err = ev16p_error_handling(err, "Preset gages");
	}
	
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	ev16p_clear_err
 *  This function sets the gages readings to zero.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Yurii Levashov
 *	01/07/2005
 */

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

    /* Check input parameters */
    if (dev_ID < 1 || dev_ID > EV16P_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	  err = ev16p_error_handling(dev_ID, msg);
			if(err != 0) return; 
    }
    
    /* Exit here if testing without hardware */
    #ifdef DUMMY_DEVICES
    	return;
    #endif
    
    /* Check to make sure the device is open */
    dev_open = ev16p_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	  err = ev16p_error_handling(err, "EV-16P is not open");
			if(err != 0) return; 
    }

    /* clear the errors */
    ev16p_out(dev_ID, "CS00");  
    Delay(.5);
    ev16p_in(dev_ID, msg);	   // Get responce
	if(strcmp (msg, "CH00") != 0) err = ev16p_error_handling(err, "clear errors");
			
    /* Done */
    return;
}

/*	**************************************************************  */
/*
 *	ev16p_exit
 *  This function prepares the EV-16P for shutdown and closes
 *	the device.
 *
 *	Input:
 *	dev_ID - device identifier
 *
 *	Yurii Levashov
 *	01/07/2005
 */

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

    // Exit here if testing without hardware 
    #ifdef DUMMY_DEVICES
    	return;
    #endif

    // Check input parameters 
    if (dev_ID < 1 || dev_ID > EV16P_MAX_NUM_DEV)
    {
    	Fmt(msg, "%s<dev_ID = %i, out of range", dev_ID);
    	  err = ev16p_error_handling(dev_ID, msg);
			if(err != 0) return; 
    }
    
    // Check to make sure the device is open 
    dev_open = ev16p_check_dev_open(dev_ID);
    if (dev_open != 1)
    {
    	return;		 /* OK, already closed */
    }
    
	/* Close the device */
    ev16p_close_dev(dev_ID);
    
    /* Done */
    return;
}

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

/*	PRIVATE FUNCTIONS  */

/*	**************************************************************  */
/*
 *	ev16p_open_dev
 *	This function opens the device and returns an identifier for
 *	future references to the device.
 *
 *	Input:
 *	rs232_com_port, address of the COM port the device is connected to
 *	rs232_dev_addr, RS232 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)
 *
 *	Yurii Levashov
 *	01/07/2005
 */

int ev16p_open_dev(int rs232_dev_addr)
{
	/* Declare variables */
    int i;
    int dev_ID;
    int descr;
    int err;
    
    /* Initialization */
    dev_ID = 0;

    /* Check to see if the device is already in the device table */
    for (i = 1; i <= EV16P_MAX_NUM_DEV; i++)
    {
        if (dev_addr[i] == rs232_dev_addr)
        {
            dev_ID = i;
            return dev_ID;
        }
    }
    
    /* Find an ID for the device */
	for (i = 1; i <= EV16P_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)
    {
      err = ev16p_error_handling(dev_ID, "The device could not be opened");
		if(err != 0) return -1; 
    }
    
    /* Get Description */
    descr = 1;
    
    
	/* Open the device */
	if (descr <= 0)
	{
      err = ev16p_error_handling(err, "The device could not be opened");
		if(err != 0) return -1; 
	}
    
    /* Open successful, store results in the device table */
    dev_addr[dev_ID] = rs232_dev_addr;
    dev_descr[dev_ID] = descr;
    dev_count++;
    
    /* Return the device ID */
    return dev_ID;
}

/*	**************************************************************  */
/*
 *	cm6k6_close_dev
 *  This function closes the device by removing it from 
 *	device table.
 *
 *	Input:
 *	dev_ID, device identifier
 *
 *	Yurii Levashov
 *	01/07/2005
 */

void ev16p_close_dev(int dev_ID)
{
	/* Close the device */
    if (dev_descr[dev_ID] != 0)
    {
        dev_descr[dev_ID] = 0;
        dev_addr[dev_ID] = 0;
        dev_count--;
    }
    
    /* Done */
    return;
}


/*	**************************************************************  */
/*
 *	ev16p_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
 *
 *	Yurii Levashov
 *	01/07/2005
 */

int ev16p_out(int dev_ID, char* buf)
{
	/* Declare variables */
	char out_buf[EV16P_MAX_CMD];
	int nbytes;
	int err;
	
	/* Flush the input and output queues */
	err = FlushInQ(com_port);
		if (err != 0) err = ev16p_error_handling(com_port, "FlushInQ");
    	   if(err != 0) return -1;

	err = FlushOutQ(com_port);
		if (err != 0) err = ev16p_error_handling(com_port, "FlushOutQ");
    	   if(err != 0) return -1;
	
	/* Allow time for the command to be processed */
	Delay(1.0);
	
	/* Add the address and CR LF to the message */
	Fmt(out_buf, "%s<%s%c%c", buf, 13, 10);
	
	/* Send the message */
	nbytes = StringLength(out_buf);
	err = ComWrt(com_port, out_buf, nbytes);
	
	/* Check for errors */
	if (err <= 0)
	{
		Fmt(msg, "%s<err = %i, problem sending RS232 command", err);
		err = ev16p_error_handling(com_port, msg);
		return -1;
	}
	
	/* Allow time for the command to be processed */
	Delay(1.0);
	
	/* Done */
    return 0;
}

/*	**************************************************************  */
/*
 *	ev16p_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
 *
 *	Yurii Levashov
 *	01/07/2005
 */

int ev16p_in(int dev_ID, char *buf)
{
	/* Declare variables */
	int nbytes, err;
	char in_buf[EV16P_MAX_CMD];
	
	/* Read the message, CR and LF are discarded */
	nbytes = ComRdTerm(com_port, in_buf, EV16P_MAX_CMD, 13);

	/* Check for errors */
	if (nbytes <= 0)
	{
		Fmt(msg, "%s<# bytes in = %i, problem receiving RS232 input", nbytes);
		err = ev16p_error_handling(nbytes, msg);
		return err;
	}
	
	/* Null terminate the string */
	in_buf[nbytes] = '\0';
	
	/* Remove the CR LF terminator */
	Scan(in_buf, "%s>%s[t-]", buf);	
	
	/* Return the string in buf */
//	strcpy(buf, in_buf);
	
	/* Done */
    return 0;
}

/*	**************************************************************  */
/*
 *	ev16p_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	Modified by Yurii Levashov 01/07/2005
 *	7/27/98
 */

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