//  **************************************************************  
//
//  Module UMACUI
//  This is a demo module for Delta TAU controller
//                   
//
//  Seva Kaplounenko, Stanford Linear Accelerator Center 
 //  6/14/06
 // 

//  INCLUDES  
#include "C:\Users\admin\Documents\LCLS-II\Repository\Lib\delay.h"
#include <utility.h>
#include <ansi_c.h>
#include <cvirte.h>     /* Needed if linking in external compiler; harmless otherwise */
#include <userint.h>
#include "umacuir.h"
#include "umacui.h"
#include "umac.h"

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

//  PRIVATE VARIABLES  
static int umac_ID;
static int umac_panel;
static char module_name[] = {"UMACUI"};

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

void umacui_error(char* msg);

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

//--------------------------   UMACUI.C FUNCTIONS  ------------------------------
//  *****************************************************************************  
void umacui_set_motor(void)
{
	int motor =-1;
	double tmp;
	motor = umac_get_axis(umac_ID);
    SetCtrlVal(umac_panel,UMACPAN_AXIS,motor);
    tmp = umac_get_velocity( umac_ID, motor);
    SetCtrlVal(umac_panel,UMACPAN_VELOCITY,tmp);
    tmp = umac_get_acceleration( umac_ID, motor);
    SetCtrlVal(umac_panel,UMACPAN_ACCELERATION,tmp);
    tmp = umac_get_distance( umac_ID, motor);
    SetCtrlVal(umac_panel,UMACPAN_REL_DISTANCE,tmp);
    umac_get_mot_position( umac_ID, motor, &tmp);
    SetCtrlVal(umac_panel,UMACPAN_ACTUAL_POSITION,tmp);
    
    //disable button
    SetCtrlAttribute(umac_panel,UMACPAN_COM_MOVE_HOME,ATTR_DIMMED,1); 
}


//  ***************************************************************************** 
void umacui_set_dimm_buttons(BOOL set)
{
	
 	SetCtrlAttribute(umac_panel,UMACPAN_MOVE_ABS,ATTR_DIMMED,set);
	SetCtrlAttribute(umac_panel,UMACPAN_MOVE_REL,ATTR_DIMMED,set);
	SetCtrlAttribute(umac_panel,UMACPAN_AXIS,ATTR_DIMMED,set); 
	SetCtrlAttribute(umac_panel,UMACPAN_COM_GET_MOT_POS,ATTR_DIMMED,set);   
    
}
//  ***************************************************************************** 
void umacui_init(int ID)
{
    umac_ID = ID;
    
    
    /* Open the UMAC panel */
    umac_panel = LoadPanel(0, "umacuir.uir", UMACPAN);
    if (umac_panel < 0)
    {
        umacui_error("Could not open user interface panel");
        return;
    }
    
    /* Display the panel when the user interface runs */
    DisplayPanel(umac_panel);
    umacui_set_motor();
    /* Done */
    return;
}

//  ***************************************************************************** 
void umacui_error(char* message)
{
    stop_error_msg(module_name,message);
}

//  ***************************************************************************** 
int CVICALLBACK umacui_move_rel(int panel, int control, int event,
        void *callbackData, int eventData1, int eventData2)
{
    int axis;
    double acceleration, velocity, distance;
    double position = 0.;
    BOOL res;
    switch (event)
    {
        case EVENT_COMMIT:
            GetCtrlVal(panel, UMACPAN_AXIS, &axis);
            GetCtrlVal(panel, UMACPAN_ACCELERATION, &acceleration);
            GetCtrlVal(panel, UMACPAN_VELOCITY, &velocity);
            GetCtrlVal(panel, UMACPAN_REL_DISTANCE, &distance);
            res = umac_rel_move(umac_ID, axis, acceleration, velocity, distance);
            umacui_set_dimm_buttons(TRUE);
            
            do
            {
            	cvi_delay(2.0);
            }
            while(umac_AxisIsMoving (umac_ID,axis));
            umacui_set_dimm_buttons(FALSE); 
            
            res = umac_get_mot_position(umac_ID, axis, &position); 
            SetCtrlVal(panel, UMACPAN_ACTUAL_POSITION, position);
            break;
    }
    return 0;
}

//  ***************************************************************************** 
int CVICALLBACK umacui_move_abs(int panel, int control, int event,
        void *callbackData, int eventData1, int eventData2)
{
    int axis;
    double acc, vel, pos;
    BOOL res;
    double position;
    switch (event)
    {
        case EVENT_COMMIT:
            GetCtrlVal(panel, UMACPAN_AXIS, &axis);
            GetCtrlVal(panel, UMACPAN_ACCELERATION, &acc);
            GetCtrlVal(panel, UMACPAN_VELOCITY, &vel);
            GetCtrlVal(panel, UMACPAN_ABS_DISTANCE, &pos);
            res = umac_abs_move(umac_ID, axis, acc, vel, pos);
             umacui_set_dimm_buttons(TRUE); 
            do
            {
            	cvi_delay(2.0);
            }
            while(umac_AxisIsMoving (umac_ID,axis));
            umacui_set_dimm_buttons(FALSE); 
            
            res = umac_get_mot_position(umac_ID, axis, &position); 
            SetCtrlVal(panel, UMACPAN_ACTUAL_POSITION, position);
            break;
    }
    return 0;
} 

//  ***************************************************************************** 
int CVICALLBACK umacui_home_move (int panel, int control, int event,
        void *callbackData, int eventData1, int eventData2)
{
    int axis;
    double vel, acc;
    UMAC_PARAM_STRUCT nParam;
    switch (event)
        {
        case EVENT_COMMIT:
            GetCtrlVal(panel, UMACPAN_AXIS, &axis);
            //GetCtrlVal(panel, UMACPAN_NUM_ACCELERATION, &acc);
            //GetCtrlVal(panel, UMACPAN_NUM_VELOCITY, &vel);
            umac_getParameters(&nParam ,  axis);
            umac_homing(umac_ID, axis, nParam.home_direction);
            break;
        }
    return 0;
}

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

int CVICALLBACK umacui_get_mot_position(int panel, int control, int event,
        void *callbackData, int eventData1, int eventData2)
{
    int axis;
    double pos;
    switch (event)
    {
        case EVENT_COMMIT:
            GetCtrlVal(panel, UMACPAN_AXIS, &axis);
            umac_get_mot_position(umac_ID, axis, &pos);
            SetCtrlVal(panel, UMACPAN_ACTUAL_POSITION, pos);
            break;
    }
    return 0;
}

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

int CVICALLBACK umacui_quit(int panel, int control, int event,
        void *callbackData, int eventData1, int eventData2)
{
    switch (event)
    {
        case EVENT_COMMIT:
            umac_exit(umac_ID);
            QuitUserInterface(0);
            break;
    }
    return 0;
}

//  ***************************************************************************** 
int CVICALLBACK OnCommand (int panel, int control, int event,
		void *callbackData, int eventData1, int eventData2)
{
	char inBuf[128];
	char outBuf[128];
	int maxlength = 10;
	switch (event)
	{
		case EVENT_COMMIT:
		GetCtrlVal(panel,UMACPAN_COMMAND, outBuf);
		if(strlen(outBuf) <=0)
		{
			message("Please enter command");
			return 0;
		}
		
		printf("\n%s",outBuf);
		if(umac_command(umac_ID,inBuf , maxlength, outBuf ))
		{
			 
			SetCtrlVal(panel,UMACPAN_RESULT,inBuf); 
			printf("\n%s",inBuf);
		}
		SetCtrlVal(panel,UMACPAN_COMMAND, "");
		SetActiveCtrl (panel, UMACPAN_COMMAND);
		SetCtrlVal(panel,UMACPAN_COMMAND, "");
		SetActivePanel (panel);
		

			break;
	}
	return 0;
}

//  ***************************************************************************** 
int CVICALLBACK OnAcceleration (int panel, int control, int event,
		void *callbackData, int eventData1, int eventData2)
{
	double acceleration =0;
	int motor =-1;
	
	switch (event)
		{
		case EVENT_COMMIT:
		motor = umac_get_axis(umac_ID);
			GetCtrlVal(umac_panel,UMACPAN_ACCELERATION,&acceleration);
			umac_set_acceleration( umac_ID, motor, acceleration);
			break;
		}
	return 0;
}

int CVICALLBACK OnVelocity (int panel, int control, int event,
		void *callbackData, int eventData1, int eventData2)
{
	double velocity =0;
	int motor =-1; 
	switch (event)
		{
		case EVENT_COMMIT:
		
	
			motor = umac_get_axis(umac_ID);
			GetCtrlVal(umac_panel,UMACPAN_VELOCITY,&velocity);
			umac_set_velocity( umac_ID, motor, velocity);
			break;
		}
	return 0;
}

//  ***************************************************************************** 
int CVICALLBACK OnAxis (int panel, int control, int event,
		void *callbackData, int eventData1, int eventData2)
{
	int axis = -1;
	switch (event)
		{
		case EVENT_COMMIT:
		 GetCtrlVal(umac_panel,UMACPAN_AXIS,&axis);
		umac_set_axis( umac_ID , axis); 
		umacui_set_motor();
			break;
		}
	return 0;
}

//  ***************************************************************************** 
int CVICALLBACK OnRelDistance (int panel, int control, int event,
		void *callbackData, int eventData1, int eventData2)
{
	double distance =0;
	int motor =-1;
	switch (event)
		{
		case EVENT_COMMIT:
			motor = umac_get_axis(umac_ID);
			GetCtrlVal(umac_panel,UMACPAN_REL_DISTANCE,&distance);
			umac_set_distance(umac_ID,motor,distance);
			break;
		}
	return 0;
}

//  ***************************************************************************** 
int CVICALLBACK OnAbsDistance (int panel, int control, int event,
		void *callbackData, int eventData1, int eventData2)
{
	switch (event)
		{
		case EVENT_COMMIT:

			break;
		}
	return 0;
}


//  ***************************************************************************** 
int CVICALLBACK OnMotorStatus (int panel, int control, int event,
		void *callbackData, int eventData1, int eventData2)
{
	unsigned long status_x, status_y;
	int axis = -1;
	BOOL res;
	unsigned int mask = 1L;
	switch (event)
		{
		case EVENT_COMMIT:
			GetCtrlVal(umac_panel,UMACPAN_AXIS,&axis);
			umac_get_mot_status(umac_ID, axis, &status_x, &status_y);
			
			res = (status_y & (mask << MOTOR_INPOSITION_Y));
			SetCtrlVal(umac_panel,UMACPAN_MOTOR_IN_POSITION,res);
			
			res = (status_y & (mask << MOTOR_HOME_COMPLETE_Y));
			SetCtrlVal(umac_panel,UMACPAN_MOTOR_HOME_COMPLETE,res);
			
			res = (status_y & (mask << MOTOR_STOP_POS_LIMIT_Y));
			
			res = (status_x & (mask << MOTOR_DESIRED_VELOCITY0_X));
			SetCtrlVal(umac_panel,UMACPAN_MOTOR_DESIRED_VELOCIT,res); 
			
			res = (status_x & (mask << MOTOR_MOVE_TIMER_ACTIVE_X));
			SetCtrlVal(umac_panel,UMACPAN_MOTOR_MOVE_TIMER,res); 
			
			res = (status_x & (mask << MOTOR_OPEN_LOOP_X));
			SetCtrlVal(umac_panel,UMACPAN_MOTOR_OPEN_LOOP,res);
			
			res = (status_x & (mask << MOTOR_AMPLIFIER_ENABLED_X));
			SetCtrlVal(umac_panel,UMACPAN_MOTOR_AMPLIFIER_ENABL,res); 
			
			res = (status_x & (mask << MOTOR_POSITIVE_LIMIT_SET_X));
			SetCtrlVal(umac_panel,UMACPAN_MOTOR_POSITIVE_LIMIT,res); 
			
			res = (status_x & (mask << MOTOR_NEGATIVE_LIMIT_SET_X));
			SetCtrlVal(umac_panel,UMACPAN_MOTOR_NEGATIVE_LIMIT,res); 
			
			res = (status_x & (mask << MOTOR_ACTIVATED_X));
			SetCtrlVal(umac_panel,UMACPAN_MOTOR_ACTIVATED,res); 
			break;
		}
	return 0;
}

//  ***************************************************************************** 
int CVICALLBACK OnCsStatus (int panel, int control, int event,
		void *callbackData, int eventData1, int eventData2)
{
	unsigned long status_x, status_y1, status_y2;
	BOOL res;
	unsigned int mask = 1L;
	
	switch (event)
		{
		case EVENT_COMMIT:
		umac_get_cs_status(umac_ID, 1, &status_x, &status_y1, &status_y2);
		res = (status_y1 & (mask << CS_INPOSITION_Y1));
		SetCtrlVal(umac_panel,UMACPAN_INPOSITIONCS,res);
			
		res = (status_x & (mask << CS_RUNPROGRAM_X));
		SetCtrlVal(umac_panel,UMACPAN_RUNPROGRAM,res);

			break;
		}
	return 0;
}

//  ***************************************************************************** 
int CVICALLBACK OnZbreak (int panel, int control, int event,
		void *callbackData, int eventData1, int eventData2)
{
	BOOL res;
	int confirm = 0;
	
	switch (event)
		{
		case EVENT_COMMIT:
			GetCtrlVal(panel,UMACPAN_ZBREAK,&res);
			if(!res)
			{
				confirm = ConfirmPopup ("ATTENTION!", "Stage will move in either direction!\n Press this button again to stop it!\nYou need to restart program to use all other buttons!");
				if(confirm)
				{
					umac_set_z_break_manual( umac_ID, !res);
					SetCtrlAttribute(panel,UMACPAN_MOVE_ABS,ATTR_DIMMED,1);
					SetCtrlAttribute(panel,UMACPAN_MOVE_REL,ATTR_DIMMED,1);
					SetCtrlAttribute(panel,UMACPAN_CS_STATUS,ATTR_DIMMED,1);
					SetCtrlAttribute(panel,UMACPAN_MOTOR_STATUS,ATTR_DIMMED,1);
					SetCtrlAttribute(panel,UMACPAN_COM_MOVE_HOME,ATTR_DIMMED,1); 
					SetCtrlAttribute(panel,UMACPAN_AXIS,ATTR_DIMMED,1); 
					SetCtrlAttribute(panel,UMACPAN_COM_GET_MOT_POS,ATTR_DIMMED,1);
					
				}
				else
				{
					SetCtrlVal(panel,UMACPAN_ZBREAK,1);
					break;
				}
			}
			umac_set_z_break_manual( umac_ID, !res);
			
			break;
		}
	return 0;
}

//  *****************************************************************************
int CVICALLBACK OnCalib (int panel, int control, int event,
		void *callbackData, int eventData1, int eventData2)
{
	int i = 0;
	int n = 11; //number of moves
	double acc, vel, pos, position;
	int axis = 1;
	BOOL res;
	char buf[128];
	switch (event)
		{
		case EVENT_COMMIT:
			//GetCtrlVal(panel, UMACPAN_AXIS, &axis);
            GetCtrlVal(panel, UMACPAN_ACCELERATION, &acc);
            GetCtrlVal(panel, UMACPAN_VELOCITY, &vel);
            
            pos = 5.5;
            res = umac_abs_move(umac_ID, axis, acc, vel, pos);
             umacui_set_dimm_buttons(TRUE); 
            do
            {
            	cvi_delay(2.0);
            }
            while(umac_AxisIsMoving (umac_ID,axis));
            umacui_set_dimm_buttons(FALSE); 
            
            res = umac_get_mot_position(umac_ID, axis, &position); 
            SetCtrlVal(panel, UMACPAN_ACTUAL_POSITION, position);
            sprintf(buf,"\n%i \t %.8f",0,position);
            umac_add_log(buf , FALSE);
            
           
            
            for(i = 0; i < n; i++)
            {
            	 cvi_delay(10.0); 	
            	res = umac_rel_move(umac_ID, axis, acc, vel, -0.1);
            	umacui_set_dimm_buttons(TRUE);
            
            	do
            	{
            		cvi_delay(2.0);
            	}
            	while(umac_AxisIsMoving (umac_ID,axis));
            	umacui_set_dimm_buttons(FALSE); 
            
            	res = umac_get_mot_position(umac_ID, axis, &position); 
            	SetCtrlVal(panel, UMACPAN_ACTUAL_POSITION, position);
            	sprintf(buf,"\n%i \t %.8f",i+1,position);
            	umac_add_log(buf , FALSE);
            
            }
            
            /*for(i = 0; i < n; i++)
            {
            	 cvi_delay(10.0); 	
            	res = umac_rel_move(umac_ID, axis, acc, vel, -0.1);
            	umacui_set_dimm_buttons(TRUE);
            
            	do
            	{
            		cvi_delay(2.0);
            	}
            	while(umac_AxisIsMoving (umac_ID,axis));
            	umacui_set_dimm_buttons(FALSE); 
            
            	res = umac_get_mot_position(umac_ID, axis, &position); 
            	SetCtrlVal(panel, UMACPAN_ACTUAL_POSITION, position);
            	sprintf(buf,"\n%i \t %.8f",n+i+1,position);
            	umac_add_log(buf , FALSE);
            
            }
			*/
			break;
		}
	return 0;
}


//Recovering from an operator error 05/19/2014


int CVICALLBACK Home (int panel, int control, int event,
					  void *callbackData, int eventData1, int eventData2)
{   
int Zvar=-10;
int Yvar=-10;
int Xvar=-10;
int Avar=-10;
int Wvar=-10;
int Vvar=-10;
int Bvar=-10;
int Cvar=-10;

int maskvar[8]={1,2,4,16,32,64,128,256};
int axisval[8]={-13,-13,-13,-13,-13,-13,-13,-13};
int axisbox[8]={UMACPAN_Box_Z_AXIS,
				 UMACPAN_Box_Y_AXIS,
				 UMACPAN_Box_X_AXIS,
				 UMACPAN_Box_A_AXIS,
				 UMACPAN_Box_W_AXIS,
				 UMACPAN_Box_V_AXIS,
				 UMACPAN_Box_B_AXIS,
				 UMACPAN_Box_C_AXIS} ;

int maskval=-1;
int i=-12;
char umacRes[100];
char umacCom[100];

char buf[120];
	
	switch (event)
	{
		case EVENT_COMMIT:
			  //GetCtrlVal(umac_panel,UMACPAN_Box_Z_AXIS,&axisval[0]);
			  //GetCtrlVal(umac_panel,UMACPAN_Box_Y_AXIS,&axisval[1]);
			  //GetCtrlVal(umac_panel,UMACPAN_Box_X_AXIS,&axisval[2]);
			  //GetCtrlVal(umac_panel,UMACPAN_Box_A_AXIS,&axisval[3]);
			  //GetCtrlVal(umac_panel,UMACPAN_Box_W_AXIS,&axisval[4]);
			  //GetCtrlVal(umac_panel,UMACPAN_Box_V_AXIS,&axisval[5]);
			  //GetCtrlVal(umac_panel,UMACPAN_Box_B_AXIS,&axisval[6]);
			  //GetCtrlVal(umac_panel,UMACPAN_Box_C_AXIS,&axisval[7]);
			  maskval=0;
			  for(i=0;i<8;i++)
			  {
			   GetCtrlVal(umac_panel,axisbox[i],&axisval[i]);	  
			  maskval=maskval+axisval[i]*maskvar[i];
			  }
			  sprintf(buf,"p810=%i\n",maskval);
			  sprintf(umacCom,"p810=%i",maskval);
			  printf(buf);
			  
			  umac_command(umac_ID, umacRes, 0, umacCom);
			  umac_command(umac_ID, umacRes, 0, "enable plc 5");
			  umac_command(umac_ID, umacRes, 0, "enable plc 10");
			  printf("Homing process started\n");
			  umac_command(umac_ID, umacRes, 0, "b1200r");
			  printf("Homing process completed\n");
			
			

			break;
	}
return 0;
}


int CVICALLBACK Trig (int panel, int control, int event,
					  void *callbackData, int eventData1, int eventData2)
{
	
	int trigbox[5]={UMACPAN_RING_TRIG_AXIS,
				 UMACPAN_TRIG_INC,
		         UMACPAN_TRIG_POS1,
				 UMACPAN_TRIG_POS2,
				 UMACPAN_TRIG_VEL};
	
	double trigval[5]={-13,-13,-13,-13,-13}; 
	
	char buf[120]; 
	char umacCom[120];
	char umacRes[100];
	int i=-1;
	double maxPulse=-2;
	int velval;
				 
	switch (event)
	{
		case EVENT_COMMIT:
			
			for(i=0;i<5;i++)
			{
			   GetCtrlVal(umac_panel,trigbox[i],&trigval[i]);	  
			}
		
			  sprintf(umacCom,"q0=%f",trigval[0]); //set the trigger source      (Kugler manual p.60)
			  umac_command(umac_ID, umacRes, 0, umacCom);
			  
			  sprintf(umacCom,"q1=%f",trigval[1]); //set the trigger pitch in mm (Kugler manual p.60)
			  umac_command(umac_ID, umacRes, 0, umacCom);
			  
			  sprintf(umacCom,"p1=%f",trigval[2]); //set init position of the carriage (motion program 8)
			  umac_command(umac_ID, umacRes, 0, umacCom);  
			  
			  sprintf(umacCom,"p2=%f",trigval[3]);
			  umac_command(umac_ID, umacRes, 0, umacCom); //set final position of the carriage (motion program 8)
			  velval=floor(trigval[0]);
			  trigval[4]=trigval[4]*20;
			  sprintf(umacCom,"i%i22=%f",velval,trigval[4]);
			  umac_command(umac_ID, umacRes, 0, umacCom); //set the trigger process velocity (motion program 8)
			  
			  umac_command(umac_ID, umacRes, 0, "q10=1"); //set the flexible start pos var to 1 (enable)
			  
			  sprintf(umacCom,"q11=%f",trigval[2]);
			  umac_command(umac_ID, umacRes, 0, umacCom); // set the position of the 1st trigger
			  
			  maxPulse=fabs(floor((trigval[3]-trigval[2])/trigval[1]));
			
			  sprintf(umacCom,"q13=%f",maxPulse);
			  umac_command(umac_ID, umacRes, 0, umacCom); // set the max number of trigger pulses
			  
			  umac_command(umac_ID, umacRes, 0, "q14=0"); //select the trigger edge 0=rising edge  
			  
			  umac_command(umac_ID, umacRes, 0, "b8r");	   //launch triggering process
			  delay(10.0);
			
			break;
	}
	return 0;
}