#ifdef LAPTOP
#include "c:\slac\Repository\Lib\delay.h"
#else
#include "v:\\met\\repository\\lib\\delay.h"
#include <analysis.h>
#endif

#include <formatio.h>


 /*	**************************************************************  */    
/* 
 *  This file contains functions for the cam_move User Interface
 * 
 *
 *  Yurii Levashov
 *
 *  09/02/2004
 */

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

#include <cvirte.h>		
#include <userint.h>
#include <ansi_c.h>
#include <utility.h>
#include "Cam_movers.h"
#include "cam_movers_dec.h"
#include "cam_movers_param.h"
#include "hp34970_sw.h"
#include "cm6k6_g.h"
//#include "ev16p.h"

static int panelHandle;

// Public Functions Declaration 

void set_coordinate_box( int c_flag);
void cam_move_ui_error(char* message);
void cam_move_ui_init(void);

// Private variables Declaration 

static int err;
static int switch_status;
static int hp34970_ID, cm6k6_ID, ev16p_ID;
static int panelHandle, panelHandleParam, panelHandleTest;
int save_param_flag = FALSE;
static char log_f_name[260];
static struct com_param cm_param;
static struct move_param mv_param;
static int GUI_control_order[20] = {CAM_PANEL_XCOORDINATE, CAM_PANEL_YCOORDINATE, CAM_PANEL_ROLL_IN,
							 CAM_PANEL_PITCH_IN, CAM_PANEL_YAW_IN, CAM_PANEL_XCOORDINATE_OUT, 
							 CAM_PANEL_YCOORDINATE_OUT, CAM_PANEL_ROLL_OUT, CAM_PANEL_PITCH_OUT, 
							 CAM_PANEL_YAW_OUT, CAM_PANEL_POT_1, CAM_PANEL_POT_2, CAM_PANEL_POT_3, 
							 CAM_PANEL_POT_4,CAM_PANEL_POT_5, CAM_PANEL_GAGE_2, CAM_PANEL_GAGE_4, 
							 CAM_PANEL_GAGE_1, CAM_PANEL_GAGE_3, CAM_PANEL_GAGE_5};
	  
/*	**************************************************************  */

/*  Public Functions  */

/*	**************************************************************  */
/*
 *	cam_move_ui_init
 *  This function initializes the user interface for the cam_move.
 *
 *	Input:
 *	ID
 *
 *	Yurii Levashov
 *	09/02/2004
 */

void cam_move_ui_init(void)
{

	/* Open the cam_move_ui panel */
	
	if ((panelHandle = LoadPanel (0, "Cam_movers.uir", CAM_PANEL)) < 0)
	 {
	 cam_move_ui_error(" Can not load UI Panel!!!");
	  return;
	 }
	DisplayPanel (panelHandle); //Display the panel when the user interface runs

	/* Done */
	return;
}

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

/* error_handling
 *
 *  This function inform operator about error and error codes 
 *
 *	Yurii Levashov
 *	09/10/2004
*/
 void cam_move_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)  cam_move_exit();     // Close all devices and exit the program
	 
  return;
  }


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

/*  Private Functions  */

/*	**************************************************************  */
/*
 *	cam_move_ui_error
 *  This function handles error messages for the cam_move user interface.
 *
 *	Input:
 *	message, string to display in standard I/O
 *
 *	Yurii Levashov
 *	09/02/2004
 */
/*	**************************************************************  */  

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

/*	**************************************************************  */  
/*
 *	update_status_line
 *  This function updates messages for the cam_move user interface.
 *
 *	Input:
 *  panel_ID, control_ID
 *	message, string to display in standard I/O
 *
 *	Yurii Levashov
 *	09/02/2004
 */
/*	**************************************************************  */  

void update_status_line(int panel, int control_ID, char* message)
{
	static int panel_ID;
	
	panel_ID = panel;
	SetCtrlAttribute (panel_ID, control_ID, ATTR_CTRL_VAL, message);
	DisplayPanel (panel_ID);
 return;
}

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

void set_coordinate_box(int flag) // Makes controls available/unavailabe 
{
		 int i;
		 
		 switch (flag)
			 {
			 case 0:
			 
			 case 1:					  		// All
			  for(i = 2; i < 15; i++)
			  SetCtrlAttribute (panelHandle, GUI_control_order[i], ATTR_DIMMED, 0);
			  if(GAGE_NUMBER != 0)
			   for(i = 15; i < 19; i++)
			    SetCtrlAttribute (panelHandle, GUI_control_order[i], ATTR_DIMMED, 0);
			  break;
			 
			 case 2:							// 2 cam motors
				for(i = 0; i < 3; i++)
				{
				 SetCtrlAttribute (panelHandle, GUI_control_order[i + 2], ATTR_DIMMED, 1);
				 SetCtrlAttribute (panelHandle, GUI_control_order[i + 7], ATTR_DIMMED, 1);
				 SetCtrlAttribute (panelHandle, GUI_control_order[i + 10], ATTR_DIMMED, 1);
				}
				for(i = 0; i < 2; i++)
				{
				 if(GAGE_NUMBER != 0)
				 SetCtrlAttribute (panelHandle, GUI_control_order[i + 15], ATTR_DIMMED, 1);
				 SetCtrlAttribute (panelHandle, GUI_control_order[i + 13], ATTR_DIMMED, 0);
				}
			  break;
			 
			 case 3:						   // 3 cam motors
				for(i = 0; i < 2; i++)
				{
				 SetCtrlAttribute (panelHandle, GUI_control_order[i + 3], ATTR_DIMMED, 1);
				 SetCtrlAttribute (panelHandle, GUI_control_order[i + 8], ATTR_DIMMED, 1);
				 SetCtrlAttribute (panelHandle, GUI_control_order[i + 13], ATTR_DIMMED, 1);
				 SetCtrlAttribute (panelHandle, GUI_control_order[i + 10], ATTR_DIMMED, 0);
				 if(GAGE_NUMBER != 0)
				 {
				  SetCtrlAttribute (panelHandle, GUI_control_order[i + 17], ATTR_DIMMED, 1);
				  SetCtrlAttribute (panelHandle, GUI_control_order[i + 15], ATTR_DIMMED, 0);
				 }
				}
				SetCtrlAttribute (panelHandle, GUI_control_order[2], ATTR_DIMMED, 0);
				SetCtrlAttribute (panelHandle, GUI_control_order[12], ATTR_DIMMED, 0);
				SetCtrlAttribute (panelHandle, GUI_control_order[7], ATTR_DIMMED, 0);
			  break;
			 
			 default:
				 
				 break;
			 }
  DisplayPanel (panelHandle);
  return;
 }
 
/*	**************************************************************  */

/*  Private User Interface Functions  */

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

int CVICALLBACK device_init (int panel, int control, int event,
		void *callbackData, int eventData1, int eventData2)
{
     int flag, err;
     int save_data;
     int f_handle;
     double f_angle[CAM_NUM];
     int i;
	 char log_file[80];
	 FILE* file_ptr;
	 int log_file_number = 1;
     long file_size;
	 static int panel_ID;
	
	panel_ID = panel;
	
	switch (event)
		{
		case EVENT_COMMIT:
		
		// Save log file name 
        strcpy(log_f_name, CAM_LOG_DIR);
        
		// check, if file exists
		do
		 {
		  // make log file name
		  if(log_file_number < 10)  Fmt(log_file,"%s%i[w1]","Cam_mover_log.00",log_file_number++);
		   else if(log_file_number < 100) Fmt(log_file,"%s%i[w2]","Cam_mover_log.0",log_file_number++);
		    else Fmt(log_file,"%s%i[w3]","Cam_mover_log.",log_file_number++);
		
		 //make log file name
		 if(MakePathname (CAM_LOG_DIR, log_file, log_f_name) != 0)
	     cam_move_error_handling(1,"Unable to create data file");
		 
		  err = GetFileInfo (log_f_name, &file_size);
		 }
		while(err != 0);
		
		
		
		// open log file  
 	    file_ptr = fopen(log_f_name, "w");
	     if (file_ptr == NULL) return -1;
	    fprintf(file_ptr, "%s %s %s %s\n", "Cam_mover system started ", DateStr(), "at:", TimeStr());
	    fprintf(file_ptr, "*************************************************************************\n");
	    fclose(file_ptr);
		
		cam_fill_param_struct(&mv_param, &cm_param);
		
		// initialize devices
		 err = cam_move_device_init(log_f_name, panel_ID, CAM_PANEL_TEXT_STATUS, cm_param, mv_param);
		 
		 // save initial coordinates 
		 cam_move_save_coord(mv_param);
		 
		 // log initial coordinates
		 cam_move_log_motion_data("Initial device coordinates", mv_param);
		 
		 // Output initial coordinates 
		 for(i = 0; i < CAM_NUM; i++)
   			cam_move_GUI_out(panel_ID, GUI_control_order[i], mv_param.cam_coord[i]);
   			
   		
		 if(err != 0)
		 MessagePopup ("Init Error", "Error in device init");
		  else  
			{
			  GetCtrlAttribute (panel_ID, CAM_PANEL_RING_REFERENCE, ATTR_CTRL_VAL, &flag);
			  GetCtrlAttribute (panel_ID, CAM_PANEL_SAVE_DATA, ATTR_CTRL_VAL, &mv_param.log_data);
			 
			  if(mv_param.log_data == TRUE)
			  {
			  // Create a read/write file to save the data 
			   MessagePopup ("File name", "Please, input file name to log the data");
			   file_open(log_f_name, &f_handle, 0);
			   if(f_handle == -1) 
			     cam_move_error_handling(f_handle, "Can not create the file");
			   }
			   
		      // set boxes available/unavailable in dependance on reference point choosen
		      set_coordinate_box(flag);
			  
		      // read current cam position
			  update_status_line(panel_ID, CAM_PANEL_TEXT_STATUS, "Reading initial position");
			  cam_move_get_coordinates(panel_ID, &mv_param, cm_param, GUI_control_order);
			  
  	  		  // Update GUI
			  cam_move_set_coordinates(panel_ID, GUI_control_order, &mv_param);
			  
			  // Set controls available
			  SetCtrlAttribute (panel_ID, CAM_PANEL_MOVE, ATTR_DIMMED, 0);
			  SetCtrlAttribute (panel_ID, CAM_PANEL_SET_PARAMETERS, ATTR_DIMMED,0);
			  SetCtrlAttribute (panel_ID, CAM_PANEL_INITIALIZATION, ATTR_DIMMED,1);
			  SetCtrlAttribute (panel_ID, CAM_PANEL_HOME_POSITION, ATTR_DIMMED, 0);
			  SetCtrlAttribute (panel_ID, CAM_PANEL_TEST_CAMS, ATTR_DIMMED, 0);
			  SetCtrlAttribute (panel_ID, CAM_PANEL_P1_READ, ATTR_DIMMED, 0);
			  SetCtrlAttribute (panel_ID, CAM_PANEL_P2_READ, ATTR_DIMMED, 0);
			  SetCtrlAttribute (panel_ID, CAM_PANEL_P3_READ, ATTR_DIMMED, 0);
			  SetCtrlAttribute (panel_ID, CAM_PANEL_P4_READ, ATTR_DIMMED, 0);
			  SetCtrlAttribute (panel_ID, CAM_PANEL_P5_READ, ATTR_DIMMED, 0);
			  if(mv_param.num_gages != 0)
			  {
			   SetCtrlAttribute (panel_ID, CAM_PANEL_ZEROING_GAGES, ATTR_DIMMED,0);
			   SetCtrlAttribute (panel_ID, CAM_PANEL_X1_READ, ATTR_DIMMED, 0);
			   SetCtrlAttribute (panel_ID, CAM_PANEL_Y1_READ, ATTR_DIMMED, 0);
			   SetCtrlAttribute (panel_ID, CAM_PANEL_X2_READ, ATTR_DIMMED, 0);
			   SetCtrlAttribute (panel_ID, CAM_PANEL_Y2_READ, ATTR_DIMMED, 0);
			   SetCtrlAttribute (panel_ID, CAM_PANEL_X1_ZERO, ATTR_DIMMED, 0);
			   SetCtrlAttribute (panel_ID, CAM_PANEL_Y1_ZERO, ATTR_DIMMED, 0);
			   SetCtrlAttribute (panel_ID, CAM_PANEL_X2_ZERO, ATTR_DIMMED, 0);
			   SetCtrlAttribute (panel_ID, CAM_PANEL_Y2_ZERO, ATTR_DIMMED, 0);
			  }
			  //SetCtrlAttribute (panel_ID, CAM_PANEL_TEST_CAMS, ATTR_DIMMED, 0);
			  
			  update_status_line(panel_ID, CAM_PANEL_TEXT_STATUS, "Devices are ready");
	    	} 
		 break;
		case EVENT_LEFT_CLICK:

			break;
		case EVENT_RIGHT_CLICK:

			break;
		}
	return 0;
}

int CVICALLBACK read_data (int panel, int control, int event,
		void *callbackData, int eventData1, int eventData2)
{
	int i;
	switch (event)
		{
	 	 case EVENT_COMMIT:
			// read data
			cam_move_read_motion_data(&mv_param);
			// output on GUI
    		for(i = 0; i < 5; i++)
    		{
     			mv_param.cam_coord[i] /= -1000.; 
     			cam_move_GUI_out(panel, GUI_control_order[i], mv_param.cam_coord[i]);
    		}
		break;
		case EVENT_LEFT_CLICK:

			break;
		case EVENT_RIGHT_CLICK:

			break;
		}
	return 0;
}

int CVICALLBACK move_motor (int panel, int control, int event,
		void *callbackData, int eventData1, int eventData2)

{
	int panel_ID;
	int err;
	int mode = 0;	 // relative motion
	int i;
	
	panel_ID = panel;

	switch (event)
		{
		case EVENT_COMMIT:
		  update_status_line(panel_ID, CAM_PANEL_TEXT_STATUS, "Motors are in motion");
		  GetCtrlAttribute (panel_ID, CAM_PANEL_MOVE_ABS, ATTR_CTRL_VAL, &mode);
		  cam_move_go(panel_ID, cm_param, &mv_param, GUI_control_order, log_f_name, DO_ITERACTIONS, mode);
		  
		  // display updated coordinates on GUI
		  update_status_line(panel_ID, CAM_PANEL_TEXT_STATUS, "Reading position");
		  
		  // read pots and gages, calculate current coordinates and save them
		  err = cam_move_get_coordinates(panel_ID, &mv_param, cm_param, GUI_control_order);

		  // output results
    	  cam_move_set_coordinates(panel_ID, GUI_control_order, &mv_param);
    	  
		 // log final coordinates
		 cam_move_log_motion_data("Final device coordinates", mv_param);
    	  
		  update_status_line(panel_ID, CAM_PANEL_TEXT_STATUS, "Done");
			break;
		case EVENT_LEFT_CLICK:

			break;
		case EVENT_RIGHT_CLICK:

			break;
		}
	return 0;
}

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

int CVICALLBACK program_quit (int panel, int control, int event,
		void *callbackData, int eventData1, int eventData2)
{
	switch (event)
		{
		case EVENT_COMMIT:
			cam_move_exit();
			// close GUI 
            QuitUserInterface (0);
			break;
		case EVENT_LEFT_CLICK:

			break;
		case EVENT_RIGHT_CLICK:

			break;
		}
	return 0;
}

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

int CVICALLBACK zero_readings(int panel, int control, int event,
		void *callbackData, int eventData1, int eventData2)
{
	int err, i;
	int panel_ID;
	
	panel_ID = panel;
	
	switch (event)
		{
		case EVENT_COMMIT:
		  // Warn the operator 
  			err = danger_operation_message("All gages will be set to ZERO.Continue?");
  			if(err == 0)
  			{
  			 update_status_line(panel_ID, CAM_PANEL_TEXT_STATUS, "Zeroing gages");
  			 for(i = 1; i <= EV16P_NUM_GAGES; i++) 
  			 {
  			 cam_move_gage_zero(cm_param, i);
  			  
  			 // Output on GUI 
   			 cam_move_GUI_out(panel, GUI_control_order[14 + i], cam_move_read_gage(cm_param, i) / 1000.);
			 }
			 update_status_line(panel_ID, CAM_PANEL_TEXT_STATUS, "All gages are set to zero");
			}
			break;
		case EVENT_LEFT_CLICK:

			break;
		case EVENT_RIGHT_CLICK:

			break;
		}
		
	return 0;
}

int CVICALLBACK reference_switch (int panel, int control, int event,
		void *callbackData, int eventData1, int eventData2)
{
	int flag;
	
	switch (event)	  // Switch between front and rear cams
		{
		case EVENT_COMMIT:
		 {
		  GetCtrlAttribute (panelHandle, CAM_PANEL_RING_REFERENCE, ATTR_CTRL_VAL, &flag);
		  set_coordinate_box(flag);
		 }
			break;
		case EVENT_LEFT_CLICK:

			break;
		case EVENT_RIGHT_CLICK:

			break;
		}
	return 0;
}

int CVICALLBACK go_home (int panel, int control, int event,
		void *callbackData, int eventData1, int eventData2)
{
	int i, err;
	int s_axis;
	int panel_ID;
	
	panel_ID = panel;
	
	switch (event)
		{
		case EVENT_COMMIT:
		   update_status_line(panel_ID, CAM_PANEL_TEXT_STATUS, "Setting all cams in Home position");
		   cam_go_zero(panel_ID, &mv_param, cm_param);   // sets cam motors at zero angle
		
			// Update GUI
		   err = cam_move_get_coordinates(panel_ID, &mv_param, cm_param, GUI_control_order);	// reads current pot positions and gages
     	   cam_move_set_coordinates(panel_ID, GUI_control_order, &mv_param);
    	   for(i = 0; i < 5; i++) cam_move_GUI_out(panel_ID, GUI_control_order[i], 0.0); 
     	   
     	   update_status_line(panel_ID, CAM_PANEL_TEXT_STATUS, "All cams are in Home position");
			break;
		}
	return 0;
}


int CVICALLBACK read_pot (int panel, int control, int event,
		void *callbackData, int eventData1, int eventData2)
{
	int pot_number;
	double angle;
	
	switch (event)
		{
		case EVENT_COMMIT:
		   switch(control)
		    {
		     case CAM_PANEL_P1_READ:
		       pot_number = 1;
		     break;
		    
		     case CAM_PANEL_P2_READ:
		       pot_number = 2;
		     break;
		     
		     case CAM_PANEL_P3_READ:
		       pot_number = 3;
		     break;
		     
		     case CAM_PANEL_P4_READ:
		       pot_number = 4;
		     break;
		     
		     case CAM_PANEL_P5_READ:
		       pot_number = 5;
		     break;
		     
		     default:
		      MessagePopup ("Reading Error", "Error in pot number");
		    }
		    
		    angle = cam_move_read_cam_angles(&mv_param, cm_param, pot_number) * mv_param.angle_dir[pot_number - 1] + mv_param.pot_zero[pot_number - 1];
			cam_move_GUI_out(panel, GUI_control_order[9 + pot_number], RAD_TO_ANGLE * angle);
			DisplayPanel (panel);
			break;
		 }
	return 0;
}

int CVICALLBACK read_gage (int panel, int control, int event,
		void *callbackData, int eventData1, int eventData2)
{
	int gage_num;
	int index;
	
	switch (event)
		{
		case EVENT_COMMIT:
		   switch(control)
		    {
		     case CAM_PANEL_X1_READ:
		       gage_num = mv_param.gage[2];
		       index = 3;
		     break;
		    
		     case CAM_PANEL_Y1_READ:
		       gage_num = mv_param.gage[0];
		       index = 1;
		     break;
		     
		     case CAM_PANEL_X2_READ:
		       gage_num = mv_param.gage[3];
		       index = 4;
		     break;
		     
		     case CAM_PANEL_Y2_READ:
		       gage_num = mv_param.gage[1];
		       index = 2;
		     break;
		     
		     case CAM_PANEL_Z_READ:
		       gage_num = 5;
		       index = 5;
		     break;
		     
		     default:
		      MessagePopup ("Reading Error", "Error in gage number");
		    }
		    
			cam_move_GUI_out(panel, GUI_control_order[14 + index], cam_move_read_gage(cm_param, gage_num) / 1000.);
			DisplayPanel (panel);
			break;
		}
	return 0;
}

int CVICALLBACK zero_gage (int panel, int control, int event,
		void *callbackData, int eventData1, int eventData2)
{
	int gage_num;
	int index;
	
	switch (event)
		{
		case EVENT_COMMIT:
		   switch(control)
		    {
		     case CAM_PANEL_X1_ZERO:
		       gage_num = mv_param.gage[2];
		       index = 3;
		     break;
		    
		     case CAM_PANEL_Y1_ZERO:
		       gage_num = mv_param.gage[0];
		       index = 1;
		     break;
		     
		     case CAM_PANEL_X2_ZERO:
		       gage_num = mv_param.gage[3];
		       index = 4;
		     break;
		     
		     case CAM_PANEL_Y2_ZERO:
		       gage_num = mv_param.gage[1];
		       index = 2;
		     break;
		     
		     case CAM_PANEL_Z_ZERO:
		       gage_num = 5;
		       index = 5;
		     break;
		     
		     default:
		      MessagePopup ("Reading Error", "Error in gage number");
		    }
		    mv_param.gage_read[gage_num - 1] = 0.; 
			cam_move_gage_zero(cm_param, gage_num);
			cam_move_GUI_out(panel, GUI_control_order[14 + index], 0.0);
			DisplayPanel (panel);
			break;
		}
	return 0;
}

/* Functions for param panel */
/*************************************************************************/

int CVICALLBACK set_param (int panel, int control, int event,
		void *callbackData, int eventData1, int eventData2)
{
	switch (event)
		{
		case EVENT_COMMIT:
		 {
			if ((panelHandleParam = LoadPanel (1, "Cam_movers.uir", PAR_PANEL)) < 0)
	 		{
	 		 cam_move_ui_error(" Can not load Param Panel!!!");
	  		 return -1;
	 		}
		  // Output current parameters
		   SetCtrlAttribute (panelHandleParam, PAR_PANEL_GPIBADDR, 
		   					 ATTR_CTRL_VAL, cm_param.gpib_addr);
		   SetCtrlAttribute (panelHandleParam, PAR_PANEL_CM6K6ADDR,
							 ATTR_CTRL_VAL, cm_param.cm6k6_addr);
		   SetCtrlAttribute (panelHandleParam, PAR_PANEL_EV16PADDR,
							 ATTR_CTRL_VAL, cm_param.ev16p_addr);
		   SetCtrlAttribute (panelHandleParam, PAR_PANEL_HP34970ADDR,
							 ATTR_CTRL_VAL, cm_param.hp34970_addr);
		   SetCtrlAttribute (panelHandleParam, PAR_PANEL_EV16PCOMPORT,
							 ATTR_CTRL_VAL, cm_param.ev16p_com_port);
		   SetCtrlAttribute (panelHandleParam, PAR_PANEL_CM6K6COMPORT,
							 ATTR_CTRL_VAL, cm_param.cm6k6_com_port);
		   SetCtrlAttribute (panelHandleParam, PAR_PANEL_MOTORVEL, ATTR_CTRL_VAL,
							 mv_param.vel);
		   SetCtrlAttribute (panelHandleParam, PAR_PANEL_MOTORACC, ATTR_CTRL_VAL,
							 mv_param.accel);
		   SetCtrlAttribute (panelHandleParam, PAR_PANEL_AXIS, ATTR_CTRL_VAL,
							 mv_param.axis);
		   SetCtrlAttribute (panelHandleParam, PAR_PANEL_STEPSIZE, ATTR_CTRL_VAL,
							 mv_param.step_size);
		   SetCtrlAttribute (panelHandleParam, PAR_PANEL_NUMBERSTEPS,
							 ATTR_CTRL_VAL, mv_param.num_steps);
		   SetCtrlAttribute (panelHandleParam, PAR_PANEL_TIMEINT, ATTR_CTRL_VAL,
							 mv_param.time_int);
		  
		  DisplayPanel (panelHandleParam); //Display the panel 
		  }
			break;
		case EVENT_LEFT_CLICK:

			break;
		case EVENT_RIGHT_CLICK:

			break;
		}
	return 0;
}

int CVICALLBACK save_param (int panel, int control, int event,
		void *callbackData, int eventData1, int eventData2)
{
	switch (event)
		{
		case EVENT_COMMIT:
		  {
		   GetCtrlAttribute (panelHandleParam, PAR_PANEL_GPIBADDR, 
		   					 ATTR_CTRL_VAL, &cm_param.gpib_addr);
		   GetCtrlAttribute (panelHandleParam, PAR_PANEL_CM6K6ADDR,
							 ATTR_CTRL_VAL, &cm_param.cm6k6_addr);
		   GetCtrlAttribute (panelHandleParam, PAR_PANEL_EV16PADDR,
							 ATTR_CTRL_VAL, &cm_param.ev16p_addr);
		   GetCtrlAttribute (panelHandleParam, PAR_PANEL_HP34970ADDR,
							 ATTR_CTRL_VAL, &cm_param.hp34970_addr);
		   GetCtrlAttribute (panelHandleParam, PAR_PANEL_EV16PCOMPORT,
							 ATTR_CTRL_VAL, &cm_param.ev16p_com_port);
		   GetCtrlAttribute (panelHandleParam, PAR_PANEL_CM6K6COMPORT,
							 ATTR_CTRL_VAL, &cm_param.cm6k6_com_port);
		   GetCtrlAttribute (panelHandleParam, PAR_PANEL_MOTORVEL, ATTR_CTRL_VAL,
							 &mv_param.vel);
		   GetCtrlAttribute (panelHandleParam, PAR_PANEL_MOTORACC, ATTR_CTRL_VAL,
							 &mv_param.accel);
		   GetCtrlAttribute (panelHandleParam, PAR_PANEL_AXIS, ATTR_CTRL_VAL,
							 &mv_param.axis);
		   GetCtrlAttribute (panelHandleParam, PAR_PANEL_STEPSIZE, ATTR_CTRL_VAL,
							 &mv_param.step_size);
		   GetCtrlAttribute (panelHandleParam, PAR_PANEL_NUMBERSTEPS,
							 ATTR_CTRL_VAL, &mv_param.num_steps);
		   GetCtrlAttribute (panelHandleParam, PAR_PANEL_TIMEINT, ATTR_CTRL_VAL,
							 &mv_param.time_int);
		  
		   save_param_flag = TRUE;
		  }	
			break;
		case EVENT_LEFT_CLICK:

			break;
		case EVENT_RIGHT_CLICK:

			break;
		}
	return 0;
}

int CVICALLBACK exit_param (int panel, int control, int event,
		void *callbackData, int eventData1, int eventData2)
{
	int err = 1;
	
	switch (event)
		{
		case EVENT_COMMIT:
		   if(save_param_flag == FALSE)
			 err = ConfirmPopup ("WARNING", "Parameters have not been saved. Continue?");
		     if(err == 1) DiscardPanel (panelHandleParam);
			break;
		case EVENT_LEFT_CLICK:

			break;
		case EVENT_RIGHT_CLICK:

			break;
		}
	return 0;
}


/* Functions for test cam mover panel */

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

 void test_read_move_param(int panel, struct move_param *m_param)
{
 unsigned short int axis;
 unsigned short int gage;
 unsigned short int num_steps;
 double step_size;				            // In motor revolutions
 double vel;
 double accel;
 double time_int;
 double dist;
 static int panel_ID;
 
 panel_ID = panel;
 
	GetCtrlVal (panel_ID, TEST_PANEL_NUMERIC_AXIS, &axis);
	GetCtrlVal (panel_ID, TEST_PANEL_NUMERIC_TIME, &time_int);
	GetCtrlVal (panel_ID, TEST_PANEL_NUMERIC_STEPS, &num_steps);
	GetCtrlVal (panel_ID, TEST_PANEL_NUMERIC_STEP_SIZE, &step_size);
	GetCtrlVal (panel_ID, TEST_PANEL_NUMERIC_ACCELERATION, &accel);
	GetCtrlVal (panel_ID, TEST_PANEL_NUMERIC_VELOCITY, &vel);
	GetCtrlVal (panel_ID, TEST_PANEL_NUMERIC_DISTANCE, &dist);
	GetCtrlVal (panel_ID, TEST_PANEL_NUMERIC_GAGE, &gage);
	m_param->axis = axis;
	m_param->time_int = time_int;
	m_param->num_steps = num_steps;
	m_param->step_size = step_size;
	m_param->accel = accel;
	m_param->vel = vel;
	m_param->distance = dist;
	m_param->gage_number = gage;
	return;
}
/*************************************************************************/


int CVICALLBACK do_cam_test (int panel, int control, int event,
		void *callbackData, int eventData1, int eventData2)
{
	switch (event)
		{
		case EVENT_COMMIT:
		  if ((panelHandleTest = LoadPanel (0, "Cam_movers.uir", TEST_PANEL)) < 0)
	 		{
	 		 cam_move_ui_error(" Can not load Test Panel!!!");
	  		 return -1;
	  		 }  
		  SetActivePanel(panelHandleTest);
			break;
		}
	return 0;
}

int CVICALLBACK test_distance_move (int panel, int control, int event,
		void *callbackData, int eventData1, int eventData2)
{
	int err;
	static int panel_ID;

	panel_ID = panel;
	
	switch (event)
		{
		case EVENT_COMMIT:
		 // read current moving parameters from GUI 
		    test_read_move_param(panel, &mv_param);
			
		//do the test move
			SetCtrlAttribute (panel_ID, TEST_PANEL_TEXT_STATUS, ATTR_VISIBLE, 1);
			SetCtrlAttribute (panel_ID, TEST_PANEL_TEXT_STATUS, ATTR_CTRL_VAL, "Motion in Progress");
	        DisplayPanel (panel_ID);
			
			//if(mv_param.distance != 0.0) 
			err = cam_test(cm_param, mv_param, log_f_name);
			
			// else cam_test_cable_test(panel_ID, mv_param); 
		 	SetCtrlAttribute (panel_ID, TEST_PANEL_TEXT_STATUS, ATTR_CTRL_VAL, "Done");
	        DisplayPanel (panel_ID);
			break;
		case EVENT_LEFT_CLICK:

			break;
		case EVENT_RIGHT_CLICK:

			break;
		}
	return 0;
}

int CVICALLBACK test_zero_data (int panel, int control, int event,
		void *callbackData, int eventData1, int eventData2)
{
	static int panel_ID;

	panel_ID = panel;
	switch (event)
		{
		case EVENT_COMMIT:
		 SetCtrlAttribute (panel_ID, TEST_PANEL_TEXT_STATUS, ATTR_CTRL_VAL, "Setting Position to zero");
	     DisplayPanel (panel_ID);
		 SetCtrlAttribute (panel_ID, TEST_PANEL_GAGE1_OUT, ATTR_CTRL_VAL, 0.0);
		 
		 cam_test_zero_readings(panel_ID, TEST_PANEL_GAGE1_OUT);
		 
		 SetCtrlAttribute (panel_ID, TEST_PANEL_TEXT_STATUS, ATTR_CTRL_VAL, "Done");
	     DisplayPanel (panel_ID);
		break;
		case EVENT_LEFT_CLICK:

			break;
		case EVENT_RIGHT_CLICK:

			break;
		}
	return 0;
}

int CVICALLBACK exit_test (int panel, int control, int event,
		void *callbackData, int eventData1, int eventData2)
{
	switch (event)
		{
		case EVENT_COMMIT:
			
			// Close panel
			DiscardPanel (panel);
			
			// Reset moving parameters
			fill_param_structure(&mv_param, &cm_param, 0);
			
			//display main panel
			DisplayPanel(panelHandle);
			break;
		case EVENT_LEFT_CLICK:

			break;
		case EVENT_RIGHT_CLICK:

			break;
		}
	return 0;
}

int CVICALLBACK test_get_temp (int panel, int control, int event,
		void *callbackData, int eventData1, int eventData2)
{
	double temp;
	
	switch (event)
		{
		case EVENT_COMMIT:
		cam_test_get_temp(&temp, cm_param);
			break;
		case EVENT_LEFT_CLICK:

			break;
		case EVENT_RIGHT_CLICK:

			break;
		}
	return 0;
}

int CVICALLBACK test_get_position (int panel, int control, int event,
		void *callbackData, int eventData1, int eventData2)
{
    double position;
    int gage;
    
	switch (event)
		{
		case EVENT_COMMIT:
		 // read current moving parameters from GUI 
		    test_read_move_param(panel, &mv_param);
		    gage = mv_param.gage_number;
			position = cam_test_get_position(cm_param, gage, 1);
			break;
		case EVENT_LEFT_CLICK:

			break;
		case EVENT_RIGHT_CLICK:

			break;
		}
	return 0;
}

int CVICALLBACK test_get_angle (int panel, int control, int event,
		void *callbackData, int eventData1, int eventData2)
{
	double angle;
	
	switch (event)
		{
		case EVENT_COMMIT:
		 // read current moving parameters from GUI 
		 test_read_move_param(panel, &mv_param);
		 angle = cam_test_get_angle(&mv_param, cm_param);
			break;
		case EVENT_LEFT_CLICK:

			break;
		case EVENT_RIGHT_CLICK:

			break;
		}
	return 0;
}

int CVICALLBACK test_device_init (int panel, int control, int event,
		void *callbackData, int eventData1, int eventData2)
{
	int f_handle;
	int err = 0;
	static int panel_ID;
	
	panel_ID = panel;
	
	switch (event)
		{
		case EVENT_COMMIT:
		 SetCtrlAttribute (panel_ID, TEST_PANEL_TEXT_STATUS, ATTR_VISIBLE, 1);
		 SetCtrlAttribute (panel_ID, TEST_PANEL_TEXT_STATUS, ATTR_CTRL_VAL, "Initialization in Progress");
	     DisplayPanel (panel_ID);
		 
		 // fill parameter structure
		 fill_param_structure(&mv_param, &cm_param, 1);
		 
		 // read current moving parameters from GUI 
		 test_read_move_param(panel_ID, &mv_param);
		 
		 err = cam_move_device_init(log_f_name, panel_ID, TEST_PANEL_TEXT_STATUS, cm_param, mv_param);
		 if(err != 0)
		 MessagePopup ("Init Error", "Error in device init");
		  else
			{
			// Create a read/write file to save the data 
/*			 MessagePopup ("File name", "Please, input file name to log the data");
			 file_open(log_f_name, &f_handle, 0);
			 if(f_handle == -1) error_handling(f_handle, "Can not create the file"); */
			   
			// Make command buttons available 
			 SetCtrlAttribute (panel_ID, TEST_PANEL_COMMAND_GET_ANGLE, ATTR_DIMMED,0);
			 SetCtrlAttribute (panel_ID, TEST_PANEL_COMMAND_SET_ANGLE, ATTR_DIMMED,0);
			 SetCtrlAttribute (panel_ID, TEST_PANEL_COMMAND_POS, ATTR_DIMMED, 0);
			 SetCtrlAttribute (panel_ID, TEST_PANEL_COMMAND_TEMP, ATTR_DIMMED, 0);
			 SetCtrlAttribute (panel_ID, TEST_PANEL_COMMAND_MOVE, ATTR_DIMMED, 0);
			 SetCtrlAttribute (panel_ID, TEST_PANEL_COMMANDBUTTON_Z, ATTR_DIMMED, 0);
			 SetCtrlAttribute (panel_ID, TEST_PANEL_GO_TO_ZERO, ATTR_DIMMED, 0);
			 SetCtrlAttribute (panel_ID, TEST_PANEL_GO_TO_HOME, ATTR_DIMMED, 0);
			 SetCtrlAttribute (panel_ID, TEST_PANEL_WORK_POINT, ATTR_DIMMED, 0);
			 SetCtrlAttribute (panel_ID, TEST_PANEL_TEXT_STATUS, ATTR_VISIBLE, 1);
			 err = SetAxisRange (panel_ID, TEST_PANEL_GRAPH, VAL_MANUAL, 0.0,
											  GEAR_RATIO, VAL_NO_CHANGE, 0.0, 0.0);
				if(err < 0)  cam_move_error_handling(err, " Problem changing X limit");
			 

			 SetCtrlAttribute (panel_ID, TEST_PANEL_COMMANDBUTTON_INIT, ATTR_DIMMED, 1);
			 SetCtrlAttribute (panel_ID, TEST_PANEL_TEXT_STATUS, ATTR_CTRL_VAL, "Devices Ready");
	         DisplayPanel (panel_ID);
			 }
			break;
		case EVENT_LEFT_CLICK:

			break;
		case EVENT_RIGHT_CLICK:

			break;
		}
	return 0;
}

int CVICALLBACK test_refresh_graph (int panel, int control, int event,
		void *callbackData, int eventData1, int eventData2)
{
	int err;
	static int panel_ID;
	
	panel_ID = panel;
	
	switch (event)
		{
		case EVENT_COMMIT:
		 err = DeleteGraphPlot (panel_ID, TEST_PANEL_GRAPH, -1, VAL_IMMEDIATE_DRAW);
		   if (err != 0) cam_move_error_handling(err, " Problem deleting Graph");
		 err = SetAxisRange (panel_ID, TEST_PANEL_GRAPH, VAL_MANUAL, 0.0,
											  GEAR_RATIO, VAL_MANUAL, -1.0, 1.0);
		 SetCtrlAttribute (panel_ID, TEST_PANEL_AMPLITUDE, ATTR_VISIBLE, 0);
	     SetCtrlAttribute (panel_ID, TEST_PANEL_PHASE, ATTR_VISIBLE, 0);
		 DisplayPanel (panel_ID);	
			break;
		}
	return 0;
}							   


int CVICALLBACK test_go_zero (int panel, int control, int event,
		void *callbackData, int eventData1, int eventData2)
{
	static int panel_ID;
	double angle;
	
	panel_ID = panel;
	switch (event)
		{
		case EVENT_COMMIT:
		
		 // read current moving parameters from GUI 
		 SetCtrlAttribute (panel_ID, TEST_PANEL_TEXT_STATUS, ATTR_CTRL_VAL, "Go to Pot zero position");
	     DisplayPanel (panel_ID);
	     
		 test_read_move_param(panel_ID, &mv_param);
		 cam_test_go_zero(panel_ID, &mv_param, cm_param);
		 
		 angle = cam_test_get_angle(&mv_param, cm_param);
		 
		 SetCtrlAttribute (panel_ID, TEST_PANEL_TEXT_STATUS, ATTR_CTRL_VAL, "Pot zero Done");
	     DisplayPanel (panel_ID);
			break;
		}
	return 0;
}

int CVICALLBACK test_go_home (int panel, int control, int event,
		void *callbackData, int eventData1, int eventData2)
{
	static int panel_ID;
	
	panel_ID = panel;
	switch (event)
		{
		case EVENT_COMMIT:
		  SetCtrlAttribute (panel_ID, TEST_PANEL_TEXT_STATUS, ATTR_CTRL_VAL,"Go to Pot home position");
	      DisplayPanel (panel_ID);
	      
		  test_read_move_param(panel_ID, &mv_param);
		  cam_test_go_zero(panel_ID, &mv_param, cm_param);
		  Delay(0.5);
		  cam_test_go_home(&mv_param, cm_param);
		  
		  SetCtrlAttribute (panel_ID, TEST_PANEL_TEXT_STATUS, ATTR_CTRL_VAL, "Homing Done");
	      DisplayPanel (panel_ID);
			break;
		}
	return 0;
}   


int CVICALLBACK find_work_point (int panel, int control, int event,
		void *callbackData, int eventData1, int eventData2)
{
	static int panel_ID;
	
	panel_ID = panel;
	switch (event)
		{
		case EVENT_COMMIT:
		// find position of the work point
		 mv_param.step_size = cam_test_find_work_point (mv_param, cm_param);
		 
		 //move cam into work point position
		 move_cam_motor(panel_ID, &mv_param, &mv_param.step_size, 0);
		 SetCtrlAttribute (panel_ID, TEST_PANEL_TEXT_STATUS, ATTR_CTRL_VAL, "Done");
	     DisplayPanel (panel_ID);
			break;
		}
	return 0;
}

int CVICALLBACK test_set_angle (int panel, int control, int event,
		void *callbackData, int eventData1, int eventData2)
{
	int i;
	double angle;
	static int panel_ID;
	
	panel_ID = panel;
	switch (event)
		{ 
		case EVENT_COMMIT: 
		 SetCtrlAttribute (panel_ID, TEST_PANEL_TEXT_STATUS, ATTR_CTRL_VAL, "Measure angle");
	     DisplayPanel (panel_ID);
	     
		 for(i = 0; i < 20; i++) 
		  { 
		   angle = cam_test_get_angle(&mv_param, cm_param);
		   Delay(0.1);
		  }
		  SetCtrlAttribute (panel_ID, TEST_PANEL_TEXT_STATUS, ATTR_CTRL_VAL, "Done");
	      DisplayPanel (panel_ID);
			break;
		}
	return 0;
}