CAENcard_767.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
*/


#include <config.h>
#include "CAENcard_767.h"



#include <string>
#include <Iostream.h>
#include <CVMEInterface.h>

#ifdef HAVE_STD_NAMESPACE
using namespace std;
#endif



CAENcard_767::CAENcard_767(int slotNum, int crateNum,
                           bool fisGeo, unsigned long nBase) :
  slot(0), 
  m_pSpace(0)
  
{
  if(slotInit(slotNum, crateNum, fisGeo, nBase) < 0) {
    throw string("CAENcard_767 construction failed!");
  }

};

CAENcard_767::CAENcard_767(const CAENcard_767& card) :
  slot(card.slot),
  m_pSpace(card.m_pSpace)
{

};

CAENcard_767& 
CAENcard_767::operator=(const CAENcard_767& card)
{
  if(this != &card) {
    slot     = card.slot;
    m_pSpace = card.m_pSpace;
  }
  return *this;

};

int CAENcard_767::slotInit(int slotNum, int crateNum, 
                           bool fisGeo, unsigned long nBase)
{

  //ensure that the slot and crate specified stay within bounds

  
  slot = slotNum;


  if((slot > VME_CRATE_SIZE) || (slot <= 0))
  {
    perror("Invalid slot number specified to slotInit(). ");
    return(-1);
  }



  // Create the VME module... this may be a GEO or an extended address
  // modifier range, depending on the base parameter.

  CVmeModule::Space space;
  unsigned long     base;
  
  // Based on the geo flag, figure out which space, and what the base is.

  if (fisGeo) {
    space = CAEN_GEO24;
    base  = slot << 19;
  }
  else {
    space = CAEN_A32D16;
    base  = nBase;
  }

  try {
    m_pSpace = new CVmeModule(space, base, CAEN_767_CARD_MMAP_LEN, crateNum);
  } 
  catch (string& msg) {
    cerr << "Could not map crate: " << crateNum << " slot: " << slot
         << " : " << msg << endl;
    return(-6);  
  }
   


  if(  !( (0x0040e6 == mfgId())                   &&
          (767    == cardType())                  &&
          (((short int)slot ==  (0x001F & m_pSpace->peekw(CAEN_767_ADDR_GEO))) ||
           !fisGeo))) {

      printf( "\n767 Card %d is not inserted or is of an incompatable type!\n", slotNum);
      printf("  One of the following tests has failed\n");
      printf("    0x0040e6 = 0x%6.6X\n", mfgId());
      printf("    767    == %d\n",  cardType());
      printf("    0x%4.4X == 0x%4.4X & 0x001F\n", slot,
                                          m_pSpace->peekw(CAEN_767_ADDR_GEO));

      delete m_pSpace;
      m_pSpace = NULL;
      return(-7);
  }
  // If the card is not being accessed geographically we program the slot:

  reset();


  if(!fisGeo) {
     m_pSpace->pokew(slot,CAEN_767_ADDR_GEO);
  }

  //disable the auto load of the user configuration at the next reset

  if(  ( writeOpcode(0x1900, 1000000) < 0 ) || ( opcodeWait(1000000) < 0 )  )
  {
    delete m_pSpace;
    m_pSpace = NULL;
    return(-10);
  }

  // end of slot initialization, begin address initialization.. This is only needed
  // if access is geographical.... as otherwise we're already mapped the way we
  // want to be!

  if(fisGeo) {
    m_pSpace->pokew(slot, CAEN_767_ADDR_32); // Set the new module address...
    m_pSpace->pokew(0,    CAEN_767_ADDR_24);
    m_pSpace->pokew(1<<4, CAEN_767_BIT_SET); // Enable address relocation.

    delete m_pSpace;
    m_pSpace = NULL;
    try {
      m_pSpace = new CVmeModule(CAEN_A32D16, slot << 24,
                                CAEN_767_CARD_MMAP_LEN, crateNum);
    }
    catch (string& msg) {
      cerr << "Unable to create relocated address for CAEN-767 " 
           << msg << endl;
      return -11;
    }

  }



  // load the default configuration (only problem is that it is "Stop Trigger 
  // Matching")

  if(cardType() == 767)   {
    if(  ( writeOpcode(0x1500, 1000000) < 0 ) || ( opcodeWait(1000000) < 0 )  )
    {
      delete m_pSpace;
      m_pSpace = NULL;
      return(-14);
    }
  }
  sleep(5);

  return(0);
};

CAENcard_767::~CAENcard_767()
{
  m_pSpace->pokew(1 << 4, CAEN_767_BIT_CLEAR); // Turn off any relocation
  delete m_pSpace;
};

int CAENcard_767::readOpcode(unsigned short int *value, int maxRetry)
{
  int i;  
  for( i = 0; i < maxRetry; ++i ) {
    if( m_pSpace->peekw(CAEN_767_OPCODE_STATUS) & (1 << 0) ) {
      //the "read okay" bit is set
      break;
    }
  }
  
  if( i >= maxRetry )  {
    //never broke the loop...
    return(-1);
  }
  
  //take the prescribed 10ms timeout before reading the value
  
  usleep(10000);
  
  //now read the register and return
  *value = m_pSpace->peekw(CAEN_767_OPCODE);
  return( i );
}

int 
CAENcard_767::writeOpcode(unsigned short int value, int maxRetry)
{
  int i = opcodeWait(maxRetry);

  if (i >= 0) {
    
    //take the prescribed 10ms timeout before reading the value
    
    usleep(10000);
    
    //now write the register and return
    
    m_pSpace->pokew(value, CAEN_767_OPCODE);
  }
  return( i );

};
int CAENcard_767::opcodeWait(int maxRetry)
{
  int i;  
  for( i = 0; i < maxRetry; ++i ) {
    if( m_pSpace->peekw(CAEN_767_OPCODE_STATUS) & (1 << 1) ) {
      //the "write okay" bit is set
      break;
    }
  }
  
  if( i == maxRetry ) {
    //never broke the loop...
    return(-2);
  }
  
  //take the prescribed 10ms timeout before doing anything else
  
  usleep(10000);
  
  return( i );
  
}

int CAENcard_767::cardType()
{
  return (( (int)m_pSpace->peekw(CAEN_767_BOARD_ID) << 24)   |
          ( (int)m_pSpace->peekw(CAEN_767_BOARD_ID+2) << 16) |
          ( (int)m_pSpace->peekw(CAEN_767_BOARD_ID+4) << 8)  |
          ( (int)m_pSpace->peekw(CAEN_767_BOARD_ID+6)));
};

void CAENcard_767::clearData()
{
  m_pSpace->pokew(1, CAEN_767_CLEAR);

};


void CAENcard_767::reset()
{
  m_pSpace->pokew(1, CAEN_767_SS_RESET);
  sleep(2);

};

int CAENcard_767::dataPresent()
{

  unsigned short s1 = m_pSpace->peekw(CAEN_767_STATUS_1);
  
  return ((s1 & 5) == 1 );

};

int CAENcard_767::readEvent(void* buf)
{
  int temp, n = dataPresent();
  if(n > 0) {
    n = 0;
    // read until it hits an invalid datum (should there be an option to stop at EOB?)
    temp = m_pSpace->peekl(0);
    while( (temp & CAEN_767_DATUM_TYPE) != CAEN_767_INVALID )  {
      *(((int*)buf) + n) = temp;
      ++n;
      temp = m_pSpace->peekl(0);
    }
    n *= 4;  //convert the number of integers to the number of bytes
  }
  
  return(n);
};

int CAENcard_767::readEvent(DAQWordBuffer& wbuf, int offset)
{
  int n = dataPresent();
  union{                        // Assume little endian longword order.
    int dword;
    struct{
      short int low;
      short int high;
    } word;
  } temp;

  if(n > 0)  {
    n = 0;
    // read until it hits an invalid datum (should there be an option to stop at EOB?)
    temp.dword = m_pSpace->peekl(0);
    
    while( (temp.dword & CAEN_767_DATUM_TYPE) != CAEN_767_FOOTER ) {
      wbuf[offset] = temp.word.high;
      wbuf[offset+1] = temp.word.low;
      ++n;
      temp.dword = m_pSpace->peekl(0);
    }
    if( (temp.dword & CAEN_767_DATUM_TYPE) == CAEN_767_FOOTER ) {
      wbuf[offset] = temp.word.high;
      wbuf[offset + 1] = temp.word.low;
      ++n;
    }
    
    n *= 2;
  }
  return(n);
};

int CAENcard_767::readEvent(DAQWordBufferPtr& wp)
{
  int n = dataPresent();
  union{
    int dword;
    struct{
      short int low;
      short int high;
    } word;
  } temp;

  if(n > 0)
  {
    n = 0;
    temp.dword = m_pSpace->peekl(0);
    while( (temp.dword & CAEN_767_DATUM_TYPE) != CAEN_767_INVALID )
    {
      *wp = temp.word.high;
      wp++;
      *wp = temp.word.low;
      wp++;
      ++n;
      temp.dword = m_pSpace->peekl(0);
    }

    n *= 2;
  }
  return(n);
};

int CAENcard_767::readEvent(DAQDWordBuffer& dwbuf, int offset)
{
  int temp, n = dataPresent();
  if(n > 0)
  {
    n = 0;
    temp = m_pSpace->peekl(0);
    while( (temp & CAEN_767_DATUM_TYPE) != CAEN_767_INVALID )
    {
      dwbuf[offset + n] = temp;
      ++n;
      temp = m_pSpace->peekl(0);
    }
  }
  return(n);
};

int CAENcard_767::readEvent(DAQDWordBufferPtr& dwp)
{
  int temp, n = dataPresent();
  if(n > 0)
  {
    n = 0;
    temp = m_pSpace->peekl(0);
    while( (temp & CAEN_767_DATUM_TYPE) != CAEN_767_INVALID )
    {
      *dwp = temp;
      dwp++;
      ++n;
      temp = m_pSpace->peekl(0);
    }
  }
  return(n);
};


int
CAENcard_767::tempSetup()
{
  //set to common start mode ("Start Gating")
  // -- saves all conversions while the start signal is high.  the trigger signal is unused
  if( writeOpcode(0x1200, 1000000) < 0 )
    {
      return(-1);
    }
  
  //set data-ready mode to be event-ready
  if( writeOpcode(0x7000, 1000000) < 0 )
    {
      return(-2);
    }
  
  //enable subtraction of start time for start gating mode
  if( writeOpcode(0x4300, 1000000) < 0)
    {
      return(-3);
    }
  opcodeWait(1000000);
  
  return(0);
}
int 
CAENcard_767::SetRisingEdgeStart()
{
  if(writeOpcode(0x6400, 1000000) < 0) {
    return -1;
  }
  opcodeWait(1000000);
  return 0;
}
int
CAENcard_767::SetFallingEdgeStart()
{
  if(writeOpcode(0x6500, 100000) < 0) {
    return -1;
  }
  opcodeWait(100000);
  return 0;
}
int
CAENcard_767::SetRisingEdgeAll()
{
  if(writeOpcode(0x6000, 1000000) < 0) {
    return -1;
  }
  opcodeWait(1000000);
  return 0;
}
int
CAENcard_767::SetFallingEdgeAll()
{
  if(writeOpcode(0x6100, 1000000) < 0) {
    return -1;
  }
  opcodeWait(1000000);
  return 0;
}
int
CAENcard_767::getStartEdge() {
  unsigned short edges[3];
  int stat = readEdgeConfiguration(edges);
  if (stat < 0) {
    return stat;
  }
  return edges[2];
}
int
CAENcard_767::getEdgeEven()
{
  unsigned short edges[3];
  int stat = readEdgeConfiguration(edges);
  if (stat < 0) {
    return stat;
  }
  return edges[0];
}
int 
CAENcard_767::getEdgeOdd()
{
  unsigned short edges[3];
  int stat = readEdgeConfiguration(edges);
  if (stat < 0) {
    return stat;
  }
  return edges[1];  
}
unsigned short CAENcard_767::getSr2()
{
  return m_pSpace->peekw(CAEN_767_STATUS_2);
}
int
CAENcard_767::mfgId()
{
  return ((m_pSpace->peekw(CAEN_767_MANUFACT_ID) <<   16)  |
          (m_pSpace->peekw(CAEN_767_MANUFACT_ID+2) << 8)  |
          (m_pSpace->peekw(CAEN_767_MANUFACT_ID+4)));
}


int
CAENcard_767::readEdgeConfiguration(unsigned short* values)
{
  if (writeOpcode(0x6700, 10000) < 0) {
    return -1;
  }
  opcodeWait(1000000);
  if (readOpcode(values, 1000) < 0) { // Even channels..
    return -2;
  }
  *values &= CAEN_767_EDGE_BOTH;
  values++;
  if (readOpcode(values, 1000) < 0) { // Odd channels..
    return -3;
  } 
  *values &= CAEN_767_EDGE_BOTH;
  values++;
  if (readOpcode(values, 1000) < 0) { // Start channel...
    return -4;
  }
  *values &= CAEN_767_EDGE_BOTH;
  return 0;
}

---