#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/time.h>
#include <time.h>
#include "midas.h"
#include "crate.h"
#include "vme.h"
#include "odb_wrapper.h"
#include "diag.h"

Data Structures
struct	caenV767

Macros
#define	CAENV767_MAX_DMA_SIZE 256

#define	CAENV767_MAX_SIZE (3210244)

#define	ACTIVE_READOUT_MAX_PER_POLL (2*1024)

#define	CAENV767_NUM_CHANNELS 128

#define	MAX_CAENV767 4

#define	CAENV767_OUTBUF 0x00

#define	CAENV767_CTR1 0x10

#define	CAENV767_STR2 0x48

#define	CAENV767_EVT_COUNT 0x4C

#define	CAENV767_OPHAND 0x50

#define	CAENV767_OPCODE 0x52

#define	CAENV767_CLEAR 0x54

#define	CAENV767_NOT_VALID 0x00600000

#define	CAENV767_GLOBAL_TDC_ERROR 0x0008

Functions
INT	caenV767_bor ()

INT	caenV767_eor ()

INT	caenV767_poll_live ()

INT	caenV767_read (char *pevent)

void	caenV767_opcode_write (struct caenV767 *caen, short code)

short	caenV767_opcode_read (struct caenV767 *caen)

INT	caenV767_bor1 (struct caenV767 *caen)

INT	caenV767_eor1 (struct caenV767 *caen)

INT	caenV767_fifo_read (struct caenV767 caen, unsigned char buffer, int max_size, bool in_active_readout)

INT	caenV767_poll1 (struct caenV767 *caen)

INT	caenV767_read1 (struct caenV767 caen, char pevent)

Variables
struct readout_module	caenV767_module

struct timeval	block_start_time

struct caenV767	caenV767 [MAX_CAENV767]

Macro Definition Documentation

#define ACTIVE_READOUT_MAX_PER_POLL (2*1024)

Definition at line 35 of file caenV767.cpp.

Referenced by caenV767_poll1().

#define CAENV767_CLEAR 0x54

Definition at line 65 of file caenV767.cpp.

Referenced by caenV767_bor1(), and caenV767_read1().

#define CAENV767_CTR1 0x10

Definition at line 60 of file caenV767.cpp.

Referenced by caenV767_bor1().

#define CAENV767_EVT_COUNT 0x4C

Definition at line 62 of file caenV767.cpp.

#define CAENV767_GLOBAL_TDC_ERROR 0x0008

Definition at line 71 of file caenV767.cpp.

Referenced by caenV767_read1().

#define CAENV767_MAX_DMA_SIZE 256

Definition at line 33 of file caenV767.cpp.

Referenced by caenV767_bor1().

#define CAENV767_MAX_SIZE (32*1024*4)

Definition at line 34 of file caenV767.cpp.

Referenced by caenV767_read1().

#define CAENV767_NOT_VALID 0x00600000

Definition at line 68 of file caenV767.cpp.

Referenced by caenV767_fifo_read(), and caenV767_read1().

#define CAENV767_NUM_CHANNELS 128

Definition at line 36 of file caenV767.cpp.

Referenced by caenV767_bor1().

#define CAENV767_OPCODE 0x52

Definition at line 64 of file caenV767.cpp.

Referenced by caenV767_opcode_read(), and caenV767_opcode_write().

#define CAENV767_OPHAND 0x50

Definition at line 63 of file caenV767.cpp.

Referenced by caenV767_opcode_read(), and caenV767_opcode_write().

#define CAENV767_OUTBUF 0x00

Definition at line 59 of file caenV767.cpp.

Referenced by caenV767_fifo_read().

#define CAENV767_STR2 0x48

Definition at line 61 of file caenV767.cpp.

Referenced by caenV767_read1().

#define MAX_CAENV767 4

Definition at line 55 of file caenV767.cpp.

Referenced by caenV767_bor().

Function Documentation

INT caenV767_bor ( )

Definition at line 219 of file caenV767.cpp.

References bank_name, caenV767_bor1(), crate_number, diag_print(), enabled, caenV767::enabled, MAX_CAENV767, odb_find_key(), odb_get_bool(), sprintf(), and SUCCESS.

 {
   // Use the ODB to find any CAENV767 modules
   for(int j = 0; j < MAX_CAENV767; j++) {
 
     bool enabled = false;
 
     if (odb_find_key("/Equipment/Crate %d/Settings/CAEN %d", crate_number, j)) {
       diag_print(1, "ODB says CAEN %d is present, ", j);
       enabled = 
         odb_get_bool("/Equipment/Crate %d/Settings/CAEN %d/enabled status", 
             crate_number, j);
       if (enabled) {
         diag_print(1, "and is enabled.  Initializing...\n");
       } else {
         diag_print(1, "but is disabled.\n");
       }
     }
 
     caenV767[j].enabled = enabled;
 
     // Set up the name of the MIDAS bank associated with the module
     sprintf(caenV767[j].bank_name, "CAE%d", j);
     sprintf(caenV767[j].odb_name, "CAEN %d", j);
 
     if(enabled) {
       caenV767_bor1(&caenV767[j]);
     }
   }
 
   return SUCCESS;
 }

INT caenV767_bor1 ( struct caenV767 * caen)

Definition at line 128 of file caenV767.cpp.

References caenV767::active_readout_buffer, caenV767::active_readout_buffer_size, caenV767::active_readout_size, CAENV767_CLEAR, CAENV767_CTR1, CAENV767_MAX_DMA_SIZE, CAENV767_NUM_CHANNELS, caenV767_opcode_write(), channel, crate_number, diag_print(), caenV767::do_active_readout, caenV767::half_full_level, handle, odb_get_bool(), odb_get_boolarray(), odb_get_dword(), odb_get_int(), caenV767::odb_name, caenV767::record_trailing_edges, SUCCESS, caenV767::vme_base, caenV767::vme_handle, vme_open(), vme_write_d16(), VMEMAP_ASPACE_A32, VMEMAP_DWIDTH_32, VMEMAP_PRGDATAAM_DATA, and VMEMAP_SUPUSERAM_SUPER.

 {
   // Get the VME base address of the module
   caen->vme_base = odb_get_dword("/Equipment/Crate %d/Settings/%s/vme address", 
                     crate_number, caen->odb_name);
 
   // Open a VME handle for memory-mapped access
   struct vme_mapping_ctrl mapping = { 
           VMEMAP_DWIDTH_32, 
           VMEMAP_ASPACE_A32, 
           VMEMAP_SUPUSERAM_SUPER, 
           VMEMAP_PRGDATAAM_DATA 
   };
 
   struct vme_handle *handle = 
           vme_open(caen->vme_base, mapping, 0x200, CAENV767_MAX_DMA_SIZE);
   caen->vme_handle = handle;
  
   // Determine whether we're supposed to do active readout
   caen->do_active_readout =
     odb_get_bool("/Equipment/Crate %d/Settings/%s/Active Readout mode",
                     crate_number, caen->odb_name);
 
   // Determine whether we should record trailing edges, or only leading edges
   caen->record_trailing_edges  =
     odb_get_bool("/Equipment/Crate %d/Settings/%s/Record trailing edges",
                     crate_number, caen->odb_name);
 
   // Request a bus error when DMA transfer reaches end of data
   vme_write_d16(caen->vme_handle, caen->vme_base | CAENV767_CTR1, 0x0020);
 
   // Read the half-full mark and the active readout buffer size
   caen->half_full_level = 
     odb_get_int("/Equipment/Crate %d/Settings/%s/Half-full level",
                     crate_number, caen->odb_name);
   caen->active_readout_buffer_size = 
     odb_get_int("/Equipment/Crate %d/Settings/%s/Active readout buffer size",
                     crate_number, caen->odb_name);
  
   // Allocate the active readout buffer
   caen->active_readout_buffer = new unsigned char[caen->active_readout_buffer_size];
 
   // Set various TDC options
   caenV767_opcode_write(caen, 0x1200); // set start gating mode
   caenV767_opcode_write(caen, 0x7100); // set DRDY = almost full
   caenV767_opcode_write(caen, 0x7400); // prepare to set almost full level...
   caenV767_opcode_write(caen, caen->half_full_level); // ...set almost full level 
   caenV767_opcode_write(caen, 0x4000); // enable readout of start time
   caenV767_opcode_write(caen, 0x4300); // enable subtraction of start time 
                                        // from hit times
 
   if(caen->record_trailing_edges) {
     caenV767_opcode_write(caen, 0x6600); // enable both edges on all channels 
                                          // and start
   } else {
     caenV767_opcode_write(caen, 0x6000); // enable only leading edge on all
                                          // channels and start
   }
 
   // Enable the CAEN channels according to the ODB settings
   diag_print(1, "Enabling all channels on %s.\n", caen->odb_name);
   caenV767_opcode_write(caen, 0x2300); // enable all channels first 
   BOOL channel_enable_array[CAENV767_NUM_CHANNELS], channelstatus;
   odb_get_boolarray(&channel_enable_array[0], CAENV767_NUM_CHANNELS,
                     "/Equipment/Crate %d/Settings/%s/channels/channel enabled",
                     crate_number, caen->odb_name);
   // disable each masked channel 
   for (int channel=0; channel<=(CAENV767_NUM_CHANNELS-1); channel++) {
     channelstatus = channel_enable_array[channel];
     if (channelstatus == 0) {
       diag_print(1, "Disabling %s channel %d.\n", caen->odb_name, channel);
       caenV767_opcode_write(caen, 0x2100 | channel);
     }
   }
 
   // Reset the TDC
   vme_write_d16(caen->vme_handle, caen->vme_base | CAENV767_CLEAR, 1);
 
   // Clear for the next block
   caen->active_readout_size = 0;
 
   return SUCCESS;
 }

INT caenV767_eor ( )

INT caenV767_eor1 ( struct caenV767 * caen)

Definition at line 253 of file caenV767.cpp.

References caenV767::active_readout_buffer, SUCCESS, vme_close(), and caenV767::vme_handle.

 {
   vme_close(caen->vme_handle);
   delete[] caen->active_readout_buffer;
   return SUCCESS;
 }

INT caenV767_fifo_read	(	struct caenV767 *	caen,
		unsigned char *	buffer,
		int	max_size,
		bool	in_active_readout
	)

Definition at line 283 of file caenV767.cpp.

References CAENV767_NOT_VALID, CAENV767_OUTBUF, i, size, status, caenV767::vme_base, vme_dma_read(), caenV767::vme_handle, and vme_read_d32().

 {
   if(!in_active_readout) {
     int status = vme_dma_read(caen->vme_handle,
                               caen->vme_base | CAENV767_OUTBUF,
                               buffer,
                               max_size);
     return status;
   } else {
     int size = 0;
 
     for(int i = 0; i < max_size / sizeof(DWORD); i++) {
       DWORD word = 
         vme_read_d32(caen->vme_handle, caen->vme_base | CAENV767_OUTBUF);
 
       if((word & CAENV767_NOT_VALID) == CAENV767_NOT_VALID) {
         break;
       }
 
       *((DWORD *) buffer) = word;
       buffer += sizeof(DWORD);
       size += sizeof(DWORD);
     }
 
     return size;
   }
 }

short caenV767_opcode_read ( struct caenV767 * caen)

Definition at line 107 of file caenV767.cpp.

References CAENV767_OPCODE, CAENV767_OPHAND, caenV767::vme_base, caenV767::vme_handle, and vme_read_d16().

 {
   // Wait for the microcontroller to become ready
   while(!(vme_read_d16(caen->vme_handle, caen->vme_base | CAENV767_OPHAND) & 
          0x1)) {
     ss_sleep(10);
   }
 
   // Wait a little longer
   ss_sleep(10);
 
   // Read the opcode value
   return vme_read_d16(caen->vme_handle, caen->vme_base | CAENV767_OPCODE);
 }

void caenV767_opcode_write	(	struct caenV767 *	caen,
		short	code
	)

Definition at line 91 of file caenV767.cpp.

References CAENV767_OPCODE, CAENV767_OPHAND, caenV767::vme_base, caenV767::vme_handle, vme_read_d16(), and vme_write_d16().

 {
   // Wait for the microcontroller to become ready
   while(!(vme_read_d16(caen->vme_handle, caen->vme_base | CAENV767_OPHAND) & 
          0x0002)) {
     ss_sleep(10);
   }
 
   // Wait a little longer
   ss_sleep(10);
 
   // Write the opcode value
   vme_write_d16(caen->vme_handle, caen->vme_base | CAENV767_OPCODE, code); 
 }

INT caenV767_poll1 ( struct caenV767 * caen)

Definition at line 318 of file caenV767.cpp.

References caenV767::active_readout_buffer, caenV767::active_readout_buffer_size, ACTIVE_READOUT_MAX_PER_POLL, caenV767::active_readout_size, block_start_time, caenV767::bytes_per_second, caenV767_fifo_read(), diag_print(), caenV767::do_active_readout, FE_NEED_STOP, MIN, caenV767::odb_name, size, status, SUCCESS, and TRUE.

 {
   // If active readout is not enabled, skip it.
   if(!caen->do_active_readout) {
     return SUCCESS;
   }
 
   // Check whether there's anything at all in the buffer.
  
   // How many words do we expect?  
   struct timeval now;
   gettimeofday(&now, NULL);
   double block_seconds = (now.tv_sec - block_start_time.tv_sec) + 
                            1e-6*(now.tv_usec - block_start_time.tv_usec);
   int expected_words = 
     (int) (caen->bytes_per_second / block_seconds  / sizeof(DWORD));
 
   // First check how much space we have available in the active
   // readout buffer.
   int size_left = caen->active_readout_buffer_size - caen->active_readout_size;
   int size = MIN(ACTIVE_READOUT_MAX_PER_POLL, size_left);
   size = MIN(size, expected_words);
 
   // Now try to read up to that amount, without using block transfers,
   // which can potentially drop the last data word.
   int status = 
      caenV767_fifo_read(caen, 
                         caen->active_readout_buffer + caen->active_readout_size,
                         size,
                         TRUE);
                             
   // Check the status
   if(status >= 0) {
     caen->active_readout_size += status;
   } else {
     diag_print(0, "Status from caenV767_fifo_read is %d for %s\n", status,
       caen->odb_name);
     return FE_ERR_HW;
   }
 
   if(caen->active_readout_size == caen->active_readout_buffer_size) {
     return FE_NEED_STOP; 
   } else {
     return SUCCESS;
   }
 }

INT caenV767_poll_live ( )

INT caenV767_read ( char * pevent)

INT caenV767_read1	(	struct caenV767 *	caen,
		char *	pevent
	)

Definition at line 401 of file caenV767.cpp.

References caenV767::active_readout_buffer, caenV767::active_readout_size, caenV767::bank_name, block_start_time, caenV767::bytes_per_second, CAENV767_CLEAR, caenV767_fifo_read(), CAENV767_GLOBAL_TDC_ERROR, CAENV767_MAX_SIZE, CAENV767_NOT_VALID, CAENV767_STR2, diag_print(), FALSE, caenV767::odb_name, status, SUCCESS, caenV767::vme_base, caenV767::vme_handle, vme_read_d16(), and vme_write_d16().

 {
   // Create the MIDAS bank
   DWORD *pdata;
   bk_create(pevent, caen->bank_name, TID_DWORD, &pdata);
 
   // Copy data that was read during the active readout
   int active_size = caen->active_readout_size;
   memcpy(pdata, caen->active_readout_buffer, active_size);
 
   // Read any data remaining in the module
   int status = 
     caenV767_fifo_read(caen,  ((unsigned char *) pdata) + active_size,
                       CAENV767_MAX_SIZE, FALSE);
 
   // Check the status
   int final_size = 0;
   if(status >= 0) {
     final_size = status;
   } else {
     // handle the error
   }
  
   // Check the TDC status for error codes (typically "DLL unlocked" problems)
   // and add an error flag word if a problem is found.
   short str2 = vme_read_d16(caen->vme_handle, caen->vme_base | CAENV767_STR2);
   if(str2 & CAENV767_GLOBAL_TDC_ERROR) {
     DWORD flag_word = CAENV767_NOT_VALID;
     for(int tdc = 0; tdc < 4; tdc++) {
       short ind_tdc_error_mask = (1 << (12+tdc));
       if(str2 & (1 << (12+tdc))) {
         flag_word |= (1 << tdc); 
       }
     }
 
     pdata[(active_size + final_size)/sizeof(DWORD)] = flag_word;
     final_size += sizeof(DWORD);
 
     diag_print(0, "TDC error in %s: 0x%08x\n", caen->odb_name, flag_word);
   }
 
   // Close the bank
   bk_close(pevent, pdata + (active_size + final_size)/sizeof(DWORD));
 
   // Clear for the next block
   caen->active_readout_size = 0;
 
   // Reset the TDC
   vme_write_d16(caen->vme_handle, caen->vme_base | CAENV767_CLEAR, 1);
 
   // Update the expected rate.
   if(block_start_time.tv_sec != 0) {  
     struct timeval now;
     gettimeofday(&now, NULL);
     double block_seconds = (now.tv_sec - block_start_time.tv_sec) + 
                              1e-6*(now.tv_usec - block_start_time.tv_usec);
     caen->bytes_per_second = (active_size + final_size)/block_seconds;
   }
   block_start_time.tv_sec = block_start_time.tv_usec = 0;
 
   return SUCCESS;
 }

Variable Documentation

struct timeval block_start_time

Definition at line 53 of file caenV767.cpp.

struct caenV767 caenV767[MAX_CAENV767]

Definition at line 56 of file caenV767.cpp.

struct readout_module caenV767_module

Initial value:

= {
  NULL,                 
  NULL,                 
  NULL,                 
  caenV767_bor,          
  caenV767_eor,          
  caenV767_poll_live,    
  NULL,                 
  NULL,                 
  NULL,                 
  caenV767_read,         
}

Definition at line 20 of file caenV767.cpp.

Data Structures

Macros

Functions

Variables

Macro Definition Documentation

Function Documentation

Variable Documentation