#include <time.h>
#include <stdio.h>
#include <stddef.h>
#include <errno.h>
#include <signal.h>
#include "/usr/include/bsd/sys/time.h"
#include "rd13liberrs.h"
#include "MultiIntFlags.h"
#include "VME_trig.h"
#include "hbook_defs.h"

#define CSR_CONF 0xE0
#define CSR_CONF1 0x8C

#define INBURST 0
#define OUTBURST 1

#define DSP_STATE 4
#define EXECUTING 2
#define SIGNAL_EVENT 1
#define SIGNAL_SOB 2
#define SIGNAL_EOB 3
#define SIGNAL_SOFT 4
#define DEBUG 1
#define SIGNAL_DEBUG 1
int nint(float);
static int state = OUTBURST;

int i, corboflag[4];
int counter[4];
int value, mask;
int k, sts;
int nbursts;
int badsob = 0;
int badeob = 0;
int offburst = 0;
int evinburst = 0;
int no_trig = 0;
int  vr_value;	
int loops;
int step;
int ext_trg;
int num_points; 
float rinterval;
float start_val;
int good_events;
int par_CORBO;
int eff_array[768][128];
int dsp_num;
int run_no;
int num_words;
int link_num;
float atup[3];
float stepVal[128];
float  end_val;
int verb_flag;
int printev_flag; 


main()
{
  int init_gpib;
  int yesno_str, yesno;
  int theItem;
  float displ, start_pos, final_pos, act_pos;
  int idac_set;
  float dac_set;
 
printf("\nExternal trigger "); 
/*  printf("\nExternal trigger  [0=no (default),1=yes]");
  if( scanf("%d",&ext_trg) == 0 ) ext_trg = 0; */
 
 ext_trg=1;
  
  if( ext_trg ) 
    {
      for( i=0; i<4; i++) counter[i] = 0;
      initCORBO();
    }

  do_initialization();

  init_gpib = 1;
  yesno_str = 1;
  while(yesno_str)
    {
      
      printf ("\n OPTIONS MENU \n");
      printf ("  ------------ ");
      printf ("\n  Auto Threshold Scan  [1]");
      printf ("\n  Auto  Position Scan  [2]");
      printf ("\n  Position Movement    [3]");
      printf ("\n ");
      printf ("\n  Setting LL DAC [5]");
      printf ("\n  Reading DACs   [6]");
      printf ("\n ");
      printf ("\n  Exit Program   [0]\n");
      printf ("\n ");
      printf ("\n  Type your choice :");
      scanf("%d",&theItem); 

      switch (theItem)
        {
        case 1:
	  if( do_init_thresh_scan() == 1 ) break;
	  yesno = 1;
	  while(yesno  != 0)
	    { 
	      printf("\n Enter RUN number -> ");
	      scanf("%d",&run_no);
	      hist_init(); 
              for (i=0; i<128; i++) 
               {
                for (k= 0;k<768; k++)
	         {
	            eff_array[k][i] = 0;  /* Zero out the hits array */
	         }
               }
	      do_thresh_scan();
	      /* do_fit_attlbl(loops,num_points,2,link_num,run_no) ; */
	      
	      hist_out();
              /* TM_test(3); */
	      printf(" Continue with more Threshold Scan ? yes [1] or no [0]");
	      scanf("%d",&yesno);
	      if(yesno == 0)  break;
	    }
	  break; 
	case 2:
	  if( init_gpib ) 
	    {
	      init_pmc();
	      init_gpib = 0;
	    }
	  if( do_init_thresh_scan() == 1 ) break;
/*	  do_binary_SOB(dsp_num); */
	  do_pos_scan();
	  break;
        case 3:
	  if( init_gpib ) 
	    {
	      init_pmc();
	      init_gpib = 0;
	    }
          start_pos=getpos_pmc();
          printf("\n Current position (mm.) -> %f",start_pos);
          printf("\n Enter displacement (micron) -> ");
          scanf("%f",&displ);
          final_pos = displ * 0.001;
          mvtopos_pmc(start_pos+final_pos);
          act_pos=getpos_pmc();
          printf("\n Final position (mm.) -> %f\n",act_pos);
	  break;
	case 0:
	  yesno_str = 0;
	  break;
	case 5:

          printf("Threshold value :\n");
          scanf("%f",&dac_set);
          do_set_ll_dac(dsp_num,2,&dac_set);
	  break;
	case 6:
          do_get_status(dsp_num);
	  break;
	default:
	  break;
        }
    }
  
  if( ext_trg == 1 )
    {
      /*  do_binary_exit(); <----- Careful !!! */
      exitCORBO();
    }
}

initCORBO()
	{

if (TM_init!=0) 
	{
	printf("\t\tan error mapping the card CORBO\n");
	exit(1);
	}

          value = RD13_flags_initialise();
          if ( value != RD13_FLAGS_SUCCESS )
          { printf( " error from flags init is %x \n",value);
            exit();  }

          value = RD13_flags_add(10,0,1,&corboflag[0], SIGNAL_EVENT);
             if ( value != RD13_FLAGS_SUCCESS )
             {  printf(" error %x from add flag 0 \n",value);
                exit();  }

          value = RD13_flags_add(20,0,2,&corboflag[1], SIGNAL_SOB);
             if ( value != RD13_FLAGS_SUCCESS )
             {  printf(" error  %x from add flag 1 \n",value);
                exit();  }
          
	  value = RD13_flags_add(30,0,2,&corboflag[2], SIGNAL_EOB);
             if ( value != RD13_FLAGS_SUCCESS )
             {  printf(" error  %x from add flag 2 \n",value);
                exit();  }

          TM_csrW(1,0x00);
          TM_csrW(2,0x00);
          TM_csrW(3,0x00);
          TM_csrW(4,0x00);

          TM_clear(1);
          TM_clear(2);
          TM_clear(3);
          TM_clear(4);

          TM_vrW(1,10);
	TM_vrR(1,vr_value);
	printf("VR 1 = %d\n",vr_value);
	TM_vr1R(1,vr_value);
	printf("VR (bim2) 1 = %d\n",vr_value);
          TM_vrW(2,20);
	TM_vrR(2,vr_value);
	printf("VR 1 = %d\n",vr_value);
	TM_vr1R(2,vr_value);
	printf("VR (bim2) 2 = %d\n",vr_value);
          TM_vrW(4,30);
	TM_vrR(4,vr_value);
	printf("VR 1 = %d\n",vr_value);
	TM_vr1R(4,vr_value);
	printf("VR (bim2) 4 = %d\n",vr_value);
          TM_cptW(1,0x00);
          TM_cptW(2,0x00);
          TM_cptW(4,0x00);


          TM_crW(1,0x1a);
          TM_crW(2,0x1b);        
          TM_crW(4,0x1c);

          TM_csrW(1,CSR_CONF);
          TM_csrW(2,CSR_CONF);
          TM_csrW(4,CSR_CONF);
          TM_csrW(3,CSR_CONF1);

          TM_crW(3,0x0);
          TM_clear(3);
          /* TM_test(3); */

	for(i=0; i<3; i++)
		printf("Flag %d assigned to vector %d\n",
			corboflag[i], (10*(i+1)));
	}


int waitCORBO()
	{
	int signal;

/* printf("  waiting for interrupts \n"); */
	RD13_wait_signal(&signal);

	switch(signal)
		{
case SIGNAL_SOB:
                printf("                             SIGNAL_SOB \n");
		do_sob(signal - 1, 0);
                return signal;
		break;
case SIGNAL_EOB:
                printf("                             SIGNAL_EOB \n");
		do_eob(signal - 1, 0); 	
                return signal;
		break;
case SIGNAL_EVENT:
/*		printf("SIGNAL_EVENT    \n");
		do_event(signal - 1, 0); */
		return signal;
		break;
case SIGNAL_SOFT:
                printf("                             SIGNAL_SOFT \n");
		do_soft(signal - 1, 0);
                return signal;
		break;
default:
	printf("Invalid SIGNAL received... %d\n", signal);
	break;
		}




	}

exitCORBO()
	{

          TM_clear(1);
          TM_clear(2);
          TM_clear(3);
          TM_clear(4);

          TM_csrW(1,0x00);
          TM_csrW(2,0x00);
          TM_csrW(4,0x00);
          value = RD13_flags_remove(corboflag[0]);
          if(value!=0)
          printf(" error from flags remove is %x \n",value);

          value = RD13_flags_remove(corboflag[1]);
          if(value!=0)
          printf(" error from flags remove is %x \n",value);

          value = RD13_flags_remove(corboflag[2]);
          if(value!=0)
          printf(" error from flags remove is %x \n",value);


	printf("Total Triggers %d SOB %d  EOB %d\n",
		counter[0], counter[1], counter[3]);
	printf("Triggers off burst %d Bad SOB %d Bad EOB %d\n",
		offburst, badsob, badeob);

TM_release;
printf("done...\n");
exit(0);
}
int do_event(i, sts)
	int i;
	int sts;
	{
	if(state == INBURST)
		{
		counter[i]++;
		evinburst++;
                do_binary_readout(dsp_num);
		}
		else offburst++;

       		TM_clear(1);
       		TM_crW(1,0x1a); 
	}

int do_sob(i, sts)
	int i;
	int sts;
	{
	if(state == INBURST)
		{
		badsob++;
		}
	else
		{
		evinburst = 0;
		counter[i]++;
		printf("Start Of BURST %d\n", counter[i]);
			state = INBURST;
                 if ( par_CORBO==1 )
                  do_binary_SOB(dsp_num);
		}
        /* TM_clear(3);  */ 
       	TM_clear(2);
       	TM_crW(2,0x1b); 
	}




int do_eob(i, sts)
	int i;
	int sts;
	{
	if(state == OUTBURST)
		badeob++;
	else
		{
		counter[i]++;
		printf("End Of BURST %d. %d Triggers\n", 
			counter[i], evinburst);
                if (evinburst == 0) no_trig++;
		state = OUTBURST;
                if ( par_CORBO==1 ) 
                  do_binary_EOB(dsp_num);
		}
       	TM_clear(4);
     	TM_crW(4,0x1c);

/*	RD13_soft_signal(SIGNAL_SOFT); */ 
	}

int do_soft(i, sts)
	int i;
	int sts;
	{
	counter[i]++;
	}

int do_init_thresh_scan()

{
  int vf; 
  int i, k, ok;
  int n1, n2;
  int ndac;
  float sys_dac[4], dac_set, I_ref, V_cal;

  printf("\n link number ->");
  /* scanf("%d",&link_num); */
    link_num=0;
    if(link_num >3 ){
                      printf("\n !!INVALID link number !!! Enter new value ->");
                      scanf("%d",&link_num);
                    }
  printf("\n print event flag off/on [0/1]:");
  scanf("%d",&vf);
  printev_flag = vf;
  printf("\n number of events (multiple of 100) ->");
  scanf("%d",&loops);
  
  printf("\n VATT - float ->");
  scanf("%f",&dac_set);
  do_set_dac(dsp_num,0,&dac_set)      ;
  sys_dac[0]=dac_set;
  printf("\n VREF - float ->");
  scanf("%f",&I_ref);
  do_set_dac(dsp_num,1,&I_ref)        ;
  sys_dac[1]=I_ref;
  printf("\n VCAL = 0.");
  V_cal = 0.;
  do_set_dac(dsp_num,3,&V_cal);
  sys_dac[3]=V_cal;
  
/* Generate interval according to DAC units (1.638 mV) */

  printf("\n MIN thr. value (mV) ->");
  scanf("%f",&start_val);
  n1 = nint(start_val*1.638); 
  start_val = n1/1.638;
  printf("\n MAX thr. value (mV) ->");
  scanf("%f",&end_val);
  n2 = nint(end_val*1.638); 
  end_val = n2/1.638;
/*
  rinterval = (end_val - start_val) / (float)(num_points-1)  ;
*/
  printf("Number of DAC counts per interval :");
  scanf("%d",&ndac);
  rinterval = ndac/1.638;
  num_points = abs((abs(n2-n1)+1)/ndac);
  
  printf("\n             Settings \n");
  printf(" -----------------------------");
  printf("\n      link number -> %d",link_num);
  printf("\n threshold points -> %d",num_points);
  printf("\n number of events -> %d",loops);
  printf("\n             VATT -> %f",sys_dac[0]);
  printf("\n             VREF -> %f",sys_dac[1]);
  printf("\n     Thresh range -> %f - %f",start_val,end_val);
  
  printf("\nAre the above values OK ? [1]yes=>continue  [0]no=>go back to menu  -> ");
  scanf("%d",&ok);
  
  if(ok == 0) return(1);
  
  load_control_block (dsp_num,0,0,"Control_cal.com") ;
/*
  load_control_block (dsp_num,1,0,"Cal_all.com") ;
  load_control_block (dsp_num,2,0,"Cal_all.com") ;
*/
  do_execute_control_block (dsp_num,0,2) ;
	  
  for (i=0; i<128; i++) 
    {
      for (k= 0;k<768; k++)
	{
	  eff_array[k][i] = 0;  /* Zero out the hits array */
	}
    }
  return(0);
}

do_thresh_scan()

{
  int i, j, id=150;
  float set_val;
  int sob_tmp;
  int status;
  int sl;
  int nevt;
  int mult;

  set_val = start_val;

  for(i = 0 ; i < num_points; i++)  /* loop  on  threshold points */
    {
      step=i;
      printf(" POINT %d \n",i+1);
      counter[0]=0;
      good_events=0;
      stepVal[i] = set_val ;
 
      if( ext_trg == 1 ) 
	{
             par_CORBO = 1;
             while( (sl=waitCORBO()) != SIGNAL_EOB )
                {
                 /* printf(" Signal while waiting for EOB %d\n",sl); */
                  if(sl == SIGNAL_EVENT)
                   {
                     TM_clear(1); 
                     TM_crW(1,0x1a); 
                   } 
                }

              printf("Value of set_val : %f\n",set_val);
              do_set_ll_dac(dsp_num,2,&set_val)  ;

/* The order of the next two lines is very important ! */
          while( (sl=waitCORBO()) != SIGNAL_SOB ); 
          TM_test(3);

          par_CORBO = 0;

          nevt=0;
          mult=100;
	  while(good_events<loops)
	    {
	      if (no_trig > 100) 
		{
		  exitCORBO(); 
		}
	      sl=waitCORBO(); 
              /* printf("While waiting for events %d\n",sl); */

              if(sl == SIGNAL_EVENT) 
              {
                nevt=nevt+1;
                if ( loops-good_events < mult ) mult=loops-good_events; 
                if( nevt%mult == 0 )
                 {
                   do_event(sl - 1, 0);
                   nevt=0;
                 }
                else  
                 {
                     TM_clear(1); 
                     TM_crW(1,0x1a); 
                 }
                /* printf(" event %d \n",good_events); */
               }
	    }
	}
      else
	{
	  do_binary_SOB(dsp_num);
	  for(j = 0 ; j < loops/50 ; j++)
	    {
              do_calibrate (dsp_num,50,1,1);
	      do_binary_readout(dsp_num);
	    }
          do_binary_EOB(dsp_num);
	}

	  set_val = set_val + rinterval;  
	  
      TM_clear(3);
      printf("Good events registered : %d\n",good_events);
    }
  
    for(i = 0 ; i < num_points; i++)  /* loop  on  threshold points */
      for ( j = 0; j < 768; j++ )    /* loop over channels  */
	{
	  atup[0] = stepVal[i] ;
	  atup[1] = (float) j;
	  atup[2] = (float) eff_array[j][i];
	 /* 
          printf("Step, eff. : %f,%f\n",stepVal[i],eff_array[j][i]);
         */
          hfn (id, atup[0]);
	}

    printf("histograms filled !\n");

    par_CORBO = 1;
    while( (sl=waitCORBO()) != SIGNAL_EOB )
                {
                  if(sl == SIGNAL_EVENT)
                   {
                     TM_clear(1);
                     TM_crW(1,0x1a); 
                   }
                }
 
  TM_clear(3);
}
  
do_pos_scan()

{
  int nstep;
  int i, j;
  float step_size, start_pos, act_pos;

  start_pos=getpos_pmc();
  printf("\n Current position (mm.) -> %f",start_pos);
  
  printf("\n Step size [in micrometer] ? ");
  scanf("%f",&step_size);
  step_size = step_size * 0.001 ;
  
  printf ("\n Number of steps ? ");
  scanf ("%d", &nstep);
  
  printf("\n Enter first RUN number -> ");
  scanf("%d",&run_no);

  for ( i = 0 ; i < nstep; i++ ) 
    {
      run_no = run_no + nstep;
      hist_init;
      do_thresh_scan();
      hist_out;
      act_pos=getpos_pmc();
      act_pos = act_pos*1000.;
      printf(" step %d current position %f \n",i,act_pos);
      
      if ( i < (nstep-1) )
	jog_pmc(step_size);
    }
  mvtopos_pmc(start_pos-step_size/fabs(step_size)*0.05);
  mvtopos_pmc(start_pos);
  act_pos=getpos_pmc();
  printf("\n Final position (mm.) -> %f",act_pos);
  
}

do_initialization ()

{
  static int nlinks =1;
  int countv=37;
  register int status;

  char* filnam = "/usr/people/sctdaq/BINARY/sys_main.asc";

  int dsp;
  int dsp_min = 0, dsp_max = 0;
  static int flag_val = 0 ;
  static int run_mode = 0;
  static int burst=0;
  int ans,vf;
  char fname [80];
  static int  ll_dac[4] ={0,0,0,0};
  int cal_lines = 2;
  int link_dis,dis_enable;

  int chips = 2;
  static int countv_arr[7] = {0,20,37,53,68,88,104};
  static int num_words_arr[7] = {0,6,10,14,18,23,27};

  int num_rep = 999;

  /* initialize DSP's according to binary_in.h dsp_min-dsp_max */
  dsp_init(dsp_min,dsp_max);
  printf("\n dsp number is 0 ");
  /* scanf("%d",&dsp_num); */
  dsp_num=0;
    if(dsp_num >3 ){
                      printf("\n !!INVALID dsp number !!! Enter new value ->");
                      scanf("%d",&dsp_num);
                    }
  dsp=dsp_num;
  printf("\n link number is 0 ");
  /* scanf("%d",&link_num); */
  link_num=0;
   if(link_num >3 ){
                      printf("\n !!INVALID link number !!! Enter new value ->");
                      scanf("%d",&link_num);
                    }

  init_dsps(dsp_min,dsp_max,filnam);
  
  status= do_initialize(dsp_num);
  if(status != 0)
    printf("\n couldn't initialize DSP %d \n",dsp_num);
  
/*  printf("\n VERBOSE MODE off/on [0/1]:");
   scanf("%d",&vf); */
  vf=1;
  verb_flag = vf;
  set_flag(dsp_num,6,vf) ;
/* VERBOSE should be on for the m_wait and get_general_reply to be activated */
  
  printf("\n number of chips is 2  ");
  /* scanf("%d", &chips ); */
  chips=2;
      if(chips >3 ){
                  printf("\n !!INVALID number of chips !!! Enter new value ->");
                  scanf("%d",&chips);
                   }

  countv = countv_arr[chips];
  num_words = num_words_arr[chips];
  
  do_set_counter_val (dsp_num,countv);
  
  run_mode = 0;  /* DSP-EOB  mode */
  do_select_run_mode(dsp_num,run_mode) ;
  
  do_enable_readout(dsp_num);
  do_dis_enable_link(dsp_num,link_num,1);
  
  
  load_control_block (dsp_num,0,0,"TrigControl.dat") ;
  do_execute_control_block (dsp_num,0,100) ;
  printf("\n executing TrigControl.dat \n");
  while(get_flag(dsp_num,DSP_STATE) == EXECUTING)
    loop_delay(20000);
  
}