v1190B.h File Reference

Go to the source code of this file.

Defines

#define V1190_MAX_CHANNELS   (DWORD) 64
#define V1190_REG_BASE   (DWORD) (0x1000)
#define V1190_CR_RW   (DWORD) (0x1000)
#define V1190_SR_RO   (DWORD) (0x1002)
#define V1190_DATA_READY   (DWORD) (0x0001)
#define V1190_ALMOST_FULL   (DWORD) (0x0002)
#define V1190_FULL   (DWORD) (0x0004)
#define V1190_TRIGGER_MATCH   (DWORD) (0x0008)
#define V1190_HEADER_ENABLE   (DWORD) (0x0010)
#define V1190_GEO_REG_RW   (DWORD) (0x001E)
#define V1190_MODULE_RESET_WO   (DWORD) (0x1014)
#define V1190_SOFT_CLEAR_WO   (DWORD) (0x1016)
#define V1190_SOFT_EVT_RESET_WO   (DWORD) (0x1018)
#define V1190_SOFT_TRIGGER_WO   (DWORD) (0x101A)
#define V1190_EVT_CNT_RO   (DWORD) (0x101C)
#define V1190_EVT_STORED_RO   (DWORD) (0x1020)
#define V1190_FIRM_REV_RO   (DWORD) (0x1026)
#define V1190_MICRO_HAND_RO   (DWORD) (0x1030)
#define V1190_MICRO_RW   (DWORD) (0x102E)
#define V1190_WINDOW_WIDTH_WO   (WORD) (0x1000)
#define V1190_WINDOW_OFFSET_WO   (WORD) (0x1100)
#define V1190_MICRO_WR_OK   (WORD) (0x0001)
#define V1190_MICRO_RD_OK   (WORD) (0x0002)
#define V1190_MICRO_TDCID   (WORD) (0x6000)
#define V1190_EDGE_DETECTION_WO   (WORD) (0x2200)
#define V1190_LE_RESOLUTION_WO   (WORD) (0x2400)
#define V1190_LEW_RESOLUTION_WO   (WORD) (0x2500)
#define V1190_RESOLUTION_RO   (WORD) (0x2600)
#define V1190_TRIGGER_MATCH_WO   (WORD) (0x0000)
#define V1190_CONTINUOUS_WO   (WORD) (0x0100)
#define V1190_ACQ_MODE_RO   (WORD) (0x0200)
#define LE_RESOLUTION_100   (WORD) (0x10)
#define LE_RESOLUTION_200   (WORD) (0x01)
#define LE_RESOLUTION_800   (WORD) (0x00)

Functions

int udelay (int usec)
WORD v1190_Read16 (MVME_INTERFACE *mvme, DWORD base, int offset)
DWORD v1190_Read32 (MVME_INTERFACE *mvme, DWORD base, int offset)
void v1190_Write16 (MVME_INTERFACE *mvme, DWORD base, int offset, WORD value)
int v1190_EventRead (MVME_INTERFACE *mvme, DWORD base, DWORD *pdest, int *nentry)
int v1190_DataRead (MVME_INTERFACE *mvme, DWORD base, DWORD *pdest, int nentry)
void v1190_SoftReset (MVME_INTERFACE *mvme, DWORD base)
void v1190_SoftClear (MVME_INTERFACE *mvme, DWORD base)
void v1190_SoftTrigger (MVME_INTERFACE *mvme, DWORD base)
void v1190_DataReset (MVME_INTERFACE *mvme, DWORD base)
int v1190_DataReady (MVME_INTERFACE *mvme, DWORD base)
int v1190_EvtCounter (MVME_INTERFACE *mvme, DWORD base)
int v1190_EvtStored (MVME_INTERFACE *mvme, DWORD base)
int v1190_MicroCheck (MVME_INTERFACE *mvme, const DWORD base, int what)
int v1190_MicroWrite (MVME_INTERFACE *mvme, DWORD base, WORD data)
int v1190_MicroRead (MVME_INTERFACE *mvme, const DWORD base)
int v1190_MicroFlush (MVME_INTERFACE *mvme, const DWORD base)
void v1190_TdcIdList (MVME_INTERFACE *mvme, DWORD base)
int v1190_ResolutionRead (MVME_INTERFACE *mvme, DWORD base)
void v1190_LEResolutionSet (MVME_INTERFACE *mvme, DWORD base, WORD le)
void v1190_LEWResolutionSet (MVME_INTERFACE *mvme, DWORD base, WORD le, WORD width)
void v1190_TriggerMatchingSet (MVME_INTERFACE *mvme, DWORD base)
void v1190_AcqModeRead (MVME_INTERFACE *mvme, DWORD base)
void v1190_ContinuousSet (MVME_INTERFACE *mvme, DWORD base)
void v1190_WidthSet (MVME_INTERFACE *mvme, DWORD base, WORD width)
void v1190_OffsetSet (MVME_INTERFACE *mvme, DWORD base, WORD offset)
int v1190_GeoWrite (MVME_INTERFACE *mvme, DWORD base, int geo)
int v1190_Setup (MVME_INTERFACE *mvme, DWORD base, int mode)
int v1190_Status (MVME_INTERFACE *mvme, DWORD base)
void v1190_SetEdgeDetection (MVME_INTERFACE *mvme, DWORD base, int eLeading, int eTrailing)


Define Documentation

#define LE_RESOLUTION_100   (WORD) (0x10)

Definition at line 54 of file v1190B.h.

Referenced by v1190_LEResolutionSet().

#define LE_RESOLUTION_200   (WORD) (0x01)

Definition at line 55 of file v1190B.h.

Referenced by v1190_LEResolutionSet().

#define LE_RESOLUTION_800   (WORD) (0x00)

Definition at line 56 of file v1190B.h.

Referenced by v1190_LEResolutionSet().

#define V1190_ACQ_MODE_RO   (WORD) (0x0200)

Definition at line 52 of file v1190B.h.

#define V1190_ALMOST_FULL   (DWORD) (0x0002)

Definition at line 26 of file v1190B.h.

#define V1190_CONTINUOUS_WO   (WORD) (0x0100)

Definition at line 51 of file v1190B.h.

#define V1190_CR_RW   (DWORD) (0x1000)

Definition at line 23 of file v1190B.h.

#define V1190_DATA_READY   (DWORD) (0x0001)

Definition at line 25 of file v1190B.h.

#define V1190_EDGE_DETECTION_WO   (WORD) (0x2200)

Definition at line 46 of file v1190B.h.

Referenced by v1190_SetEdgeDetection().

#define V1190_EVT_CNT_RO   (DWORD) (0x101C)

Definition at line 35 of file v1190B.h.

#define V1190_EVT_STORED_RO   (DWORD) (0x1020)

Definition at line 36 of file v1190B.h.

#define V1190_FIRM_REV_RO   (DWORD) (0x1026)

Definition at line 37 of file v1190B.h.

#define V1190_FULL   (DWORD) (0x0004)

Definition at line 27 of file v1190B.h.

#define V1190_GEO_REG_RW   (DWORD) (0x001E)

Definition at line 30 of file v1190B.h.

#define V1190_HEADER_ENABLE   (DWORD) (0x0010)

Definition at line 29 of file v1190B.h.

#define V1190_LE_RESOLUTION_WO   (WORD) (0x2400)

Definition at line 47 of file v1190B.h.

Referenced by v1190_LEResolutionSet().

#define V1190_LEW_RESOLUTION_WO   (WORD) (0x2500)

Definition at line 48 of file v1190B.h.

#define V1190_MAX_CHANNELS   (DWORD) 64

Definition at line 21 of file v1190B.h.

#define V1190_MICRO_HAND_RO   (DWORD) (0x1030)

Definition at line 38 of file v1190B.h.

#define V1190_MICRO_RD_OK   (WORD) (0x0002)

Definition at line 44 of file v1190B.h.

#define V1190_MICRO_RW   (DWORD) (0x102E)

Definition at line 39 of file v1190B.h.

#define V1190_MICRO_TDCID   (WORD) (0x6000)

Definition at line 45 of file v1190B.h.

#define V1190_MICRO_WR_OK   (WORD) (0x0001)

Definition at line 43 of file v1190B.h.

#define V1190_MODULE_RESET_WO   (DWORD) (0x1014)

Definition at line 31 of file v1190B.h.

#define V1190_REG_BASE   (DWORD) (0x1000)

Definition at line 22 of file v1190B.h.

#define V1190_RESOLUTION_RO   (WORD) (0x2600)

Definition at line 49 of file v1190B.h.

#define V1190_SOFT_CLEAR_WO   (DWORD) (0x1016)

Definition at line 32 of file v1190B.h.

#define V1190_SOFT_EVT_RESET_WO   (DWORD) (0x1018)

Definition at line 33 of file v1190B.h.

#define V1190_SOFT_TRIGGER_WO   (DWORD) (0x101A)

Definition at line 34 of file v1190B.h.

#define V1190_SR_RO   (DWORD) (0x1002)

Definition at line 24 of file v1190B.h.

#define V1190_TRIGGER_MATCH   (DWORD) (0x0008)

Definition at line 28 of file v1190B.h.

#define V1190_TRIGGER_MATCH_WO   (WORD) (0x0000)

Definition at line 50 of file v1190B.h.

#define V1190_WINDOW_OFFSET_WO   (WORD) (0x1100)

Definition at line 42 of file v1190B.h.

Referenced by v1190_OffsetSet().

#define V1190_WINDOW_WIDTH_WO   (WORD) (0x1000)

Definition at line 41 of file v1190B.h.

Referenced by v1190_WidthSet().


Function Documentation

int udelay ( int  usec  ) 

Definition at line 402 of file caenv1190B.c.

00403 {
00404   int i, j, k = 0;
00405   for (i=0; i<133; i++)
00406     for (j=0; j<usec; j++)
00407       k += (k+1)*j*k*(j+1);
00408   return k;
00409 }

void v1190_AcqModeRead ( MVME_INTERFACE mvme,
DWORD  base 
)

Definition at line 273 of file v1190B.c.

00274 {
00275   int   cmode, value;
00276 
00277   mvme_get_dmode(mvme, &cmode);
00278   mvme_set_dmode(mvme, MVME_DMODE_D16);
00279 
00280   value = v1190_MicroWrite(mvme, base, V1190_ACQ_MODE_RO);
00281   value = v1190_MicroRead(mvme, base);
00282   //  printf("Received AR :code: 0x%04x  0x%08x\n", V1190_ACQ_MODE_RO, value);
00283   mvme_set_dmode(mvme, cmode);
00284 }

void v1190_ContinuousSet ( MVME_INTERFACE mvme,
DWORD  base 
)

Definition at line 301 of file v1190B.c.

00302 {
00303   int   cmode, value;
00304 
00305   mvme_get_dmode(mvme, &cmode);
00306   mvme_set_dmode(mvme, MVME_DMODE_D16);
00307 
00308   value = v1190_MicroWrite(mvme, base, V1190_CONTINUOUS_WO);
00309   //  printf("Received CS :code: 0x%04x  0x%08x\n", V1190_CONTINUOUS_WO, value);
00310 
00311   mvme_set_dmode(mvme, cmode);
00312 }

int v1190_DataRead ( MVME_INTERFACE mvme,
DWORD  base,
DWORD pdest,
int  nentry 
)

Read data buffer for nentry data.

Parameters:
*mvme VME structure
base Module base address
*pdest destination pointer address
*nentry number of entries requested and returned.
Returns:

Definition at line 99 of file v1190B.c.

00100 {
00101   int cmode, status;
00102 
00103     mvme_get_dmode(mvme, &cmode);
00104     mvme_set_dmode(mvme, MVME_DMODE_D32);
00105     mvme_set_blt(mvme, MVME_BLT_BLT32);
00106 
00107     status = mvme_read(mvme, pdest, base, sizeof(DWORD) * nentry);
00108 
00109     mvme_set_dmode(mvme, cmode);
00110     return nentry;
00111 
00112     /*
00113       for (i=0 ; i<nentry ; i++) {
00114       if (!v1190_DataReady(mvme, base))
00115       break;
00116       pdest[i] = mvme_read_value(mvme, base);
00117       }
00118       mvme_set_dmode(mvme, cmode);
00119       return i;
00120     */
00121 }

int v1190_DataReady ( MVME_INTERFACE mvme,
DWORD  base 
)

Definition at line 171 of file v1190B.c.

00172 {
00173   int cmode, data;
00174 
00175   mvme_get_dmode(mvme, &cmode);
00176   mvme_set_dmode(mvme, MVME_DMODE_D16);
00177   data = mvme_read_value(mvme, base+V1190_SR_RO);
00178   mvme_set_dmode(mvme, cmode);
00179   return (data & V1190_DATA_READY);
00180 }

void v1190_DataReset ( MVME_INTERFACE mvme,
DWORD  base 
)

int v1190_EventRead ( MVME_INTERFACE mvme,
DWORD  base,
DWORD pdest,
int *  nentry 
)

Read Data buffer for single event (check delimiters) 0x4... and 0xC...

Parameters:
*mvme VME structure
base Module base address
*pdest destination pointer address
*nentry number of entries requested and returned.
Returns:

Definition at line 45 of file v1190B.c.

00046 {
00047   int cmode;
00048   DWORD hdata;
00049 
00050   *nentry = 0;
00051   mvme_get_dmode(mvme, &cmode);
00052   mvme_set_dmode(mvme, MVME_DMODE_D32);
00053   if (v1190_DataReady(mvme, base)) {
00054     do {
00055       hdata = mvme_read_value(mvme, base);
00056     } while (!(hdata & 0x40000000));
00057     pdest[*nentry] = hdata;
00058     *nentry += 1;
00059 
00060     do {
00061       pdest[*nentry] = mvme_read_value(mvme, base);
00062       *nentry += 1;
00063     } while (!(pdest[*nentry-1] & 0xc0000000));
00064   }
00065   mvme_set_dmode(mvme, cmode);
00066   return *nentry;
00067 
00068 /*
00069   header = *pbase & 0xFF000000;
00070 
00071   switch (header) {
00072   case 0x40000000:  // Global Header
00073     break;
00074   case 0x00000000:  // TDC Header
00075     break;
00076   case 0x10000000:  // Data
00077     break;
00078   case 0x20000000:  // Error
00079     break;
00080   case 0x80000000:  // Trailer
00081     break;
00082   case 0xc0000000:  // Filler
00083     break;
00084   }
00085 
00086   return *nentry;
00087 */
00088 }

int v1190_EvtCounter ( MVME_INTERFACE mvme,
DWORD  base 
)

Definition at line 195 of file v1190B.c.

00196 {
00197   int cmode, data;
00198 
00199   mvme_get_dmode(mvme, &cmode);
00200   mvme_set_dmode(mvme, MVME_DMODE_D32);
00201   data = mvme_read_value(mvme, base+V1190_EVT_CNT_RO);
00202   mvme_set_dmode(mvme, cmode);
00203   return (data);
00204 }

int v1190_EvtStored ( MVME_INTERFACE mvme,
DWORD  base 
)

Definition at line 183 of file v1190B.c.

00184 {
00185   int cmode, data;
00186 
00187   mvme_get_dmode(mvme, &cmode);
00188   mvme_set_dmode(mvme, MVME_DMODE_D16);
00189   data = mvme_read_value(mvme, base+V1190_EVT_STORED_RO);
00190   mvme_set_dmode(mvme, cmode);
00191   return (data);
00192 }

int v1190_GeoWrite ( MVME_INTERFACE mvme,
DWORD  base,
int  geo 
)

Definition at line 124 of file v1190B.c.

00125 {
00126   int cmode, data;
00127 
00128   mvme_get_dmode(mvme, &cmode);
00129   mvme_set_dmode(mvme, MVME_DMODE_D16);
00130   mvme_write_value(mvme, base+V1190_GEO_REG_RW, (geo & 0x1F));
00131   data = mvme_read_value(mvme, base+V1190_GEO_REG_RW);
00132   mvme_set_dmode(mvme, cmode);
00133 
00134   return (int) (data & 0x1F);
00135 }

void v1190_LEResolutionSet ( MVME_INTERFACE mvme,
DWORD  base,
WORD  le 
)

Definition at line 245 of file v1190B.c.

00246 {
00247   int   cmode, value;
00248 
00249   mvme_get_dmode(mvme, &cmode);
00250   mvme_set_dmode(mvme, MVME_DMODE_D16);
00251 
00252   if ((le == LE_RESOLUTION_100) ||
00253       (le == LE_RESOLUTION_200) ||
00254       (le == LE_RESOLUTION_800)) {
00255     printf("le:%x\n", le);
00256     value = v1190_MicroWrite(mvme, base, V1190_LE_RESOLUTION_WO);
00257     value = v1190_MicroWrite(mvme, base, le);
00258   } else {
00259     printf("Wrong Leading Edge Resolution -> Disabled\n");
00260     value = v1190_MicroWrite(mvme, base, V1190_LE_RESOLUTION_WO);
00261     value = v1190_MicroWrite(mvme, base, 3);
00262   }
00263   mvme_set_dmode(mvme, cmode);
00264 }

void v1190_LEWResolutionSet ( MVME_INTERFACE mvme,
DWORD  base,
WORD  le,
WORD  width 
)

Definition at line 267 of file v1190B.c.

00268 {
00269   printf("Not yet implemented\n");
00270 }

int v1190_MicroCheck ( MVME_INTERFACE mvme,
const DWORD  base,
int  what 
)

int v1190_MicroFlush ( MVME_INTERFACE mvme,
const DWORD  base 
)

Definition at line 430 of file v1190B.c.

00431 {
00432   int cmode, count = 0;
00433 
00434   mvme_get_dmode(mvme, &cmode);
00435   mvme_set_dmode(mvme, MVME_DMODE_D16);
00436 
00437   while (1)
00438     {
00439       int data = v1190_MicroRead(mvme, base);
00440       printf("microData[%d]: 0x%04x\n",count,data);
00441       if (data < 0)
00442   break;
00443       count++;
00444     }
00445   mvme_set_dmode(mvme, cmode);
00446   return count;
00447 }

int v1190_MicroRead ( MVME_INTERFACE mvme,
const DWORD  base 
)

Definition at line 408 of file v1190B.c.

00409 {
00410   int cmode, i;
00411   int reg=-1;
00412 
00413   mvme_get_dmode(mvme, &cmode);
00414   mvme_set_dmode(mvme, MVME_DMODE_D16);
00415   for (i=100; i>0; i--) {
00416     WORD  microHS = mvme_read_value(mvme, base+V1190_MICRO_HAND_RO);
00417     if (microHS & V1190_MICRO_RD_OK) {
00418       reg = mvme_read_value(mvme, base+V1190_MICRO_RW);
00419 //      printf("i:%d microHS:%d %x\n", i, microHS, reg);
00420       mvme_set_dmode(mvme, cmode);
00421       return (reg);
00422     }
00423     udelay(500);
00424   };
00425   mvme_set_dmode(mvme, cmode);
00426   return -1;
00427 }

int v1190_MicroWrite ( MVME_INTERFACE mvme,
DWORD  base,
WORD  data 
)

Definition at line 384 of file v1190B.c.

00385 {
00386   int cmode, i;
00387 
00388   mvme_get_dmode(mvme, &cmode);
00389   mvme_set_dmode(mvme, MVME_DMODE_D16);
00390 
00391   for (i=0; i<1000; i++)
00392   {
00393     WORD microHS = mvme_read_value(mvme, base+V1190_MICRO_HAND_RO);
00394     if (microHS & V1190_MICRO_WR_OK) {
00395       mvme_write_value(mvme, base+V1190_MICRO_RW, data);
00396       mvme_set_dmode(mvme, cmode);
00397       return 1;
00398     }
00399     udelay(500);
00400   }
00401 
00402   printf("v1190_MicroWrite: Micro not ready for writing!\n");
00403   mvme_set_dmode(mvme, cmode);
00404   return -1;
00405 }

void v1190_OffsetSet ( MVME_INTERFACE mvme,
DWORD  base,
WORD  offset 
)

Set the offset of the matching window with respect to the trigger. The offset parameter should be in 25ns units. The range is from -2048(0x800) to +40(0x28). Example 0xFE8 == 600ns.

Parameters:
*mvme VME structure
base Module base address
offset offset in ns units

Definition at line 347 of file v1190B.c.

00348 {
00349   int   cmode, value;
00350 
00351   mvme_get_dmode(mvme, &cmode);
00352   mvme_set_dmode(mvme, MVME_DMODE_D16);
00353 
00354   //  v1190_MicroFlush(mvme, base);
00355   value = v1190_MicroWrite(mvme, base, V1190_WINDOW_OFFSET_WO);
00356   value = v1190_MicroWrite(mvme, base, offset);
00357   //  printf("Received OS :code: 0x%04x  0x%08x\n", V1190_WINDOW_OFFSET_WO, value);
00358 
00359   mvme_set_dmode(mvme, cmode);
00360 }

WORD v1190_Read16 ( MVME_INTERFACE mvme,
DWORD  base,
int  offset 
)

Definition at line 15 of file v1190B.c.

00016 {
00017   mvme_set_am(mvme, MVME_AM_A24);
00018   mvme_set_dmode(mvme, MVME_DMODE_D16);
00019   return mvme_read_value(mvme, base+offset);
00020 }

DWORD v1190_Read32 ( MVME_INTERFACE mvme,
DWORD  base,
int  offset 
)

Definition at line 22 of file v1190B.c.

00023 {
00024   mvme_set_am(mvme, MVME_AM_A24);
00025   mvme_set_dmode(mvme, MVME_DMODE_D32);
00026   return mvme_read_value(mvme, base+offset);
00027 }

int v1190_ResolutionRead ( MVME_INTERFACE mvme,
DWORD  base 
)

Definition at line 226 of file v1190B.c.

00227 {
00228   WORD  i, code;
00229   int   cmode, value;
00230 
00231   mvme_get_dmode(mvme, &cmode);
00232   mvme_set_dmode(mvme, MVME_DMODE_D16);
00233 
00234   for (i=0; i<2 ; i++) {
00235     code = V1190_RESOLUTION_RO | (i & 0x0F);
00236     value = v1190_MicroWrite(mvme, base, code);
00237     value = v1190_MicroRead(mvme, base);
00238     // printf("Received RR :code: 0x%04x  0x%08x\n", code, value);
00239   }
00240   mvme_set_dmode(mvme, cmode);
00241   return value;
00242 }

void v1190_SetEdgeDetection ( MVME_INTERFACE mvme,
DWORD  base,
int  eLeading,
int  eTrailing 
)

Definition at line 363 of file v1190B.c.

00364 {
00365   int cmode, value = 0;
00366 
00367   mvme_get_dmode(mvme, &cmode);
00368   mvme_set_dmode(mvme, MVME_DMODE_D16);
00369 
00370   if (eLeading)
00371     value |= 2;
00372 
00373   if (eTrailing)
00374     value |= 1;
00375 
00376   //  v1190_MicroFlush(mvme, base);
00377   v1190_MicroWrite(mvme, base, V1190_EDGE_DETECTION_WO);
00378   v1190_MicroWrite(mvme, base, value);
00379   mvme_set_dmode(mvme, cmode);
00380 }

int v1190_Setup ( MVME_INTERFACE mvme,
DWORD  base,
int  mode 
)

Sets all the necessary paramters for a given configuration. The configuration is provided by the mode argument. Add your own configuration in the case statement. Let me know your setting if you want to include it in the distribution.

Parameters:
*mvme VME structure
base Module base address
mode Configuration mode number
*nentry number of entries requested and returned.
Returns:
MVME_SUCCESS

Definition at line 461 of file v1190B.c.

00462 {
00463   WORD code, value;
00464   int      cmode, status = -1;
00465 
00466   mvme_get_dmode(mvme, &cmode);
00467   mvme_set_dmode(mvme, MVME_DMODE_D16);
00468 
00469 //  v1190_MicroFlush(mvme, base);
00470   switch (mode) {
00471   case 0x1:
00472     printf("Trigger Matching Setup (mode:%d)\n", mode);
00473     printf("Default setting + Width : 800ns, Offset : -400ns\n");
00474     printf("Time subtract, Leading Edge only\n");
00475     code = 0x0000;  // Trigger matching Flag
00476     if ((status = v1190_MicroWrite(mvme, base, code)) < 0)
00477       return status;
00478     code = 0x1000;  // Width
00479     value = v1190_MicroWrite(mvme, base, code);
00480     value = v1190_MicroWrite(mvme, base, 0x20);   // Width : 800ns
00481     code = 0x1100;  // Offset
00482     value = v1190_MicroWrite(mvme, base, code);
00483     value = v1190_MicroWrite(mvme, base, 0xfe8);  // offset: -400ns
00484     code = 0x1500;  // Subtraction flag
00485     value = v1190_MicroWrite(mvme, base, code);
00486     code = 0x2100;  // Leading Edge Detection
00487     value = v1190_MicroWrite(mvme, base, code);
00488     break;
00489   case 0x2:
00490     code = 0x0500;  // Default configuration
00491     value = v1190_MicroWrite(mvme, base, code);
00492     break;
00493   default:
00494     printf("Unknown setup mode\n");
00495     mvme_set_dmode(mvme, cmode);
00496     return -1;
00497   }
00498   v1190_Status(mvme, base);
00499   mvme_set_dmode(mvme, cmode);
00500   return 0;
00501 }

void v1190_SoftClear ( MVME_INTERFACE mvme,
DWORD  base 
)

Definition at line 149 of file v1190B.c.

00150 {
00151   int cmode;
00152 
00153   mvme_get_dmode(mvme, &cmode);
00154   mvme_set_dmode(mvme, MVME_DMODE_D16);
00155   mvme_write_value(mvme, base+V1190_SOFT_CLEAR_WO, 0);
00156   mvme_set_dmode(mvme, cmode);
00157 }

void v1190_SoftReset ( MVME_INTERFACE mvme,
DWORD  base 
)

Definition at line 138 of file v1190B.c.

00139 {
00140   int cmode;
00141 
00142   mvme_get_dmode(mvme, &cmode);
00143   mvme_set_dmode(mvme, MVME_DMODE_D16);
00144   mvme_write_value(mvme, base+V1190_MODULE_RESET_WO, 0);
00145   mvme_set_dmode(mvme, cmode);
00146 }

void v1190_SoftTrigger ( MVME_INTERFACE mvme,
DWORD  base 
)

Definition at line 160 of file v1190B.c.

00161 {
00162   int cmode;
00163 
00164   mvme_get_dmode(mvme, &cmode);
00165   mvme_set_dmode(mvme, MVME_DMODE_D16);
00166   mvme_write_value(mvme, base+V1190_SOFT_TRIGGER_WO, 0);
00167   mvme_set_dmode(mvme, cmode);
00168 }

int v1190_Status ( MVME_INTERFACE mvme,
DWORD  base 
)

Read and display the curent status of the TDC.

Parameters:
*mvme VME structure
base Module base address
Returns:
MVME_SUCCESS, MicroCode error

Definition at line 510 of file v1190B.c.

00511 {
00512   WORD  i, code, pair=0;
00513   int   cmode, value;
00514   int ns = 25; // ns per tdc count
00515 
00516   mvme_get_dmode(mvme, &cmode);
00517   mvme_set_dmode(mvme, MVME_DMODE_D16);
00518 
00519   //-------------------------------------------------
00520   printf("\n");
00521   printf("V1190 TDC at VME A24 0x%06x:\n", base);
00522   printf("\n--- Trigger Section [0x1600]:\n");
00523   code = 0x1600;
00524   if ((value = v1190_MicroWrite(mvme, base, code)) < 0)
00525     return -value;
00526   value = v1190_MicroRead(mvme, base);
00527   printf("  Match Window width       : 0x%04x, %d ns\n", value, value*ns);
00528   value = v1190_MicroRead(mvme, base);
00529   printf("  Window offset            : 0x%04x, %d ns\n", value, ((WORD)value)*ns);
00530   value = v1190_MicroRead(mvme, base);
00531   printf("  Extra Search Window Width: 0x%04x, %d ns\n", value, value*ns);
00532   value = v1190_MicroRead(mvme, base);
00533   printf("  Reject Margin            : 0x%04x, %d ns\n", value, value*ns);
00534   value = v1190_MicroRead(mvme, base);
00535   printf("  Trigger Time subtraction : %s\n",(value & 0x1) ? "y" : "n");
00536 
00537   //-------------------------------------------------
00538   printf("\n--- Edge Detection & Resolution Section[0x2300/26/29]:\n");
00539   code = 0x2300;
00540   value = v1190_MicroWrite(mvme, base, code);
00541   pair = value = v1190_MicroRead(mvme, base);
00542   printf("  Edge Detection (1:T/2:L/3:TL)           : 0x%02x\n", (value&0x3));
00543   code = 0x2600;
00544   value = v1190_MicroWrite(mvme, base, code);
00545   value = v1190_MicroRead(mvme, base);
00546   if (pair==0x3) {
00547     value = v1190_MicroRead(mvme, base);
00548     printf("  Leading Edge Resolution (see table)     : 0x%02x\n", (value&0x3));
00549     printf("  Pulse Width Resolution (see table)      : 0x%02x\n", ((value>>8)&0xF));
00550   } else {
00551     printf("  Resolution [ps] (0:800/1:200/2:100)     : 0x%02x\n", (value&0x3));
00552   }
00553   code = 0x2900;
00554   value = v1190_MicroWrite(mvme, base, code);
00555   value = v1190_MicroRead(mvme, base);
00556   printf("  Dead Time between hit [~ns](5/10/30/100): 0x%02x\n", (value&0x3));
00557 
00558   //-------------------------------------------------
00559   printf("\n--- Readout Section[0x3200/34/3a/3c]:\n");
00560   code = 0x3200;
00561   value = v1190_MicroWrite(mvme, base, code);
00562   value = v1190_MicroRead(mvme, base);
00563   printf("  Header/Trailer                            : %s\n",(value & 0x1) ? "y" : "n");
00564   code = 0x3400;
00565   value = v1190_MicroWrite(mvme, base, code);
00566   value = v1190_MicroRead(mvme, base);
00567   printf("  Max #hits per event 2^n-1 (>128:no limit) : %d\n", value&0xF);
00568   code = 0x3a00;
00569   value = v1190_MicroWrite(mvme, base, code);
00570   value = v1190_MicroRead(mvme, base);
00571   printf("  Internal TDC error type (see doc)         : 0x%04x\n", (value&0x7FF));
00572   code = 0x3c00;
00573   value = v1190_MicroWrite(mvme, base, code);
00574   value = v1190_MicroRead(mvme, base);
00575   printf("  Effective size of readout Fifo 2^n-1      : 0x%04x\n", (value&0xF));
00576 
00577   //-------------------------------------------------
00578   printf("\n--- Channel Enable Section[0x4500/47/49]:\n");
00579   code = 0x4500;
00580   value = v1190_MicroWrite(mvme, base, code);
00581   value = v1190_MicroRead(mvme, base);
00582   printf("  Read Enable Pattern [  0..15 ] : 0x%04x\n", value);
00583   value = v1190_MicroRead(mvme, base);
00584   printf("  Read Enable Pattern [ 16..31 ] : 0x%04x\n", value);
00585   value = v1190_MicroRead(mvme, base);
00586   printf("  Read Enable Pattern [ 32..47 ] : 0x%04x\n", value);
00587   value = v1190_MicroRead(mvme, base);
00588   printf("  Read Enable Pattern [ 48..63 ] : 0x%04x\n", value);
00589   code = 0x4700;
00590   value = v1190_MicroWrite(mvme, base, code);
00591   value = v1190_MicroRead(mvme, base);
00592   value = (v1190_MicroRead(mvme, base)<<16) | value;
00593   printf("  Read Enable Pattern 32 (0) : 0x%08x\n", value);
00594   code = 0x4701;
00595   value = v1190_MicroWrite(mvme, base, code);
00596   value = v1190_MicroRead(mvme, base);
00597   value = (v1190_MicroRead(mvme, base)<<16) | value;
00598   printf("  Read Enable Pattern 32 (1) : 0x%08x\n", value);
00599 
00600   //-------------------------------------------------
00601   printf("\n--- Adjust Section[0x5100/60]:\n");
00602   code = 0x5100;
00603   value = v1190_MicroWrite(mvme, base, code);
00604   value = v1190_MicroRead(mvme, base);
00605   printf("  Coarse Counter Offset: 0x%04x\n", (value&0x7FF));
00606   value = v1190_MicroRead(mvme, base);
00607   printf("  Fine   Counter Offset: 0x%04x\n", (value&0x1F));
00608   printf("\nMiscellaneous Section:\n");
00609   for (i=0; i<2 ; i++) {
00610     code = 0x6000 | (i & 0x0F);
00611     value = v1190_MicroWrite(mvme, base, code);
00612     value = v1190_MicroRead(mvme, base);
00613     value = (v1190_MicroRead(mvme, base) << 16) | value;
00614     printf("  TDC ID(%i)  0x%08x  [code:0x%04x]\n", i, value, code);
00615   }
00616   mvme_set_dmode(mvme, cmode);
00617   return 0;
00618 }

void v1190_TdcIdList ( MVME_INTERFACE mvme,
DWORD  base 
)

Definition at line 207 of file v1190B.c.

00208 {
00209   int  cmode, i, code;
00210   DWORD value;
00211 
00212   mvme_get_dmode(mvme, &cmode);
00213   mvme_set_dmode(mvme, MVME_DMODE_D16);
00214 
00215   for (i=0; i<2 ; i++) {
00216     code   = V1190_MICRO_TDCID | (i & 0x0F);
00217     value  = v1190_MicroWrite(mvme, base, code);
00218     value  = v1190_MicroRead(mvme, base);
00219     value = (v1190_MicroRead(mvme, base) << 16) | value;
00220     //    printf("Received :code: 0x%04x  0x%08lx\n", code, value);
00221   }
00222   mvme_set_dmode(mvme, cmode);
00223 }

void v1190_TriggerMatchingSet ( MVME_INTERFACE mvme,
DWORD  base 
)

Definition at line 287 of file v1190B.c.

00288 {
00289   int   cmode, value;
00290 
00291   mvme_get_dmode(mvme, &cmode);
00292   mvme_set_dmode(mvme, MVME_DMODE_D16);
00293 
00294   value = v1190_MicroWrite(mvme, base, V1190_TRIGGER_MATCH_WO);
00295   //  printf("Received MS :code: 0x%04x  0x%08x\n", V1190_TRIGGER_MATCH_WO, value);
00296 
00297   mvme_set_dmode(mvme, cmode);
00298 }

void v1190_WidthSet ( MVME_INTERFACE mvme,
DWORD  base,
WORD  width 
)

Set the width of the matching Window. The width parameter should be in the range of 1 to 4095 (0xFFF). Example 0x14 == 500ns.

Parameters:
*mvme VME structure
base Module base address
width window width in ns units
Returns:

Definition at line 323 of file v1190B.c.

00324 {
00325   int   cmode, value;
00326 
00327   mvme_get_dmode(mvme, &cmode);
00328   mvme_set_dmode(mvme, MVME_DMODE_D16);
00329 
00330   //  v1190_MicroFlush(mvme, base);
00331   value = v1190_MicroWrite(mvme, base, V1190_WINDOW_WIDTH_WO);
00332   value = v1190_MicroWrite(mvme, base, width);
00333   //  printf("Received WS :code: 0x%04x  0x%08x\n", V1190_WINDOW_WIDTH_WO, value);
00334 
00335   mvme_set_dmode(mvme, cmode);
00336 }

void v1190_Write16 ( MVME_INTERFACE mvme,
DWORD  base,
int  offset,
WORD  value 
)

Definition at line 29 of file v1190B.c.

00030 {
00031   mvme_set_am(mvme, MVME_AM_A24);
00032   mvme_set_dmode(mvme, MVME_DMODE_D16);
00033   mvme_write_value(mvme, base+offset, value);
00034 }


Midas DOC Version 3.0.0 ---- PSI Stefan Ritt ----
Contributions: Pierre-Andre Amaudruz - Sergio Ballestrero - Suzannah Daviel - Doxygen - Peter Green - Qing Gu - Greg Hackman - Gertjan Hofman - Paul Knowles - Exaos Lee - Rudi Meier - Glenn Moloney - Dave Morris - John M O'Donnell - Konstantin Olchanski - Renee Poutissou - Tamsen Schurman - Andreas Suter - Jan M.Wouters - Piotr Adam Zolnierczuk