Subversion Repositories f9daq

Rev

Blame | Last modification | View Log | RSS feed

  1. #include <ansi_c.h>
  2. #include "CAENV673A.h"
  3. #include "CAENV673A_DEF.h"
  4. //#include "pcivme_dll.h"
  5. #ifdef SISVME
  6. #include "sisvme_dll.h"
  7. #endif
  8. #ifdef WIENVME
  9. #include "wienvme_dll.h"
  10. #endif
  11. #ifdef WUSBVME
  12. #include "wusbvme_dll.h"
  13. #endif
  14.  
  15. unsigned int ModuleAddress[10];
  16. static const unsigned short bufevnum[2][4]=
  17.     {CAENV673A_ENR0B0, CAENV673A_ENR0B1, CAENV673A_ENR0B2, CAENV673A_ENR0B3,
  18.      CAENV673A_ENR1B0, CAENV673A_ENR1B1, CAENV673A_ENR1B2, CAENV673A_ENR1B3};
  19.  
  20. int V673A_map (int ModuleNumber,
  21.                          unsigned long ModuleOffset, int print)
  22. {
  23.   unsigned long vsr, mmt, fix;
  24.  
  25.   ModuleAddress[ModuleNumber] =  ModuleOffset;
  26.   VME_A24D16_R(ModuleAddress[ModuleNumber] + CAENV673A_FIX, &fix);
  27.   VME_A24D16_R(ModuleAddress[ModuleNumber] + CAENV673A_MMT, &mmt);
  28.   VME_A24D16_R(ModuleAddress[ModuleNumber] + CAENV673A_VSR, &vsr);
  29.   if (print) {
  30.     printf("fixed code = 0x%04x\n", fix);
  31.     printf("manufacturer number = %i\n", MANUFACTURER(mmt));
  32.     printf("module type = %i\n", MODULE_TYPE(mmt));
  33.     printf("version = %i\n", VERSION(vsr));
  34.     printf("serial no. = %i\n", SERIAL(vsr));
  35.   }
  36.   if ((fix != CAEN_FIX_CODE) || (mmt != CAENV673A_MMT_VALUE)) return -1;
  37.   return 0;
  38. }
  39.  
  40. int V673A_init (int ModuleNumber)
  41. {
  42.   unsigned long dum16;
  43.   VME_A24D16_R(ModuleAddress[ModuleNumber] + CAENV673A_CLRTDC, &dum16);
  44.  
  45.   dum16= 0xF77F;
  46.   VME_A24D16_W(ModuleAddress[ModuleNumber] + CAENV673A_MCR0,dum16);
  47.   dum16= 0xF77F;
  48.   VME_A24D16_W(ModuleAddress[ModuleNumber] + CAENV673A_MCR1, dum16);
  49.  
  50.   VME_A24D16_R(ModuleAddress[ModuleNumber] + CAENV673A_CLALLB, &dum16);
  51.   /* range 2**(NBITS+1)*1.0416s
  52.      NBITS =
  53.              4         32 ns
  54.              5         64
  55.              6         128
  56.              7         256
  57.              8         512
  58.              9        1024
  59.              A        2048
  60.              B        4096
  61.              C        8200
  62.              D       16400
  63.              E       32000
  64.    */          
  65.   dum16=0x003A;// RANGE  2048 ns
  66.   //dum16=0x003E; //range 32us  
  67.   VME_A24D16_W(ModuleAddress[ModuleNumber] + CAENV673A_CRR0, dum16);
  68.   VME_A24D16_W(ModuleAddress[ModuleNumber] + CAENV673A_CRR1, dum16);
  69.  
  70.   dum16=0x001A;
  71.   VME_A24D16_W(ModuleAddress[ModuleNumber] + CAENV673A_CLKCR0, dum16);
  72.   VME_A24D16_W(ModuleAddress[ModuleNumber] + CAENV673A_CLKCR1, dum16);
  73.  
  74.   VME_A24D16_R(ModuleAddress[ModuleNumber] + CAENV673A_BEGDLL, &dum16);
  75.   VME_A24D16_R(ModuleAddress[ModuleNumber] + CAENV673A_CLALLB, &dum16);
  76.  
  77.   dum16=0xF35F; // both edges  + stop mode
  78.   VME_A24D16_W(ModuleAddress[ModuleNumber] + CAENV673A_MCR0, dum16);
  79.   VME_A24D16_W(ModuleAddress[ModuleNumber] + CAENV673A_MCR1, dum16);
  80.  
  81.   dum16=0xFFFF;
  82.   VME_A24D16_W(ModuleAddress[ModuleNumber] + CAENV673A_MR0L, dum16);
  83.   VME_A24D16_W(ModuleAddress[ModuleNumber] + CAENV673A_MR0H, dum16);
  84.   VME_A24D16_W(ModuleAddress[ModuleNumber] + CAENV673A_MR1L, dum16);
  85.   VME_A24D16_W(ModuleAddress[ModuleNumber] + CAENV673A_MR1H, dum16);
  86.  
  87.   return 0;
  88. }
  89.  
  90. int V673A_status (int ModuleNumber)
  91. {
  92.   unsigned long dum16;
  93.   VME_A24D16_R(ModuleAddress[ModuleNumber] + CAENV673A_BSR, &dum16);
  94.   return dum16;
  95. }
  96.  
  97. int V673A_ntrig (int ModuleNumber)
  98. {
  99.   unsigned long ntr[2];
  100.  
  101.   VME_A24D16_R(ModuleAddress[ModuleNumber] + CAENV673A_ENR0, &ntr[0] );
  102.   VME_A24D16_R(ModuleAddress[ModuleNumber] + CAENV673A_ENR1, &ntr[1] );
  103.  
  104.   if (ntr[0] == ntr[1]) return ntr[0];
  105.   else printf ("CAENV673A [%d] ENR0=%04x ENR1=%04x\n",ModuleNumber, ntr[0],ntr[1]);
  106.   return -1;
  107. }
  108.  
  109. int V673A_read0 (int ModuleNumber, unsigned long whereto[], int size)
  110. {
  111.   unsigned long status, ndata;
  112.   unsigned int data;
  113.  
  114.   ndata = 0;
  115.   if (size<=0) return 0;
  116.  
  117.   VME_A24D16_R(ModuleAddress[ModuleNumber] + CAENV673A_BSR, &status);
  118.   if (!(status & (1<<5))) {
  119.     //printf ("CAENV673A  BSR STATUS=%04x\n",status);
  120.     return 0;
  121.   }
  122.   VME_A24D32_R(ModuleAddress[ModuleNumber] + CAENV673A_SEQ0, &data  );
  123.   *whereto= data;
  124.   if ((*whereto) & (1<<23)) {
  125.     ndata++;
  126.     do {  
  127.     VME_A24D32_R(ModuleAddress[ModuleNumber] + CAENV673A_SEQ0, &data);
  128.       *(++whereto) = data;
  129.       ndata++;
  130.     } while (!((*whereto) & ((1<<30) | (1<<31))) && ndata<size);
  131.     if (ndata>=size) {
  132.        
  133.        printf("V673A_read0 Increase buffer size ndata=%d\ndata=0x%x\n", ndata,data);  
  134.        return ndata;
  135.     }
  136.     if (!((*whereto) & (1<<31))) return ndata;
  137.   }
  138.    
  139.   return 0;  
  140.  
  141. }
  142.  
  143. int V673A_read1 (int ModuleNumber, unsigned long whereto[], int size)
  144. {
  145.   unsigned long  status, ndata;
  146.   unsigned int data;
  147.  
  148.   ndata = 0;
  149.   if (size<=0) return 0;
  150.  
  151.   VME_A24D16_R(ModuleAddress[ModuleNumber] + CAENV673A_BSR, &status);
  152.   if (!(status & (1<<7))) return 0;
  153.  
  154.  
  155.   VME_A24D32_R(ModuleAddress[ModuleNumber] + CAENV673A_SEQ1, &data);
  156.   *whereto = data;    
  157.   if ((*whereto) & (1<<23)) {
  158.     ndata++;
  159.     do {
  160.     VME_A24D32_R(ModuleAddress[ModuleNumber] + CAENV673A_SEQ1, &data);  
  161.       *(++whereto) =  data;
  162.       ndata++;
  163.     } while (!((*whereto) & ((1<<30) | (1<<31))) && ndata<size);
  164.     if (ndata>=size) {
  165.        printf("V673A_read1 Increase buffer size ndata=%d\ndata=0x%x\n", ndata,data);
  166.        return ndata;
  167.     }
  168.     if (!((*whereto) & (1<<31))) return ndata;
  169.   }
  170.    
  171.   return 0;  
  172.  
  173. }
  174.  
  175. int V673A_firstevnt (int ModuleNumber)
  176. {
  177.   unsigned long status, ptr;
  178.   int evn[2];
  179.  
  180.   VME_A24D16_R(ModuleAddress[ModuleNumber] + CAENV673A_BSR, &status);
  181.   if (!(status & 0x8000)) return -1;
  182.  
  183.   if (status & 0x0020) {
  184.     VME_A24D16_R(ModuleAddress[ModuleNumber] + CAENV673A_PTR0, &ptr);
  185.     ptr &= 0x3;
  186.     evn[0]=0;
  187.     VME_A24D16_R(ModuleAddress[ModuleNumber] + bufevnum[0][ptr], &evn[0]);
  188.    } else {
  189.     evn[0]=0x10000;
  190.   }
  191.   if (status & 0x0080) {
  192.     VME_A24D16_R(ModuleAddress[ModuleNumber] + CAENV673A_PTR1, &ptr);
  193.     ptr &= 0x3;
  194.     evn[1]=0;
  195.     VME_A24D16_R(ModuleAddress[ModuleNumber] + bufevnum[1][ptr], &evn[1]);
  196.    } else {
  197.     evn[1]=0x10000;
  198.   }
  199.   //printf ("first event [%d] evn: %d %d \n",ModuleNumber ,evn[0]&0xffff,evn[1]&0xffff);
  200.   if (evn[0] < evn[1]) {
  201.     return evn[0];
  202.    } else {
  203.     return evn[1];
  204.   }
  205. }
  206.  
  207. int V673A_getevnt (int ModuleNumber, int evn, unsigned long whereto[], int size)
  208. {
  209.   unsigned long dum16;
  210.   unsigned long status, bptr, bevn, ndata;
  211.   int msize=size;
  212.   ndata=0;
  213.  
  214.   VME_A24D16_R(ModuleAddress[ModuleNumber] + CAENV673A_BSR, &status);
  215.   if (!(status & 0x8000)) return -1;
  216.  
  217.   while (1) {
  218.     if (status & 0x0020) {
  219.       VME_A24D16_R(ModuleAddress[ModuleNumber] + CAENV673A_PTR0, &bptr);
  220.       bptr &= 0x3;
  221.       VME_A24D16_R(ModuleAddress[ModuleNumber] + bufevnum[0][bptr], &bevn);
  222.       if (bevn == evn) {
  223.         ndata += V673A_read0(ModuleNumber, whereto, msize);
  224.         msize-=ndata;
  225.         whereto += ndata;
  226.         break;
  227.        } else if (bevn < evn) {
  228.         VME_A24D16_R(ModuleAddress[ModuleNumber] + CAENV673A_CLRCB0, &dum16);
  229.         VME_A24D16_R(ModuleAddress[ModuleNumber] + CAENV673A_BSR, &status);
  230.         if (!(status & 0x8000)) return ndata;
  231.        } else {
  232.         break;
  233.       }
  234.      } else {
  235.       break;
  236.     }
  237.   }
  238.   while (1) {
  239.     if (status & 0x0080) {
  240.       VME_A24D16_R(ModuleAddress[ModuleNumber] + CAENV673A_PTR1, &bptr);
  241.       bptr &= 0x3;
  242.       VME_A24D16_R(ModuleAddress[ModuleNumber] + bufevnum[1][bptr], &bevn);
  243.       if (bevn == evn) {
  244.         ndata += V673A_read1(ModuleNumber, whereto, msize);
  245.         msize-=ndata;
  246.         break;
  247.        } else if (bevn < evn) {
  248.         VME_A24D16_R(ModuleAddress[ModuleNumber] + CAENV673A_CLRCB1, &dum16);
  249.         VME_A24D16_R(ModuleAddress[ModuleNumber] + CAENV673A_BSR, &status);
  250.         if (!(status & 0x8000)) return ndata;
  251.        } else {
  252.         break;
  253.       }
  254.      } else {
  255.       break;
  256.     }
  257.   }
  258.   return ndata;  
  259. }
  260.  
  261.  
  262.  
  263. int V673A_clallb (int ModuleNumber){
  264.   unsigned long dum16;  
  265.   VME_A24D16_R(ModuleAddress[ModuleNumber] + CAENV673A_CLALLB, &dum16);
  266.   return 0;
  267. }
  268.  
  269. int V673A_getreg (int ModuleNumber, int reg){
  270.   unsigned long dum16;
  271.   VME_A24D16_R(ModuleAddress[ModuleNumber] + reg, &dum16);
  272.   return dum16;
  273. }
  274.  
  275. void V673A_setreg (int ModuleNumber, int reg, int set){
  276.   unsigned long dum16=set;
  277.   VME_A24D16_W(ModuleAddress[ModuleNumber] + reg, dum16);
  278.   return;
  279. }
  280.