#include "LibCC32.h"       
#include <ansi_c.h>
#include <userint.h>
#include <utility.h>

#include "daquir.h"
#include "stdlib.h"
#include "hbooklib.h"

 
#define DEFDEVICENAME "\\\\.\\C:\\windows\\Vpcic32D.vxd" 
#define MODULE_NUMBER    1    // number of connected CC32 module

CC32_HANDLE   CC32handle;  

#define CSSA(N,A,F)   cc32_read_long_all(CC32handle, N, A, F);
#define CSSAW(N,A,F,dum)  cc32_write_long(CC32handle, N, A, F,dum);


//#define CSSA(N,A,F)   cc32_read_word(CC32handle, N, A, F);
//#define CSSAW(N,A,F,dum)   cc32_write_word(CC32handle, N, A, F,dum);
#define CSET_I cc32_read_word(CC32handle, 27, 0, 0); 
#define CREM_I cc32_read_word(CC32handle, 27, 1, 0);


#define PAWC_SIZE 500000
#define TDCmax 0xFFF+1
#define MAXCH 64
#define MAXLIMIT 1000



static int panelHandle;
int plh,plg;
int neve;	  			/* number of all events */
int Ne[MAXCH][TDCmax]; 	/* Ne[j]= number of events in channel j */

#define DATASIZE 10000
static unsigned long data0[DATASIZE];  
static int evnbuff[DATASIZE] ;
static int ind[DATASIZE];


static int daqID;
volatile int flstop;
void  UIRDimming(int pnl,int flag);
int RunID;

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

int hbookinit(char *filename);
int hbookend(void);
int hopen=0;
#define NTMAX 1024
typedef struct { 
	int  evnt;
  float  time;
  int  nh ;
  unsigned int  hits[NTMAX]; 
}  NTDEF;

static NTDEF NT;



/* spreminjaj samo funkcijo Run    */


#define DEBUG
#define NTDC 20   
#define NADC 23
#define NSCA 22

#define NSCA0 2
#define NSCA1 3

void CAMAC_cccc(unsigned long *c_ext)
{
  unsigned short dum;
  dum = CSSA (0, 0, 0);
}

void CAMAC_cccd(unsigned long * c_ext,unsigned long *  c_sw)
{
  unsigned short dum;
  if (*c_sw) {
    dum = CSSA (30, 10, 26);
  } else {
    dum = CSSA (30, 10, 24);
  }
}

void CAMAC_ccci(unsigned long *c_ext, unsigned long *c_sw)
{
  unsigned short dum;
  if (*c_sw) {   
    dum = CSSA (27, 0, 0);
   } else {  
    dum = CSSA (27, 1, 0);
   }
}

void CAMAC_cccz(unsigned long *c_ext)
{
  unsigned short dum;

  dum  = CSSA (0, 1, 0);
 
  
}

void camac_init ()
{
  unsigned long ext_c;
  unsigned short dum;



  //BZ = dum;
  CAMAC_cccz (&ext_c);
  CAMAC_cccc (&ext_c);
  dum = CSSA (NADC, 12, 26);
}

void camac_clear ()
{
  unsigned short dum;



  dum = CSET_I;
  dum = CSSA (NSCA, NSCA0, 9);
  dum = CSSA (NSCA, NSCA1, 9);
  dum = CSSA (NADC, 12, 11);
  dum = CREM_I;
}

int dumpdata(char *fname, int* ach, int n){
 	 FILE *fp= fopen(fname, "w");
 	 int i,j,ch;
 	 
 	 fprintf(fp, "Praktikum IV (ADC/TDC)\n");
 	 fprintf(fp, "Cas meritve %s %s\n\n",DateStr(), TimeStr() );
 	 fprintf(fp, "Kanal hid=")	;
 	 for (j=0;j<n;j++)  fprintf(fp, "%d\t",ach[j]);
 	 fprintf(fp, "\n-------------------------------------------------\n");   				 
 	  
 	  
 	 for (i=0;i<TDCmax;i++){
 	   fprintf(fp, "%d\t",i);
 	   for (j=0;j<n;j++){ 
          fprintf(fp, "%d\t",Ne[ach [j]][i]);
 	   }
 	   fprintf(fp, "\n");   
 	 }
 	 fclose(fp);
 	 printf("Izbrani podatki so zapisani tudi  v datoteki %s\n",fname);
 	 return 0;
 }


void CAMAC_status(void)
{
  unsigned short id,fpga,modid,q,x,inhibit,lam;
  
  unsigned short dum;
  //printf("CAMAC_status %x\n",&(mptr+MAKE_CC32_OFFSET(0,0,0)));
  dum = cc32_read_word(CC32handle, 0, 0, 0);

  id   = (dum & 0xF000) >> 12;
  fpga = (dum & 0x0F00) >> 8;   
  modid =  (dum & 0x00F0) >> 4; 
  q      =  (dum & 0x0008) >> 3;
  x      =  (dum & 0x0004) >> 2;
  inhibit=  (dum & 0x0002) >> 1;
  lam    =  (dum & 0x0001);	
  printf ("CC32 CSR ID=%x FPGA=%x modID=%x Q=%d X=%d INHIBIT=%d LAM=%d \n",id,fpga,modid, q,x,inhibit,lam);
}


float stime;
void *CC32mem = NULL; 

int userinit(){
  unsigned long lbuf;		// holds the long (32 bits) reads
  unsigned short wbuf;	// holds the short (16 bit) reads

  int error;
  unsigned short dum;
  /* open a path to a device. */
    error = cc32_open(DEFDEVICENAME, MODULE_NUMBER, &CC32handle);
	if (error)
	{
		printf("Can't open interface %s!\n", DEFDEVICENAME);
		getchar();
		exit(error);
	}

	// write a reset to CC32
	cc32_write_word(CC32handle, 31, 0, 16, 0x55aa);

	// read the CC32 local status
	lbuf = cc32_read_long_all(CC32handle, 0, 0, 0);
	//printf("Read %d bytes (0x%08x) with X and Q.\n", 4, lbuf);

	// enable all LAM channels
	cc32_write_long(CC32handle, 28, 1, 16, 0xFFFFFFFF);

  CAMAC_status();
  stime= Timer(); 
  return 0;
}


int userend(int *ch, int nch){
  char filename[256];
  char fpath[256];
  char fname[256];  
  
  int result;
  
  GetCtrlVal(plh,PANEL_FNAME,fname);  
  GetCtrlVal(plh,PANEL_PATH,fpath);
  sprintf(filename,"%s\\%s.dat", fpath,fname);
  	  
  
  dumpdata(filename,ch, nch);
  /* close the opened path */
	result = cc32_close(CC32handle); 
	if (result)
	{
		printf("Can't close interface!\n");
		exit(result);
	}



  if (flstop) printf("STOP %d\n",Ne[0]);
  hbookend();
  flstop = 1;
  UIRDimming(plh,1); 
  return 0;
} 

int CVICALLBACK RunAD811 (void *functionData)
{
   
  int i=0,j,bevn=0;
  float stime;
   

  
  int nerr=0;
  int nloop;

  int fmax;
  int fcount=0;
  char fpath[256];
  char fname[256];  
  char filename[256];
  
  
  unsigned int error ;
  int status,ndata,ch;
  
  char q,x;
  unsigned long data; 
  unsigned long dum;		// holds the long (32 bits) reads
  unsigned short wbuf;	// holds the short (16 bit) reads
  int ntwrite;
  
  GetCtrlVal(plh,PANEL_NEVE,&neve);
  GetCtrlVal(plh,PANEL_FNAME,fname);  
  GetCtrlVal(plh,PANEL_PATH,fpath);
  GetCtrlVal(plh,PANEL_NTON,&ntwrite); 
  GetCtrlVal(plh,PANEL_MAXFSIZE,&fmax);  
       
  
  userinit();

  camac_init();
  camac_clear(); 
  //CAMAC_status();

   printf("Reading ADC AD811 from  CAMAC slot nr. %d...\n",NADC);
   dum = CSSA (NADC, 12, 26); 

	
  while (i<neve){
	
    if ( flstop != 0 ) break;
    nerr=0;
  
    dum = CSSA (NADC, 12, 11);  
	
	dum = CREM_I;
	
	
   
	 nloop=0;  

    do{ 
      q=0;
      dum =  cc32_read_long(CC32handle, NADC, 12, 8, &q, &x);
	 //dum =  cc32_read_long(CC32handle, NADC, 12, 8, &q, &x);// To bi moralo biti,ampak potem ne dela
      
    
      if (nloop== -999  ) {
        // CAMAC_status();
         printf("neve:%d.-> WAIT LAM  nloop=%d dum:%x q=%d x=%d\n",i, nloop, dum, q,x);    

      }   
      nloop++;
   
     
    } while ( q==0 && !flstop && nloop <MAXLIMIT);
    //
    dum = CSET_I;
	

	bevn++;
    ndata = 1 ;
    for ( j=0 ; j<ndata ; j++ ) data0[j] = CSSA (NADC, j, 2);
   
    
    if (i % fmax == 0) {
				hbookend();
				sprintf(filename,"%s\\%s_file%d.hbook", fpath,fname,fcount);
				//printf("filename=%s\n",filename);
				fcount++;
				hbookinit(filename); 
	} 
      
    i++;  	
 	
	for (j=0;j<ndata;j++){
  		NT.nh=0;
	  	NT.evnt=nloop;
	  	NT.time=Timer()-stime;  
				
	  			
	    Ne[j][data0[j]]++; 
	    Hf1(j+1,data0[j],1);
	  			
	  	NT.hits[NT.nh]=data0[j];
	    NT.nh++;
	  		
	}
    
	SetCtrlVal(plh, PANEL_TIME, NT.time);     
	SetCtrlVal(plh, PANEL_CEVE, i);
				
	 
    SetCtrlVal(plh,PANEL_ERR,bevn);
    if (ntwrite)	Hfnt(1000);  
  }
   
  ch=0; 
  userend(&ch,1);    
  return 0;
}


 

int usereventLC2277(int i,int bevn, int ndata,int fmax, char *fpath, char* fname, int *fcount, int ntwrite){
 char filename[256];     
 int  j;
 unsigned long data,ch,edge;
 unsigned long tdcfirst[16],tdchit[16],dx,sx;
    
    SetCtrlVal(plh, PANEL_TIME, NT.time);     
	SetCtrlVal(plh, PANEL_CEVE, i+1);
	
    if (i % fmax == 0) {
				hbookend();
				sprintf(filename,"%s\\%s_file%d.hbook", fpath,fname,*fcount);
				//printf("filename=%s\n",filename);
				(*fcount)++;
				hbookinit(filename); 
	} 
      
    NT.nh=0;
	NT.evnt=i;
	NT.time=Timer()-stime;  	
	// pocistimo arraye
    for (j=0;j<16;j++){ 
       tdcfirst[j]=0;
       tdchit[j]=0;
    }	
    // dekodiramo podatke
	for (j=0;j<ndata;j++){
  		
				
	
	  	data =  data0[j]&0xFFFF;		
	  	ch   = (data0[j] >> 17 ) &0x1F;
	  	edge = (data0[j] >> 16 ) &0x1;
	  	
	  	if (edge) {
	      if ((data/10) < TDCmax) Ne[ch][data/10]++; 
	      Hf1(ch+1,data,1);
	      
	      if (ch<16){
            tdcfirst[ch]=data;
            tdchit[ch]=1;
          }
	      
	  	}
	  	NT.hits[NT.nh]=data0[j];
	    NT.nh++;
	  		
	}
	
    
	SetCtrlVal(plh,PANEL_ERR,bevn+1);
	// napolnimo histogram
    if (ntwrite) Hfnt(1000);  
    
	return 0;
}



int tdcreg2277=0x8C00;
//  tdcreg2277= 0xC00;  // status register common stop (red LED),leading,trailing edge recording
//  tdcreg2277= 0xCC00; //  status register common start (green LED),8192 ns timeout ,leading+trailing
//--------------------------------------------
int CVICALLBACK RunLC2277  (void *functionData)
{

  int ach[8]={2};
  int nch=8;
  int ntwrite;
  char q,x;   
  long int nloop;
   // TDC LC 2277      
   
  int i=0,j,k,bevn=0;
  int fmax;
  char fpath[256];
  char fname[256];  
  int fcount=0; 
  int ndata,neve; 
  unsigned long dum;
  unsigned long data,ch; 
  int print=0;

  printf("Reading TDC LC 2277 from  CAMAC slot nr. %d\n",NTDC);     
  GetCtrlVal(plh,PANEL_FNAME,fname);  
  GetCtrlVal(plh,PANEL_PATH,fpath);
  GetCtrlVal(plh,PANEL_MAXFSIZE,&fmax);  
  GetCtrlVal(plh,PANEL_NEVE,&neve);       
  GetCtrlVal(plh,PANEL_NTON,&ntwrite);       
 
  userinit();
  camac_init();
  camac_clear(); 
  
  CSSAW( NTDC, 0, 17, tdcreg2277);
  CSSAW( NTDC, 0, 26, dum);       // enable LAM
  
 
  dum =  cc32_read_long(CC32handle, NTDC, 0, 1, &x, &q); 
  printf("TDC mode set to  %x\n",dum&0xFFFF );

  while (i<neve){
	
    if ( flstop != 0 ) break;
 

	//if (nloop>2 )  printf("-> WAIT nloop:%d\n" ,nloop);

    ndata = 2;
    
    nloop=0;  
    do{ 
      if ((nloop%1000000)==0) {
        if (nloop>0) printf("LAM timeout: neve=%i, nloop=%i\n",i,nloop);
    	dum = CSET_I;
//        dum=CSSA( NTDC,0 , 10);  // clear LAM     
        dum=CSSA( NTDC,0,   9);  // clear TDC 
        dum = CREM_I;      
      }
      q=0;
      dum =  cc32_read_long(CC32handle, NTDC, 0, 8, &q, &x);
      nloop++;
   
     //printf("q=0x%08x\n",q) ;
    } while ( q==0 && x==1 && !flstop );
//	dum=CSSA( NTDC,0 , 10);  // clear LAM  
	nloop=0;    
    do {
     data0[nloop] =  cc32_read_long(CC32handle, NTDC, 0, 0, &q, &x); 
     
     ch = (data0[nloop] >> 17 ) &0x1F;
     
     
     // if (print) printf("%d\tdata=%d Edge=%d ch=%d X=%d Q=%d\n", i,
     //   data0[nloop]&0xFFFF,(data0[nloop] >> 16 ) &0x1,(data0[nloop] >> 17 ) &0x1F ,x,q);  
     
     
	 if (q==1 && ch!=31){ 
     
       if (print) printf("%d\tdata=%d Edge=%d ch=%d X=%d Q=%d\n", i,
         data0[nloop]&0xFFFF,(data0[nloop] >> 16 ) &0x1,(data0[nloop] >> 17 ) &0x1F ,x,q);  
     
	    nloop++;
	 }
	 // pazi tole ne dela vedno , zakaj 32?     16*32 naceloma
    } while (q==1 && !flstop && nloop< 16*32);
 
    if (nloop) bevn++;
    //if (nloop>2){
	   usereventLC2277(i, bevn, nloop, fmax, fpath, fname, &fcount, ntwrite);
       i++;
    //}
  }
  
  userend(ach,nch);
  return 0;
}




/*********************************************************************/
 
int main (int argc, char *argv[])
{
  
  if (InitCVIRTE (0, argv, 0) == 0)  return -1;	/* out of memory */
  if ((plh = LoadPanel (0, "daquir.uir", PANEL)) < 0) return -1;
 SetStdioPort (CVI_STDIO_WINDOW);	
  UIRDimming(plh,1);
  SetCtrlVal (plh, PANEL_UPRAG, TDCmax);
  DisplayPanel(plh);
  RunUserInterface ();
	
		
  return 0;
}

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

int hbookinit(char *filename)
{
  int record_size=1024;
  int istat;
  int ldim=0,i;
  char *ldir="EXP"; 
  char htitle[128];

  
  Hlimit(PAWC_SIZE);

  Hropen(1,ldir,filename,"NX",&record_size,&istat);
  if (istat) {
    printf("Error in opening file %s...",filename);
    return -1;
  } else {
  
     printf("Podatki so v Hbook datoteki %s\n",filename); 
  }

  sprintf(htitle,"iev,time,nh[0,%d],ihits(nh):U",NTMAX );
  Hbnt(1000,"DATA"," "); 
  Hbname(1000,"DATA",(int *) &(NT.evnt), htitle);

  for (i=0;i<MAXCH;i++){
    sprintf(htitle,"ch. %d",i+1);
    Hbook1(i+1,htitle,2048,-0.5,20479.5,0.);    //!!!!!!!!!!!!!!!
  }
  hopen=1;
  return 0;
}

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

int hbookend() 
{ 
  int icycle=0;
  
  if (hopen){
    Hrout(0,&icycle," "); 
    Hrend("EXP");
    hopen=0;
  }  
  return 0;
}
/************************************************************/

int Graph_Refresh()
{  
  int ch;
  int nch;
  int nval;
  int lprag,uprag;
  int i, j,ndata,data[TDCmax];
  
  GetCtrlVal (plh, PANEL_CHANNEL, &ch);
  GetCtrlVal (plh, PANEL_PRAG, &lprag); 
  GetCtrlVal (plh, PANEL_UPRAG, &uprag);
  GetCtrlVal (plh, PANEL_WIDTH, &nch);
  if (uprag>TDCmax) {
    uprag= TDCmax;
    SetCtrlVal (plh, PANEL_UPRAG, uprag); 
  }

  ndata=0;
  for (i=lprag;i<(uprag-nch);i+=nch){
    data[ndata]=0;
    for (j=0;j<nch;j++) data[ndata]+= Ne[ch][i+j];
    ndata++;
  }
  
  //printf("%d\n",i+1);
  DeleteGraphPlot (plh, PANEL_GRAPH, -1, VAL_IMMEDIATE_DRAW);			
  PlotY (plh, PANEL_GRAPH, data, ndata, VAL_INTEGER, VAL_VERTICAL_BAR,  
	 VAL_NO_POINT, VAL_SOLID, 1, VAL_DK_BLUE);
  return 0;
}


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

void UIRDimming(int pnl,int flag)
{
  SetInputMode (pnl, PANEL_START,flag);
  SetInputMode (pnl, PANEL_STOP, !flag);
  SetInputMode (pnl, PANEL_EXIT, flag); 
}


/************************** Od tu naprej User Interface klici *************/    

int CVICALLBACK  Start (int panel, int control, int event,		
			void *callbackData, int eventData1, int eventData2)
{
    int kaj;

	switch (event){
  	case EVENT_COMMIT:
      flstop = 0;
      UIRDimming(panel,0);
      GetCtrlVal (plh, PANEL_KAJ, &kaj); 
  	  switch (kaj) {
  	    case 1:
		CmtScheduleThreadPoolFunctionAdv (DEFAULT_THREAD_POOL_HANDLE, RunLC2277,
										  (void *)(&panel),
										  THREAD_PRIORITY_NORMAL, NULL,
										  EVENT_TP_THREAD_FUNCTION_BEGIN,
										  NULL, RUN_IN_SCHEDULED_THREAD,
										  &RunID);
					break;
	    case 0:
	    /*
	    CmtScheduleThreadPoolFunctionAdv (
					DEFAULT_THREAD_POOL_HANDLE, RunQAdc, (void *)(&panel),
					THREAD_PRIORITY_NORMAL, NULL, NULL, NULL, NULL,&RunID);
					*/
		CmtScheduleThreadPoolFunctionAdv (DEFAULT_THREAD_POOL_HANDLE, RunAD811,
										  (void *)(&panel),
										  THREAD_PRIORITY_NORMAL, NULL,
										  EVENT_TP_THREAD_FUNCTION_BEGIN,
										  NULL, RUN_IN_SCHEDULED_THREAD,
										  &RunID);			
	     break;
	  }  
      break;    
  }
  return 0;
}

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

int CVICALLBACK  Stop (int panel, int control, int event,		
		       void *callbackData, int eventData1, int eventData2)
{
  switch (event){
    int status;
    int handle= DEFAULT_THREAD_POOL_HANDLE;
    
  case EVENT_COMMIT:
    if (!flstop){
      flstop = 1;
      UIRDimming(panel,1);  
      /*
        CmtGetThreadPoolFunctionAttribute (handle, daqID,
					ATTR_TP_FUNCTION_EXECUTION_STATUS,&status);
        if (status != kCmtThreadFunctionComplete)
				CmtWaitForThreadPoolFunctionCompletion (handle, daqID, 1);
				CmtReleaseThreadPoolFunctionID (handle,daqID);
      */  
            
    }
    break;    
  }
  return 0;

}

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


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

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

int CVICALLBACK Refresh (int panel, int control, int event,
			 void *callbackData, int eventData1, int eventData2)
{
  switch (event){
    case EVENT_TIMER_TICK:
    case EVENT_COMMIT:
      Graph_Refresh();
      break;
  }
  return 0;
}

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

int CVICALLBACK Reset (int panel, int control, int event,
		       void *callbackData, int eventData1, int eventData2)
{
  int i,j;
  switch (event){
    case EVENT_COMMIT:
      //memset(Ne,0,TDCmax*sizeof(int));
      for (i=0;i<MAXCH;i++) for (j=0;j<TDCmax;j++) Ne[i][j]=0;
      Graph_Refresh();  
      break;
  }
  return 0;
}

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

int CVICALLBACK Print (int panel, int control, int event,
		       void *callbackData, int eventData1, int eventData2)
{
  switch (event){
    case EVENT_COMMIT:
      PrintCtrl (plh,PANEL_GRAPH , "", 0, 0);
      break;
  }
  return 0;
}



int CVICALLBACK CloseScan (int panel, int control, int event,
		void *callbackData, int eventData1, int eventData2)
{
	switch (event)
		{
		case EVENT_COMMIT:
			HidePanel(plg); 
			break;
		}
	return 0;
}