Subversion Repositories f9daq

Rev

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

  1. #include "H1D.h"
  2. #include "H2D.h"
  3. #include <formatio.h>
  4. #include <utility.h>
  5. #include <ansi_c.h>
  6. #include <cvirte.h>
  7. #include <userint.h>
  8. #include "drs4.h"
  9. #include "drsread.h"
  10.  
  11. #define MIKRO
  12.  
  13. #ifdef MIKRO
  14. #include "MIKRO.h"
  15. #endif
  16.  
  17. static int daq_on;
  18. static int ph, p2,plothandle[4]= {0,0,0,0};
  19. static int scanplothandle;
  20. static int tfID;
  21. static int controlID;
  22.  
  23. #define MAX_THREADS 10
  24.  
  25. static CmtThreadPoolHandle poolHandle = 0;
  26.  
  27. static float gSum[4]={0,0,0,0};
  28. int main (int argc, char *argv[]) {
  29.         short port;
  30.         if (InitCVIRTE (0, argv, 0) == 0)
  31.                 return -1;  /* out of memory */
  32.         if ((ph = LoadPanel (0, "drs4.uir", PANEL)) < 0)
  33.                 return -1;
  34.         if ((p2 = LoadPanel (0, "drs4.uir", SCAN)) < 0)
  35.                 return -1;
  36.         SetStdioPort (CVI_STDIO_WINDOW);
  37.         SetSleepPolicy(VAL_SLEEP_MORE);
  38.         CmtNewThreadPool (MAX_THREADS,  &poolHandle);
  39.  
  40.         DisplayPanel (ph);
  41.         DisplayPanel (p2);
  42.        
  43. #ifdef MIKRO
  44.         GetCtrlVal(p2, SCAN_PORT, &port);
  45.         if (MIKRO_Open (port)) MessagePopup ("Error", "Mikro Port Not found !\n Change in the GUI") ;
  46.         MIKRO_Init(1,0);
  47.         MIKRO_Init(2,0);
  48. #endif
  49.        
  50.         RunUserInterface ();
  51.         DiscardPanel (ph);
  52.         DiscardPanel (p2);
  53.         CmtDiscardThreadPool (poolHandle);
  54.         MIKRO_Close ();
  55.         return 0;
  56. }
  57.  
  58.  
  59. char strbuf[0xFF];
  60.  
  61. int gLog=0;
  62.  
  63. int printf(const char *format, ...) {
  64.   va_list aptr;
  65.   int ret;
  66.   FILE *flog;
  67.  
  68.   va_start(aptr, format);
  69.   ret = vsprintf(strbuf, format, aptr);
  70.   va_end(aptr);
  71.   SetCtrlVal(ph,PANEL_STDIO,strbuf);
  72.  
  73.   if (gLog) {
  74.     flog = fopen ("stdio.log", "a");
  75.     fprintf (flog, "%s", strbuf);
  76.     fclose (flog);
  77.   }
  78.   return(ret);
  79. }
  80.  
  81.  
  82.  
  83. static void start_timer (double tout) {
  84.         SetCtrlAttribute (ph, PANEL_TIMER, ATTR_INTERVAL, tout);
  85.         SetCtrlAttribute (ph, PANEL_TIMER, ATTR_ENABLED, 1);
  86. }
  87.  
  88. static void stop_timer ( void ) {
  89.         SetCtrlAttribute (ph, PANEL_TIMER, ATTR_ENABLED, 0);
  90.         DRSSetTimeout();
  91. }
  92.  
  93.  
  94.  
  95.  
  96. void CVICALLBACK EndOfThread ( CmtThreadPoolHandle poolhandle,
  97.                                                                                                                          CmtThreadFunctionID functionID, unsigned int event,
  98.                                                                                                                          int value, void *callbackData  ) {
  99.  
  100.         daq_on=0;
  101.         //SetDimming(0);
  102.         printf("End of Thread \n");
  103.         return ;
  104.  
  105. }
  106.  
  107.  
  108. static float xs[4][1024];      
  109. int CVICALLBACK daq(void *functionData) {
  110.  
  111.  
  112.         int neve;
  113.         char filename[0xff];
  114.         int imask[4];
  115.         unsigned long mask;
  116.         int frequency;
  117.         double trgdelay;
  118.         double trglevel;
  119.         int trgtype;
  120.         int trgchannel;
  121.         int trgpolarity;
  122.         int verbose;
  123.         double range;
  124.         int pfreq;
  125.         int enabledoutput;
  126.         int neveold = 0;
  127.         double rate;
  128.         int *args =  (int *) functionData;
  129.         double twin[2];
  130.  
  131.        
  132.  
  133.         GetCtrlVal(ph, PANEL_CH0, &imask[0] );
  134.         GetCtrlVal(ph, PANEL_CH1, &imask[1]  );
  135.         GetCtrlVal(ph, PANEL_CH2, &imask[2]  );
  136.         GetCtrlVal(ph, PANEL_CH3, &imask[3]  );
  137.         mask = 0;
  138.         for (int i=0; i<4; i++) {
  139.                 if (imask[i]) mask |= (1<<i);
  140.         }
  141.  
  142.  
  143.                
  144.         GetCtrlVal(ph,PANEL_NEVE, &neve);
  145.         GetCtrlVal(ph,PANEL_DEBUG, &verbose);
  146.         GetCtrlVal(ph,PANEL_PFREQ, &pfreq);
  147.         GetCtrlVal(ph,PANEL_ENABLEDOUTPUT, &enabledoutput);
  148.  
  149.         GetCtrlVal(ph,PANEL_FREQUENCY, &frequency);
  150.         GetCtrlVal(ph,PANEL_TRGDELAY, &trgdelay);
  151.         GetCtrlVal(ph,PANEL_TRGCHANNEL, &trgchannel);
  152.  
  153.        
  154.         GetCtrlVal(ph,PANEL_TRGTYPE, &trgtype);
  155.         GetCtrlVal(ph,PANEL_TRGLEVEL, &trglevel);
  156.         GetCtrlVal(ph,PANEL_TRGPOLARITY, &trgpolarity);
  157.         GetCtrlVal(ph,PANEL_RANGE, &range);
  158.  
  159.         GetCtrlVal(ph,PANEL_TWIN0, &twin[0]);
  160.   GetCtrlVal(ph,PANEL_TWIN1, &twin[1]);
  161.         //printf("mask=0x%x\n",mask);
  162.  
  163.         DRSSetMask( (unsigned char)( mask & 0xF ) );
  164.  
  165.         DRSSetFrequency( frequency  );
  166.         DRSSetTriggerDelay(trgdelay );
  167.         DRSSetTriggerChannel(trgchannel );
  168.         DRSSetTriggerType( trgtype );
  169.         DRSSetTriggerLevel(trglevel);
  170.         DRSSetTriggerPolarity(trgpolarity);
  171.  
  172.         DRSSetRange (  range );
  173.  
  174.  
  175.  
  176.         FILE *fp= NULL;
  177.  
  178.         if (enabledoutput) {
  179.                 if (args[0]) {
  180.                         GetCtrlVal(ph, PANEL_FILENAME, filename );  
  181.                         fp =  fopen(filename,"wb");
  182.           } else {
  183.                         GetCtrlVal(p2, SCAN_FILENAME, filename );  
  184.                         fp =  fopen(filename,"ab");
  185.                 }      
  186.         }
  187.  
  188.         static unsigned char *buffer;
  189.  
  190.         int buffer_size = 0;
  191.         const int nBoards=1;
  192.         const int waveDepth=1024;
  193.  
  194.         if (buffer_size == 0) {
  195.          buffer_size =   8; // file header + time header
  196.          buffer_size +=  nBoards * (4 + 4*(4+waveDepth*4)); // bin widths
  197.          buffer_size += 24 + nBoards * (8 + 4*(8+waveDepth*2));
  198.          buffer = (unsigned char *)malloc(buffer_size);
  199.   }
  200.                        
  201.         time_t t=0,told=0, tstart=0;
  202.  
  203.         if (!DRSInit()) {
  204.  
  205.                 time(&tstart);
  206.                 told=tstart;
  207.                 int nev=0;
  208.                 for (int k = 0;k<4;k++){
  209.                          gSum[k]=0;
  210.                 }
  211.                 for (int i=0; i<neve; i++) {
  212.                         start_timer(1);// 1 s timeout
  213.                         int retval = DRSRead(0);
  214.                         stop_timer();
  215.                         int nb =  ( retval == 0 && fp ) ? DRSToBuffer( buffer , i ) : 0;
  216.                         SetCtrlVal(ph,PANEL_CEVE,i);
  217.                         if (retval) i--;
  218.                         nev++;
  219.                         if (!daq_on) break;
  220.                         time(&t);
  221.                         if (t!=told ) {
  222.                                 rate =  (i-neveold);
  223.                                 printf("%d events in %2.2f min (%d s) Rate %f Hz %s   ",i+1, (double)(t-tstart)/60.,(t-tstart), rate , ctime(&t));
  224.                                 GetCtrlVal(ph,PANEL_PFREQ, &pfreq);
  225.                                 neveold = i;
  226.                         }
  227.                         told=t;
  228. // Save data
  229.                         if (nb>0 && fp) fwrite(buffer, 1,nb ,fp);
  230. // Plot Data
  231.                          for (int k=0; k<4; k++) {
  232.                                         if ( (mask & ( 0x1<<k ))  ){
  233.                                           float *t=DRSGetTime(k);
  234.                                           float *x=DRSGetWave(k);
  235.                                                                  ;
  236.                                           for (int j=0 ; j<1024 ; j++) {
  237.                                                   xs[k][j]= x[j]*1e-3;
  238.                                                
  239.                                                   if (t[j]> twin[0] && t[j] < twin[1]) gSum[k]+= fabs(xs[k][j]);
  240.                                                   if (verbose) printf("[%d] %d. x= %3.2f  y=%3.2f\n", k, i, t[j], x[j] );
  241.                                                   //h[k]->Fill( t[i], x[i]*1e-3);
  242.                                           }
  243.  
  244.                                           if (i % pfreq == 0) {
  245.                                                        
  246.                                             const int col[4]= {VAL_WHITE,VAL_RED,VAL_GREEN,VAL_BLUE};
  247.                                           if (plothandle[k])    DeleteGraphPlot (ph, PANEL_GRAPH, plothandle[k], VAL_IMMEDIATE_DRAW);
  248.                                             plothandle[k] = PlotXY (ph, PANEL_GRAPH, t, xs[k], 1024, VAL_FLOAT, VAL_FLOAT, VAL_THIN_LINE, VAL_NO_POINT, VAL_SOLID, 1, col[k]);
  249.                                           }    
  250.                                         }
  251.                                        
  252.                                 }
  253.  
  254.  
  255.                 }
  256.                 time(&t);
  257.                 printf("%d events in %2.2f min (%d s) %s",nev, (double)(t-tstart)/60.,t-tstart, ctime(&t));
  258.                 DRSEnd();
  259.         }
  260.  
  261.         if (fp) fclose(fp);
  262.  
  263.         free(buffer);
  264.  
  265.         return 0;
  266.  
  267. }
  268.  
  269.  
  270.  
  271. int CVICALLBACK scan(void *functionData) {
  272.  
  273.         int dx[3]={0,0,0};
  274.         int nx[3]={0,0,0};
  275.         int x0[3]={0,0,0};
  276.         int ix[3]={0,0,0};
  277.         int idx[3]={0,0,0};  
  278.         int size;
  279.         char posrec[4]="POSR"; 
  280.         char runbuf[4]="PRUN";
  281.        
  282.         int  n[3];
  283.         char filename[0xFF];
  284.         int enabledoutput;
  285.        
  286.         FILE *fp;
  287.         GetCtrlVal(p2, SCAN_FILENAME, filename );
  288.        
  289.         GetCtrlVal(ph,PANEL_ENABLEDOUTPUT, &enabledoutput);
  290.        
  291.         if ( GetFileInfo(filename,&size) ) {
  292.                 MessagePopup ("Warning","File exist. Remove it first or choose another file");
  293.           return 0;
  294.         }        
  295.         GetCtrlVal(p2, SCAN_STEPX, &dx[0]);
  296.         GetCtrlVal(p2, SCAN_STEPY, &dx[1]);
  297.         GetCtrlVal(p2, SCAN_NSTEPSX, &nx[0]);
  298.         GetCtrlVal(p2, SCAN_NSTEPSY, &nx[1]);
  299.         GetCtrlVal(p2, SCAN_STARTX, &x0[0]);
  300.         GetCtrlVal(p2, SCAN_STARTY, &x0[1]);
  301.         for (int k=0;k<4;k++)  {
  302.                 H2D_Init(k, "charge","Induced charge",
  303.                                                 nx[0], x0[0] - dx[0]*0.5 ,x0[0] + dx[0] * ( nx[0] - 0.5) ,
  304.                                                 nx[1], x0[1] - dx[1]*0.5 ,x0[1] + dx[1] * ( nx[1] - 0.5));  
  305.           H1D_Init(k, "charge","Induced charge projection x",
  306.                                                 nx[0], x0[0] - dx[0]*0.5 ,x0[0] + dx[0] * ( nx[0] - 0.5) );  
  307.           H1D_Init(100 + k, "charge","Induced charge projection y",
  308.                                                 nx[1], x0[1] - dx[1]*0.5 ,x0[1] + dx[1] * ( nx[1] - 0.5) );  
  309.         }
  310.         if (enabledoutput) {
  311.                                 fp =  fopen(filename,"ab");
  312.                                 if (fp) {
  313.                                          size=36;
  314.                                          fwrite(runbuf, 1,4 ,fp);
  315.                                          fwrite(&size  , 1,4 ,fp);
  316.                                          fwrite(x0    , 1,4*3 ,fp);
  317.                                          fwrite(dx    , 1,4*3 ,fp);
  318.                                          fwrite(nx    , 1,4*3 ,fp);
  319.                                          fclose(fp);
  320.                                 }    
  321.         }      
  322.        
  323.         for (int i=0; i<nx[0]; i++) {
  324.  
  325.                 ix[0]= x0[0]+i*dx[0];
  326. #ifdef MIKRO
  327.                 MIKRO_MoveTo(1,ix[0]);
  328. #endif
  329.                 SetCtrlVal (p2, SCAN_IX, i);
  330.                 for (int j=0; j<nx[1]; j++) {
  331.                        
  332.                         SetCtrlVal (p2, SCAN_IY, j);
  333.  
  334.                         ix[1]= x0[1]+j*dx[1];
  335. #ifdef MIKRO
  336.                         MIKRO_MoveTo(2,ix[1]);
  337.  
  338.                         MIKRO_GetPosition(1,&n[0]);
  339.                         SetCtrlVal (p2, SCAN_XP, n[0]);
  340.                         MIKRO_GetPosition(2,&n[1]);
  341.                         SetCtrlVal (p2, SCAN_YP, n[1]);
  342.        
  343.                         if (enabledoutput) {
  344.                                 fp =  fopen(filename,"ab");
  345.                                 if (fp) {
  346.                                          idx[0]=i;
  347.                                          idx[1]=j;
  348.                                          size=24;
  349.                                          fwrite(posrec, 1,4 ,fp);
  350.                                          fwrite(&size , 1,4 ,fp);
  351.                                          fwrite(n     , 1,4*3 ,fp);
  352.                                          fwrite(idx    , 1,4*3 ,fp);
  353.                                          fclose(fp);
  354.                                 }    
  355.                         }      
  356.                                
  357. #endif
  358.                         daq(functionData);
  359.                        
  360.                         for (int k=0;k<4;k++) {
  361.                                 H2D_Fill(k, ix[0], ix[1] , gSum[k] );
  362.                                 H1D_Fill(k, ix[0] , gSum[k] );
  363.                                 H1D_Fill(100+ k, ix[1] , gSum[k] );  
  364.                         }      
  365.                         PlotScanHistogramCB(0,0,EVENT_COMMIT,NULL, 0,0);
  366.                         if (!daq_on) break;
  367.                 }
  368.                 if (!daq_on) break;
  369.         }
  370.  
  371.         return 0;
  372. }
  373.  
  374.  
  375. int CVICALLBACK StartCB (int panel, int control, int event,
  376.                                                                                                  void *callbackData, int eventData1, int eventData2) {
  377.         ThreadFunctionPtr mythread = NULL;
  378.         switch (event) {
  379.  
  380.                 case EVENT_COMMIT:
  381.  
  382.                         controlID=0;
  383.                         if (panel == ph && control == PANEL_START) {
  384.                                 mythread = daq;
  385.                                 controlID= control;
  386.                         }
  387.                         if (panel == p2 && control == SCAN_SCAN)   mythread = scan;
  388.                         if (mythread!=NULL) {
  389.                                 printf("New Thread panel=%d button=%d\n", panel, control);
  390.  
  391.                                 // SetDimming(1);
  392.  
  393.                                 daq_on=1;
  394.                                 CmtScheduleThreadPoolFunctionAdv (poolHandle, mythread, &controlID,
  395.                                                                                                                                                                         DEFAULT_THREAD_PRIORITY,
  396.                                                                                                                                                                         EndOfThread,
  397.                                                                                                                                                                         EVENT_TP_THREAD_FUNCTION_END,
  398.                                                                                                                                                                         NULL, RUN_IN_SCHEDULED_THREAD,
  399.                                                                                                                                                                         &tfID);
  400.                         }
  401.                         break;
  402.         }
  403.         return 0;
  404. }
  405.  
  406. int CVICALLBACK StopCB (int panel, int control, int event,
  407.                                                                                                 void *callbackData, int eventData1, int eventData2) {
  408.         switch (event) {
  409.                 case EVENT_COMMIT:
  410.                         daq_on=0;
  411.                         break;
  412.         }
  413.         return 0;
  414. }
  415.  
  416. int CVICALLBACK ExitCB (int panel, int control, int event,
  417.                                                                                                 void *callbackData, int eventData1, int eventData2) {
  418.         switch (event) {
  419.                 case EVENT_COMMIT:
  420.                         QuitUserInterface (0);
  421.                         break;
  422.         }
  423.         return 0;
  424. }
  425.  
  426. int CVICALLBACK MoveStageCB (int panel, int control, int event,
  427.                                                                                                                  void *callbackData, int eventData1, int eventData2) {
  428.         int axis=0, step=1000, direction=1, n;
  429.         switch (event) {
  430.                 case EVENT_COMMIT:
  431.  
  432.                         if (panel == p2) {
  433.                                 switch (control) {
  434.                                         case SCAN_BR :
  435.                                                 axis = 1;
  436.                                                 direction = 1;
  437.                                                 GetCtrlVal(p2, SCAN_STEPX, &step);
  438.                                                 break;
  439.                                         case SCAN_BL :
  440.                                                 axis = 1;
  441.                                                 direction = -1;
  442.                                                 GetCtrlVal(p2, SCAN_STEPX, &step);
  443.                                                 break;
  444.                                         case SCAN_BU :
  445.                                                 axis = 2;
  446.                                                 direction = 1;
  447.                                                 GetCtrlVal(p2, SCAN_STEPY, &step);
  448.                                                 break;
  449.                                         case SCAN_BD :
  450.                                                 axis = 2;
  451.                                                 direction = -1;
  452.                                                 GetCtrlVal(p2, SCAN_STEPY, &step);
  453.                                                 break;
  454.                                 }
  455. #ifdef MIKRO
  456.                                 MIKRO_MoveFor(axis,  direction*step );
  457.                                 MIKRO_GetPosition(axis,&n);
  458.                                 if (axis == 1) SetCtrlVal (p2, SCAN_XP, n);
  459.                                 if (axis == 2) SetCtrlVal (p2, SCAN_YP, n);
  460. #endif // MIKRO                                
  461.                         }
  462.  
  463.                         break;
  464.         }
  465.         return 0;
  466. }
  467.  
  468.  
  469.  
  470.  
  471.  
  472. int CVICALLBACK GoXCB (int panel, int control, int event,
  473.                                                                                          void *callbackData, int eventData1, int eventData2) {
  474.         int n2;
  475.         switch (event) {
  476.                 case EVENT_COMMIT:
  477.                         GetCtrlVal (p2, SCAN_XG, &n2);
  478. #ifdef MIKRO
  479.                         MIKRO_MoveTo(1,n2);
  480.                         MIKRO_GetPosition(1,&n2);
  481.                        
  482. #endif
  483.                         SetCtrlVal (p2, SCAN_XP, n2);
  484.                         break;
  485.         }
  486.         return 0;
  487. }
  488.  
  489. int CVICALLBACK GoYCB (int panel, int control, int event,
  490.                                                                                          void *callbackData, int eventData1, int eventData2) {
  491.         int n2;
  492.         switch (event) {
  493.                 case EVENT_COMMIT:
  494.                         GetCtrlVal (p2, SCAN_YG, &n2);
  495. #ifdef MIKRO
  496.                         MIKRO_MoveTo(2,n2);
  497.                         MIKRO_GetPosition(2,&n2);
  498.                        
  499. #endif
  500.                         SetCtrlVal (p2, SCAN_YP, n2);
  501.                         break;
  502.         }
  503.         return 0;
  504. }
  505.  
  506. int CVICALLBACK GetCurrentPositionCB (int panel, int control, int event,
  507.                                                                                                                                         void *callbackData, int eventData1, int eventData2) {
  508.        
  509.         int n[2];      
  510.         switch (event) {
  511.                 case EVENT_COMMIT:
  512. #ifdef MIKRO                   
  513.                         MIKRO_GetPosition(1,&n[0]);
  514.                         SetCtrlVal (p2, SCAN_XP, n[0]);
  515.                         MIKRO_GetPosition(2,&n[1]);
  516.                         SetCtrlVal (p2, SCAN_YP, n[1]);
  517. #endif                 
  518.                         break;
  519.         }
  520.         return 0;
  521. }
  522.  
  523. int CVICALLBACK HomeCB (int panel, int control, int event,
  524.                                                                                                 void *callbackData, int eventData1, int eventData2) {
  525.         switch (event) {
  526.                 case EVENT_COMMIT:
  527. #ifdef MIKRO                   
  528.                         MIKRO_ReferenceMove(1);
  529.                         MIKRO_ReferenceMove(2);
  530.                         GetCurrentPositionCB(panel, control, event, NULL, 0, 0);
  531. #endif                 
  532.                         break;
  533.         }
  534.         return 0;
  535. }
  536.  
  537. int CVICALLBACK PlotScanHistogramCB (int panel, int control, int event,
  538.                                                                                                                                                  void *callbackData, int eventData1, int eventData2) {
  539.         int hid=0;
  540.         int nx;
  541.         int ny;
  542.         switch (event) {
  543.                 case EVENT_COMMIT:
  544.                         GetCtrlVal (p2, SCAN_CHANNEL, &hid);
  545.                         GetCtrlVal(p2, SCAN_NSTEPSX, &nx);
  546.             GetCtrlVal(p2, SCAN_NSTEPSY, &ny);
  547.                         if (nx>1 && ny>1) {
  548.                                 H2D_Draw(hid,p2,SCAN_GRAPH,&scanplothandle);
  549.                                 printf("redraw 2d\n");
  550.                         } else {
  551.                                 if (nx>1)  {
  552.                                         printf("redraw 1d x\n");
  553.                                         H1D_Draw(hid,p2,SCAN_GRAPH,&scanplothandle);
  554.                                 }      
  555.                           if (ny>1) {
  556.                                         printf("redraw 1d x\n");
  557.                                         H1D_Draw(100+hid,p2,SCAN_GRAPH,&scanplothandle);
  558.                                 }
  559.                         }      
  560.                         break;
  561.         }
  562.         return 0;
  563. }
  564.  
  565. int CVICALLBACK OpenGuiCB (int panel, int control, int event,
  566.                                                                                                          void *callbackData, int eventData1, int eventData2) {
  567.         switch (event) {
  568.                 case EVENT_COMMIT:
  569.                         DisplayPanel (ph);
  570.             DisplayPanel (p2);
  571.                         break;
  572.         }
  573.         return 0;
  574. }
  575.  
  576. int CVICALLBACK CalibrateCB (int panel, int control, int event,
  577.                                                                                                                  void *callbackData, int eventData1, int eventData2) {
  578.         int status = 0;
  579.         switch (event) {
  580.                 case EVENT_COMMIT:
  581.                   status = DRSCalibrateTiming();
  582.                         printf("DRSCalibrateTiming() status = %d\n", status);
  583.                         break;
  584.         }
  585.         return 0;
  586. }
  587.