CCAENChain.cpp

Go to the documentation of this file.

/*
    This software is Copyright by the Board of Trustees of Michigan
    State University (c) Copyright 2005.

    You may use this software under the terms of the GNU public license
    (GPL).  The terms of this license are described at:

     http://www.gnu.org/licenses/gpl.txt

     Author:
             Ron Fox
             NSCL
             Michigan State University
             East Lansing, MI 48824-1321
*/


#define DMA_THRESHOLD 34*20*4   // Don't allow it to go DMA.

/*
  Revision history:
  $Log$
  Revision 8.2  2005/06/24 11:30:36  ron-fox
  Bring the entire world onto the 8.2 line

  Revision 4.3  2004/12/07 15:20:21  ron-fox
  - Fix some CVS errors with the wiener driver.
  - Re create the autotools based build for the wiener driver stuff.
  - Actually check that we can compile the stuff selecting the wiener
    vme device

  Revision 4.2  2004/11/16 15:24:48  ron-fox
  - Port to the gnu 3.x compiler set.
  - Integrate buid of tests.
  - Integrate build of docos.

  Revision 1.2  2004/11/16 15:23:28  ron-fox
  - Port -> gcc/g++ 3.x
  - Support integrated test building.
  - Support integrated doxygen docu7mentation building.

  Revision 1.1  2003/12/03 18:45:45  ron-fox
  Update 767 documentation

  Revision 1.2  2003/09/19 19:52:45  ron-fox
  This is probably debugged.  Need to see what CAEN says about data corruption .

  Revision 1.1  2003/09/16 12:16:24  ron-fox
  Added support for CBLT readout of CAEN 32 channel adcs.  Note for SBS/bit3 the driver must be patched to support early termination of block transfers.

*/
#include <config.h>
#include "CCAENChain.h"
#include "CAENcard.h"
#include <CVMEInterface.h>
#ifdef HAVE_SBSVME_INTERFACE
#include <SBSBit3API.h>
#endif

#include <stdio.h>

#ifdef HAVE_STD_NAMESPACE
using namespace std;
#endif


static const int QualifyingFirmware(0x0904);


static int fwMajor(int firmware) 
{
  return (firmware >> 8) & 0xff;
}
static int fwMinor(int firmware) 
{
  return firmware & 0xff;
}
CCAENChain::CCAENChain(int nFirstSlot, int nLastSlot,
                       vector<unsigned long>& vBases,
                       int nCrate, bool geo) throw (string)
      : m_nCBLTAddress(0),
        m_nCrate(nCrate),
        m_pHandle(0),
        m_nMaxBytes(0)
{

  // Require legitimate length of chain:

  int nModules = (nLastSlot - nFirstSlot + 1);
  if(nModules < 2) {
    throw string("Chains must have at least two modules!!");
  }
  // If not geo, require sufficient bases:

  if(!geo & (vBases.size() != nModules)) {
    throw string("Insufficient module base addresses in CAENChain");
  }
  

  // Create the modules in the chain.
  // 
  int i = 0;
  try {
    for(int slot = nFirstSlot; slot <= nLastSlot; slot++, i++) {
      m_vCards.push_back(new CAENcard(slot, nCrate, geo,
                                      geo ?  0 : vBases[i]));
    }
  } 
  catch(...) {                  // On any exception:
    FreeModules();              // Free the modules already created
    throw;                      // and rethrow.
  }

  // All of the modules in the chain must be at firmware 9.04 or higher
  // at least.  This corresponds to a firmware value of
  // 0x0904 or larger.

  try {
    for (int slot = 0; slot < m_vCards.size(); slot++) {
      if (m_vCards[slot]->getFirmware() < QualifyingFirmware) {
        unsigned long base    = m_vCards[slot]->getBase();
        int           fw      = m_vCards[slot]->getFirmware();
        int           major   = fwMajor(fw);
        int           minor   = fwMinor(fw);
        int           qmajor  = fwMajor(QualifyingFirmware);
        int           qminor  = fwMinor(QualifyingFirmware);
        char errorMessage[1000];
        sprintf(errorMessage,
                "All modules in the chain must have firmware rev at least %d.%d, the module base address 0x%08x (slot %d) has firmware rev %d.%d",
                qmajor, qminor, base, m_vCards[slot]->getSlot(), major, minor);
        throw(string(errorMessage));

      }
    }
  }
  catch (...) {
    FreeModules();
    throw;
  }

  //  The base address of the chain is essentially the first
  //  slot number (shifted left by 16 bits to fall into the 
  //  range of address bits covered by the MCST/CBLT bits in the
  //  module's MCST/CBLT register.
  //

  m_nCBLTAddress = nFirstSlot << 24;
  for(i = 0; i < nModules; i++) {
    CAENcard::ChainMember where(CAENcard::IntermediateInChain);
    if(i == 0) where = CAENcard::FirstInChain;
    if(i == (nModules - 1))  where = CAENcard::LastInChain;
    m_vCards[i]->SetCBLTChainMembership(nFirstSlot, where);
  }

  // Calculate the  number of bytes that can be read:
  // In cblt seems like a module returns
  //  header data trailer invalid 
  //   Data can be 32 longs,
  //   header, trailer and invalid are both a single long.

  m_nMaxBytes = (nModules * 35 + 1) * sizeof(long);

  // The very last thing to do is open the VME crate on
  // CBLT addressing so that we can do a read(2) to read an event:

  try {
    m_pHandle = CVMEInterface::Open(CVMEInterface::CBLT, nCrate);
#ifdef HAVE_SBSVME_INTERFACE
    CSBSBit3VmeInterface::SetDMABlockTransfer(m_pHandle, true);
    CSBSBit3VmeInterface::SetDMAThreshold(m_pHandle, DMA_THRESHOLD);
#endif
  }
  catch (...) {
    FreeModules();
    throw;
  }
                                   
  
}
CCAENChain::~CCAENChain() 
{
  FreeModules();
  CVMEInterface::Close(m_pHandle);
}
CAENcard*
CCAENChain::operator[](int index) throw (CRangeError)
{
  if( (index >= 0) && (index < m_vCards.size())) {
    return m_vCards[index];
  }
  else {
    throw CRangeError(0, m_vCards.size(), index,
                      "Selecting a CAENcard from a chain");
  }

}
int
CCAENChain::ReadEvent(void* pBuffer)
{
  int nCards = m_vCards.size();
  int nRead = 0;
  try {
    nRead = CVMEInterface::Read(m_pHandle,
                        m_nCBLTAddress,
                        pBuffer, m_nMaxBytes);
  }
  catch (... ) {                //  Try to reset the adapter on error.
    // See if reopening fixes this (ugghhh).
    CVMEInterface::Close(m_pHandle);
    m_pHandle = CVMEInterface::Open(CVMEInterface::CBLT, m_nCrate);
#ifdef HAVE_SBSVME_INTERFACE
    CSBSBit3VmeInterface::SetDMABlockTransfer(m_pHandle, true);
    CSBSBit3VmeInterface::SetDMAThreshold(m_pHandle, DMA_THRESHOLD);    
#endif
    throw;                      // But re-report the error.
  }

  return nRead/sizeof(unsigned short);
}
void
CCAENChain::ClearData()
{
  int ncards = m_vCards.size();
  for(int i = 0; i < ncards; i++) {
    m_vCards[i]->clearData();
  }
}

void
CCAENChain::FreeModules()
{
  for(int i=0; i < m_vCards.size(); i++ ) {
    delete m_vCards[i];
  }
  m_vCards.erase(m_vCards.begin(), m_vCards.end());
}

void 
CCAENChain::lastModuleEmptyEnable() 
{

  CAENcard* pCard = lastCard();
  pCard->emptyEnable();
}

void 
CCAENChain::lastModuleEmptyDisable()
{
  CAENcard*  pCard = lastCard();
  pCard->emptyDisable();
}

/*
  Utility to return the last card in the chain (DRY).
*/
CAENcard*
CCAENChain::lastCard()
{
  // Get the pointer to the last module:

  CAENcard* pCard = m_vCards.back();
  return pCard;
}

---