Subversion Repositories f9daq

Rev

Rev 262 | Rev 322 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | RSS feed

  1. #include "redpitaya_gui.h"
  2. #include <ansi_c.h>
  3. #include <tcpsupp.h>
  4. #include <utility.h>
  5. #include <cvirte.h>
  6. #include <userint.h>
  7. #include "redpitaya_gui.h"
  8.  
  9. #include "H1D.h"
  10.  
  11.  
  12. #define NBEFORE 150
  13. #define MAXSAMPLES 16384
  14. #define MINTRGDELAY -8192
  15.  
  16.  
  17. static int panelHandle;
  18.  
  19. static unsigned int chandle = 0;
  20. //static int tfID;
  21. int pfreq;
  22. static int plothandle[2]= {0,0};
  23. static int tdcplothandle[2]= {0,0};
  24. static int adcplothandle[2]= {0,0};
  25. static int excludefirst[2]= {0,0};
  26. int debug ;
  27. int initialized = 0;
  28. #define MAX_THREADS 10
  29. int nsamples=0;
  30. int adctype;
  31. float athreshold, twin0,twin1;
  32. float timebins[0XFFFF];
  33. float daqtime;
  34. double starttime;
  35.  
  36. FILE *foutput;
  37. int outwaveforms=0;
  38.  
  39. static CmtThreadPoolHandle poolHandle = 0;
  40. int ctrl_c=0;
  41.  
  42.  
  43. int CVICALLBACK SocketCB (unsigned handle, int xType, int errCode, void *callbackData);
  44.  
  45.  
  46.  
  47. static int export_data (int hid) {
  48.  
  49.   char filename[0xFF],rootcmd[0xFF];
  50.   char fname[0xFF];
  51.   int type=0;
  52.  
  53.   GetCtrlVal(panelHandle,PANEL_EXPORTNAME,fname);
  54.   GetCtrlVal(panelHandle,PANEL_FILETYPE,&type);
  55.  
  56.   FILE *fp;
  57.  
  58.   switch (type) {
  59.     case 0:
  60.     case 1:
  61.       sprintf(filename,"%s_%d.root",fname, hid);
  62.       fp  =fopen(filename,"wb");
  63.       if (fp) {
  64.         H1D_Write2File(hid,fp);
  65.         fclose(fp);
  66.         if (type) {
  67.           sprintf(rootcmd ,"thisroot.bat && root.exe H1Dload.cxx(\\\"%s\\\")", filename);
  68.           LaunchExecutable(rootcmd);
  69.  
  70.         }
  71.         printf("Histogram %d exported to %s\n", hid, filename);
  72.       }
  73.       break;
  74.     case 2:
  75.       sprintf(filename,"%s_%d.txt",fname, hid);
  76.       fp=fopen(filename,"w");
  77.       if (fp) {
  78.         for (int i=0; i<H1D_GetNbinsX(hid); i++) fprintf(fp,"%g\t%g\n", H1D_GetXBinCenter(hid,i), H1D_GetBinContent(hid,i) );
  79.         fclose(fp);
  80.         printf("Histogram %d exported to %s\n", hid, filename);
  81.       }
  82.  
  83.       break;
  84.  
  85.   }
  86.  
  87.  
  88.   return (0);
  89. }
  90.  
  91.  
  92. int main (int argc, char *argv[]) {
  93.   if (InitCVIRTE (0, argv, 0) == 0)
  94.     return -1;  /* out of memory */
  95.   if ((panelHandle = LoadPanel (0, "redpitaya_gui.uir", PANEL)) < 0)
  96.     return -1;
  97.  
  98.  
  99.   SetStdioPort (CVI_STDIO_WINDOW);
  100.   SetSleepPolicy(VAL_SLEEP_MORE);
  101.   CmtNewThreadPool (MAX_THREADS,  &poolHandle);
  102.  
  103.  
  104.   //printf("size of double = %d\n",sizeof(double));
  105.   DisplayPanel (panelHandle);
  106.   RunUserInterface ();
  107.   DiscardPanel (panelHandle);
  108.   CmtDiscardThreadPool (poolHandle);
  109.   if (chandle!=0) DisconnectFromTCPServer (chandle);
  110.   return 0;
  111. }
  112.  
  113. char strbuf[0xFF];
  114.  
  115. int gLog=0;
  116.  
  117. int printf(const char *format, ...) {
  118.   va_list aptr;
  119.   int ret;
  120.   FILE *flog;
  121.  
  122.   va_start(aptr, format);
  123.   ret = vsprintf(strbuf, format, aptr);
  124.   va_end(aptr);
  125.   SetCtrlVal(panelHandle,PANEL_STDIO,strbuf);
  126.  
  127.   if (gLog) {
  128.     flog = fopen ("stdio.log", "a");
  129.     fprintf (flog, "%s", strbuf);
  130.     fclose (flog);
  131.   }
  132.   return(ret);
  133. }
  134.  
  135.  
  136. int CVICALLBACK SetGraphLogYCB (int panel, int control, int event,
  137.                                 void *callbackData, int eventData1, int eventData2) {
  138.  
  139.   int cid=0;
  140.   int logy=0;
  141.   switch (event) {
  142.     case EVENT_COMMIT:
  143.       GetCtrlVal(panel,control, &logy);
  144.       switch (control) {
  145.         case PANEL_LOGY_1:
  146.           cid = PANEL_TDC1;
  147.           break;
  148.         case PANEL_LOGY_2:
  149.           cid = PANEL_ADC1;
  150.           break;
  151.         case PANEL_LOGY_3:
  152.           cid = PANEL_TDC2;
  153.           break;
  154.         case PANEL_LOGY_4:
  155.           cid = PANEL_ADC2;
  156.           break;
  157.       }
  158.       if (logy) SetCtrlAttribute (panel, cid, ATTR_YMAP_MODE, VAL_LOG);
  159.       else    SetCtrlAttribute (panel, cid, ATTR_YMAP_MODE, VAL_LINEAR);
  160.       break;
  161.   }
  162.   return 0;
  163. }
  164.  
  165. int CVICALLBACK SetGraphPropertiesCB (int panel, int control, int event,
  166.                                       void *callbackData, int eventData1, int eventData2) {
  167.  
  168.   float min, max;
  169.   int autoscale;
  170.   switch (event) {
  171.     case EVENT_COMMIT:
  172.       GetCtrlVal(panelHandle,PANEL_MINX_5, &min);
  173.       GetCtrlVal(panelHandle,PANEL_MAXX_5, &max);
  174.       GetCtrlVal(panelHandle,PANEL_AUTOY, &autoscale);
  175.       if (autoscale)
  176.         SetAxisScalingMode (panelHandle, PANEL_GRAPH, VAL_LEFT_YAXIS, VAL_AUTOSCALE, min, max);
  177.       else
  178.         SetAxisScalingMode (panelHandle, PANEL_GRAPH, VAL_LEFT_YAXIS, VAL_MANUAL, min, max);
  179.  
  180.       GetCtrlVal(panelHandle,PANEL_MINX_6, &min);
  181.       GetCtrlVal(panelHandle,PANEL_MAXX_6, &max);
  182.       GetCtrlVal(panelHandle,PANEL_AUTOX, &autoscale);
  183.       if (autoscale)
  184.         SetAxisScalingMode (panelHandle, PANEL_GRAPH, VAL_BOTTOM_XAXIS, VAL_AUTOSCALE, min, max);
  185.       else
  186.         SetAxisScalingMode (panelHandle, PANEL_GRAPH, VAL_BOTTOM_XAXIS, VAL_MANUAL, min, max);
  187.  
  188.  
  189.       GetCtrlVal(panelHandle,PANEL_MINX_7, &min);
  190.       GetCtrlVal(panelHandle,PANEL_MAXX_7, &max);
  191.       GetCtrlVal(panelHandle,PANEL_AUTOY_2, &autoscale);
  192.       if (autoscale)
  193.         SetAxisScalingMode (panelHandle, PANEL_TDC1, VAL_LEFT_YAXIS, VAL_AUTOSCALE, min, max);
  194.       else
  195.         SetAxisScalingMode (panelHandle, PANEL_TDC1, VAL_LEFT_YAXIS, VAL_MANUAL, min, max);
  196.  
  197.       GetCtrlVal(panelHandle,PANEL_MINX_8, &min);
  198.       GetCtrlVal(panelHandle,PANEL_MAXX_8, &max);
  199.       GetCtrlVal(panelHandle,PANEL_AUTOY_3, &autoscale);
  200.       if (autoscale)
  201.         SetAxisScalingMode (panelHandle, PANEL_ADC1, VAL_LEFT_YAXIS, VAL_AUTOSCALE, min, max);
  202.       else
  203.         SetAxisScalingMode (panelHandle, PANEL_ADC1, VAL_LEFT_YAXIS, VAL_MANUAL, min, max);
  204.  
  205.       GetCtrlVal(panelHandle,PANEL_MINX_9, &min);
  206.       GetCtrlVal(panelHandle,PANEL_MAXX_9, &max);
  207.       GetCtrlVal(panelHandle,PANEL_AUTOY_4, &autoscale);
  208.       if (autoscale)
  209.         SetAxisScalingMode (panelHandle, PANEL_TDC2, VAL_LEFT_YAXIS, VAL_AUTOSCALE, min, max);
  210.       else
  211.         SetAxisScalingMode (panelHandle, PANEL_TDC2, VAL_LEFT_YAXIS, VAL_MANUAL, min, max);
  212.  
  213.       GetCtrlVal(panelHandle,PANEL_MINX_10, &min);
  214.       GetCtrlVal(panelHandle,PANEL_MAXX_10, &max);
  215.       GetCtrlVal(panelHandle,PANEL_AUTOY_5, &autoscale);
  216.       if (autoscale)
  217.         SetAxisScalingMode (panelHandle, PANEL_ADC2, VAL_LEFT_YAXIS, VAL_AUTOSCALE, min, max);
  218.       else
  219.         SetAxisScalingMode (panelHandle, PANEL_ADC2, VAL_LEFT_YAXIS, VAL_MANUAL, min, max);
  220.  
  221.  
  222.  
  223.       break;
  224.   }
  225.   return 0;
  226. }
  227.  
  228.  
  229. int histoinit() {
  230.   int nch;
  231.   float min,max;
  232.  
  233.   GetCtrlVal(panelHandle,PANEL_NCH_1, &nch);
  234.   GetCtrlVal(panelHandle,PANEL_MINX_1, &min);
  235.   GetCtrlVal(panelHandle,PANEL_MAXX_1, &max);
  236.  
  237.   H1D_Init(1, "ADC ch 1","Pulse height", nch, min, max );
  238.   H1D_SetTitleX(1,"ADC (V)");
  239.   H1D_SetTitleY(1,"N");
  240.  
  241.   GetCtrlVal(panelHandle,PANEL_NCH_2, &nch);
  242.   GetCtrlVal(panelHandle,PANEL_MINX_2, &min);
  243.   GetCtrlVal(panelHandle,PANEL_MAXX_2, &max);
  244.  
  245.   H1D_Init(2, "ADC ch 2","Pulse height", nch, min, max );
  246.   H1D_SetTitleX(2,"ADC (V)");
  247.   H1D_SetTitleY(2,"N");
  248.  
  249.   GetCtrlVal(panelHandle,PANEL_NCH_3, &nch);
  250.   GetCtrlVal(panelHandle,PANEL_MINX_3, &min);
  251.   GetCtrlVal(panelHandle,PANEL_MAXX_3, &max);
  252.  
  253.   H1D_Init(3, "TDC ch 1","TDC", nch, min, max  );
  254.   H1D_SetTitleX(3,"TDC (us)");
  255.   H1D_SetTitleY(3,"N");
  256.  
  257.   GetCtrlVal(panelHandle,PANEL_NCH_4, &nch);
  258.   GetCtrlVal(panelHandle,PANEL_MINX_4, &min);
  259.   GetCtrlVal(panelHandle,PANEL_MAXX_4, &max);
  260.  
  261.   H1D_Init(4, "TDC ch 2","TDC", nch, min, max   );
  262.   H1D_SetTitleX(4,"TDC (us)");
  263.   H1D_SetTitleY(4,"N");
  264.  
  265.   SetCtrlAttribute  (panelHandle, PANEL_ADC1, ATTR_XNAME, H1D_GetTitleX(1) );
  266.   SetCtrlAttribute  (panelHandle, PANEL_ADC1, ATTR_YNAME, H1D_GetTitleY(1) );
  267.   SetCtrlAttribute  (panelHandle, PANEL_ADC2, ATTR_XNAME, H1D_GetTitleX(2) );
  268.   SetCtrlAttribute  (panelHandle, PANEL_ADC2, ATTR_YNAME, H1D_GetTitleY(2) );
  269.  
  270.   SetCtrlAttribute  (panelHandle, PANEL_TDC1, ATTR_XNAME, H1D_GetTitleX(3) );
  271.   SetCtrlAttribute  (panelHandle, PANEL_TDC1, ATTR_YNAME, H1D_GetTitleY(3) );
  272.   SetCtrlAttribute  (panelHandle, PANEL_TDC2, ATTR_XNAME, H1D_GetTitleX(4) );
  273.   SetCtrlAttribute  (panelHandle, PANEL_TDC2, ATTR_YNAME, H1D_GetTitleY(4) );
  274.   SetGraphLogYCB( panelHandle, PANEL_LOGY_1,  EVENT_COMMIT,NULL,0,0);
  275.   SetGraphLogYCB( panelHandle, PANEL_LOGY_2,  EVENT_COMMIT,NULL,0,0);
  276.   SetGraphLogYCB( panelHandle, PANEL_LOGY_3,  EVENT_COMMIT,NULL,0,0);
  277.   SetGraphLogYCB( panelHandle, PANEL_LOGY_4,  EVENT_COMMIT,NULL,0,0);
  278.  
  279.   SetGraphPropertiesCB( panelHandle, PANEL, EVENT_COMMIT,NULL,0,0);
  280.  
  281.   SetCtrlAttribute  (panelHandle, PANEL_GRAPH, ATTR_LABEL_TEXT , "sampling adc data");
  282.   SetCtrlAttribute  (panelHandle, PANEL_GRAPH, ATTR_XNAME, "t(us)" );
  283.   SetCtrlAttribute  (panelHandle, PANEL_GRAPH, ATTR_YNAME, "U(V)" );
  284.  
  285.   GetCtrlVal(panelHandle,PANEL_TWIN0, &twin0);
  286.   GetCtrlVal(panelHandle,PANEL_TWIN1, &twin1);
  287.   GetCtrlVal(panelHandle,PANEL_ADCTYPE, &adctype);
  288.   GetCtrlVal(panelHandle,PANEL_ITRGLEVEL  , &athreshold);
  289.   return 0;
  290. }
  291.  
  292. int analyse(int nb, unsigned char *cdata, int *info, int *ninfo) {
  293.  
  294.   int   *ibuf = (int *)cdata;
  295.   float *fbuf = (float *)cdata;
  296.   float *finfo = (float *)info;
  297.   int neve=0;
  298.   int *data = (ibuf+3);
  299.   int nr=0;
  300.   static float adc = 10000;
  301.   static float qdc = 0;
  302.   *ninfo = 0;
  303.   printf("Run HDR LEN=%d NEVE=%d dt=%f adc=%f qdc=%f\n", ibuf[0],ibuf[1],fbuf[2],adc,qdc);
  304.   daqtime += fbuf[2];
  305.  
  306.   SetCtrlVal(panelHandle, PANEL_CDAQTIME,daqtime);
  307.   SetCtrlVal(panelHandle, PANEL_CTIME, Timer() -starttime);
  308.   daqtime  =0;
  309.   while (nr<nb) {
  310.  
  311.     int recid   = *data++;
  312.     int chmask  = *data++;
  313.     nr +=8;
  314.     if (recid!=0x2) continue;
  315.     for (int id=0; id<2; id++) {
  316.       if ( !(chmask & (1 << id)) ) {
  317.         if (neve % pfreq == 0)
  318.           if (plothandle[id]) {
  319.             DeleteGraphPlot (panelHandle, PANEL_GRAPH, plothandle[id], VAL_IMMEDIATE_DRAW);
  320.             plothandle[id] = 0;
  321.           }
  322.         continue;
  323.       }
  324.       if ( id != *(data++) ) printf("Error\n");
  325.  
  326.       int nsamples = *(data++);
  327.       if (nsamples<=0 || nsamples>16*1024) {
  328.         printf("Error nsamples %d\n", nsamples);
  329.         return -1;
  330.       }
  331.       float *fdata = (float *) data;
  332.       if ( nsamples>0  && neve % pfreq == 0) {
  333.         const int col[4]= {VAL_RED,VAL_GREEN,VAL_BLUE,VAL_WHITE};
  334.         if (plothandle[id]) DeleteGraphPlot (panelHandle, PANEL_GRAPH, plothandle[id], VAL_IMMEDIATE_DRAW);
  335.  
  336.         plothandle[id] = PlotXY (panelHandle, PANEL_GRAPH, timebins, fdata, nsamples, VAL_FLOAT, VAL_FLOAT, VAL_FAT_LINE, VAL_NO_POINT, VAL_SOLID, 1, col[id]);
  337.  
  338.         H1D_Draw(1,panelHandle,PANEL_ADC1,&adcplothandle[0]);
  339.         H1D_Draw(2,panelHandle,PANEL_ADC2,&adcplothandle[1]);
  340.         H1D_Draw(3,panelHandle,PANEL_TDC1,&tdcplothandle[0]);
  341.         H1D_Draw(4,panelHandle,PANEL_TDC2,&tdcplothandle[1]);
  342.  
  343.         if (debug) for (int k=0; k<10; k++) printf("%d %d (%f , %d)\n", id,k, timebins[k],data[k]);
  344.       }
  345.  
  346.       nr+=8;
  347.       adc=10000;
  348.       qdc=0;
  349.       int nqdc=0;
  350.       int ntdc=0;
  351.       for (int k=1; k<nsamples; k++) {
  352.         float t =timebins[k];
  353.         float tp=timebins[k-1];
  354.         if (fdata[k] < adc) adc = fdata[k];
  355.         if (t>twin0 && t<twin1 ) {
  356.           nqdc++;
  357.           qdc+=fdata[k];
  358.         }
  359.         if (fdata[k]< athreshold && fdata[k-1]> athreshold) {
  360.           double t0= tp+(athreshold-fdata[k-1])/(fdata[k]-fdata[k-1])* (t-tp);
  361.           if (ntdc>0) H1D_Fill(3+id, t0,1);
  362.           if (ntdc==0 && !excludefirst[id]) H1D_Fill(3+id, t0,1);
  363.           finfo[*ninfo+4+ntdc]=t0;
  364.           ntdc++;
  365.         }
  366.       }
  367.       if (nqdc) qdc/=nqdc;
  368.       //printf("adc %f qdc %f\n", adc,qdc);
  369.       info[*ninfo]=(ntdc+4)*sizeof(int); // len
  370.       info[*ninfo+1]=id | 0xF0000000;    // recid
  371.       finfo[*ninfo+2]=adc;
  372.       finfo[*ninfo+3]=qdc;
  373.       *ninfo+= ntdc+4;
  374.  
  375.       if (adctype)
  376.         H1D_Fill(1+id, -adc,1);
  377.       else
  378.         H1D_Fill(1+id, -qdc,1);
  379.  
  380.       nr+=4*nsamples;
  381.       data+=nsamples;
  382.     }
  383.     recid      = *data++;
  384.     int event  = *data++;
  385.     nr+=8;
  386.     neve++;
  387.     if (debug) printf("recid %d event %d\n",recid, event );
  388.   }
  389.  
  390.   return neve;
  391. }
  392.  
  393. const int maxlen = 100000000;
  394. unsigned char data[maxlen];
  395. int *idata = (int *) &data[0];
  396.  
  397.  
  398. int evinfo[maxlen];
  399. int CVICALLBACK SocketCB (unsigned handle, int xType, int errCode, void *callbackData) {
  400.  
  401.   int nb = 0 ;
  402.   static int event = 0;
  403.   static int ncalls = 0;
  404.   static time_t t0, t1;
  405.   time(&t0);
  406.   switch (xType) {
  407.     case TCP_DISCONNECT:
  408.       printf("TCP_DISCONNECT ErrorString %s\n",GetTCPErrorString(errCode));
  409.       printf("TCP_DISCONNECT SystemErrorString %s\n",GetTCPSystemErrorString());
  410.  
  411.       chandle = 0;
  412.       break;
  413.     case TCP_DATAREADY: {
  414.       int  hdr[2]= {0,0};
  415.       nb = ClientTCPRead(handle,&hdr[0],8,1000);
  416.  
  417.       int size = hdr[1] - 8;
  418.       if (size>maxlen) size=maxlen;
  419.       nb = 0;
  420.       while (nb < size) {
  421.         int retval = ClientTCPRead(handle,&data[nb],size-nb,1000);
  422.         if (retval<1) break;
  423.         nb += retval;
  424.       }
  425.       if (debug) printf("Received RECID %d HDRLEN %d == read %d\n", hdr[0], size, nb);
  426.  
  427.       int ninfo=0;
  428.       switch (hdr[0]) {
  429.         case 0:
  430.           data[nb]=0;
  431.           printf("%s\n",data);
  432.           break;
  433.         case 1:// read
  434.  
  435.           GetCtrlVal(panelHandle,PANEL_CEVE     , &event);
  436.           GetCtrlVal(panelHandle,PANEL_NTOTAL   , &ncalls);
  437.  
  438.           event += analyse(nb,data, evinfo, &ninfo);
  439.           if (foutput) {
  440.             if (outwaveforms) fwrite(data, 1, nb, foutput);
  441.             fwrite(evinfo, 1, ninfo*sizeof(int), foutput);
  442.             time(&t1);
  443.             if ((t1-t0)>10000) {
  444.               for (int i=0; i<4; i++) H1D_Write2File(1+i,foutput);
  445.  
  446.               time(&t0);
  447.             }
  448.           }
  449.           SetCtrlVal(panelHandle,PANEL_CEVE     , event);
  450.           if (event>=ncalls) StartCB (panelHandle, PANEL_START, EVENT_COMMIT, NULL,1,0);
  451.  
  452.           break;
  453.         default:
  454.           printf("Unknown command = %d\n", hdr[0]);
  455.           break;
  456.       }
  457.       break;
  458.  
  459.     }
  460.   }
  461.   return 0;
  462. }
  463.  
  464. int rpdecimation(int i) {
  465.  
  466.   switch (i) {
  467.     case 1:
  468.       return 0;
  469.     case 8:
  470.       return 1;
  471.     case 64:
  472.       return 2;
  473.     case 1024:
  474.       return 3;
  475.     case 8192:
  476.       return 4;
  477.     case 65536:
  478.       return 5;
  479.   }
  480.   return 0;
  481.  
  482. }
  483.  
  484. int CVICALLBACK StartCB (int panel, int control, int event,
  485.                          void *callbackData, int eventData1, int eventData2) {
  486.   char ip[0xFF];
  487.   int hdr[0xFF];
  488.   char filename[0xFF];
  489.   unsigned short *sbuff = (unsigned short *)&hdr[5] ;
  490.   unsigned char  *cbuff = (unsigned char *)&sbuff[3] ;
  491.   int imask[2];
  492.   unsigned char mask;
  493.   unsigned char trigger;
  494.   unsigned short nsamples;
  495.   int delay;
  496.   int nbefore;
  497.   unsigned int decimation;
  498.   unsigned short neve;
  499.   int output;
  500.   switch (event) {
  501.     case EVENT_COMMIT: {
  502.       GetCtrlVal(panel,PANEL_IP, ip);
  503.       GetCtrlVal(panel,PANEL_TRIGGER, &trigger);
  504.       GetCtrlVal(panel,PANEL_SAMPLES, &nsamples);
  505.       GetCtrlVal(panel,PANEL_DECIMATION,&decimation);
  506.       GetCtrlVal(panel,PANEL_NEVE   , &neve);
  507.       GetCtrlVal(panel,PANEL_CH0    , &imask[0] );
  508.       GetCtrlVal(panel,PANEL_CH1    , &imask[1]  );
  509.       GetCtrlVal(panel,PANEL_PFREQ  , &pfreq);
  510.       GetCtrlVal(panel,PANEL_DEBUG  , &debug);
  511.       GetCtrlVal(panel,PANEL_NBEFORE  , &nbefore);
  512.       GetCtrlVal(panel,PANEL_ENABLEDOUTPUT, &output);
  513.       GetCtrlVal(panel,PANEL_OUTWAVE, &outwaveforms);
  514.       GetCtrlVal(panel,PANEL_FILENAME, filename);
  515.  
  516.       delay= MINTRGDELAY + nsamples - nbefore + 1;
  517.  
  518.       mask = 0;
  519.       for (int i=0; i<2; i++) {
  520.         if (imask[i]) mask |= (1<<i);
  521.       }
  522.  
  523.       double level =0;
  524.       GetCtrlVal(panel,PANEL_TRGLEVEL , &level);
  525.  
  526.  
  527.       switch (control) {
  528.         case PANEL_CONNECT: {
  529.           int state;
  530.           GetCtrlVal(panel,PANEL_CONNECT, &state);
  531.           if (state) {
  532.             ConnectToTCPServerEx (&chandle, 9930, ip, SocketCB, NULL, 0, TCP_ANY_LOCAL_PORT);
  533.           } else {
  534.             if (chandle!=0) DisconnectFromTCPServer (chandle);
  535.             chandle = 0;
  536.           }
  537.         }
  538.         break;
  539.         case PANEL_START: {
  540.           int state;
  541.           GetCtrlVal(panel,PANEL_START, &state);
  542.           GetCtrlVal(panel,PANEL_EXCLUDE_1, &excludefirst[0]);
  543.           GetCtrlVal(panel,PANEL_EXCLUDE_2, &excludefirst[1]);
  544.           if (state && eventData1==0) {
  545.             histoinit();
  546.             starttime=Timer();
  547.             daqtime  =0;
  548.             /* decimation n (=1,8,64...) : frequency = 125/n MHz*/
  549.             for (int i=0; i<nsamples; i++) timebins[i]=(i-nbefore)* (float)decimation /125.;
  550.             if (output) foutput = fopen(filename, "wb");
  551.             printf("decimation %d\n", decimation);
  552.             SetCtrlVal(panel,PANEL_CEVE  , 0);
  553.             ctrl_c=0;
  554.             hdr[0] = 0;
  555.             hdr[1] = 7*sizeof(int);
  556.             hdr[2] = delay;
  557.             hdr[3] = rpdecimation(decimation);
  558.             hdr[4] = level * 1000;
  559.             sbuff[0] = neve;
  560.             sbuff[1] = nsamples;
  561.             sbuff[2] = 1000; //tout
  562.             cbuff[0] = trigger;
  563.             cbuff[1] = mask;
  564.             ClientTCPWrite(chandle,&hdr[0],hdr[1],5000);  // acquire
  565.           } else {
  566.             hdr[0] = 1;
  567.             hdr[1] = 2*sizeof(int);
  568.             ClientTCPWrite(chandle,&hdr[0],hdr[1],5000);  // stop the transfer
  569.             printf("INFO Stopping the acquisition\n");
  570.             SetCtrlVal(panel,PANEL_START, 0);
  571.             if (foutput) fclose(foutput);
  572.             foutput=NULL;
  573.           }
  574.           break;
  575.         }
  576.         default:
  577.           printf("Unknown command\n");
  578.           break;
  579.       }
  580.  
  581.  
  582.  
  583.  
  584.       ProcessSystemEvents ();
  585.       break;
  586.     }
  587.   }
  588.   return 0;
  589. }
  590.  
  591.  
  592. int CVICALLBACK ExitCB (int panel, int control, int event,
  593.                         void *callbackData, int eventData1, int eventData2) {
  594.   switch (event) {
  595.     case EVENT_COMMIT:
  596.       QuitUserInterface(0);
  597.       break;
  598.   }
  599.   return 0;
  600. }
  601.  
  602.  
  603.  
  604. int CVICALLBACK ExportCB (int panel, int control, int event,
  605.                           void *callbackData, int eventData1, int eventData2) {
  606.   int hid=0;
  607.   switch (event) {
  608.     case EVENT_COMMIT:
  609.       switch (control) {
  610.         case PANEL_EXPORT_1:
  611.           hid=1;
  612.           break;
  613.         case PANEL_EXPORT_2:
  614.           hid=2;
  615.           break;
  616.         case PANEL_EXPORT_3:
  617.           hid=3;
  618.           break;
  619.         case PANEL_EXPORT_4:
  620.           hid=4;
  621.           break;
  622.  
  623.       }
  624.       export_data(hid);
  625.       break;
  626.   }
  627.   return 0;
  628. }
  629.  
  630. int CVICALLBACK ResetCB (int panel, int control, int event,
  631.                          void *callbackData, int eventData1, int eventData2) {
  632.   switch (event) {
  633.     case EVENT_COMMIT:
  634.  
  635.       for (int i=1; i<=4; i++) H1D_Clear(i);
  636.       break;
  637.   }
  638.   return 0;
  639. }
  640.  
  641.  
  642.