Subversion Repositories f9daq

Rev

Blame | Last modification | View Log | RSS feed

  1. //
  2. //  test.c
  3. //
  4. //  Description : test program for V729
  5. //
  6. //  Author : S. Korpar
  7. //  Date   : 2005/07/15
  8. // adapted to CAEN V1719 by R. Pestotnik  2012/09/07
  9.  
  10. #include <stdlib.h>
  11. #include <stdint.h>
  12. #include <stdio.h>
  13. #include <string.h>
  14.  
  15.  
  16.  
  17. #ifdef _CVI_
  18. #  include <windows.h>
  19. #  include "CAEN_V729_CVI.h"
  20. #  include "asynctmr.h"
  21. #  include "H1D.h"
  22. #  include "H2D.h"
  23. #  include "HDraw.h"
  24. typedef signed char   int8_t;
  25. typedef unsigned char  uint8_t;
  26. typedef short  int16_t;
  27. typedef unsigned short uint16_t;
  28. typedef int  int32_t;
  29. typedef unsigned int  uint32_t;
  30. #  include <utility.h>
  31. #  define usleep(x) Delay(x*1e-3)
  32. #include "sa02lib.h"
  33. #define printf sa02Printf
  34. # else _CVI_
  35. #  include <unistd.h>
  36. #  include <ctype.h>
  37. #  include <vector>
  38. #  include <sys/time.h>
  39. #  include <sys/stat.h>
  40. #  include <signal.h>
  41. #  include <string>
  42. #endif _CVI_
  43.  
  44.  
  45. #include "vme.h"
  46. #include "CAEN_V729_DEF.h"
  47. #include "CAEN_V729.h"
  48. #include "dataio.h"
  49.  
  50. //#include <utility.h>
  51. CAEN_V729_PARAM  CAEN_V729_param;
  52.  
  53. #define IREG_OFFSET 0x2000
  54. #define V729_WAIT 100
  55.  
  56.  
  57. #define TRUE 1
  58. #define FALSE 0
  59.  
  60. uint32_t V729_module=0;
  61.  
  62.  
  63. static int          g_timerId              = 0;
  64.  
  65. #ifdef V729_MAIN
  66. int ctrl_c=0;
  67. # else V729_MAIN
  68. #  ifdef V729_WINMAIN
  69. int ctrl_c=0;
  70. #   else V729_WINMAIN
  71. extern int ctrl_c;
  72. #  endif V729_WINMAIN
  73. #endif V729_MAIN
  74.  
  75. #ifndef WIN32
  76. struct sigaction oact;
  77. #endif WIN32
  78. //---------------------------------------------------------
  79.  
  80.  
  81. //---------------------------------------------------------
  82. DefineThreadSafeScalarVar (int, TimerOut,0);
  83.  
  84.  
  85. void timerast (int signumber) {
  86.  
  87. }
  88.  
  89. //---------------------------------------------------------
  90.  
  91. int CVICALLBACK TimerOutCallback (int reserved, int theTimerId, int event,
  92.                                   void *callbackData, int eventData1,
  93.                                   int eventData2) {
  94.   double currentTime = 0.0;
  95.   double deltaTime   = 0.0;
  96.   int id;
  97.   /* Like a regular UI timer, the async. timer's callback is passed the    */
  98.   /* total elapsed time and the time since the last tick.                  */
  99.   if ((double*)eventData1)
  100.     currentTime = *((double*)eventData1);
  101.   if ((double*)eventData2)
  102.     deltaTime   = *((double*)eventData2);
  103.   if (event == EVENT_TIMER_TICK) {
  104.     SetTimerOut(TRUE);
  105.     id= *((int *)callbackData);
  106.     fprintf(stdout,"TIMEOUT %d !!!\n", id );
  107.  
  108.   }
  109.   /* We will get an EVENT_DISCARD when the timer is destroyed. */
  110.   if (event == EVENT_DISCARD)
  111.     g_timerId = 0;
  112.   return 0;
  113. }
  114.  
  115. int g_tmlnk;
  116. void tmlnk (int tout) {
  117.  
  118.   //timer_out=0;
  119. #ifdef _CVI_
  120.   g_tmlnk = tout;
  121.   SetTimerOut(FALSE);
  122.   g_timerId = NewAsyncTimer (((double)tout) *10./ 1000.0, 1, 1, TimerOutCallback, &g_tmlnk);
  123. # else _CVI_
  124.  
  125.   struct sigaction act;
  126.   struct itimerval tdelay;
  127.  
  128.   act.sa_handler = timerast;
  129.   sigemptyset (&act.sa_mask);
  130.   act.sa_flags = 0;
  131.  
  132.   tdelay.it_value.tv_sec = tout / 100;
  133.   tdelay.it_value.tv_usec = 10000 * (tout % 100);
  134.   tdelay.it_interval.tv_sec = 0;
  135.   tdelay.it_interval.tv_usec = 0;
  136.  
  137.   if (sigaction (SIGALRM, &act, &oact) < 0) {
  138.     perror ("sigaction(tmlnk)");
  139.     exit (EXIT_FAILURE);
  140.   }
  141.   if (setitimer (ITIMER_REAL, &tdelay, NULL) < 0) {
  142.     perror ("setitimer(tmlnk)");
  143.     exit (EXIT_FAILURE);
  144.   }
  145.  
  146. #endif _CVI_
  147. }
  148.  
  149. //---------------------------------------------------------
  150. void tmulk ( void ){
  151. #ifdef _CVI_
  152.   DiscardAsyncTimer( g_timerId );
  153. # else _CVI_
  154.   struct itimerval tdelay;
  155.  
  156.   tdelay.it_value.tv_sec = 0;
  157.   tdelay.it_value.tv_usec = 0;
  158.   tdelay.it_interval.tv_sec = 0;
  159.   tdelay.it_interval.tv_usec = 0;
  160.  
  161.   if (setitimer (ITIMER_REAL, &tdelay, NULL) < 0) {
  162.     perror ("setitimer(tmulk)");
  163.     exit (EXIT_FAILURE);
  164.   }
  165.   if (sigaction (SIGALRM, &oact, NULL) < 0) {
  166.     perror ("sigaction(tmulk)");
  167.     exit (EXIT_FAILURE);
  168.   }
  169. #endif _CVI_
  170. }
  171.  
  172. //---------------------------------------------------------
  173. int wait_while (int num) {
  174.   int i, tmp = 0;
  175.  
  176.   for ( i =0; i <num; i++ ) tmp = 0;
  177.   return tmp;
  178. }
  179.  
  180. //---------------------------------------------------------
  181.  
  182.  
  183. void V729_map( uint32_t addr) {
  184.   V729_module = addr;
  185.   return;
  186. }
  187. //---------------------------------------------------------  
  188. int V729_status( void ){
  189.   uint32_t status;
  190.   VME_A24D16_R(V729_module+V729_CSR, &status);
  191.   return status;
  192. }
  193. //---------------------------------------------------------
  194. void V729_info(FILE *kam) {
  195.   uint32_t code, mid, ver;
  196.  
  197.  
  198.   VME_A24D16_R(V729_module+0xFA,&code);
  199.   VME_A24D16_R(V729_module+0xFC,&mid);
  200.   VME_A24D16_R(V729_module+0xFE,&ver);
  201.   printf( "code/mid/ver = 0x%04X/0x%04X/0x%04X\n", code, mid, ver);
  202.   printf( "Fixed code (0xFAF5) = 0x%04X\n", code);
  203.   printf( "Manufacturer/Type = 0x%02X/0x%03X\n",
  204.           (mid & 0xFC00)>>10, mid & 0x3FF);
  205.   printf( "Version/Serial = %d/%d\n",
  206.           (ver & 0xF000)>>12, ver & 0xFFF);
  207.   return;
  208. }
  209.  
  210.  
  211. //---------------------------------------------------------
  212. void V729_reg( uint32_t val) {
  213.   uint32_t push=0;
  214.  
  215.   VME_A24D16_W(V729_module+V729_FSR, val);
  216.   VME_A24D16_W(V729_module+V729_UFSR, push); //push
  217.   usleep(V729_WAIT);
  218.  
  219. }
  220.  
  221.  
  222. //---------------------------------------------------------
  223. void V729_reset(int nall,int nbefore,int obae,int obaf) {
  224.   uint32_t cbl;
  225.   uint32_t val=0;
  226. //  cbl=4096+12-100;
  227.   cbl=4096+12-nbefore;
  228.  
  229.   VME_A24D16_W(V729_module+V729_RR, val); // reset
  230.   printf("nbefore=%d\t", nbefore);
  231.   printf("nall=%d\t", nall);
  232.   printf("obae=%d\t", obae);
  233.   printf("obaf=%d\n", obaf);
  234.  
  235. // set AE
  236.   V729_reg( (obae & 0xFF)<<8 );//
  237.   V729_reg( (obae & 0xF00) ); //
  238.  
  239.   printf("CSR = 0x%x\n", V729_status() );
  240. // set AF and CBL
  241.   V729_reg( ((obaf & 0xFF)<<8) + (cbl & 0xFF)   );
  242.   V729_reg( (obaf & 0xF00) + ((cbl & 0xF00)>>8) );
  243.  
  244.  
  245.  
  246.   VME_A24D16_W(V729_module+V729_SR,nall); //total number of samples
  247.  
  248.   return;
  249. }
  250. //---------------------------------------------------------
  251.  
  252. void V729_set_bias(int range, int bias1, int bias2) {
  253.   int i;
  254.   uint32_t bias;
  255.  
  256.   switch (range) {
  257.     case 0: //User
  258.       for (i=0x18; i<0x27; i+=4) {
  259.         VME_A24D16_W(V729_module+i, bias1); //bias
  260.         usleep(V729_WAIT);
  261.         VME_A24D16_W(V729_module+i+2, bias2); //bias
  262.         usleep(V729_WAIT);
  263.       }
  264.       printf("Bias + %x  - %x\n", bias1, bias2);
  265.       break;
  266.     case 1: //Single Ended +
  267.       for (i=0x18; i<0x27; i+=4) {
  268.         bias = 0xCC;
  269.         VME_A24D16_W(V729_module+i, bias); //bias
  270.         usleep(V729_WAIT);
  271.         bias =0x733;
  272.         VME_A24D16_W(V729_module+i+2, bias); //bias
  273.         usleep(V729_WAIT);
  274.       }
  275.       break;
  276.     case 2: //Single Ended -
  277.       for (i=0x18; i<0x27; i+=4) {
  278.         bias =0x733;
  279.         VME_A24D16_W(V729_module+i, bias); //bias
  280.         usleep(V729_WAIT);
  281.         bias= 0xD99 ;
  282.         VME_A24D16_W(V729_module+i+2, bias); //bias
  283.         usleep(V729_WAIT);
  284.       }
  285.       break;
  286.     case 4: //Differential Unipolar
  287.       for (i=0x18; i<0x27; i+=4) {
  288.         bias = 0x400;
  289.         VME_A24D16_W(V729_module+i,bias); //bias
  290.         usleep(V729_WAIT);
  291.         bias = 0xA66;
  292.         VME_A24D16_W(V729_module+i+2, bias); //bias
  293.         usleep(V729_WAIT);
  294.       }
  295.       break;
  296.     case 3: //Single Ended Bipolar
  297.     case 5: //Differential Bipolar
  298.     default:
  299.       for (i=0x18; i<0x27; i+=2) {
  300.         bias=0x733;
  301.         VME_A24D16_W(V729_module+i, bias); //bias
  302.         usleep(V729_WAIT);
  303.       }
  304.       break;
  305.   }
  306.   return;
  307. }
  308.  
  309. //---------------------------------------------------------
  310. void V729_aquisition_mode(uint32_t mode) { // mode 0 aqusition mode, 0x30 buffers programming
  311. #ifdef V729_DEBUG
  312.   int status;
  313.   VME_A24D16_R(V729_module+V729_CSR, &status);
  314.   usleep(V729_WAIT);
  315.   fprintf(stderr, "V729_CSR 0x0E = 0x%04X\n", status);
  316. #endif V729_DEBUG
  317.  
  318.   VME_A24D16_W(V729_module+V729_CSR, mode); //aquisition mode
  319.   usleep(V729_WAIT);
  320. #ifdef V729_DEBUG
  321.   fprintf(stderr, "V729_CSR 0x0E = 0x%04X\n", mode);
  322.   VME_A24D16_R(V729_module+V729_CSR, &status);
  323.   usleep(V729_WAIT);
  324.   fprintf(stderr, "V729_CSR 0x0E = 0x%04X\n", status);
  325. #endif V729_DEBUG
  326.   return;
  327. }
  328.  
  329. //---------------------------------------------------------
  330. void V729_soft_stop( void ){
  331.   uint32_t sw=1;
  332.   VME_A24D16_W(V729_module+V729_SSR,sw);
  333. //  usleep(V729_WAIT);
  334.   sw =0;
  335.   VME_A24D16_W(V729_module+V729_OBR1,sw);
  336. //  usleep(V729_WAIT);
  337.   return;
  338. }
  339.  
  340. //---------------------------------------------------------
  341. void V729_clear_buffer( void ){
  342.     uint32_t data1,data2;
  343.     const int tout=100; /* 1/100 of a second */
  344.    
  345.   int cnt=0;
  346.   tmlnk (tout);
  347.  
  348.   do {
  349.     VME_A24D32_R(V729_module+V729_OBR1, &data1);
  350.  
  351.     if (ctrl_c|| GetTimerOut()) break;
  352.  
  353.  
  354.     cnt++;
  355.   } while (data1 & (0x3<<29));
  356.  
  357.   cnt=0;
  358.   do {
  359.     VME_A24D32_R(V729_module+V729_OBR2, &data2);
  360.  
  361.     if (ctrl_c|| GetTimerOut()) break;
  362.  
  363.     cnt++;
  364.   } while (data2 & (0x3<<29));
  365.  
  366.   tmulk();
  367.   return;
  368. }
  369.  
  370. void V729_get_buffer(uint32_t *data1, uint32_t *data2) {
  371.   VME_A24D32_R(V729_module+V729_OBR1, data1);
  372. //    usleep(V729_WAIT);
  373.   VME_A24D32_R(V729_module+V729_OBR2, data2);
  374. //    usleep(V729_WAIT);
  375.   return;
  376. }
  377.  
  378.  
  379.  
  380. //---------------------------------------------------------
  381. void V729_init(uint32_t addr, int nall, int cbl, uint32_t bias1, uint32_t bias2) {
  382.   V729_map(addr);
  383.   V729_info(stderr);
  384.   //V729_reset(nall,cbl,nall,0x1); // obaf = 1, disable start signals when there is at least one sample in the buffer
  385.   V729_reset(nall,cbl,nall,4000); // obaf = 1, disable start signals when there is at least one sample in the buffer
  386.   V729_set_bias(0,bias1,bias2);
  387.   V729_aquisition_mode(0);
  388. #ifndef WIN32
  389.   CAENVME_SetFIFOMode(udev,1);
  390.   sleep(1);
  391. #endif WIN32
  392. }
  393.  
  394.  
  395. //---------------------------------------------------------
  396. int V729_blt=0;
  397. int V729_SetBltMode(int mode) {
  398.   V729_blt = mode;
  399.   return mode;
  400. }
  401.  
  402. int V729_event(int mask, int nall, uint32_t *data,uint32_t *data1,uint32_t *data2) {
  403.   uint32_t status;
  404.   const int tout=200; /* 1/100 of a second */
  405.   int nb=0;
  406.   int count=0;
  407.   int i;
  408.   tmlnk (tout);
  409.  
  410.  
  411.   //status= 0x80 ; VME_A16D16_W(IREG_OFFSET+0x8,&status); // pulse ch 8
  412.   //status = 0x1a ; VME_A16D16_W(IREG_OFFSET+0xC,&status); // clr1 enable1  .... clear busy1 flag   // KEK magnet
  413.   //
  414.   do {
  415.  
  416.     VME_A24D16_R(V729_module+V729_CSR, &status);
  417.  
  418.     count++;
  419.     if (ctrl_c || GetTimerOut()) {
  420.       tmulk ();
  421.       printf("[%d] daq=%x status %x AE01=%d AE23=%d Waiting for DATA TRG bit... at line %d\n",count ,  (status>>4)&0x3,status, status&0x1,(status>>2)&0x1 , __LINE__);
  422.  
  423.       V729_clear_buffer();
  424.  
  425.       return -1;
  426.     }
  427.  
  428.   } while ((status & 0x5) ^ 0x5);
  429.   tmulk ();
  430.   //count =  (nall+5);
  431.   count =  (nall+1);
  432.   if (V729_blt) {
  433.  
  434. //#ifdef CAEN_V1718
  435. //  VME_A24D32_FIFOBLTR(V729_module+V729_OBR1,data1,count*sizeof(uint32_t),&nb);
  436. //  VME_A24D32_FIFOBLTR(V729_module+V729_OBR2,data2,count *sizeof(uint32_t),&nb);
  437. //#endif CAEN_V1718
  438.     for (i=0; i<count; i++) {
  439.       data[2*i]   = data1[i];
  440.       data[2*i+1] = data2[i];
  441.     }
  442.     nb*=2;
  443.   } else {
  444.     int nc=0;
  445.     int j=0;
  446.     VME_MRRST(); // MultiReadReset
  447.  
  448.     do {
  449.       VME_R(VME_A24,VME_D32,V729_module+V729_OBR1, &data[nc]);
  450.     } while ( !((data[nc]>>31)&0x1) );
  451.     nc++;
  452.     do {
  453.       VME_R(VME_A24,VME_D32,V729_module+V729_OBR2, &data[nc]);
  454.     } while ( !((data[nc]>>31)&0x1) );
  455.     nc++;
  456.     for (i=0; i<nall; i++) {
  457.       //if (mask & 0x3)
  458.       VME_MR(VME_A24,VME_D32,V729_module+V729_OBR1, &data[nc++]);
  459.       //if (mask & 0xc)
  460.       VME_MR(VME_A24,VME_D32,V729_module+V729_OBR2, &data[nc++]);
  461.     }
  462.  
  463.     j = nc;
  464.     if ( VME_GetInterface()!= WIENER_VMEMM ) j = VME_MREXEC(data); // MultiReadExecute  
  465.                                            
  466.  
  467.     nb=j*sizeof(uint32_t);
  468.  
  469.   }
  470.  
  471.   return nb;
  472. }
  473. int V729_plothandle;
  474. //---------------------------------------------------------
  475. int V729_plot(int first, uint16_t *buf ) {
  476. #ifdef _CVI_
  477.   int start=23;
  478.   int end=35;
  479.  
  480.   //const double maxy=2048;
  481.   const double maxy=512;
  482.   const double maxx=512;
  483.   //const double maxy=2048;
  484.   //const double maxy=128;
  485.   //const double maxy=512;
  486.   const int nx=500;
  487.  
  488.   const int ny=100;
  489.   const int h0=10;
  490.  
  491.   int i;
  492.   uint32_t *hdr = (uint32_t *)buf;
  493.   int nb= hdr[1]-2*sizeof(uint32_t);
  494.   int nitems = nb /sizeof(uint16_t);
  495.   unsigned int recid=hdr[0];
  496.   uint16_t *data = &buf[4];
  497.   double x,y;
  498.   double baseline=0;
  499.   double charge=0;
  500.  
  501.  
  502.   while (nitems>0) {
  503.     int id = data[0]-1;
  504.     int len= data[1]/sizeof(uint16_t)-2;
  505.  
  506.     if (CAEN_V729_param.verbose)  printf("\t->> recid=%d nb=%d nitems=%d id=%d len=%d\n", recid, hdr[1],nitems,id,len);
  507.     if (id>3) return 0;
  508.  
  509.     data+=2;
  510.  
  511.     if (first) {
  512.       for (i=0; i<4; i++) {
  513.         char hname[0xFF];
  514.         char htitle[0xFF];
  515.         sprintf (hname,"hwf%d",i);
  516.         sprintf (htitle,"CAEN V729 ch%d",i);
  517.         H2DInit(h0+i,hname, htitle ,len,-0.5,1,ny,-maxy,2*maxy/ny);
  518.         H2DSetTitleX(h0+i,"timebin");
  519.         H2DSetTitleY(h0+i,"pulse height");
  520.  
  521.         sprintf (hname,"hcharge%d",i);
  522.         sprintf (htitle,"CAEN V729 ch%d",i);
  523.         H1DInit(h0+i,hname, htitle ,nx,-maxx,2*maxx/nx);
  524.         H1DSetTitleX(h0+i,"timebin");
  525.         H1DSetTitleY(h0+i,"charge");
  526.       }
  527.       first=0;
  528.       // h1d=new TH1F("h1d","Charge;signal charge(a.u.);N",500,-maxy,5*maxy);
  529.  
  530.     }
  531.  
  532.     baseline=0;
  533.     for (i=0; i<20; i++) baseline += data[i];
  534.     baseline /=20.;
  535.     // baseline=2000;
  536.  
  537.  
  538.     for (i=0; i<len; i++) {
  539.       if (CAEN_V729_param.verbose >2) printf("ADC %d %d\n", i, data[i]);
  540.       x=i;
  541.       y=data[i];
  542.       y-=baseline;
  543.       if (i>=start && i<end) charge += y;
  544.  
  545.       H2DFill(h0+id,x,y,1);
  546.     }
  547.     charge /=(end-start);
  548.     H1DFill(h0+id,charge,1);
  549.  
  550.     data+=len;
  551.     nitems=nitems - len-2;
  552.     //if (id==2) h1d->Fill(charge);
  553.   }
  554. #else
  555. #warning _CVI_ is not defined  
  556. #endif _CVI_
  557.  
  558.   return 0;
  559. }
  560.  
  561. //---------------------------------------------------------
  562. int V729_decode(uint32_t mask, int nall, uint32_t *data,  uint16_t *dadc, int debug) {
  563.  
  564.   int hdrlen=6;  // 4+2
  565.   uint16_t *adc[4]= {0};
  566.   int i,j;
  567.  
  568.   int nc=0;
  569.   int narrays=0;
  570.  
  571.  
  572.   int indx[4] = {0,0,0,0};
  573.   int shft[4] = {0,0,0,0};
  574.   int ashft[4]= {0,0,0,0};
  575.   int nmask=0;
  576.  
  577.   for (i=0; i<4; i++) {
  578.     adc[i] = &dadc[hdrlen+i*(nall+2)];
  579.     // printf("---->ID %d len %d ,%d\n",dadc[hdrlen+i*(nall-2)],dadc[hdrlen+i*(nall-1)],hdrlen+i*(nall+2)) ;
  580.   }
  581.   if (mask & 0x3) narrays++;
  582.   if (mask & 0xc) narrays++;
  583.  
  584.   for (i=0; i<4; i++) if (mask & (1<<i) ) {
  585.       indx[nmask] = i;
  586.       shft[nmask] = (i%2)*12;
  587.       if (( (mask & 0x3) > 0 ) && (i>1))  ashft[nmask]=1;
  588.       else ashft[nmask]=0;
  589.       nmask++;
  590.     }
  591.   for (j=0; j<nmask; j++) {
  592.     nc=0;
  593.     for (i=0; i<nall+1; i++) {
  594.       int ii=narrays*i+ashft[j];
  595.  
  596.       uint32_t data1 = data[ii];
  597.  
  598.       if (data1 & (1<<31)) {
  599.         if (debug)
  600.           fprintf(stdout,"data1: empty flags: 0x%X, time tag: 0x%06X %d\n", (data1>>29) & 0x3, data1 & 0xFFFFFF, data1 & 0xFFFFFF);
  601.       } else if ((data1>>29) & 0x3) {
  602.         if (nc<nall) {
  603.           adc[j][nc] = (data1>>shft[j]) & 0xFFF;
  604.           if (debug >2) printf("[%d/%d] ADC%d adc0=%d\n", i,nc,indx[j], adc[j][nc]);
  605.           nc++;
  606.         }
  607.  
  608.       } else {
  609.         if (debug) fprintf(stdout,"Data(%4d) %d indx=%d %d nc=%d(%d) %d 0x%08X\n", i, indx[j],narrays*i+ashft[j],j,nc,nmask,narrays, data1);
  610.       }
  611.     }
  612.   }
  613.   return nc;
  614. }
  615.  
  616. //---------------------------------------------------------
  617. void V729_Usage(void) {
  618.  
  619.   printf ("*********************************************************************************:\n");
  620.   printf ("Usage: CAEN_V729 <arguments> .........   CAEN V729A data aquisition:\n\n");
  621.   printf ("Arguments: \n");
  622.   printf ("-d <debuglevel>  \n");
  623.   printf ("-b <bias+>  \n");
  624.   printf ("-e <bias->  \n");
  625.   printf ("-a <VME address>  \n");
  626.   printf ("-c <n samples before stop>  \n");
  627.   printf ("-n <number of events> \n");
  628.   printf ("-l <nall> number of samples \n");
  629.   printf ("-m <channel mask: 4bits (1 bit/ch)> \n");
  630.   printf ("-o <output file name> \n");
  631.  
  632.   printf ("*********************************************************************************:\n");
  633. }
  634. //---------------------------------------------------------
  635. // test program
  636.  
  637. int V729_GetParams(int argc,char **argv) {
  638. #ifdef _CVI_
  639.   int p = CAEN_V729_param.panel;
  640.   GetCtrlVal(p,P4_MASK,&CAEN_V729_param.mask);
  641.   GetCtrlVal(p,P4_CBL ,&CAEN_V729_param.cbl);
  642.   GetCtrlVal(p,P4_NALL,&CAEN_V729_param.nall);
  643.   GetCtrlVal(p,P4_FILENAME,CAEN_V729_param.filename);
  644.   GetCtrlVal(p,P4_VERBOSE,&CAEN_V729_param.verbose);
  645.   GetCtrlVal(p,P4_NEVE,&CAEN_V729_param.neve);
  646.   GetCtrlVal(p,P4_ADDR,&CAEN_V729_param.addr);
  647.   GetCtrlVal(p,P4_BIAS1,&CAEN_V729_param.bias1);
  648.   GetCtrlVal(p,P4_BIAS2,&CAEN_V729_param.bias2);
  649.   GetCtrlVal(p,P4_FRACTION,&CAEN_V729_param.fraction);
  650.  
  651. # else _CVI_
  652.   CAEN_V729_param.mask=0xF;
  653.   CAEN_V729_param.cbl=13;
  654.   CAEN_V729_param.nall=1330;
  655.   CAEN_V729_param.filename= 0;
  656.   CAEN_V729_param.verbose = 0;
  657.   CAEN_V729_param.neve    = 1;
  658.   CAEN_V729_param.addr = V729_OFFSET;
  659.   CAEN_V729_param.bias1 = 0x500; // vecje vrednosti povzrocajo tezave in zacno kanali oscilirat ....
  660.   CAEN_V729_param.bias2 = 0x500;
  661.   CAEN_V729_param.append = 0;
  662.   CAEN_V729_param.fp = NULL;
  663.   CAEN_V729_param.fraction = 0;
  664.   int c=0;
  665.   while ((c = getopt (argc, argv, "b:e:a:d:c:l:n:o:m:f:r:")) != -1)
  666.     switch (c) {
  667.       case 'd':
  668.         CAEN_V729_param.verbose=atoi(optarg);
  669.         break;
  670.       case 'c':
  671.         CAEN_V729_param.cbl=atoi(optarg);
  672.         break;
  673.       case 'l':
  674.         CAEN_V729_param.nall=atoi(optarg);
  675.  
  676.         if (CAEN_V729_param.nall%16) {
  677.           printf ("buffer length should be multiple of 16 , modulo = %d\n",CAEN_V729_param.nall%16);
  678.           // exit(-1);
  679.         }
  680.         break;
  681.       case 'n':
  682.         CAEN_V729_param.neve=atoi(optarg);
  683.         break;
  684.       case 'r':
  685.         CAEN_V729_param.fraction=atof(optarg);
  686.         break;
  687.       case 'a':
  688.         CAEN_V729_param.addr=strtoul (optarg,NULL,0);
  689.         break;             // address
  690.       case 'b':
  691.         CAEN_V729_param.bias1=strtoul (optarg,NULL,0);
  692.         break;             // bias
  693.       case 'e':
  694.         CAEN_V729_param.bias2=strtoul (optarg,NULL,0);
  695.         break;             // bias
  696.  
  697.       case 'm':
  698.         CAEN_V729_param.mask=strtoul (optarg,NULL,0);
  699.         break;             // mask
  700.       case 'o':
  701.         sprintf(CAEN_V729_param.filename,"%s", optarg );
  702.         CAEN_V729_param.append=0;
  703.         break;       // output
  704.       case 'f':
  705.         sprintf(CAEN_V729_param.filename,"%s", optarg );
  706.         CAEN_V729_param.append=1;
  707.         break;       // output
  708.     }
  709. #endif _CVI_
  710.   return 0;
  711. }
  712.  
  713. int V729_LoadPanel (int Parent_Panel_Handle, char Filename[], int Panel_Resource_ID) {
  714.  
  715.   CAEN_V729_param.panel = LoadPanel(Parent_Panel_Handle, Filename, Panel_Resource_ID);
  716.   return CAEN_V729_param.panel;
  717. }
  718.  
  719.  
  720.  
  721. #ifdef _CVI_
  722. int CVICALLBACK HDrawCB (int panel, int control, int event,
  723.                          void *callbackData, int eventData1, int eventData2) {
  724.   int ch=0,type=0;
  725.   switch (event) {
  726.     case EVENT_COMMIT:
  727.       GetCtrlVal(CAEN_V729_param.panel,P4_ADCCH, &ch);
  728.       GetCtrlVal(CAEN_V729_param.panel,P4_HDISPLAY, &type);
  729.       if (type) {
  730.         H2DDraw(10+ch,CAEN_V729_param.panel,P4_GRAPH, &V729_plothandle);
  731.       } else {
  732.         H1DDraw(10+ch,CAEN_V729_param.panel,P4_GRAPH, &V729_plothandle);
  733.       }
  734.       break;
  735.   }
  736.   return 0;
  737. }
  738.  
  739. int CVICALLBACK V729_daq(void *functionData) {
  740.   return V729_main ( 0, NULL);
  741. }
  742. #endif _CVI_
  743.  
  744. void CatchSig (int i) {
  745.   ctrl_c = 1;
  746. }
  747.  
  748. int p4h;
  749.  
  750. int  V729_SetFilePointer (FILE *fp) {
  751.   CAEN_V729_param.fp = fp;
  752.   return 0;
  753. }
  754.  
  755. int  V729_main (int argc,char **argv) {
  756.   int hdrlen=4; // number of u16 words
  757.   FILE *fp=NULL;
  758.   int output=0;
  759.   int bsize;
  760.   int nmask,imask;
  761.   int i,ch, len,nb;
  762.   int adclen;
  763.   uint32_t *data , *data1 ,*data2 ;
  764.   uint16_t *adc ;
  765.   uint32_t *evhdr;
  766.   int ncount =0;
  767.   int nerrors=0;
  768.   int nball  =0;
  769.  
  770.  
  771.   // reset timers
  772.   time_t t,told=0, tstart;
  773.   time(&t);
  774.   tstart=t;
  775.   InitializeTimerOut();
  776.   printf("V729_main \n");
  777.   V729_GetParams(argc,argv);
  778.   // open file
  779.   if (CAEN_V729_param.fp !=NULL) {
  780.     fp= CAEN_V729_param.fp;
  781.     output=2;
  782.     printf("V729_main Data file is already opened\n");
  783.   } else {
  784.     if (strlen(CAEN_V729_param.filename)>0) {
  785.       if (CAEN_V729_param.verbose) printf("Data in the file:%s\n", CAEN_V729_param.filename);
  786.       if (CAEN_V729_param.append) fp=fopen(CAEN_V729_param.filename,"a");
  787.       else        fp=fopen(CAEN_V729_param.filename,"w");
  788.       output=1;
  789.     }
  790.   }
  791.  
  792.  
  793.   // allocate storage
  794.  
  795.   bsize = sizeof(uint32_t)*2*(CAEN_V729_param.nall+1);
  796.   data  = (uint32_t *)malloc(bsize);
  797.   data1 = (uint32_t *)malloc(bsize);
  798.   data2 = (uint32_t *)malloc(bsize);
  799.   nmask=0;
  800.   for (i=0; i<4; i++) if (CAEN_V729_param.mask & (1<<i)) nmask++;
  801.   adclen = CAEN_V729_param.nall+2;
  802.   len    = nmask* adclen+hdrlen;
  803.   adc = (uint16_t *) malloc(len  *sizeof(uint16_t)); // 4 channels + 4 ch header + 1 event hdr
  804.  
  805.   // write headers
  806.   evhdr  = (uint32_t *) &adc[0];
  807.   evhdr[0] = CAENV729REC_ID;
  808.   evhdr[1] = len  *sizeof(uint16_t);
  809.   imask=0;
  810.   for (ch=0; ch<4; ch++) {
  811.     if (  CAEN_V729_param.mask & (1<<ch) ) {
  812.       uint16_t *chhdr= &adc[hdrlen+imask*adclen];
  813.       chhdr[0] = (uint16_t) ch+1;
  814.       chhdr[1] = (uint16_t) adclen * sizeof(uint16_t);
  815.       //printf("========>%d %d [%d,%d,%d]hdr=%d %d\n",ch, hdrlen+imask*adclen,hdrlen,imask,adclen,chhdr[0],chhdr[1]);
  816.       imask++;
  817.  
  818.     }
  819.   }
  820.  
  821.   // start
  822.  
  823.  
  824.   // open VME and initialize board
  825.  
  826.   V729_init(CAEN_V729_param.addr, CAEN_V729_param.nall, CAEN_V729_param.cbl, CAEN_V729_param.bias1,CAEN_V729_param.bias2);
  827.  
  828.   // event loop
  829.   for (i=0; i<CAEN_V729_param.neve; i++) {
  830.     GetCtrlVal(CAEN_V729_param.panel,P4_VERBOSE,&CAEN_V729_param.verbose);
  831.     if ( CAEN_V729_param.verbose) printf("neve=%d\n",i);
  832.     nb = V729_event(CAEN_V729_param.mask,CAEN_V729_param.nall,data, data1,data2);
  833.  
  834.     if (ctrl_c) {
  835.  
  836.       break;
  837.     }
  838.     if (nb<0) {  // timeout
  839.       i--;
  840.       nerrors++;
  841.     } else {
  842.  
  843.       V729_decode(CAEN_V729_param.mask,CAEN_V729_param.nall,data,adc, CAEN_V729_param.verbose);
  844.  
  845. #ifdef _CVI_
  846.       V729_plot(!i, adc );
  847. #endif _CVI_
  848.  
  849.       if (output) {
  850.         if (Random(0,1)<CAEN_V729_param.fraction) {
  851.           nball += fwrite(adc  ,   1, sizeof(uint16_t)*len, fp);
  852.         }
  853.       }
  854.       ncount++;
  855.     }
  856.     time(&t);
  857. #ifdef _CVI_
  858.     if (t/4!=told ) {
  859.       double done=0;
  860.       if (CAEN_V729_param.neve) done= (double) (i)/CAEN_V729_param.neve;
  861.       HDrawCB ( 0, 0, EVENT_COMMIT ,NULL, 0,0);
  862.  
  863.       EstimatedFinish(CAEN_V729_param.panel, P4_PROGRESS, P4_ETA, tstart, done);
  864.     }
  865. #endif _CVI_
  866.     if (t/4!=told ) printf("%d events in %2.2f min (%d s) TIMEOUTS=%d %s",ncount, (double)(t-tstart)/60.,(int)(t-tstart), nerrors, ctime(&t));
  867.     told=t/4;
  868.   }
  869. #ifdef _CVI_
  870.   HDrawCB ( 0, 0, EVENT_COMMIT ,NULL, 0,0);
  871. #endif _CVI_
  872.   // end
  873.   if (output) {
  874.     for (ch=0; ch<4; ch++) {
  875.       if (  CAEN_V729_param.mask & (1<<ch) ) {
  876.         H2DWrite2File(10+ch,fp);
  877.         H1DWrite2File(10+ch,fp);
  878.       }
  879.     }
  880.     if (output==1) fclose(fp);
  881.   }
  882.   CAEN_V729_param.fp = NULL;
  883.   free(data);
  884.   free(data2);
  885.   free(data1);
  886.   free(adc);
  887.   time(&t);
  888.   printf("%d events in %2.2f min  (%d s)  TIMEOUTS=%d  %s\n",ncount, (double)(t-tstart)/60.,(int)(t-tstart), nerrors, ctime(&t));
  889.   return 0;
  890. }
  891.  
  892.  
  893.  
  894. #ifdef V729_MAIN
  895. int main(int argc,char **argv) {
  896.   if (argc == 1) {
  897.  
  898.     V729_Usage();
  899.     exit (-1);
  900.   }
  901.   // intercept routine
  902.   if (signal (SIGINT, CatchSig) == SIG_ERR)  perror ("sigignore");
  903.   VME_START(NULL);
  904.   V729_main (argc,argv);
  905.   VME_STOP();
  906.   return ;
  907. }
  908. #endif V729_MAIN
  909.  
  910. #ifdef V729_WINMAIN
  911.  
  912. int CVICALLBACK HidePanelCB (int panel, int control, int event,
  913.                              void *callbackData, int eventData1, int eventData2) {
  914.   switch (event) {
  915.     case EVENT_COMMIT:
  916.       HidePanel (panel);
  917.       break;
  918.   }
  919.   return 0;
  920. }
  921.  
  922.  
  923. void SetDimming(int state) {
  924.   SetCtrlAttribute (p4h, P4_DAQ, ATTR_DIMMED, state);
  925.   SetCtrlAttribute (p4h, P4_STOP, ATTR_DIMMED, !state);
  926. }
  927.  
  928. void CVICALLBACK EndOfThread (int poolHandle, int functionID, unsigned int event, int value, void *callbackData) {
  929.  
  930.  
  931.   SetDimming(0);
  932.   printf("End of Thread \n");
  933.   return ;
  934.  
  935. }
  936.  
  937. static int poolHandle = 0;
  938. static int p1h, pID, rID, tfID;
  939. #  define MAX_THREADS 10
  940. int __stdcall WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
  941.                        LPSTR lpszCmdLine, int nCmdShow) {
  942.   char title[0xFF]="";
  943.   int i;
  944.   if (InitCVIRTE (hInstance, 0, 0) == 0)
  945.     return -1;  /* out of memory */
  946.  
  947.   SetSleepPolicy(VAL_SLEEP_MORE);
  948.   CmtNewThreadPool (MAX_THREADS, &poolHandle);
  949.  
  950.   VME_START(WIENER_VMEMM);
  951.   SetStdioPort (CVI_STDIO_WINDOW );
  952.   if ((p4h = V729_LoadPanel (0, "CAEN_V729_CVI.uir", P4)) < 0)
  953.     return -1;
  954.  
  955.   GetPanelAttribute (p4h, ATTR_TITLE, title );
  956.  
  957.   SetPanelAttribute (p4h, ATTR_TITLE, title );
  958.  
  959.  
  960.   DisplayPanel (p4h);
  961.  
  962.   InitColors();
  963.  
  964.   do {
  965.     ThreadFunctionPtr mythread = NULL;
  966.     GetUserEvent (1, &pID, &rID);
  967.  
  968.  
  969.     if (pID ==p4h && rID == P4_DAQ            ) mythread=V729_daq;
  970.     if (mythread!=NULL) {
  971.       printf("New Thread panel=%d button=%d\n", pID, rID);
  972.       ctrl_c=0;
  973.  
  974.  
  975.       CmtScheduleThreadPoolFunctionAdv (poolHandle, mythread, &rID,
  976.                                         DEFAULT_THREAD_PRIORITY,
  977.                                         EndOfThread,
  978.                                         EVENT_TP_THREAD_FUNCTION_END,
  979.                                         NULL, RUN_IN_SCHEDULED_THREAD,
  980.                                         &tfID);
  981.       SetDimming(1);
  982.     }
  983.  
  984.     if ( pID==p4h && rID == P4_STOP ) {
  985.       printf("Stopping the  Thread %d\n", tfID);
  986.       ctrl_c=1;
  987.     }
  988.     if ( pID==p4h && rID == P4_HIDE ) {
  989.       printf("Exit\n");
  990.       break;
  991.     }
  992.   } while (1);
  993.  
  994.   CmtDiscardThreadPool (poolHandle);
  995.   DiscardPanel (p4h);
  996.  
  997.   VME_STOP();
  998.   return 0;
  999. }
  1000. #endif V729_WINMAIN
  1001.