WebSVN – f9daq – Diff – /sipmScan/src/sipmThreshold.c


#define USE_DAQ
#define USE_MIKRO
 
// Izberi ustrezni interface v meniju projektnega okna
//  Options->CompilerDefines (dodaj /DSISVME ali /DWIENVME)
#ifdef USE_DAQ
#  define USE_CAMAC
#include "c:\HOME\dino\sipmScan\include\camac.h"
#  ifdef SISVME
#    include "sisvme_dll.h"
#  endif
#  ifdef WIENVME
#    include "wienvme_dll.h"
#  endif
# include "CAENV673A.h" 
# include "CAENV462.h" 
#endif
 
#ifdef USE_MIKRO
#  include "MIKRO.h"
#endif
 
#include <userint.h>
#include <ansi_c.h>
#include <utility.h>
#include <analysis.h>
 
#include "c:\HOME\dino\sipmScan\include\sipmThreshold_ui.h"
 
#ifdef USE_DAQ
#  define USE_CAMAC
#  include "camac.h"
#  define NDAC 1
 
#  define CAEN_V673A   0x22220000 // IJS
//#define CAEN_V673A   0x10110000 // FMF
#  define CAEN_V462    0x100300
#endif
 
#ifdef USE_MIKRO
#  define MIKRO_COM 5
#  define MIKRO_X 1
#  define USE_MIKRO_Y
#  define MIKRO_Y 2
#  define USE_MIKRO_Z
#  define MIKRO_Z 3
#  define STEP_TOLERANCE 50
#endif
 
#define MAXCH 512
#define MAX_THREADS 10
 
#define IWAIT 200
 
#define NCH 64
 
static int p1h, pID, rID, tfID;
static int ph_tdc, ph_adc;
static int dtdc[NCH][2][MAXCH];
static int something[NCH][2][MAXCH];
 
static int daq_on;
static int poolHandle = 0;
static int ntics,dummy;
 
/************************************************************/
void wait_loop(unsigned long iloop)
 
{
  int i;
 
  for (i=0;i<iloop;i++);
  return;
}
 
int CVICALLBACK cb_timer (int panel, int control, int event, void *callbackData,
                           int eventData1, int eventData2)
{
  QueueUserEvent (9000, p1h, P1_TIMER);
  return (0);
}
 
int update_plots (void)
{
  int irange, ch;
 
  GetCtrlVal (p1h, P1_PLCH, &ch);
 
  if (ph_tdc>0) DeleteGraphPlot (p1h, P1_TDC, ph_tdc, VAL_DELAYED_DRAW);
  GetCtrlVal (p1h, P1_TDCHL, &irange);
  ph_tdc = PlotY (p1h, P1_TDC, &dtdc[ch][irange], MAXCH, VAL_INTEGER,
                  VAL_VERTICAL_BAR, VAL_EMPTY_SQUARE, VAL_SOLID, 1, VAL_RED);
 
  if (ph_adc>0) DeleteGraphPlot (p1h, P1_ADC, ph_adc, VAL_DELAYED_DRAW);
  GetCtrlVal (p1h, P1_ADCHL, &irange);
  ph_adc = PlotY (p1h, P1_ADC, &something[ch][irange], MAXCH, VAL_INTEGER,
                  VAL_VERTICAL_BAR, VAL_EMPTY_SQUARE, VAL_SOLID, 1, VAL_BLUE);
  return (0);
}
 
 
int module_header(int recid,unsigned long *data,int len){
   data[0] = recid;
   data[1] = (len >0)? len : 0 ;
   return data[1]+2;
}
 
int SetDac(int, double);
 
int CVICALLBACK daq_run(void *functionData)
{
        // ***
        // variable declarations
        int i,j;
        int dtype,ch,rg,adc,cres,bsr;
       
        //unsigned short aa[NCH][4];
        unsigned long tdc[NCH];
        unsigned long step_minutes, end_time_s, cur_time_s;
        int start_hours, start_minutes, start_seconds;
 
        int status,fmax,fcount,fev;
        int popupret;
        int mikroX; // check the position
        int mikroY; // check the position
 
  char dfile[MAX_PATHNAME_LEN],dfile0[MAX_PATHNAME_LEN];
  int supr0,tdcmin,fseed;
  float frac;
  double fracg;
  unsigned short dum16;
  int count;
  int print = 0;
  int timer_out = 0;
  //time_t t,told, tstart;
  int ntrig;  
  int chip, len;
  unsigned long *pdata;
 
  FILE *fp;
  #define RUNREC_ID 1
  #define ENDREC_ID 2
  #define POSREC_ID 3
  #define EVTREC_ID 4
  #define THRREC_ID 5
 
  typedef struct {
    unsigned long id,len;
    unsigned long fver,time;
    unsigned long nev,nch,ped,xy;
    unsigned long thLow, thUp, thStep;
    long nx,x0,dx,ny,y0,dy;
    } RUNREC;
        RUNREC runrec;
       
  typedef struct {
    unsigned long id,len;
    unsigned long time;
    } ENDREC;
        ENDREC endrec;
       
  typedef struct {
    unsigned long id,len;
    unsigned long time;
    long ix,x,xset,iy,y,yset;
    } POSREC;
        POSREC posrec;
 
  typedef struct {
    unsigned long id,len;
    unsigned long nev;
    //unsigned short data[NCH];
    } EVTREC;
        EVTREC evtrec;
       
  typedef struct {
        unsigned long id;
        unsigned long len;
        unsigned long threshold;
        } THRREC;
  THRREC thrrec;
       
        double thresholdLow;
        double thresholdUp;
        double thresholdStep;
 
#define BSIZE 20000
       
        int maxn = BSIZE-4; // 2 words x 2 headers
        int tdcdata, edge_type, overflow, tdc_num, channel, ev_dat, last_dat, nval_dat;
        // end of declarations
        // ***
       
        runrec.id = RUNREC_ID;
        runrec.len = sizeof(runrec);
        //runrec.fver = 0x10000;
        runrec.nch = NCH;
        GetCtrlVal(p1h, P1_ADCHLSAVE, &runrec.xy);//runrec.xy = 1;
        GetCtrlVal(p1h, P1_DEBUG, &print);
        endrec.id = ENDREC_ID;
        endrec.len = sizeof(endrec);
        posrec.id = POSREC_ID;
        posrec.len = sizeof(posrec);
        evtrec.id = EVTREC_ID;
        evtrec.len = sizeof(evtrec);
        thrrec.id = THRREC_ID;
        thrrec.len = sizeof(thrrec);
       
       
        cres = 0;
       
        GetCtrlVal (p1h, P1_NEVE, &runrec.nev);
        GetCtrlVal (p1h, P1_PEDESTAL, &runrec.ped);
       
        GetCtrlVal (p1h, P1_NX, &runrec.nx);
        GetCtrlVal (p1h, P1_XSTEP, &runrec.dx);
        GetCtrlVal (p1h, P1_XMIN, &runrec.x0);
        GetCtrlVal (p1h, P1_NY, &runrec.ny);
        GetCtrlVal (p1h, P1_YSTEP, &runrec.dy);
        GetCtrlVal (p1h, P1_YMIN, &runrec.y0);
       
        GetCtrlVal (p1h, P1_NMIN, &step_minutes);
        GetSystemTime(&start_hours, &start_minutes, &start_seconds);
        //cur_time_s = start_hours*3600 + start_minutes*60 + start_seconds;
        time(&cur_time_s);
        end_time_s = cur_time_s + step_minutes*60;
        printf("START:%2d-%2d-%2d (cur_time = %u s, end_time = %u s)\n", start_hours, start_minutes, start_seconds, cur_time_s, end_time_s);
 
        //GetCtrlVal (p1h, P1_DSAVE, &dsave);
  //if (dsave) {
          GetCtrlVal (p1h, P1_DFILE, dfile0);
         
          fev=0;
          fcount=1;
          GetCtrlVal (p1h, P1_NEWF, &fmax);
          fmax*=1000000;//fmax in Mega Bytes
  //}
        GetCtrlVal (p1h, P1_SUPR, &supr0);
        if (supr0) {
          GetCtrlVal (p1h, P1_TDCMIN, &tdcmin);
          GetCtrlVal (p1h, P1_FRAC, &frac);
        }
       
        GetCtrlVal (p1h, P1_STHRLOW, &thresholdLow);
        runrec.thLow = thresholdLow*1000; // mV
        GetCtrlVal (p1h, P1_STHRUP, &thresholdUp);
        runrec.thUp = thresholdUp*1000; // mV
        GetCtrlVal (p1h, P1_STEP, &thresholdStep);
        runrec.thStep = thresholdStep*1000; // mV
       
 
#ifdef USE_DAQ
        V673A_map(0,CAEN_V673A,0);
        V673A_init(0);
 
        V462_map(0,CAEN_V462,0);
        V462_set0(0,1);
#endif
 
  //if (dsave) {
    sprintf(dfile,"%s_file%02d.dat",dfile0,fcount);
 
    fp = fopen (dfile, "wb");
    time (&runrec.time);
    status = fwrite (&runrec, 1, runrec.len, fp);
        //}
        if (supr0) {
          fseed = runrec.time & 0x7fffffff;
          Uniform (1, fseed, &fracg);
        }
       
  thrrec.threshold = (unsigned long) ceil(thresholdLow*1000); // threshold in mV
  while (thrrec.threshold <= thresholdUp*1000) {
    SetDac(0, thrrec.threshold/1000.0);
        SetCtrlVal(p1h, P1_STHRLOW, thrrec.threshold/1000.0);
    //wait_loop(100000);
    status = fwrite(&thrrec, 1, thrrec.len, fp);
    if (print) printf("THRREC status %d len %d threshold %d\n", status, thrrec.len, thrrec.threshold);
   
  for (posrec.ix=0; posrec.ix<runrec.nx; posrec.ix++) {
                posrec.xset = runrec.x0 + posrec.ix*runrec.dx;
#ifdef USE_MIKRO
          //printf("MIKRO_MoveTo (1, x);%d\n",posrec.x);
          do {
        MIKRO_MoveTo (MIKRO_X, posrec.xset);
        MIKRO_GetPosition(MIKRO_X, &mikroX);
      } while (abs(posrec.xset - mikroX) > STEP_TOLERANCE);
          //printf("->MIKRO_MoveTo (1, x);%d\n",posrec.xset);
#endif
          //SetCtrlVal (p1h, P1_X, posrec.xset);
          posrec.xset = mikroX; // set the true value
          SetCtrlVal(p1h, P1_X, mikroX);
          SetCtrlVal (p1h, P1_IX, posrec.ix);
          for (posrec.iy=0; posrec.iy<runrec.ny; posrec.iy++) {
      posrec.yset = runrec.y0 + posrec.iy*runrec.dy;
#ifdef USE_MIKRO_Y
      //printf("MIKRO_MoveTo (2, y);%d\n",y);
      do {
        MIKRO_MoveTo (MIKRO_Y, posrec.yset);
        MIKRO_GetPosition(MIKRO_Y, &mikroY);
        } while (abs(posrec.yset - mikroY) > STEP_TOLERANCE);
          //printf("->MIKRO_MoveTo (2, y);%d\n",posrec.yset);
#endif
      //SetCtrlVal (p1h, P1_Y, posrec.yset);
      posrec.yset = mikroY; // set the true value
      SetCtrlVal (p1h, P1_Y, mikroY);
      SetCtrlVal (p1h, P1_IY, posrec.iy);
      //if (dsave) {
      if (fmax && (ftell(fp) > fmax)) {
        fcount+=1;
        sprintf(dfile,"%s_file%02d.dat",dfile0,fcount);
        fclose(fp);
        fp = fopen (dfile, "wb");
      }
         
      time (&posrec.time);
            status = fwrite (&posrec, 1, posrec.len, fp);
            if (print) printf("POSREC status %d len %d\n", status, posrec.len);
                  //}
                 
// clear the plots
      for (j=0;j<NCH;j++) {
       for (i=0;i<MAXCH;i++){
          dtdc[j][0][i]=0;
          dtdc[j][1][i]=0;
        }
      }
 
          evtrec.nev=1;  
      //time(&t);
      //tstart=t;
      if (print) printf("RUN START.\n");
       
      do {
        unsigned long word[BSIZE];
            count=0;
            ntics=0;
            if (print) printf("Event counter: %d\n", evtrec.nev);
           
                //if (t!=told ) printf("%d in %2.2f min daq::event() %s\n",i, (double)(t-tstart)/60., ctime(&t)); 
             
#ifdef USE_DAQ
#ifdef CAEN_V673A
 
   
        V462_start0(0);
                //tmlnk (tout); 
        do {  
          ntrig  = V673A_ntrig(0);
        } while (ntrig==0 &&(ntics<2));
        //tmulk();
        //if (timer_out) {
        //   fprintf(stderr,"-----------------> V673a timeout !!!\n");
        //   V673A_clallb(0); 
        //   continue;
        //}
     
        if (ntics>=2) {
           fprintf(stderr,"-----------------> V673a timeout !!!\n");
           printf("Timer tics %d\n", ntics);
           ntics = 0;
           evtrec.nev--;
           V673A_clallb(0);
           continue;
          }
 
        if (ntrig>0){
          // chip readout
          for (chip=0;chip<2;chip++){
            if (chip) len = V673A_read1 (0, &word[count+2],maxn-count-2);
            else          len = V673A_read0 (0, &word[count+2],maxn-count-2);
         
            if (len>16*32*4){
              if (print) printf("Length > 2048 per chip!\n");
              chip=2;
              V673A_clallb(0);
              evtrec.nev--;
              continue;
            }
            pdata=&word[count+2];
            for(i=0;i< len;i++){
              tdcdata   =  pdata[i] & 0xFFFF ;
              edge_type = (pdata[i]>>16)&0x1  ;
              overflow  = (pdata[i]>>17)&0x1  ;
              tdc_num   = (pdata[i]>>25)&0x1  ;
              channel   = ((pdata[i]>>18)&0x1F) |tdc_num<<5 ;
              ev_dat    = (pdata[i]>>23)&0x1  ;    
              last_dat  = (pdata[i]>>30)&0x1  ;
              nval_dat  = (pdata[i]>>31)&0x1  ;
              if (ev_dat) {
                if(print) printf("Event %d\n",tdcdata);
              } else {
                dtdc[channel][edge_type][tdcdata]++;
             
              if (print) printf
                       ("ch=%d edge=%d ev=%d data=%d last=%d nval=%d\n",channel, edge_type,ev_dat,tdcdata,last_dat,nval_dat);
              }
            }
            if (count+2 < maxn) count+=module_header(0x140+chip,&word[count],len);
                  }
                  if (print) printf("Received triggers: %d \n", ntrig);
        } else {
          if (ntrig==0) {
                fprintf(stderr,"-----------------> no trigger");
                break;
          } else {
                if (print) fprintf(stderr,"-----------------> wrong number of triggers in chips V673a  !!!\n");
          }
          V673A_clallb(0);
          evtrec.nev--;
          continue;
        }
       
        V673A_clallb(0);
#endif
#endif
       
 
        GetCtrlVal(p1h, P1_ADCHLSAVE, &runrec.xy);
        evtrec.len = count*sizeof(unsigned long) + sizeof(evtrec);
        if (print) printf("EVTREC.len = %d bytes.\n", evtrec.len);
       
        status = fwrite (&evtrec, 1, sizeof(evtrec), fp);
        status = fwrite (&word, 1, count*sizeof(unsigned long), fp);
                   
             
            if (!(evtrec.nev%1000)) SetCtrlVal (p1h, P1_CEVE, evtrec.nev);
             
            if (!((evtrec.nev+1)%1000)) {                                                            
            if (fmax && (ftell(fp) > fmax)) {
              time (&endrec.time);
                      status = fwrite (&endrec, 1, endrec.len, fp);
              fcount+=1;
                  sprintf(dfile,"%s_file%02d.dat",dfile0,fcount);
                  fclose(fp);
                  fp = fopen (dfile, "wb");
            }
        }
         
        if(step_minutes > 0) {
                                  GetSystemTime(&start_hours, &start_minutes, &start_seconds);
                                  //cur_time_s = start_hours*3600 + start_minutes*60 + start_seconds;
                                  time(&cur_time_s);
                                  if(cur_time_s >= end_time_s) {
                                          end_time_s = cur_time_s + step_minutes*60;
                                          printf("STEP (nev):%2d-%2d-%2d @ %d\n", start_hours, start_minutes, start_seconds, posrec.xset);
                        break;
                }
        }
        //told=t;
       
        GetCtrlVal(p1h, P1_DAQ, &daq_on);
         
            } while (evtrec.nev++<runrec.nev && daq_on);
            if (!daq_on) break;
          } // x loop
          if (!daq_on) break;
        } // y loop
        if (!daq_on) break;
        thrrec.threshold += thresholdStep*1000;
        } // threhsold loop
       
  //if (dsave) {
    time (&endrec.time);
    status = fwrite (&endrec, 1, endrec.len, fp);
    if (print) printf("ENDREC status %d len %d\n", status, endrec.len);
    fclose(fp);
        //}
        GetSystemTime(&start_hours, &start_minutes, &start_seconds);
        printf("STOP:%2d-%2d-%2d (start_time = %u s, end_time = %u s)\n", start_hours, start_minutes, start_seconds, runrec.time, endrec.time);
        printf("Elapsed time: %u s.\n", endrec.time-runrec.time);
       
    daq_on=0;  
        SetCtrlVal (p1h, P1_DAQ, daq_on);
        SetCtrlVal (p1h, P1_CEVE, evtrec.nev);
        if (print) printf("RUN END. \n\n");
 
        return 0;
}
 
 
int SetDac(int ch, double val){
       
        const unsigned int maxdac=0xFFF;
        const double RANGE = +9.9976; //V
        unsigned int dac;
       
        if ((val > RANGE) || (val < 0)) {
                printf("DAC value OUT OF RANGE!!!\n");
                return(-1);
        }
       
        dac = (val/RANGE)*maxdac;
        CSSA_W(NDAC,ch,16,&dac);
        printf("DAC ch %d set to %f V dac=%d\n", ch, val, dac);
        return 0;
}
 
int __stdcall WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                       LPSTR lpszCmdLine, int nCmdShow)
{
  int i,j,status,refon;
  long int xpos, ypos, zpos;
  char dfile[300];
  FILE *fp;
 
  typedef struct {
  unsigned long id,len;
  unsigned long fver,time;
  unsigned long nev,nch,ped,xy;
  long nx,x0,dx,ny,y0,dy;
  } RUNREC;
  RUNREC runrec;
 
  if (InitCVIRTE (hInstance, 0, 0) == 0)
        return -1;      /* out of memory */
 
  SetSleepPolicy(VAL_SLEEP_MORE);
  CmtNewThreadPool (MAX_THREADS, &poolHandle);
 
  SetStdioWindowOptions (1000, 0, 0);
  SetStdioWindowSize (200, 560);
  SetStdioWindowPosition (825, 250);
 
#ifdef USE_DAQ
  VME_START(NULL);
#endif
 
#ifdef USE_MIKRO
  MIKRO_Open (MIKRO_COM);
  MIKRO_Init (MIKRO_X,0);
#ifdef USE_MIKRO_Y
  MIKRO_Init (MIKRO_Y,0);
#endif
#ifdef USE_MIKRO_Z
  MIKRO_Init (MIKRO_Z,0);
#endif
#endif
 
  if ((p1h = LoadPanel (0, "include/sipmThreshold_ui.uir", P1)) < 0) return -1;
  DisplayPanel (p1h);
  SetCtrlAttribute (p1h, P1_PLCH, ATTR_MAX_VALUE, NCH-1);
 
  GetCtrlVal(p1h, P1_ADCHLSAVE, &runrec.xy);
  SetCtrlVal(p1h, P1_ADCHL, runrec.xy-2);
 
  QueueUserEvent (1000, p1h, P1_RESET);
  QueueUserEvent (1000, p1h, P1_ASD8THR);
  QueueUserEvent (1000, p1h, P1_AMPDISSHTHR);
  QueueUserEvent (1000, p1h, P1_BIAS);
  do {
    GetUserEvent (1, &pID, &rID);
        switch (rID) {
      case P1_TIMER:
        ntics+=1;
        GetCtrlVal (p1h, P1_REFON, &refon);
                    if (refon) update_plots();
            break;
      case P1_REFRESH:
                update_plots();
            break;
          case P1_DAQ:
                GetCtrlVal (p1h, P1_DAQ, &daq_on);
                if (daq_on) {
                  CmtScheduleThreadPoolFunction (poolHandle, daq_run, (void *)&dummy, &tfID);
                } else {
          CmtWaitForThreadPoolFunctionCompletion (poolHandle, tfID,
                                                                        OPT_TP_PROCESS_EVENTS_WHILE_WAITING);
              CmtReleaseThreadPoolFunctionID (poolHandle, tfID);
            }
            break;
           
          case P1_ZSET:
            if (!daq_on) {
              GetCtrlVal (p1h, P1_ZSET, &zpos);
#ifdef USE_MIKRO_Z
          MIKRO_MoveTo (MIKRO_Z, zpos);
#endif
        }
            break;
          case P1_REREAD:
            if (!daq_on) {
          status = FileSelectPopup ("", "*.dat", ".dat",
                                    "Choose the previous file",
                                    VAL_LOAD_BUTTON, 0, 0, 1, 0, dfile);
          if (status==1) {
            fp = fopen (dfile, "rb");
                        status = fread (&runrec, 1, sizeof(runrec), fp);
                        fclose(fp);
                        if (runrec.id==1) {
                          SetCtrlVal (p1h, P1_NX, runrec.nx);
                          SetCtrlVal (p1h, P1_XSTEP, runrec.dx);
                          SetCtrlVal (p1h, P1_XMIN, runrec.x0);
                          SetCtrlVal (p1h, P1_NY, runrec.ny);
                          SetCtrlVal (p1h, P1_YSTEP, runrec.dy);
                          SetCtrlVal (p1h, P1_YMIN, runrec.y0);
                          SetCtrlVal (p1h, P1_NEVE, runrec.nev);
            }
              }
        }
            break;
          case P1_MGET:
          #ifdef USE_MIKRO
                MIKRO_GetPosition(MIKRO_X,&xpos);
                Delay(0.01);
                SetCtrlVal (p1h, P1_X, xpos);  
          #ifdef USE_MIKRO_Y    
                MIKRO_GetPosition(MIKRO_Y,&ypos);
                Delay(0.01);
                SetCtrlVal (p1h, P1_Y, ypos);
          #endif
          #ifdef USE_MIKRO_Z    
                MIKRO_GetPosition(MIKRO_Z,&zpos);
                Delay(0.01);
                SetCtrlVal (p1h, P1_Z, zpos);
          #endif 
          #endif
                break;
          case P1_HO:
            if (!daq_on) {
                  SetWaitCursor (1);
#ifdef USE_MIKRO
                  MIKRO_ReferenceMove (MIKRO_X);
                #ifdef USE_MIKRO_Y      
                  MIKRO_ReferenceMove (MIKRO_Y);
                #endif
                #ifdef USE_MIKRO_Z
                  MIKRO_ReferenceMove (MIKRO_Z);
                #endif
#endif
                  SetWaitCursor (0);
            }
            break;
          case P1_RESET:
        for (j=0;j<NCH;j++) {
          for (i=0;i<MAXCH;i++){
            dtdc[j][0][i]=0;
            dtdc[j][1][i]=0;
           
          }
        }
                update_plots();
            break;
          case P1_TDCLOG:
            GetCtrlVal (p1h, P1_TDCLOG, &status);
        SetCtrlAttribute (p1h, P1_TDC, ATTR_YMAP_MODE, status);
                update_plots();
            break;
          case P1_ADCLOG:
            GetCtrlVal (p1h, P1_ADCLOG, &status);
        SetCtrlAttribute (p1h, P1_ADC, ATTR_YMAP_MODE, status);
                update_plots();
            break;
          case P1_ASD8THR:
            {
              double value;
              GetCtrlVal (p1h, P1_STHRLOW, &value);
              SetDac(0, value);
             
            }
            break;
          case P1_BIAS:
            {
              double value;
              GetCtrlVal (p1h, P1_SBIAS, &value);
              SetDac(2, value);
            }
            break;
          case P1_AMPDISSHTHR:
            {
              double value;
              GetCtrlVal (p1h, P1_SAMPDISSHTHR, &value);
              SetDac(1, value);
 
            }  
            break;
             
        }
       
  } while ((rID != P1_EXIT)||daq_on);
           
  CmtDiscardThreadPool (poolHandle);
  DiscardPanel (p1h);
 
#ifdef USE_MIKRO
  MIKRO_Close ();
#endif
 
#ifdef USE_DAQ
  VME_STOP();
#endif  
  return 0;
               
}
 

Rev 32	Rev 37
1	#define USE_DAQ	1	#define USE_DAQ
2	#define USE_MIKRO	2	#define USE_MIKRO
3		3
4	// Izberi ustrezni interface v meniju projektnega okna	4	// Izberi ustrezni interface v meniju projektnega okna
5	// Options->CompilerDefines (dodaj /DSISVME ali /DWIENVME)	5	// Options->CompilerDefines (dodaj /DSISVME ali /DWIENVME)
6	#ifdef USE_DAQ	6	#ifdef USE_DAQ
7	# define USE_CAMAC	7	# define USE_CAMAC
8	#include "c:\HOME\dino\sipmScan\include\camac.h"	8	#include "c:\HOME\dino\sipmScan\include\camac.h"
9	# ifdef SISVME	9	# ifdef SISVME
10	# include "sisvme_dll.h"	10	# include "sisvme_dll.h"
11	# endif	11	# endif
12	# ifdef WIENVME	12	# ifdef WIENVME
13	# include "wienvme_dll.h"	13	# include "wienvme_dll.h"
14	# endif	14	# endif
15	# include "CAENV673A.h"	15	# include "CAENV673A.h"
16	# include "CAENV462.h"	16	# include "CAENV462.h"
17	#endif	17	#endif
18		18
19	#ifdef USE_MIKRO	19	#ifdef USE_MIKRO
20	# include "MIKRO.h"	20	# include "MIKRO.h"
21	#endif	21	#endif
22		22
23	#include <userint.h>	23	#include <userint.h>
24	#include <ansi_c.h>	24	#include <ansi_c.h>
25	#include <utility.h>	25	#include <utility.h>
26	#include <analysis.h>	26	#include <analysis.h>
27		27
28	#include "c:\HOME\dino\sipmScan\include\sipmThreshold_ui.h"	28	#include "c:\HOME\dino\sipmScan\include\sipmThreshold_ui.h"
29		29
30	#ifdef USE_DAQ	30	#ifdef USE_DAQ
31	# define USE_CAMAC	31	# define USE_CAMAC
32	# include "camac.h"	32	# include "camac.h"
33	# define NDAC 1	33	# define NDAC 1
34		34
35	# define CAEN_V673A 0x22220000 // IJS	35	# define CAEN_V673A 0x22220000 // IJS
36	//#define CAEN_V673A 0x10110000 // FMF	36	//#define CAEN_V673A 0x10110000 // FMF
37	# define CAEN_V462 0x100300	37	# define CAEN_V462 0x100300
38	#endif	38	#endif
39		39
40	#ifdef USE_MIKRO	40	#ifdef USE_MIKRO
41	# define MIKRO_COM 5	41	# define MIKRO_COM 5
42	# define MIKRO_X 1	42	# define MIKRO_X 1
43	# define USE_MIKRO_Y	43	# define USE_MIKRO_Y
44	# define MIKRO_Y 2	44	# define MIKRO_Y 2
45	# define USE_MIKRO_Z	45	# define USE_MIKRO_Z
46	# define MIKRO_Z 3	46	# define MIKRO_Z 3
47	# define STEP_TOLERANCE 50	47	# define STEP_TOLERANCE 50
48	#endif	48	#endif
49		49
50	#define MAXCH 512	50	#define MAXCH 512
51	#define MAX_THREADS 10	51	#define MAX_THREADS 10
52		52
53	#define IWAIT 200	53	#define IWAIT 200
54		54
55	#define NCH 64	55	#define NCH 64
56		56
57	static int p1h, pID, rID, tfID;	57	static int p1h, pID, rID, tfID;
58	static int ph_tdc, ph_adc;	58	static int ph_tdc, ph_adc;
59	static int dtdc[NCH][2][MAXCH];	59	static int dtdc[NCH][2][MAXCH];
60	static int something[NCH][2][MAXCH];	60	static int something[NCH][2][MAXCH];
61		61
62	static int daq_on;	62	static int daq_on;
63	static int poolHandle = 0;	63	static int poolHandle = 0;
64	static int ntics,dummy;	64	static int ntics,dummy;
65		65
66	/************************************************************/	66	/************************************************************/
67	void wait_loop(unsigned long iloop)	67	void wait_loop(unsigned long iloop)
68		68
69	{	69	{
70	int i;	70	int i;
71		71
72	for (i=0;i<iloop;i++);	72	for (i=0;i<iloop;i++);
73	return;	73	return;
74	}	74	}
75		75
76	int CVICALLBACK cb_timer (int panel, int control, int event, void *callbackData,	76	int CVICALLBACK cb_timer (int panel, int control, int event, void *callbackData,
77	int eventData1, int eventData2)	77	int eventData1, int eventData2)
78	{	78	{
79	QueueUserEvent (9000, p1h, P1_TIMER);	79	QueueUserEvent (9000, p1h, P1_TIMER);
80	return (0);	80	return (0);
81	}	81	}
82		82
83	int update_plots (void)	83	int update_plots (void)
84	{	84	{
85	int irange, ch;	85	int irange, ch;
86		86
87	GetCtrlVal (p1h, P1_PLCH, &ch);	87	GetCtrlVal (p1h, P1_PLCH, &ch);
88		88
89	if (ph_tdc>0) DeleteGraphPlot (p1h, P1_TDC, ph_tdc, VAL_DELAYED_DRAW);	89	if (ph_tdc>0) DeleteGraphPlot (p1h, P1_TDC, ph_tdc, VAL_DELAYED_DRAW);
90	GetCtrlVal (p1h, P1_TDCHL, &irange);	90	GetCtrlVal (p1h, P1_TDCHL, &irange);
91	ph_tdc = PlotY (p1h, P1_TDC, &dtdc[ch][irange], MAXCH, VAL_INTEGER,	91	ph_tdc = PlotY (p1h, P1_TDC, &dtdc[ch][irange], MAXCH, VAL_INTEGER,
92	VAL_VERTICAL_BAR, VAL_EMPTY_SQUARE, VAL_SOLID, 1, VAL_RED);	92	VAL_VERTICAL_BAR, VAL_EMPTY_SQUARE, VAL_SOLID, 1, VAL_RED);
93		93
94	if (ph_adc>0) DeleteGraphPlot (p1h, P1_ADC, ph_adc, VAL_DELAYED_DRAW);	94	if (ph_adc>0) DeleteGraphPlot (p1h, P1_ADC, ph_adc, VAL_DELAYED_DRAW);
95	GetCtrlVal (p1h, P1_ADCHL, &irange);	95	GetCtrlVal (p1h, P1_ADCHL, &irange);
96	ph_adc = PlotY (p1h, P1_ADC, &something[ch][irange], MAXCH, VAL_INTEGER,	96	ph_adc = PlotY (p1h, P1_ADC, &something[ch][irange], MAXCH, VAL_INTEGER,
97	VAL_VERTICAL_BAR, VAL_EMPTY_SQUARE, VAL_SOLID, 1, VAL_BLUE);	97	VAL_VERTICAL_BAR, VAL_EMPTY_SQUARE, VAL_SOLID, 1, VAL_BLUE);
98	return (0);	98	return (0);
99	}	99	}
100		100
101		101
102	int module_header(int recid,unsigned long *data,int len){	102	int module_header(int recid,unsigned long *data,int len){
103	data[0] = recid;	103	data[0] = recid;
104	data[1] = (len >0)? len : 0 ;	104	data[1] = (len >0)? len : 0 ;
105	return data[1]+2;	105	return data[1]+2;
106	}	106	}
107		107
108	int SetDac(int, double);	108	int SetDac(int, double);
109		109
110	int CVICALLBACK daq_run(void *functionData)	110	int CVICALLBACK daq_run(void *functionData)
111	{	111	{
112	// ***	112	// ***
113	// variable declarations	113	// variable declarations
114	int i,j;	114	int i,j;
115	int dtype,ch,rg,adc,cres,bsr;	115	int dtype,ch,rg,adc,cres,bsr;
116		116
117	//unsigned short aa[NCH][4];	117	//unsigned short aa[NCH][4];
118	unsigned long tdc[NCH];	118	unsigned long tdc[NCH];
119	unsigned long step_minutes, end_time_s, cur_time_s;	119	unsigned long step_minutes, end_time_s, cur_time_s;
120	int start_hours, start_minutes, start_seconds;	120	int start_hours, start_minutes, start_seconds;
121		121
122	int status,fmax,fcount,fev;	122	int status,fmax,fcount,fev;
123	int popupret;	123	int popupret;
124	int mikroX; // check the position	124	int mikroX; // check the position
125	int mikroY; // check the position	125	int mikroY; // check the position
126		126
127	char dfile[MAX_PATHNAME_LEN],dfile0[MAX_PATHNAME_LEN];	127	char dfile[MAX_PATHNAME_LEN],dfile0[MAX_PATHNAME_LEN];
128	int supr0,tdcmin,fseed;	128	int supr0,tdcmin,fseed;
129	float frac;	129	float frac;
130	double fracg;	130	double fracg;
131	unsigned short dum16;	131	unsigned short dum16;
132	int count;	132	int count;
133	int print = 0;	133	int print = 0;
134	int timer_out = 0;	134	int timer_out = 0;
135	//time_t t,told, tstart;	135	//time_t t,told, tstart;
136	int ntrig;	136	int ntrig;
137	int chip, len;	137	int chip, len;
138	unsigned long *pdata;	138	unsigned long *pdata;
139		139
140	FILE *fp;	140	FILE *fp;
141	#define RUNREC_ID 1	141	#define RUNREC_ID 1
142	#define ENDREC_ID 2	142	#define ENDREC_ID 2
143	#define POSREC_ID 3	143	#define POSREC_ID 3
144	#define EVTREC_ID 4	144	#define EVTREC_ID 4
145	#define THRREC_ID 5	145	#define THRREC_ID 5
146		146
147	typedef struct {	147	typedef struct {
148	unsigned long id,len;	148	unsigned long id,len;
149	unsigned long fver,time;	149	unsigned long fver,time;
150	unsigned long nev,nch,ped,xy;	150	unsigned long nev,nch,ped,xy;
151	unsigned long thLow, thUp, thStep;	151	unsigned long thLow, thUp, thStep;
152	long nx,x0,dx,ny,y0,dy;	152	long nx,x0,dx,ny,y0,dy;
153	} RUNREC;	153	} RUNREC;
154	RUNREC runrec;	154	RUNREC runrec;
155		155
156	typedef struct {	156	typedef struct {
157	unsigned long id,len;	157	unsigned long id,len;
158	unsigned long time;	158	unsigned long time;
159	} ENDREC;	159	} ENDREC;
160	ENDREC endrec;	160	ENDREC endrec;
161		161
162	typedef struct {	162	typedef struct {
163	unsigned long id,len;	163	unsigned long id,len;
164	unsigned long time;	164	unsigned long time;
165	long ix,x,xset,iy,y,yset;	165	long ix,x,xset,iy,y,yset;
166	} POSREC;	166	} POSREC;
167	POSREC posrec;	167	POSREC posrec;
168		168
169	typedef struct {	169	typedef struct {
170	unsigned long id,len;	170	unsigned long id,len;
171	unsigned long nev;	171	unsigned long nev;
172	//unsigned short data[NCH];	172	//unsigned short data[NCH];
173	} EVTREC;	173	} EVTREC;
174	EVTREC evtrec;	174	EVTREC evtrec;
175		175
176	typedef struct {	176	typedef struct {
177	unsigned long id;	177	unsigned long id;
178	unsigned long len;	178	unsigned long len;
179	unsigned long threshold;	179	unsigned long threshold;
180	} THRREC;	180	} THRREC;
181	THRREC thrrec;	181	THRREC thrrec;
182		182
183	double thresholdLow;	183	double thresholdLow;
184	double thresholdUp;	184	double thresholdUp;
185	double thresholdStep;	185	double thresholdStep;
186		186
187	#define BSIZE 20000	187	#define BSIZE 20000
188		188
189	int maxn = BSIZE-4; // 2 words x 2 headers	189	int maxn = BSIZE-4; // 2 words x 2 headers
190	int tdcdata, edge_type, overflow, tdc_num, channel, ev_dat, last_dat, nval_dat;	190	int tdcdata, edge_type, overflow, tdc_num, channel, ev_dat, last_dat, nval_dat;
191	// end of declarations	191	// end of declarations
192	// ***	192	// ***
193		193
194	runrec.id = RUNREC_ID;	194	runrec.id = RUNREC_ID;
195	runrec.len = sizeof(runrec);	195	runrec.len = sizeof(runrec);
196	//runrec.fver = 0x10000;	196	//runrec.fver = 0x10000;
197	runrec.nch = NCH;	197	runrec.nch = NCH;
198	GetCtrlVal(p1h, P1_ADCHLSAVE, &runrec.xy);//runrec.xy = 1;	198	GetCtrlVal(p1h, P1_ADCHLSAVE, &runrec.xy);//runrec.xy = 1;
199	GetCtrlVal(p1h, P1_DEBUG, &print);	199	GetCtrlVal(p1h, P1_DEBUG, &print);
200	endrec.id = ENDREC_ID;	200	endrec.id = ENDREC_ID;
201	endrec.len = sizeof(endrec);	201	endrec.len = sizeof(endrec);
202	posrec.id = POSREC_ID;	202	posrec.id = POSREC_ID;
203	posrec.len = sizeof(posrec);	203	posrec.len = sizeof(posrec);
204	evtrec.id = EVTREC_ID;	204	evtrec.id = EVTREC_ID;
205	evtrec.len = sizeof(evtrec);	205	evtrec.len = sizeof(evtrec);
206	thrrec.id = THRREC_ID;	206	thrrec.id = THRREC_ID;
207	thrrec.len = sizeof(thrrec);	207	thrrec.len = sizeof(thrrec);
208		208
209		209
210	cres = 0;	210	cres = 0;
211		211
212	GetCtrlVal (p1h, P1_NEVE, &runrec.nev);	212	GetCtrlVal (p1h, P1_NEVE, &runrec.nev);
213	GetCtrlVal (p1h, P1_PEDESTAL, &runrec.ped);	213	GetCtrlVal (p1h, P1_PEDESTAL, &runrec.ped);
214		214
215	GetCtrlVal (p1h, P1_NX, &runrec.nx);	215	GetCtrlVal (p1h, P1_NX, &runrec.nx);
216	GetCtrlVal (p1h, P1_XSTEP, &runrec.dx);	216	GetCtrlVal (p1h, P1_XSTEP, &runrec.dx);
217	GetCtrlVal (p1h, P1_XMIN, &runrec.x0);	217	GetCtrlVal (p1h, P1_XMIN, &runrec.x0);
218	GetCtrlVal (p1h, P1_NY, &runrec.ny);	218	GetCtrlVal (p1h, P1_NY, &runrec.ny);
219	GetCtrlVal (p1h, P1_YSTEP, &runrec.dy);	219	GetCtrlVal (p1h, P1_YSTEP, &runrec.dy);
220	GetCtrlVal (p1h, P1_YMIN, &runrec.y0);	220	GetCtrlVal (p1h, P1_YMIN, &runrec.y0);
221		221
222	GetCtrlVal (p1h, P1_NMIN, &step_minutes);	222	GetCtrlVal (p1h, P1_NMIN, &step_minutes);
223	GetSystemTime(&start_hours, &start_minutes, &start_seconds);	223	GetSystemTime(&start_hours, &start_minutes, &start_seconds);
224	//cur_time_s = start_hours3600 + start_minutes60 + start_seconds;	224	//cur_time_s = start_hours3600 + start_minutes60 + start_seconds;
225	time(&cur_time_s);	225	time(&cur_time_s);
226	end_time_s = cur_time_s + step_minutes*60;	226	end_time_s = cur_time_s + step_minutes*60;
227	printf("START:%2d-%2d-%2d (cur_time = %u s, end_time = %u s)\n", start_hours, start_minutes, start_seconds, cur_time_s, end_time_s);	227	printf("START:%2d-%2d-%2d (cur_time = %u s, end_time = %u s)\n", start_hours, start_minutes, start_seconds, cur_time_s, end_time_s);
228		228
229	//GetCtrlVal (p1h, P1_DSAVE, &dsave);	229	//GetCtrlVal (p1h, P1_DSAVE, &dsave);
230	//if (dsave) {	230	//if (dsave) {
231	GetCtrlVal (p1h, P1_DFILE, dfile0);	231	GetCtrlVal (p1h, P1_DFILE, dfile0);
232		232
233	fev=0;	233	fev=0;
234	fcount=1;	234	fcount=1;
235	GetCtrlVal (p1h, P1_NEWF, &fmax);	235	GetCtrlVal (p1h, P1_NEWF, &fmax);
236	fmax*=1000000;//fmax in Mega Bytes	236	fmax*=1000000;//fmax in Mega Bytes
237	//}	237	//}
238	GetCtrlVal (p1h, P1_SUPR, &supr0);	238	GetCtrlVal (p1h, P1_SUPR, &supr0);
239	if (supr0) {	239	if (supr0) {
240	GetCtrlVal (p1h, P1_TDCMIN, &tdcmin);	240	GetCtrlVal (p1h, P1_TDCMIN, &tdcmin);
241	GetCtrlVal (p1h, P1_FRAC, &frac);	241	GetCtrlVal (p1h, P1_FRAC, &frac);
242	}	242	}
243		243
244	GetCtrlVal (p1h, P1_STHRLOW, &thresholdLow);	244	GetCtrlVal (p1h, P1_STHRLOW, &thresholdLow);
245	runrec.thLow = thresholdLow*1000; // mV	245	runrec.thLow = thresholdLow*1000; // mV
246	GetCtrlVal (p1h, P1_STHRUP, &thresholdUp);	246	GetCtrlVal (p1h, P1_STHRUP, &thresholdUp);
247	runrec.thUp = thresholdUp*1000; // mV	247	runrec.thUp = thresholdUp*1000; // mV
248	GetCtrlVal (p1h, P1_STEP, &thresholdStep);	248	GetCtrlVal (p1h, P1_STEP, &thresholdStep);
249	runrec.thStep = thresholdStep*1000; // mV	249	runrec.thStep = thresholdStep*1000; // mV
250		250
251		251
252	#ifdef USE_DAQ	252	#ifdef USE_DAQ
253	V673A_map(0,CAEN_V673A,0);	253	V673A_map(0,CAEN_V673A,0);
254	V673A_init(0);	254	V673A_init(0);
255		255
256	V462_map(0,CAEN_V462,0);	256	V462_map(0,CAEN_V462,0);
257	V462_set0(0,1);	257	V462_set0(0,1);
258	#endif	258	#endif
259		259
260	//if (dsave) {	260	//if (dsave) {
261	sprintf(dfile,"%s_file%02d.dat",dfile0,fcount);	261	sprintf(dfile,"%s_file%02d.dat",dfile0,fcount);
262		262
263	fp = fopen (dfile, "wb");	263	fp = fopen (dfile, "wb");
264	time (&runrec.time);	264	time (&runrec.time);
265	status = fwrite (&runrec, 1, runrec.len, fp);	265	status = fwrite (&runrec, 1, runrec.len, fp);
266	//}	266	//}
267	if (supr0) {	267	if (supr0) {
268	fseed = runrec.time & 0x7fffffff;	268	fseed = runrec.time & 0x7fffffff;
269	Uniform (1, fseed, &fracg);	269	Uniform (1, fseed, &fracg);
270	}	270	}
271		271
272	thrrec.threshold = (unsigned long) ceil(thresholdLow*1000); // threshold in mV	272	thrrec.threshold = (unsigned long) ceil(thresholdLow*1000); // threshold in mV
273	while (thrrec.threshold <= thresholdUp*1000) {	273	while (thrrec.threshold <= thresholdUp*1000) {
274	SetDac(0, thrrec.threshold/1000.0);	274	SetDac(0, thrrec.threshold/1000.0);
275	SetCtrlVal(p1h, P1_STHRLOW, thrrec.threshold/1000.0);	275	SetCtrlVal(p1h, P1_STHRLOW, thrrec.threshold/1000.0);
276	//wait_loop(100000);	276	//wait_loop(100000);
277	status = fwrite(&thrrec, 1, thrrec.len, fp);	277	status = fwrite(&thrrec, 1, thrrec.len, fp);
278	if (print) printf("THRREC status %d len %d threshold %d\n", status, thrrec.len, thrrec.threshold);	278	if (print) printf("THRREC status %d len %d threshold %d\n", status, thrrec.len, thrrec.threshold);
279		279
280	for (posrec.ix=0; posrec.ix<runrec.nx; posrec.ix++) {	280	for (posrec.ix=0; posrec.ix<runrec.nx; posrec.ix++) {
281	posrec.xset = runrec.x0 + posrec.ix*runrec.dx;	281	posrec.xset = runrec.x0 + posrec.ix*runrec.dx;
282	#ifdef USE_MIKRO	282	#ifdef USE_MIKRO
283	//printf("MIKRO_MoveTo (1, x);%d\n",posrec.x);	283	//printf("MIKRO_MoveTo (1, x);%d\n",posrec.x);
284	do {	284	do {
285	MIKRO_MoveTo (MIKRO_X, posrec.xset);	285	MIKRO_MoveTo (MIKRO_X, posrec.xset);
286	MIKRO_GetPosition(MIKRO_X, &mikroX);	286	MIKRO_GetPosition(MIKRO_X, &mikroX);
287	} while (abs(posrec.xset - mikroX) > STEP_TOLERANCE);	287	} while (abs(posrec.xset - mikroX) > STEP_TOLERANCE);
288	//printf("->MIKRO_MoveTo (1, x);%d\n",posrec.xset);	288	//printf("->MIKRO_MoveTo (1, x);%d\n",posrec.xset);
289	#endif	289	#endif
290	//SetCtrlVal (p1h, P1_X, posrec.xset);	290	//SetCtrlVal (p1h, P1_X, posrec.xset);
291	posrec.xset = mikroX; // set the true value	291	posrec.xset = mikroX; // set the true value
292	SetCtrlVal(p1h, P1_X, mikroX);	292	SetCtrlVal(p1h, P1_X, mikroX);
293	SetCtrlVal (p1h, P1_IX, posrec.ix);	293	SetCtrlVal (p1h, P1_IX, posrec.ix);
294	for (posrec.iy=0; posrec.iy<runrec.ny; posrec.iy++) {	294	for (posrec.iy=0; posrec.iy<runrec.ny; posrec.iy++) {
295	posrec.yset = runrec.y0 + posrec.iy*runrec.dy;	295	posrec.yset = runrec.y0 + posrec.iy*runrec.dy;
296	#ifdef USE_MIKRO_Y	296	#ifdef USE_MIKRO_Y
297	//printf("MIKRO_MoveTo (2, y);%d\n",y);	297	//printf("MIKRO_MoveTo (2, y);%d\n",y);
298	do {	298	do {
299	MIKRO_MoveTo (MIKRO_Y, posrec.yset);	299	MIKRO_MoveTo (MIKRO_Y, posrec.yset);
300	MIKRO_GetPosition(MIKRO_Y, &mikroY);	300	MIKRO_GetPosition(MIKRO_Y, &mikroY);
301	} while (abs(posrec.yset - mikroY) > STEP_TOLERANCE);	301	} while (abs(posrec.yset - mikroY) > STEP_TOLERANCE);
302	//printf("->MIKRO_MoveTo (2, y);%d\n",posrec.yset);	302	//printf("->MIKRO_MoveTo (2, y);%d\n",posrec.yset);
303	#endif	303	#endif
304	//SetCtrlVal (p1h, P1_Y, posrec.yset);	304	//SetCtrlVal (p1h, P1_Y, posrec.yset);
305	posrec.yset = mikroY; // set the true value	305	posrec.yset = mikroY; // set the true value
306	SetCtrlVal (p1h, P1_Y, mikroY);	306	SetCtrlVal (p1h, P1_Y, mikroY);
307	SetCtrlVal (p1h, P1_IY, posrec.iy);	307	SetCtrlVal (p1h, P1_IY, posrec.iy);
308	//if (dsave) {	308	//if (dsave) {
309	if (fmax && (ftell(fp) > fmax)) {	309	if (fmax && (ftell(fp) > fmax)) {
310	fcount+=1;	310	fcount+=1;
311	sprintf(dfile,"%s_file%02d.dat",dfile0,fcount);	311	sprintf(dfile,"%s_file%02d.dat",dfile0,fcount);
312	fclose(fp);	312	fclose(fp);
313	fp = fopen (dfile, "wb");	313	fp = fopen (dfile, "wb");
314	}	314	}
315		315
316	time (&posrec.time);	316	time (&posrec.time);
317	status = fwrite (&posrec, 1, posrec.len, fp);	317	status = fwrite (&posrec, 1, posrec.len, fp);
318	if (print) printf("POSREC status %d len %d\n", status, posrec.len);	318	if (print) printf("POSREC status %d len %d\n", status, posrec.len);
319	//}	319	//}
320		320
321	// clear the plots	321	// clear the plots
322	for (j=0;j<NCH;j++) {	322	for (j=0;j<NCH;j++) {
323	for (i=0;i<MAXCH;i++){	323	for (i=0;i<MAXCH;i++){
324	dtdc[j][0][i]=0;	324	dtdc[j][0][i]=0;
325	dtdc[j][1][i]=0;	325	dtdc[j][1][i]=0;
326	}	326	}
327	}	327	}
328		328
329	evtrec.nev=1;	329	evtrec.nev=1;
330	//time(&t);	330	//time(&t);
331	//tstart=t;	331	//tstart=t;
332	if (print) printf("RUN START.\n");	332	if (print) printf("RUN START.\n");
333		333
334	do {	334	do {
335	unsigned long word[BSIZE];	335	unsigned long word[BSIZE];
336	count=0;	336	count=0;
337	ntics=0;	337	ntics=0;
338	if (print) printf("Event counter: %d\n", evtrec.nev);	338	if (print) printf("Event counter: %d\n", evtrec.nev);
339		339
340	//if (t!=told ) printf("%d in %2.2f min daq::event() %s\n",i, (double)(t-tstart)/60., ctime(&t));	340	//if (t!=told ) printf("%d in %2.2f min daq::event() %s\n",i, (double)(t-tstart)/60., ctime(&t));
341		341
342	#ifdef USE_DAQ	342	#ifdef USE_DAQ
343	#ifdef CAEN_V673A	343	#ifdef CAEN_V673A
344		344
345		345
346	V462_start0(0);	346	V462_start0(0);
347	//tmlnk (tout);	347	//tmlnk (tout);
348	do {	348	do {
349	ntrig = V673A_ntrig(0);	349	ntrig = V673A_ntrig(0);
350	} while (ntrig==0 &&(ntics<2));	350	} while (ntrig==0 &&(ntics<2));
351	//tmulk();	351	//tmulk();
352	//if (timer_out) {	352	//if (timer_out) {
353	// fprintf(stderr,"-----------------> V673a timeout !!!\n");	353	// fprintf(stderr,"-----------------> V673a timeout !!!\n");
354	// V673A_clallb(0);	354	// V673A_clallb(0);
355	// continue;	355	// continue;
356	//}	356	//}
357		357
358	if (ntics>=2) {	358	if (ntics>=2) {
359	fprintf(stderr,"-----------------> V673a timeout !!!\n");	359	fprintf(stderr,"-----------------> V673a timeout !!!\n");
360	printf("Timer tics %d\n", ntics);	360	printf("Timer tics %d\n", ntics);
361	ntics = 0;	361	ntics = 0;
362	evtrec.nev--;	362	evtrec.nev--;
363	V673A_clallb(0);	363	V673A_clallb(0);
364	continue;	364	continue;
365	}	365	}
366		366
367	if (ntrig>0){	367	if (ntrig>0){
368	// chip readout	368	// chip readout
369	for (chip=0;chip<2;chip++){	369	for (chip=0;chip<2;chip++){
370	if (chip) len = V673A_read1 (0, &word[count+2],maxn-count-2);	370	if (chip) len = V673A_read1 (0, &word[count+2],maxn-count-2);
371	else len = V673A_read0 (0, &word[count+2],maxn-count-2);	371	else len = V673A_read0 (0, &word[count+2],maxn-count-2);
372		372
373	if (len>16324){	373	if (len>16324){
374	if (print) printf("Length > 2048 per chip!\n");	374	if (print) printf("Length > 2048 per chip!\n");
375	chip=2;	375	chip=2;
376	V673A_clallb(0);	376	V673A_clallb(0);
377	evtrec.nev--;	377	evtrec.nev--;
378	continue;	378	continue;
379	}	379	}
380	pdata=&word[count+2];	380	pdata=&word[count+2];
381	for(i=0;i< len;i++){	381	for(i=0;i< len;i++){
382	tdcdata = pdata[i] & 0xFFFF ;	382	tdcdata = pdata[i] & 0xFFFF ;
383	edge_type = (pdata[i]>>16)&0x1 ;	383	edge_type = (pdata[i]>>16)&0x1 ;
384	overflow = (pdata[i]>>17)&0x1 ;	384	overflow = (pdata[i]>>17)&0x1 ;
385	tdc_num = (pdata[i]>>25)&0x1 ;	385	tdc_num = (pdata[i]>>25)&0x1 ;
386	channel = ((pdata[i]>>18)&0x1F) \|tdc_num<<5 ;	386	channel = ((pdata[i]>>18)&0x1F) \|tdc_num<<5 ;
387	ev_dat = (pdata[i]>>23)&0x1 ;	387	ev_dat = (pdata[i]>>23)&0x1 ;
388	last_dat = (pdata[i]>>30)&0x1 ;	388	last_dat = (pdata[i]>>30)&0x1 ;
389	nval_dat = (pdata[i]>>31)&0x1 ;	389	nval_dat = (pdata[i]>>31)&0x1 ;
390	if (ev_dat) {	390	if (ev_dat) {
391	if(print) printf("Event %d\n",tdcdata);	391	if(print) printf("Event %d\n",tdcdata);
392	} else {	392	} else {
393	dtdc[channel][edge_type][tdcdata]++;	393	dtdc[channel][edge_type][tdcdata]++;
394		394
395	if (print) printf	395	if (print) printf
396	("ch=%d edge=%d ev=%d data=%d last=%d nval=%d\n",channel, edge_type,ev_dat,tdcdata,last_dat,nval_dat);	396	("ch=%d edge=%d ev=%d data=%d last=%d nval=%d\n",channel, edge_type,ev_dat,tdcdata,last_dat,nval_dat);
397	}	397	}
398	}	398	}
399	if (count+2 < maxn) count+=module_header(0x140+chip,&word[count],len);	399	if (count+2 < maxn) count+=module_header(0x140+chip,&word[count],len);
400	}	400	}
401	if (print) printf("Received triggers: %d \n", ntrig);	401	if (print) printf("Received triggers: %d \n", ntrig);
402	} else {	402	} else {
403	if (ntrig==0) {	403	if (ntrig==0) {
404	fprintf(stderr,"-----------------> no trigger");	404	fprintf(stderr,"-----------------> no trigger");
405	break;	405	break;
406	} else {	406	} else {
407	if (print) fprintf(stderr,"-----------------> wrong number of triggers in chips V673a !!!\n");	407	if (print) fprintf(stderr,"-----------------> wrong number of triggers in chips V673a !!!\n");
408	}	408	}
409	V673A_clallb(0);	409	V673A_clallb(0);
410	evtrec.nev--;	410	evtrec.nev--;
411	continue;	411	continue;
412	}	412	}
413		413
414	V673A_clallb(0);	414	V673A_clallb(0);
415	#endif	415	#endif
416	#endif	416	#endif
417		417
418		418
419	GetCtrlVal(p1h, P1_ADCHLSAVE, &runrec.xy);	419	GetCtrlVal(p1h, P1_ADCHLSAVE, &runrec.xy);
420	evtrec.len = count*sizeof(unsigned long) + sizeof(evtrec);	420	evtrec.len = count*sizeof(unsigned long) + sizeof(evtrec);
421	if (print) printf("EVTREC.len = %d bytes.\n", evtrec.len);	421	if (print) printf("EVTREC.len = %d bytes.\n", evtrec.len);
422		422
423	status = fwrite (&evtrec, 1, sizeof(evtrec), fp);	423	status = fwrite (&evtrec, 1, sizeof(evtrec), fp);
424	status = fwrite (&word, 1, count*sizeof(unsigned long), fp);	424	status = fwrite (&word, 1, count*sizeof(unsigned long), fp);
425		425
426		426
427	if (!(evtrec.nev%1000)) SetCtrlVal (p1h, P1_CEVE, evtrec.nev);	427	if (!(evtrec.nev%1000)) SetCtrlVal (p1h, P1_CEVE, evtrec.nev);
428		428
429	if (!((evtrec.nev+1)%1000)) {	429	if (!((evtrec.nev+1)%1000)) {
430	if (fmax && (ftell(fp) > fmax)) {	430	if (fmax && (ftell(fp) > fmax)) {
431	time (&endrec.time);	431	time (&endrec.time);
432	status = fwrite (&endrec, 1, endrec.len, fp);	432	status = fwrite (&endrec, 1, endrec.len, fp);
433	fcount+=1;	433	fcount+=1;
434	sprintf(dfile,"%s_file%02d.dat",dfile0,fcount);	434	sprintf(dfile,"%s_file%02d.dat",dfile0,fcount);
435	fclose(fp);	435	fclose(fp);
436	fp = fopen (dfile, "wb");	436	fp = fopen (dfile, "wb");
437	}	437	}
438	}	438	}
439		439
440	if(step_minutes > 0) {	440	if(step_minutes > 0) {
441	GetSystemTime(&start_hours, &start_minutes, &start_seconds);	441	GetSystemTime(&start_hours, &start_minutes, &start_seconds);
442	//cur_time_s = start_hours3600 + start_minutes60 + start_seconds;	442	//cur_time_s = start_hours3600 + start_minutes60 + start_seconds;
443	time(&cur_time_s);	443	time(&cur_time_s);
444	if(cur_time_s >= end_time_s) {	444	if(cur_time_s >= end_time_s) {
445	end_time_s = cur_time_s + step_minutes*60;	445	end_time_s = cur_time_s + step_minutes*60;
446	printf("STEP (nev):%2d-%2d-%2d @ %d\n", start_hours, start_minutes, start_seconds, posrec.xset);	446	printf("STEP (nev):%2d-%2d-%2d @ %d\n", start_hours, start_minutes, start_seconds, posrec.xset);
447	break;	447	break;
448	}	448	}
449	}	449	}
450	//told=t;	450	//told=t;
451		451
452	GetCtrlVal(p1h, P1_DAQ, &daq_on);	452	GetCtrlVal(p1h, P1_DAQ, &daq_on);
453		453
454	} while (evtrec.nev++<runrec.nev && daq_on);	454	} while (evtrec.nev++<runrec.nev && daq_on);
455	if (!daq_on) break;	455	if (!daq_on) break;
456	} // x loop	456	} // x loop
457	if (!daq_on) break;	457	if (!daq_on) break;
458	} // y loop	458	} // y loop
459	if (!daq_on) break;	459	if (!daq_on) break;
460	thrrec.threshold += thresholdStep*1000;	460	thrrec.threshold += thresholdStep*1000;
461	} // threhsold loop	461	} // threhsold loop
462		462
463	//if (dsave) {	463	//if (dsave) {
464	time (&endrec.time);	464	time (&endrec.time);
465	status = fwrite (&endrec, 1, endrec.len, fp);	465	status = fwrite (&endrec, 1, endrec.len, fp);
466	if (print) printf("ENDREC status %d len %d\n", status, endrec.len);	466	if (print) printf("ENDREC status %d len %d\n", status, endrec.len);
467	fclose(fp);	467	fclose(fp);
468	//}	468	//}
469	GetSystemTime(&start_hours, &start_minutes, &start_seconds);	469	GetSystemTime(&start_hours, &start_minutes, &start_seconds);
470	printf("STOP:%2d-%2d-%2d (start_time = %u s, end_time = %u s)\n", start_hours, start_minutes, start_seconds, runrec.time, endrec.time);	470	printf("STOP:%2d-%2d-%2d (start_time = %u s, end_time = %u s)\n", start_hours, start_minutes, start_seconds, runrec.time, endrec.time);
471	printf("Elapsed time: %u s.\n", endrec.time-runrec.time);	471	printf("Elapsed time: %u s.\n", endrec.time-runrec.time);
472		472
473	daq_on=0;	473	daq_on=0;
474	SetCtrlVal (p1h, P1_DAQ, daq_on);	474	SetCtrlVal (p1h, P1_DAQ, daq_on);
475	SetCtrlVal (p1h, P1_CEVE, evtrec.nev);	475	SetCtrlVal (p1h, P1_CEVE, evtrec.nev);
476	if (print) printf("RUN END. \n\n");	476	if (print) printf("RUN END. \n\n");
477		477
478	return 0;	478	return 0;
479	}	479	}
480		480
481		481
482	int SetDac(int ch, double val){	482	int SetDac(int ch, double val){
483		483
484	const unsigned int maxdac=0xFFF;	484	const unsigned int maxdac=0xFFF;
485	const double RANGE = +9.9976; //V	485	const double RANGE = +9.9976; //V
486	unsigned int dac;	486	unsigned int dac;
487		487
488	if ((val > RANGE) \|\| (val < 0)) {	488	if ((val > RANGE) \|\| (val < 0)) {
489	printf("DAC value OUT OF RANGE!!!\n");	489	printf("DAC value OUT OF RANGE!!!\n");
490	return(-1);	490	return(-1);
491	}	491	}
492		492
493	dac = (val/RANGE)*maxdac;	493	dac = (val/RANGE)*maxdac;
494	CSSA_W(NDAC,ch,16,&dac);	494	CSSA_W(NDAC,ch,16,&dac);
495	printf("DAC ch %d set to %f V dac=%d\n", ch, val, dac);	495	printf("DAC ch %d set to %f V dac=%d\n", ch, val, dac);
496	return 0;	496	return 0;
497	}	497	}
498		498
499	int __stdcall WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,	499	int __stdcall WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
500	LPSTR lpszCmdLine, int nCmdShow)	500	LPSTR lpszCmdLine, int nCmdShow)

Subversion Repositories f9daq

(root)/sipmScan/src/sipmThreshold.c – Rev 32 → 37