Subversion Repositories f9daq

#include <formatio.h>

#include <cvirte.h>

#include <userint.h>

#include "AitGui.h"

#include "XYSCAN.h"

#include <stdbool.h>

#include "AitInterface.h"

#include "AitMduManager_DEF.h"

#include "H1D.h"

#include "H2D.h"

#include "H3D.h"

typedef unsigned short ushort;

typedef unsigned int uint;

static int ait;

static int xyscan;

//#define MIKRO

#ifdef MIKRO

#include "MIKRO.h"

#endif

static int daq_on;

static int plothandle[4]= {0,0,0, 0};

static int tfID;

static int controlID;

static int verbose;

#define MAX_THREADS 10

static CmtThreadPoolHandle poolHandle = 0;

/*

x: 140000 280000

*/

//**************************** missing declarations in the library

char strbuf[0xFF];

int gLog=0;

int printf(const char *format, ...) {

  va_list aptr;

  int ret;

  FILE *flog;

  va_start(aptr, format);

  ret = vsprintf(strbuf, format, aptr);

  va_end(aptr);

  SetCtrlVal(ait,AIT_STDIO,strbuf);

  if (gLog) {

    flog = fopen ("stdio.log", "a");

    fprintf (flog, "%s", strbuf);

    fclose (flog);

  }

  return(ret);

}

static int timeout=0;    

int CVICALLBACK SetTimeoutCB (int panel, int control, int event,

                                                                                                                        void *callbackData, int eventData1, int eventData2) {

        switch (event) {

                case EVENT_TIMER_TICK:

                        timeout=1;

                        printf("#### Timeout\n");

                        break;

        }

        return 0;

}

static void start_timer (double tout) {

        timeout = 0;

  SetCtrlAttribute (ait, AIT_TIMER, ATTR_INTERVAL, tout);

  SetCtrlAttribute (ait, AIT_TIMER, ATTR_ENABLED, 1);

}

static void stop_timer ( void ) {

  SetCtrlAttribute (ait, AIT_TIMER, ATTR_ENABLED, 0);

  //DRSSetTimeout();

}

void CVICALLBACK EndOfThread ( CmtThreadPoolHandle poolhandle,

                               CmtThreadFunctionID functionID, unsigned int event,

                               int value, void *callbackData  ) {

  daq_on=0;

  //SetDimming(0);

  printf("End of Thread \n");

  return ;

}

int AitInit() {

  InitializeConnection();

  return 0;

}

int AitValidEvent() {

  return 1;

};

int AitToFile(FILE *fp, int n) {

        const int bsize=10000 ;

        unsigned short a[bsize] ;

        unsigned short buffer[2]={0x1};

        buffer[1] = (unsigned short)(n*CHANNELS*2);  

        for (int eventNum = 0; eventNum < n; eventNum++) {

    for (int channel = 0; channel < CHANNELS; channel++) {

                        int index = channel+ CHANNELS * eventNum;

                        if (index<bsize)

        a[index] = ExtractAdcData(eventNum, channel);

                }

        }

        fwrite(buffer, 2*sizeof(short),1,fp);

        return fwrite(a, 1,buffer[1],fp);

};

int AitFillHistograms(int events) {

  ushort rawAdcData = 0;

  ushort adcData = 0;

  int channelReceived = 0;

  int channelExpected = 0;

  bool includeSaturated = 0; // cbIncludeSaturated.Checked;

  ushort max[CHANNELS];

  ushort min[CHANNELS];

  ushort average[CHANNELS];

  int  total[CHANNELS];

  for (int i = 0; i < CHANNELS; i++) {

    min[i] = 0xFFFF;

    max[i] = 0;

    total[i] = 0;

  }

  double threshold, xysumcut;

  GetCtrlVal (ait, AIT_ADCTHRESHOLD, &threshold);

  GetCtrlVal (ait, AIT_XYCUT, &xysumcut);

  for (int eventNum = 0; eventNum < events; eventNum++) {

    int sum = 0;

    double a[4]= {0,0,0,0} ;

    for (int channel = 0; channel < CHANNELS; channel++) {

      rawAdcData = ExtractAdcData(eventNum, channel);

      if (addChannelNum == true) {

        channelReceived = (rawAdcData >> 12) & 0xF;

        channelExpected = (channel & 0xF);

        if (channelReceived != channelExpected) {

          AddMessage("ERROR in Event %d : Expected channel %d, received %d -ANALYSIS STOPPED", eventNum, channelExpected, channelReceived);

          //EnableRegisterScanTimer(true);

          return eventNum;

        }

      }

      adcData = (ushort)(rawAdcData & 0x0FFF);    // remove channel number

      //if ((includeSaturated == true) || ((includeSaturated == false) && (adcData < (ADCMAX - 2))))

      if (adcData>threshold) H1D_Fill(channel, adcData,1);

      a[channel]=adcData;

      total[channel] = total[channel] + adcData;

      if (adcData > max[channel])

        max[channel] = adcData;

      else if (adcData < min[channel])

        min[channel] = adcData;

      sum += adcData;

    }

    if (sum>threshold) {

      H1D_Fill(10, sum, 1 );

      double x = a[0]/(a[0]+a[1]);

      double y = a[2]/(a[2]+a[3]);

      if (sum>xysumcut) H2D_Fill(0, x, y , 1 );

    }

    histogramTotalEvents++;

  }

  //tbAdcStatistics.Clear();

  for (int channel = 0; channel < CHANNELS; channel++) {

    average[channel] = (ushort)(total[channel] / events);

    if (verbose) AddMessage(" {channel:%d}  : {min:0x%d}  {max:0x%d}  {max-min:%d}  {average:%d}\n", channel + 1, min[channel], max[channel], max[channel] - min[channel], average[channel]);

    //if (channel < (CHANNELS - 1))

    //    tbAdcStatistics.AppendText(Environment.NewLine);

  }

  //SetTextboxToTop(tbAdcStatistics);

  return 1;

};

int CVICALLBACK RefreshGraphs (int panel, int control, int event,

                               void *callbackData, int eventData1, int eventData2) {

  switch (event) {

    case EVENT_TIMER_TICK:

//      if (!daq_on ) return 0;

    case EVENT_COMMIT: {

      int ch=0;

                        int logy=0;

                        int updateplots=0;

      GetCtrlVal(ait,AIT_CH, &ch);

                        GetCtrlVal(ait,AIT_LOGY, &logy);

                  GetCtrlVal(ait,AIT_UPDATEPLOTS, &updateplots);

                        if (!updateplots) return 0;

                        if (logy){

                                SetCtrlAttribute (ait, AIT_GRAPH, ATTR_YMAP_MODE, VAL_LOG);

                          SetCtrlAttribute (ait, AIT_GRAPHSUM, ATTR_YMAP_MODE, VAL_LOG);

                        } else {

                                SetCtrlAttribute (ait, AIT_GRAPH, ATTR_YMAP_MODE, VAL_LINEAR);

                          SetCtrlAttribute (ait, AIT_GRAPHSUM, ATTR_YMAP_MODE, VAL_LINEAR);

                        }

      H1D_Draw(ch,ait,AIT_GRAPH,&plothandle[0]);

      H1D_Draw(10,ait,AIT_GRAPHSUM,&plothandle[1]);

      H2D_Draw(0,ait,AIT_GRAPHXY,&plothandle[2]);

    }

    break;

  }

  return 0;

}

int CVICALLBACK daq(void *functionData) {

  int neve;

  char filename[0xff];

        char fname[0xff];  

        char pname[0xff];

  int pfreq;

  int enabledoutput;

  int neveold = 0;

  double rate;

  int *args =  (int *) functionData;

  GetCtrlVal(ait, AIT_FILENAME, fname );

        GetCtrlVal(ait, AIT_PATHNAME, pname );

        sprintf(filename,"%s/%s", pname, fname);

  GetCtrlVal(ait,AIT_NEVE, &neve);

  GetCtrlVal(ait,AIT_DEBUG, &verbose);

  GetCtrlVal(ait,AIT_PFREQ, &pfreq);

  GetCtrlVal(ait,AIT_ENABLEDOUTPUT, &enabledoutput);

        int range=0;

        int nch = range;

        GetCtrlVal(ait,AIT_MAX, &range);  

        if (range>512) nch = 512;

  for (int i=0; i<4; i++) {

    char name[0xFF];

    sprintf(name,"adc%d", i);

    H1D_Init(i, name,name, range, 0 , range);

    H1D_SetTitleX(0,"ADC");

    H1D_SetTitleY(0,"N");

  }

  H1D_Init(10, "adcsum","adcsum", range, 0 , 4*range);

  H1D_SetTitleX(0,"ADC");

  H1D_SetTitleY(0,"N");

  H2D_Init(0, "cog","Center of gravity", 256, 0 ,1, 256, 0 ,1);

  H2D_SetTitleX(0,"x");

  H2D_SetTitleY(0,"y");

  FILE *fp= NULL;

  if (enabledoutput) {

    if (args[0]) fp =  fopen(filename,"wb");

    else         fp =  fopen(filename,"ab");

  }

  time_t t=0,told=0, tstart=0;

  if (!AitInit()) {

                ReadRegisters();

      // Update UI

      int csrDetector = ReadSD4Register(ADDR_CSR_DETECTOR);

      int  value = ((GetBit(csrDetector, BIT_CSR_DET_ADCGAIN2) ? 1 : 0) << 1) |

                   ((GetBit(csrDetector, BIT_CSR_DET_ADCGAIN1) ? 1 : 0) << 0);

      SetCtrlVal (ait, AIT_GETADCGAIN, value);

      double valued = GetThreshold();

      SetCtrlVal (ait, AIT_GETADCTHRESHOLD, valued);

      valued = GetIntegrationTime();

      SetCtrlVal (ait, AIT_GETADCINTEGRATIONTIME, valued);

      valued = GetHvVoltage(ADDR_HV_VMON);

      SetCtrlVal (ait, AIT_BIASMON, valued);

                        value =

                        ((GetBit(csrDetector, BIT_CSR_DET_SUMGAIN4) ? 1 : 0) << 3) |

                        ((GetBit(csrDetector, BIT_CSR_DET_SUMGAIN3) ? 1 : 0) << 2) |

                        ((GetBit(csrDetector, BIT_CSR_DET_SUMGAIN2) ? 1 : 0) << 1) |

                        ((GetBit(csrDetector, BIT_CSR_DET_SUMGAIN1) ? 1 : 0) << 0);

      SetCtrlVal (ait, AIT_GETADCSUMGAIN, value);

    RefreshGraphs (ait, 0 , EVENT_COMMIT ,NULL, 0, 0 );

    daq_on=1;

                //RefreshGraphs (ait, 0 , EVENT_TIMER_TICK ,NULL, 0, 0 );    

    time(&tstart);

    told=tstart;

    int i=0;

    for (i=0; i<neve; i++) {

      start_timer(1);// 1 s timeout

      // Set ADC reset

      ResetAdc(true);

      // Clear ADC reset

      ResetAdc(false);

      int eventsAcquired = Acquire(pfreq);

                        stop_timer();

                        if (!daq_on) break;

                        if (timeout) {

                           i--;

                                 printf("INFO Timeout\n");

                                 continue;

                        }

      int isvalid =1;

      if (eventsAcquired < 1) {

        printf("Acquired events %d\n", eventsAcquired);

        isvalid = 0;

      } else {

        AitFillHistograms(eventsAcquired);

        if (verbose) ShowEvent(1);

      }

      int nb =  ( isvalid && fp ) ? AitToFile( fp , pfreq ) : 0;

      SetCtrlVal(ait,AIT_CEVE,i);

      if (!isvalid) i--;

      time(&t);

      if (t!=told ) {

        rate =  (i-neveold);

        printf("%d events in %2.2f min (%d s) Rate %f Hz %s   ",i+1, (double)(t-tstart)/60.,(t-tstart), rate , ctime(&t));

        neveold = i;

                                RefreshGraphs (ait, 0 , EVENT_COMMIT ,NULL, 0, 0 );  

        double daqBlocksize = GetAdcEventSize() * pfreq * 2.0;

        double daqTimeMs = BlockTransferTime();

        double daqTransferRate = daqBlocksize / daqTimeMs;

        SetCtrlVal(ait,AIT_DAQBLOCKSIZE, daqBlocksize);

        SetCtrlVal(ait,AIT_DAQTIMEMS,daqTimeMs);

        SetCtrlVal(ait,AIT_DAQTRANSFERRATE,daqTransferRate);

      }

      told=t;

    }

    time(&t);

    printf("%d events in %2.2f min (%d s) %s",i+1, (double)(t-tstart)/60.,t-tstart, ctime(&t));

  }

  if (fp) fclose(fp);

        RefreshGraphs (ait, 0 , EVENT_TIMER_TICK ,NULL, 0, 0 );

  return 0;

}

int CVICALLBACK scan(void *functionData) {

        int dx[3]={0,0,0};

        int nx[3]={0,0,0};

        int x0[3]={0,0,0};

        int ix[3]={0,0,0};

        int idx[3]={0,0,0};  

        unsigned short size;

        unsigned short posrec={0x2};   

        unsigned short runbuf={0x3};

        int  n[3];

        char filename[0xFF];

        char fname[0xff];  

        char pname[0xff];

        int enabledoutput;

        FILE *fp;

        GetCtrlVal(ait, AIT_FILENAME, fname );

        GetCtrlVal(ait, AIT_PATHNAME, pname );

        sprintf(filename,"%s/%s", pname, fname);

        GetCtrlVal(ait,AIT_ENABLEDOUTPUT, &enabledoutput);

        int fsize;

        if ( GetFileInfo(filename,&fsize) ) {

                 MessagePopup ("Warning", "File exist. Remove it first or choose another file");

           return 0;

        }        

        GetCtrlVal(xyscan, SCAN_STEPX, &dx[0]);

        GetCtrlVal(xyscan, SCAN_STEPY, &dx[1]);

        GetCtrlVal(xyscan, SCAN_NSTEPSX, &nx[0]);

        GetCtrlVal(xyscan, SCAN_NSTEPSY, &nx[1]);

        GetCtrlVal(xyscan, SCAN_STARTX, &x0[0]);

        GetCtrlVal(xyscan, SCAN_STARTY, &x0[1]);

        if (enabledoutput) {

                                fp =  fopen(filename,"ab");

                                if (fp) {

                                         size=36;

                                         fwrite(&runbuf, sizeof(unsigned short),1 ,fp);

                                         fwrite(&size  , sizeof(unsigned short),1 ,fp);

                                         fwrite(x0    , 1,4*3 ,fp);

                                         fwrite(dx    , 1,4*3 ,fp);

                                         fwrite(nx    , 1,4*3 ,fp);

                                         fclose(fp);

                                }    

        }      

  for (int j=0; j<nx[1]; j++) {

         SetCtrlVal (xyscan, SCAN_IY, j);

         ix[1]= x0[1]+j*dx[1];

#ifdef MIKRO

                MIKRO_MoveTo(2,ix[1]);

                MIKRO_GetPosition(2,&n[1]);

                        SetCtrlVal (xyscan, SCAN_YP, n[1]);

#endif          

         for (int i=0; i<nx[0]; i++) {

                SetCtrlVal (xyscan, SCAN_IX, i);  

                ix[0]= x0[0]+i*dx[0];

#ifdef MIKRO

                  MIKRO_MoveTo(1,ix[0]);

                        MIKRO_GetPosition(1,&n[0]);

                        SetCtrlVal (xyscan, SCAN_XP, n[0]);

                        if (enabledoutput) {

                                fp =  fopen(filename,"ab");

                                if (fp) {

                                         time_t mtime;

                                         idx[0]=i;

                                         idx[1]=j;

                                         size=24+sizeof(mtime);

                                         fwrite(&posrec, sizeof(unsigned short),1 ,fp);

                                         fwrite(&size  , sizeof(unsigned short),1 ,fp);

                                         fwrite(n     , 1,4*3 ,fp);

                                         fwrite(idx    , 1,4*3 ,fp);

                                         time(&mtime);  

                                         fwrite(&mtime  , sizeof(time_t),1 ,fp);

                                         fclose(fp);

                                }    

                        }      

#endif

                        int newfile=0;

                        daq(&newfile);

                        if (!daq_on) break;

                }

                if (!daq_on) break;

        }

        return 0;

}

int main (int argc, char *argv[]) {

        short port;

  if (InitCVIRTE (0, argv, 0) == 0)

    return -1;  /* out of memory */

  if ((ait = LoadPanel (0, "AitGui.uir", AIT)) < 0)

    return -1;

  if ((xyscan = LoadPanel (0, "XYSCAN.uir", SCAN)) < 0)

    return -1;

  SetStdioPort (CVI_STDIO_WINDOW);

  SetSleepPolicy(VAL_SLEEP_MORE);

  CmtNewThreadPool (MAX_THREADS,  &poolHandle);

  DisplayPanel (ait);

  DisplayPanel (xyscan);

  AitInit();

#ifdef MIKRO

        GetCtrlVal(xyscan, SCAN_PORT, &port);

        if (MIKRO_Open (port)) MessagePopup ("Error", "Mikro Port Not found !\n Change in the GUI") ;

        MIKRO_Init(1,0);

        MIKRO_Init(2,0);

#endif

  RunUserInterface ();

#ifdef MIKRO    

        MIKRO_Close ();

#endif          

  DiscardPanel (ait);

  DiscardPanel (xyscan);

  return 0;

}

int CVICALLBACK StopCB (int panel, int control, int event,

                        void *callbackData, int eventData1, int eventData2) {

  switch (event) {

    case EVENT_COMMIT:

      daq_on=0;

      break;

  }

  return 0;

}

int CVICALLBACK StartCB (int panel, int control, int event,

                         void *callbackData, int eventData1, int eventData2) {

  ThreadFunctionPtr mythread = NULL;

  switch (event) {

    case EVENT_COMMIT:

      controlID= control;

      if (panel == ait && control == AIT_START) {

        mythread = daq;

      }

                        if (panel == xyscan && control == SCAN_SCAN)   mythread = scan;  

      if (mythread!=NULL) {

        printf("New Thread panel=%d button=%d\n", panel, control);

        // SetDimming(1);

        CmtScheduleThreadPoolFunctionAdv (poolHandle, mythread, &controlID,

                                          DEFAULT_THREAD_PRIORITY,

                                          EndOfThread,

                                          EVENT_TP_THREAD_FUNCTION_END,

                                          NULL, RUN_IN_SCHEDULED_THREAD,

                                          &tfID);

      }

      break;

  }

  return 0;

}

int CVICALLBACK ExitCB (int panel, int control, int event,

                        void *callbackData, int eventData1, int eventData2) {

  switch (event) {

    case EVENT_COMMIT:

      QuitUserInterface (0);

      break;

  }

  return 0;

}

int CVICALLBACK ReadCB (int panel, int control, int event,

                        void *callbackData, int eventData1, int eventData2) {

  switch (event) {

    case EVENT_COMMIT:

      ReadRegisters();

      break;

  }

  return 0;

}

int CVICALLBACK ChangeChannelCB (int panel, int control, int event,

                                 void *callbackData, int eventData1, int eventData2) {

  int ch=0;

  switch (event) {

    case EVENT_COMMIT:

      int logy=0;

      GetCtrlVal(ait,AIT_CH, &ch);

                        GetCtrlVal(ait,AIT_LOGY, &logy);

                        if (logy){

                                SetCtrlAttribute (ait, AIT_GRAPH, ATTR_YMAP_MODE, VAL_LOG);

                          SetCtrlAttribute (ait, AIT_GRAPHSUM, ATTR_YMAP_MODE, VAL_LOG);

                        } else {

                                SetCtrlAttribute (ait, AIT_GRAPH, ATTR_YMAP_MODE, VAL_LINEAR);

                          SetCtrlAttribute (ait, AIT_GRAPHSUM, ATTR_YMAP_MODE, VAL_LINEAR);

                        }

      H1D_Draw(ch,ait,AIT_GRAPH,&plothandle[0]);

      break;

  }

  return 0;

}

int CVICALLBACK InitCB (int panel, int control, int event,

                        void *callbackData, int eventData1, int eventData2) {

  switch (event) {

    case EVENT_COMMIT:

      AitInit();

      break;

  }

  return 0;

}

int CVICALLBACK QuickCB (int panel, int control, int event,

                         void *callbackData, int eventData1, int eventData2) {

  switch (event) {

    case EVENT_COMMIT:

      switch (control) {

        case AIT_QUICKSETUP_1:

          QuickSetupContinuous();

                                        SetCtrlVal(ait,AIT_TRGTYPE, 0);

          break;

        case AIT_QUICKSETUP_2:

          QuickSetupDiscriminator();

                                        SetCtrlVal(ait,AIT_TRGTYPE, 2);

          break;

        case AIT_QUICKSETUP_3:

          QuickSetupTriggerOff();

                            break;

      }

                        float bias = GetHvVoltage(ADDR_HV_VMON);

      SetCtrlVal (panel, AIT_BIASMON, bias);

                        double  value = GetIntegrationTime();

      SetCtrlVal (panel, AIT_GETADCINTEGRATIONTIME, value);

                        value = GetThreshold();

      SetCtrlVal (panel, AIT_GETADCTHRESHOLD, value);

                        int csrDetector = ReadSD4Register(ADDR_CSR_DETECTOR);

      int ivalue = ((GetBit(csrDetector, BIT_CSR_DET_ADCGAIN2) ? 1 : 0) << 1) |

              ((GetBit(csrDetector, BIT_CSR_DET_ADCGAIN1) ? 1 : 0) << 0);

      SetCtrlVal (panel, AIT_GETADCGAIN, ivalue);

                        ivalue =

                        ((GetBit(csrDetector, BIT_CSR_DET_SUMGAIN4) ? 1 : 0) << 3) |

                        ((GetBit(csrDetector, BIT_CSR_DET_SUMGAIN3) ? 1 : 0) << 2) |

                        ((GetBit(csrDetector, BIT_CSR_DET_SUMGAIN2) ? 1 : 0) << 1) |

                        ((GetBit(csrDetector, BIT_CSR_DET_SUMGAIN1) ? 1 : 0) << 0);

      SetCtrlVal (panel, AIT_GETADCSUMGAIN, ivalue);

      break;

  }

  return 0;

}

int CVICALLBACK MoveStageCB (int panel, int control, int event,

                             void *callbackData, int eventData1, int eventData2) {

  int axis=0, step=1000, direction=1;

  switch (event) {

    case EVENT_COMMIT:

      if (panel == xyscan) {

        switch (control) {

          case SCAN_BR :

            axis = 1;

            direction = 1;

            GetCtrlVal(panel, SCAN_STEPX, &step);

            break;

          case SCAN_BL :

            axis = 1;

            direction = -1;

            GetCtrlVal(panel, SCAN_STEPX, &step);

            break;

          case SCAN_BU :

            axis = 2;

            direction = 1;

            GetCtrlVal(panel, SCAN_STEPY, &step);

            break;

          case SCAN_BD :

            axis = 2;

            direction = -1;

            GetCtrlVal(panel, SCAN_STEPY, &step);

            break;

        }

#ifdef MIKRO

        {

          int n=0;

          MIKRO_MoveFor(axis,  direction*step );

          MIKRO_GetPosition(axis,&n);

          if (axis == 1) SetCtrlVal (panel, SCAN_XP, n);

          if (axis == 2) SetCtrlVal (panel, SCAN_YP, n);

        }

#endif // MIKRO         

      }