caenV767.cpp File Reference

#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"

Go to the source code of this file.

Data Structures
struct	caenV767

Macros
#define	CAENV767_MAX_DMA_SIZE   256
#define	CAENV767_MAX_SIZE   (32*1024*4)
#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_pre_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_eor(), caenV767_poll_live(), caenV767_pre_bor(), and caenV767_read().

Function Documentation

INT caenV767_bor1

(

struct caenV767 *

caen)

Definition at line 108 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.

Referenced by caenV767_bor(), and caenV767_pre_bor().

{
  // 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

(

)

Definition at line 244 of file caenV767.cpp.

References caenV767_eor1(), enabled, i, MAX_CAENV767, status, and SUCCESS.

{

  for(int i = 0; i < MAX_CAENV767; i++) {
    if(caenV767[i].enabled) {
      int status = caenV767_eor1(&caenV767[i]);
      if(status != SUCCESS) {
         return status;
      }
    }
  }

  return SUCCESS;
}

INT caenV767_eor1

(

struct caenV767 *

caen)

Definition at line 231 of file caenV767.cpp.

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

Referenced by caenV767_eor().

{
  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 259 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().

Referenced by caenV767_poll1(), and caenV767_read1().

{
  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 88 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 73 of file caenV767.cpp.

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

Referenced by caenV767_bor1().

{
  // 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 293 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.

Referenced by caenV767_poll_live().

{
  // 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

(

)

Definition at line 350 of file caenV767.cpp.

References block_start_time, caenV767_poll1(), enabled, i, MAX_CAENV767, status, and SUCCESS.

{
  // If this is our first active readout pass, just remember the time.
  if(block_start_time.tv_sec == 0 && block_start_time.tv_usec == 0) {
    return SUCCESS;
  }

  for(int i = 0; i < MAX_CAENV767; i++) {
    if(caenV767[i].enabled) {
      int status = caenV767_poll1(&caenV767[i]);
      if(status != SUCCESS) {
        return status; 
      }
    }
  }

  return SUCCESS;
}

INT caenV767_pre_bor

(

)

Definition at line 198 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_read

(

char *

pevent)

Definition at line 453 of file caenV767.cpp.

References caenV767_read1(), enabled, i, MAX_CAENV767, status, and SUCCESS.

{
  for(int i = 0; i < MAX_CAENV767; i++) {
    if(caenV767[i].enabled) {
      int status = caenV767_read1(&caenV767[i], pevent);
       if(status != SUCCESS) {
         return status;
       }
    }
  }

  return SUCCESS;
}

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

Definition at line 374 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, printf(), status, SUCCESS, caenV767::vme_base, caenV767::vme_handle, vme_read_d16(), and vme_write_d16().

Referenced by caenV767_read().

{
  // 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
  // Modified by VT on Oct-29-2010
  //bk_close(pevent, pdata + (active_size + final_size)/sizeof(DWORD));
  int total_size = active_size + final_size;
  if ( total_size > 500000 ) {
    printf("ERROR! Event size is too big (%i). The event will be rejected\n");
    bk_close(pevent, pdata + 0);
  } else {
    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.

Referenced by caenV767_poll1(), caenV767_poll_live(), caenV767_read1(), dummy_master_poll_live(), and dummy_master_start_block().

struct caenV767 caenV767[MAX_CAENV767]

Definition at line 56 of file caenV767.cpp.

struct readout_module caenV767_module

Initial value:

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

Definition at line 20 of file caenV767.cpp.