CADC2530.cpp

Go to the documentation of this file.

/*=========================================================================*\
| Copyright (C) 2008 by the Board of Trustees of Michigan State University. |
| 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                                       |
|                                                                           |
| Written by: E. Kasten                                                     |
\*=========================================================================*/

/*
  Change Log:
*/

static const char* Copyright= "(C) Copyright Michigan State University 2008, All rights reserved";

#include <config.h>

#include <CADC2530.h>
#include <string>
#include <unistd.h>
#include <string.h>
#include <math.h>

#include <assert.h>

#ifdef HAVE_STD_NAMESPACE
using namespace std;
// #include <spectrodaq.h>
#endif

//   Convenience function for longword swapping.
#define swaplong(n)  (((n >> 16) & 0xffff) | ((n & 0xffff) << 16))

// Byte offset associated with a structure/field.
#define Offset(structname, field) ((unsigned int)&(((structname*)0x0)->field))

// Short and Long noffset associated with a struct/field.
#define ShortOffset(structname, field) (Offset(structname,field)/sizeof(short))
#define LongOffset(structname, field)  (Offset(structname,field)/sizeof(long))

// VME crate definitions
#define VME_CRATE_SIZE      24  // Slots in a VME crate.

// ADC2530 register and memory sizes and offsets
#define CADC2530_REGSIZE       0xC0      // Size of register set.
#define CADC2530_MEMSIZE       0x200000  // Size of all histo/list memory.
#define CADC2530_HISTOMEMSIZE  0x40000   // Size of histogram memory.
#define CADC2530_HISTOCHANSIZE 0x2000    // Size of histogram channel in longs.

// This value masks out (logical AND) the bits returned from a
// CSR read that should not be retained during a CSR set operation.
#define CADC2530_CSRMASK 0x00FF8A

// This value masks out (logical AND) the bits returned from a
// CTR read that should not be retained during a CTR set operation.
#define CADC2530_CTRMASK 0x00810F

// Defines for parsing list mode data blocks
#define IS_LIST_HEADER(x) (((((x>>24)&0x07) == 0x2)) ? true : false) 
#define IS_LIST_EOB(x) (((((x>>24)&0x07) == 0x4)) ? true : false) 
#define IS_LIST_CHANNEL(x) ((((x>>24)&0x07) == 0x0)) ? true : false) 
#define GET_LIST_CHANCOUNT(x) (((x>>8)&0x07)+1)
#define GET_LIST_CHANNUM(x) (((x>>16)&0x07)+1)
#define GET_LIST_CHANDATA(x) (x&0x1FFF)
#define GET_LIST_EVENTCOUNT(x) (x&0x00FFFFFF)

// Definition of the register and configuration memory.
typedef struct ADCregisters_struct {
  unsigned short  ManufacturerId;              // 0x00      (R)
  unsigned short  DeviceType;                  // 0x02      (R)
  unsigned short  CSR;                         // 0x04      (RW)
  unsigned short  MemoryOffset;                // 0x06      (RW)
  unsigned short  ListAddressLS;               // 0x08      (RW)
  unsigned short  ListAddressMS;               // 0x0A      (RW)
  unsigned short  InterruptVector;             // 0x0C      (RW)
  unsigned short  CTR;                         // 0x0E      (RW)
  unsigned short  FullnessFlag;                // 0x10      (RW)
  unsigned short  InterruptMask;               // 0x12      (RW)
  unsigned short  LowerLevelDisc;              // 0x14      (RW)
  unsigned short  UpperLevelDisc;              // 0x16      (RW)
  unsigned short  EventCounterLS;              // 0x18      (RW)
  unsigned short  EventCounterMS;              // 0x1A      (RW)
  unsigned short  Conversion;                  // 0x1C      (R)
  unsigned short  SlidingScaleTest;            // 0x1E      (RW)
  unsigned short  NotUsed2[16];                // 0x20-0x3F  
  unsigned short  SerialNumber;                // 0x40      (R) 
  unsigned short  DataInNonVolatileMem[63];    // 0x42-0xBF
} ADCregisters_t;

// Bit definition for the control and status register (CSR)
typedef union ADCcsr_union {
  unsigned short csrval;
  struct bit_struct {
    unsigned char RSTBSY : 1; // Read->Busy, Write->Reset (RW)
    unsigned char SS     : 1; // Enable sliding scale (0 is ON) (RW)
    unsigned char DR     : 1; // Data ready (R)
    unsigned char SC     : 1; // Set calibration on (RW)
    unsigned char FFCLR  : 1; // Force fast clear on all channesl (W)
    unsigned char ACM    : 1; // Auto memory clear (RW) (not completed)
    unsigned char IS     : 1; // Interrupt status (R)
    unsigned char IE     : 1; // Interrupt enable (RW)
    unsigned char ARM    : 1; // Start acquisition (RW)
    unsigned char IPL    : 3; // Set interrupt priority level (RW)
    unsigned char FHE    : 1; // Full/Half full or Event interrupt (RW)
    unsigned char ZE     : 1; // Enable zero conversion (RW)
    unsigned char GE     : 1; // Enable gate mode (RW)
    unsigned char HE     : 1; // Enable histogram mode (RW)
  } bits;
} ADCcsr_t;

// Bit definition for the calibration and test register (CTR)
typedef union ADCctr_union {
  unsigned short ctrval;
  struct bit_struct {
    unsigned char M012   : 3; // Channel select bits 0-2 (RW)
    unsigned char MEN    : 1; // Enable the MUX switch (RW)
    unsigned char D04    : 1; // Unused
    unsigned char D05    : 1; // Unused
    unsigned char D06    : 1; // Unused
    unsigned char D07    : 1; // Unused
    unsigned char DISC   : 1; // Disable compensation (0 -> comp. applied) (RW)
    unsigned char D09    : 1; // Unused
    unsigned char D10    : 1; // Unused
    unsigned char D11    : 1; // Unused
    unsigned char D12    : 1; // Unused
    unsigned char D13    : 1; // Unused
    unsigned char D14    : 1; // Unused
    unsigned char DEAC   : 1; // Disable auto fast clear
  } bits;
} ADCctr_t;

// Bit definition for the fullness flag register
typedef union ADCfullnessflag_union {
  unsigned short flags;

  struct byte_struct {
    unsigned char HALFFULL : 8; // Half full flags
    unsigned char FULL     : 8; // Full flags
  } bytes;

  struct bit_struct {
    unsigned char F1     : 1; 
    unsigned char F2     : 1; 
    unsigned char F3     : 1; 
    unsigned char F4     : 1; 
    unsigned char F5     : 1; 
    unsigned char F6     : 1; 
    unsigned char F7     : 1; 
    unsigned char F8     : 1; 
    unsigned char HF1    : 1; 
    unsigned char HF2    : 1; 
    unsigned char HF3    : 1; 
    unsigned char HF4    : 1; 
    unsigned char HF5    : 1; 
    unsigned char HF6    : 1; 
    unsigned char HF7    : 1; 
    unsigned char HF8    : 1; 
  } bits;
} ADCfullnessflag_t;

/*==============================================================*/
CADC2530::CADC2530(int crateNum,long nBase) :
  my_nCrate(crateNum),
  my_nBase(nBase),
  my_nMemOffset(nBase),
  my_pModule(NULL),
  my_pMemory(NULL),
  my_nCardId(0),
  my_nCardType(0),
  my_nModFd(0),
  my_nMemFd(0),
  my_eventmode(false),
  my_cureventpos(0)
{
  assert(sizeof(ADCregisters_t) == CADC2530_REGSIZE); // Else struct misdefined.
  slotInit();
}

/*==============================================================*/
CADC2530::CADC2530(const CADC2530& card) :
  my_nCrate(card.my_nCrate),
  my_nBase(card.my_nBase),
  my_nMemOffset(card.my_nMemOffset),
  my_nCardId(card.my_nCardId),
  my_nCardType(card.my_nCardType),
  my_pModule(NULL),
  my_pMemory(NULL),
  my_nModFd(0),
  my_nMemFd(0),
  my_eventmode(false),
  my_cureventpos(0)
{
  mapCard();                    // Map the card.
}

/*==============================================================*/
CADC2530& CADC2530::operator=(const CADC2530& card) {
  if (this != (&card)) {
    if (this->my_pModule != NULL) destroyCard(); // Destroy old memory map.
    my_nCrate = card.my_nCrate;
    my_nBase  = card.my_nBase;
    my_nMemOffset = card.my_nMemOffset;
    my_eventmode = card.my_eventmode;
    my_cureventpos= card.my_cureventpos;
    my_nMemFd  = 0;
    my_nModFd  = 0;
    my_pModule = NULL;
    my_pMemory = NULL;
    mapCard();
  }
  return *this;
}

/*==============================================================*/
CADC2530::~CADC2530() {
  destroyCard();
}

/*==============================================================*/
bool CADC2530::checkCard(int nCrate,long nBase,unsigned short &rType, unsigned short &rManId) {
  // Ensure that the slot and crate specified stay within bounds.
  int crate = nCrate & 0xff;  // Not important enough to give an error,
                                // just discard the extra.

  // The card is not mapped yet, so do it.
  void *fd = NULL;
  rType = 0;
  rManId = 0;

#ifndef HAVE_VME_MAPPING
   CVmeModule *adcmod = new CVmeModule(CVmeModule::a24d32,nBase,CADC2530_REGSIZE,crate);
#else
   fd = CVMEInterface::Open(CVMEInterface::A24,crate);
   volatile unsigned short *adcmod = (volatile unsigned short*)CVMEInterface::Map(fd,nBase,CADC2530_REGSIZE);
#endif

#ifndef HAVE_VME_MAPPING
   rType = adcmod->peekw(ShortOffset(ADCregisters_t,DeviceType));
   rManId = adcmod->peekw(ShortOffset(ADCregisters_t,ManufacturerId));
   delete adcmod;
#else
   rType = ((volatile ADCregisters_t*)adcmod)->DeviceType;
   rManId = ((volatile ADCregisters_t*)adcmod)->ManufacturerId;
   CVMEInterface::Unmap(fd,(void*)adcmod,CADC2530_REGSIZE);
   CVMEInterface::Close(fd);
#endif

   adcmod = NULL;
   fd = NULL;

   if ((rManId != 0x8063)||(rType != 2530)) return false;
   else return true;
}

/*==============================================================*/
unsigned short CADC2530::volt2lld(double volt) {
  unsigned short sval = 0; 
  if (volt < 0) {
    sval = 0x0;
  } else if (volt > 0.8191) {
    sval = 0x3FFC;
  } else {
    int val = (int)((volt/3.2764)/(0.25/4095));
    sval = (unsigned short)((val << 2)&0x00003FFC);
  }

  return sval;
}

/*==============================================================*/
unsigned short CADC2530::volt2uld(double volt) {
  unsigned short sval = 0;

  if (volt < 0) {
    sval = 0x0;
  } else if (volt > 8.191) {
    sval = 0x3FFC;
  } else {
    int val = (unsigned int)trunc(((volt/3.2764)-2)/(0.5/4095));
    sval = (unsigned short)((val << 2)&0x00003FFC);
  }

  return sval;
}

/*==============================================================*/
const std::string& CADC2530::toString() {
  static string namstr;
  static char buffer[256];
  sprintf(buffer,"ADC2530 in crate %d at base 0x%x with memory offset 0x%x",my_nCrate,my_nBase,my_nMemOffset);
  namstr = buffer;
  return namstr;
}

/*==============================================================*/
/*
void CADC2530::ReadBufferBlock(int* pDest, Int_t nLongs) {
#ifdef HAVE_VME_MAPPING
  for(int i = 0; i < nLongs; i++) {
    unsigned int Datum = ReadBuffer;
    pDest[i] = swaplong(Datum);
  }
#else
  int* pd = pDest;
  m_pModule->readl(pd, LongOffset(Registers, Buffer), nLongs);
  for(int i =0; i < nLongs; i++) {
    *pDest++ = swaplong(*pDest);
  }
#endif
}
*/

/*==============================================================*/
int CADC2530::readListEvent(void* buf,int lngsLeft) {
  int lngcnt = 0;
  unsigned int *lptr = (unsigned int*)buf; 

  // Need at least a header and EOB
  if (lngsLeft < 2) return(0);

#ifndef HAVE_VME_MAPPING
  m_pMemory->readl(lptr,my_cureventpos,1);
#else
  lptr[lngcnt] = ((volatile unsigned long*)my_pMemory)[my_cureventpos];
#endif

  int chans = GET_LIST_CHANCOUNT(lptr[0]);

  // Only read out the last event if there is enough memory
  // to contain it.
  if ((chans+2) < lngsLeft) {
    lngcnt++;
    my_cureventpos++; 

#ifndef HAVE_VME_MAPPING
    m_pMemory->readl(&(lptr[lngcnt]),my_cureventpos*4,chans+1);
    lngcnt += (chans+1);
    my_cureventpos += (chans+1);
#else
    for (int i = 0; i < (chans+1); i++) {
      lptr[lngcnt] = ((volatile unsigned long*)my_pMemory)[my_cureventpos];
      my_cureventpos++;  
      lngcnt++; 
    } 
#endif
  } 

  return lngcnt*sizeof(unsigned int);
}

/*==============================================================*/
int CADC2530::readListEvents(void* buf,int& nEvents) {
  int lngcnt = 0;
  unsigned int *lptr = (unsigned int*)buf; 

  // First check list memory boundaries
  unsigned int listaddr = getListAddress();
  if (listaddr == 0) {
    if (dataReady()) listaddr = (CADC2530_MEMSIZE/sizeof(unsigned int));
  }

  // Now read the events
  int eventsread = 0;
  for (int i = 0; i < nEvents; i++) {
    int bytes = readListEvent((void*)lptr,listaddr-my_cureventpos);
    if (bytes <= 0) break;  // No more events
    eventsread++;

    lptr += (bytes/sizeof(unsigned int));
    lngcnt += (bytes/sizeof(unsigned int));
  } 

  nEvents = eventsread;
  return lngcnt*sizeof(unsigned int);
}

/*==============================================================*/
int CADC2530::readHistogramChannel(void* buf,int channum) {
  if ((channum < 1)||(channum > 8)) {
    char buffer[256];
    sprintf(buffer, "CADC2530::readHistogramChannel(): the channel number specified must be in the range [1-8].  A channel number of %d was specified\n",channum);
    throw string(buffer);
  } 

  int chstart = (channum - 1) * CADC2530_HISTOCHANSIZE;
  unsigned int *lptr = (unsigned int*)buf; 

#ifndef HAVE_VME_MAPPING
  m_pMemory->readl(lptr,chstart*sizeof(unsigned int),CADC2530_HISTOCHANSIZE);
#else
  for (int i = 0; i < CADC2530_HISTOCHANSIZE; i++) {
    lptr[i] = ((volatile unsigned long*)my_pMemory)[chstart+i];
  }
#endif

  return (CADC2530_HISTOCHANSIZE * sizeof(unsigned int));
}

/*==============================================================*/
void CADC2530::slotInit() {
  mapCard();
  resetCard();
  clearHistogramMemory();
}

/*==============================================================*/
unsigned short CADC2530::cardType() {
  if (!my_nCardType) {
#ifndef HAVE_VME_MAPPING
    my_nCardType = my_pModule->peekw(ShortOffset(ADCregisters_t,DeviceType));
#else
    my_nCardType = ((volatile ADCregisters_t*)my_pModule)->DeviceType;
#endif
  }
  return my_nCardType;
}

/*==============================================================*/
unsigned short CADC2530::manufacturerId() {
  if (!my_nCardId) {
#ifndef HAVE_VME_MAPPING
    my_nCardId = my_pModule->peekw(ShortOffset(ADCregisters_t,ManufacturerId));
#else
    my_nCardId = ((volatile ADCregisters_t*)my_pModule)->ManufacturerId;
#endif
  }
  return my_nCardId;
}

/*==============================================================*/
unsigned long CADC2530::setMemoryOffset(unsigned long memoset) {
  unsigned long lval = (memoset >> 16);
  unsigned short sval = (lval & 0xFFE0);  

#ifndef HAVE_VME_MAPPING
  my_pModule->pokew(sval,ShortOffset(ADCregisters_t,MemoryOffset));
  lval = my_pModule->peekw(ShortOffset(ADCregister_t,MemoryOffset));
#else
  ((volatile ADCregisters_t*)my_pModule)->MemoryOffset = sval;
  lval = ((volatile ADCregisters_t*)my_pModule)->MemoryOffset;
#endif

  return (lval << 16);
}

/*==============================================================*/
unsigned long CADC2530::calcMemoryOffset(unsigned long base) {
  unsigned long regset = ((base >> 8) & 0xFFE0);
  return (regset << 16); 
}

/*==============================================================*/
void CADC2530::mapModule() {
   // Donot map the register memory more than once.
   if (my_pModule != NULL) {
     char buffer[256];
     sprintf(buffer, "CADC2530::mapModule(): The Card in crate %d at base 0x%x already has a register memory map.\n",my_nCrate,my_nBase);
     throw string(buffer);
   }

   // Ensure that the slot and crate specified stay within bounds.
   my_nCrate = my_nCrate & 0xff;  // Not important enough to give an error, 
                                // just discard the extra.

   // The card is not mapped yet, so do it.
   void *fd = NULL;

#ifndef HAVE_VME_MAPPING 
   my_pModule = new CVmeModule(CVmeModule::a24d32,my_nBase,
                                CADC2530_REGSIZE,my_nCrate);
#else
   fd = CVMEInterface::Open(CVMEInterface::A24, my_nCrate);
   my_pModule = (volatile unsigned short*)CVMEInterface::Map(fd,my_nBase,
                                                 CADC2530_REGSIZE);
#endif

   // Check if the module type is a 2530(dec) and that the manufacturer is
   // 0x8063.  If not, then issue and error message.
   my_nCardId = manufacturerId();
   my_nCardType = cardType();

   if ((my_nCardId != 0x8063)||(my_nCardType != 2530)) {   
#ifndef HAVE_VME_MAPPING
     delete my_pModule;
#else
     CVMEInterface::Unmap(fd,(void*)my_pModule,CADC2530_REGSIZE);
     CVMEInterface::Close(fd);
#endif
     my_pModule = NULL;
     char buffer[256];
     sprintf(buffer, "CADC2530::mapModule(): Card in crate %d at base 0x%x is not a Hytec 2530 ADC or is missing type=%d id=0x%0x\n",my_nCrate,my_nBase,my_nCardType,my_nCardId);
     throw string(buffer);
   }

   my_nModFd = fd;                      // Save for destruction.
}

/*==============================================================*/
void CADC2530::mapMemory() {
   // We must have a register memory map first.
   if (my_pModule == NULL) {
     char buffer[256];
     sprintf(buffer, "CADC2530::mapMemory(): Cannot map list/histogram memory without first mapping the ADC2530 registers for card in crate %d at base 0x%x.\n",my_nCrate,my_nBase);
     throw string(buffer);
   } 

   // Donot map the list/histogram memory more than once.
   if (my_pMemory != NULL) {
     char buffer[256];
     sprintf(buffer, "CADC2530::mapMemory(): The Card in crate %d at base 0x%x already has a list/histogram memory map.\n",my_nCrate,my_nBase);
     throw string(buffer);
   }

   // Ensure that the slot and crate specified stay within bounds.
   my_nCrate = my_nCrate & 0xff;  // Not important enough to give an error, 
                                  // just discard the extra.

   // The card is not mapped yet, so do it.
   void *fd = NULL;

   // Now can map the list/histogram memory
   unsigned long nmemoset = calcMemoryOffset(my_nBase); 
   my_nMemOffset = setMemoryOffset(nmemoset);

   // If we did this correctly and the card is working correctly,
   // we should read back the setting we calculated.
   if (nmemoset != my_nMemOffset) {
     char buffer[256];
     sprintf(buffer, "CADC2530::mapMemory(): Error setting list/histogram memory offset for ADC2530 card in crate %d at base 0x%x (written=0x%x, read=0x%x)\n",my_nCrate,my_nBase,nmemoset,my_nMemOffset);
     throw string(buffer);
   } 

   // Now map the list/histogram memory.
#ifndef HAVE_VME_MAPPING 
   my_pMemory = new CVmeModule(CVmeModule::a32d32,my_nMemOffset,
                                CADC2530_MEMSIZE,my_nCrate);
#else
   fd = CVMEInterface::Open(CVMEInterface::A32, my_nCrate);
   my_pMemory = (volatile unsigned int*)CVMEInterface::Map(fd,my_nMemOffset,
                                                 CADC2530_MEMSIZE);
#endif
   
   my_nMemFd = fd;                      // Save for destruction.
}

/*==============================================================*/
void CADC2530::destroyMemory() {
  if (my_pMemory == NULL) return;

#ifndef HAVE_VME_MAPPING
   delete my_pMemory;
#else
  CVMEInterface::Unmap(my_nMemFd,(void*)my_pMemory,CADC2530_MEMSIZE);
  CVMEInterface::Close(my_nMemFd);
#endif

  my_pMemory = NULL;
  my_nMemFd = NULL;
}

/*==============================================================*/
void CADC2530::clearMemory() {
  // We must have a memory map first.
  if (my_pMemory == NULL) {
    char buffer[256];
    sprintf(buffer, "CADC2530::clearMemory(): Cannot clear list/histogram memory without first having a memory map for card in crate %d at base 0x%x.\n",my_nCrate,my_nBase);
    throw string(buffer);
  } 

  for (int i = 0x0; i < (CADC2530_MEMSIZE/4); i++) {
#ifndef HAVE_VME_MAPPING
    my_pMemory->pokel((unsigned int)0x0,i);
#else
    ((volatile unsigned int*)my_pMemory)[i] = (unsigned int)0x0;
#endif
  }
}

/*==============================================================*/
void CADC2530::clearHistogramMemory() {
  // We must have a memory map first.
  if (my_pMemory == NULL) {
    char buffer[256];
    sprintf(buffer, "CADC2530::clearHistogramMemory(): Cannot clear histogram memory without first having a memory map for card in crate %d at base 0x%x.\n",my_nCrate,my_nBase);
    throw string(buffer);
  } 

  for (int i = 0x0; i < (CADC2530_HISTOMEMSIZE/4); i++) {
#ifndef HAVE_VME_MAPPING
    my_pMemory->pokel((unsigned int)0x0,i);
#else
    ((volatile unsigned int*)my_pMemory)[i] = (unsigned int)0x0;
#endif
  }
}

/*==============================================================*/
void CADC2530::resetCard() {
  // We must have a memory map first.
  if (my_pModule == NULL) {
    char buffer[256];
    sprintf(buffer, "CADC2530::resetCard(): Cannot reset this card without first having a memory map for card in crate %d at base 0x%x.\n",my_nCrate,my_nBase);
    throw string(buffer);
  } 

  disarm();
  resetCTR();
  setLLD(0x0);
  setULD(0x0);
  setInterruptVector(0x0);
  setInterruptMask(0x0);
  fastClear();
  resetCSR();
  clearEventCounter();
  clearListAddress();
  clearFullnessFlags();
  modeHistogram(false);
}

/*==============================================================*/
void CADC2530::destroyModule() {
  if (my_pModule == NULL) return;

  resetCard();

#ifndef HAVE_VME_MAPPING
   delete my_pModule;
#else
  CVMEInterface::Unmap(my_nModFd,(void*)my_pModule,CADC2530_REGSIZE);
  CVMEInterface::Close(my_nModFd);
#endif

  my_pModule = NULL;
  my_nModFd = NULL;
}

/*==============================================================*/
void CADC2530::mapCard() {
  mapModule();
  mapMemory();
}

/*==============================================================*/
void CADC2530::destroyCard() {
  destroyMemory();
  destroyModule();
}

/*==============================================================*/
void CADC2530::arm() {
  ADCcsr_t csr;
  csr.csrval = 0;
  csr.bits.ARM = 1;
  setCSRbits(csr.csrval,csr.csrval);
}

/*==============================================================*/
void CADC2530::disarm() {
  ADCcsr_t csr;
  csr.csrval = 0;
  csr.bits.ARM = 1;
  resetCSRbits(csr.csrval);
}

/*==============================================================*/
void CADC2530::dataReadyOnEvent() {
  my_eventmode = true;
  ADCcsr_t csr;
  csr.csrval = 0;
  csr.bits.DR = 1;
  csr.bits.FHE = 1;
  setCSRbits(csr.csrval,csr.csrval);
}

/*==============================================================*/
void CADC2530::dataReadyOnFullness() {
  my_eventmode = false;
  ADCcsr_t csr;
  csr.csrval = 0;
  csr.bits.DR = 1;
  csr.bits.FHE = 1;
  resetCSRbits(csr.csrval);
}

/*==============================================================*/
void CADC2530::enableGate() {
  ADCcsr_t csr;
  csr.csrval = 0;
  csr.bits.GE = 1;
  setCSRbits(csr.csrval,csr.csrval);
}

/*==============================================================*/
void CADC2530::disableGate() {
  ADCcsr_t csr;
  csr.csrval = 0;
  csr.bits.GE = 1;
  resetCSRbits(csr.csrval);
}

/*==============================================================*/
void CADC2530::enableZeroCnv() {
  ADCcsr_t csr;
  csr.csrval = 0;
  csr.bits.ZE = 1;
  setCSRbits(csr.csrval,csr.csrval);
}

/*==============================================================*/
void CADC2530::disableZeroCnv() {
  ADCcsr_t csr;
  csr.csrval = 0;
  csr.bits.ZE = 1;
  resetCSRbits(csr.csrval);
}

/*==============================================================*/
void CADC2530::enableCalibration() {
  ADCcsr_t csr;
  csr.csrval = 0;
  csr.bits.SC = 1;
  setCSRbits(csr.csrval,csr.csrval);
}

/*==============================================================*/
void CADC2530::disableCalibration() {
  ADCcsr_t csr;
  csr.csrval = 0;
  csr.bits.SC = 1;
  resetCSRbits(csr.csrval);
}

/*==============================================================*/
void CADC2530::enableSlidingScale() {
  ADCcsr_t csr;
  csr.csrval = 0;
  csr.bits.SS = 1;
  resetCSRbits(csr.csrval);
}

/*==============================================================*/
void CADC2530::disableSlidingScale() {
  ADCcsr_t csr;
  csr.csrval = 0;
  csr.bits.SS = 1;
  setCSRbits(csr.csrval,csr.csrval);
}

/*==============================================================*/
void CADC2530::enableInterrupt() {
  ADCcsr_t csr;
  csr.csrval = 0;
  csr.bits.IE = 1;
  setCSRbits(csr.csrval,csr.csrval);
}

/*==============================================================*/
void CADC2530::disableInterrupt() {
  ADCcsr_t csr;
  csr.csrval = 0;
  csr.bits.IE = 1;
  resetCSRbits(csr.csrval);
}

/*==============================================================*/
bool CADC2530::isArmed() {
  ADCcsr_t csr;
  csr.csrval = getCSR();
  return (csr.bits.ARM == 1); 
}

/*==============================================================*/
void CADC2530::modeHistogram(bool indgates) {
  ADCcsr_t csr;

  csr.csrval = 0;
  csr.bits.HE = 1;
  setCSRbits(csr.csrval,csr.csrval);

  if (indgates) {
    csr.csrval = 0;
    csr.bits.GE = 1;
    setCSRbits(csr.csrval,csr.csrval);
  } else {
    csr.csrval = 0;
    csr.bits.GE = 1;
    resetCSRbits(csr.csrval);
  }

  dataReadyOnFullness();
}

/*==============================================================*/
void CADC2530::modeGate() {
  ADCcsr_t csr;
  csr.csrval = 0;
  csr.bits.HE = 1;
  resetCSRbits(csr.csrval);
  csr.csrval = 0;
  csr.bits.GE = 1;
  setCSRbits(csr.csrval,csr.csrval);
  dataReadyOnEvent();
}

/*==============================================================*/
unsigned int CADC2530::getEventCounter() {
#ifndef HAVE_VME_MAPPING
  unsigned short ecls = my_pModule->peekw(ShortOffset(ADCregisters_t,EventCounterLS));
  unsigned short ecms = my_pModule->peekw(ShortOffset(ADCregisters_t,EventCounterMS));
#else
  unsigned short ecls = ((volatile ADCregisters_t*)my_pModule)->EventCounterLS;
  unsigned short ecms = ((volatile ADCregisters_t*)my_pModule)->EventCounterMS;
#endif

  unsigned int evtcnt = ((ecms&0x00FF)<<16)|(ecls&0x0000FFFF);
  return evtcnt;
}

/*==============================================================*/
void CADC2530::clearEventCounter() {
  my_cureventpos= 0;

#ifndef HAVE_VME_MAPPING
  my_pModule->pokew(0x0,ShortOffset(ADCregisters_t,EventCounterLS));
  my_pModule->pokew(0x0,ShortOffset(ADCregisters_t,EventCounterMS));
#else
  ((volatile ADCregisters_t*)my_pModule)->EventCounterLS = 0x0;
  ((volatile ADCregisters_t*)my_pModule)->EventCounterMS = 0x0;
#endif
}

/*==============================================================*/
unsigned int CADC2530::getListAddress() {
#ifndef HAVE_VME_MAPPING
  unsigned short lals = my_pModule->peekw(ShortOffset(ADCregisters_t,ListAddressLS));
  unsigned short lams = my_pModule->peekw(ShortOffset(ADCregisters_t,ListAddressMS));
#else
  unsigned short lals = ((volatile ADCregisters_t*)my_pModule)->ListAddressLS;
  unsigned short lams = ((volatile ADCregisters_t*)my_pModule)->ListAddressMS;
#endif

  unsigned int lstaddr = ((lams&0x0000FFFF)<<16)|(lals&0x0000FFFF);
  return lstaddr;
}

/*==============================================================*/
void CADC2530::clearListAddress() {
#ifndef HAVE_VME_MAPPING
  my_pModule->pokew(0x0,ShortOffset(ADCregisters_t,ListAddressLS));
  my_pModule->pokew(0x0,ShortOffset(ADCregisters_t,ListAddressMS));
#else
  ((volatile ADCregisters_t*)my_pModule)->ListAddressLS = 0x0;
  ((volatile ADCregisters_t*)my_pModule)->ListAddressMS = 0x0;
#endif
}

/*==============================================================*/
bool CADC2530::isBusy() {
  ADCcsr_t csr;
  csr.csrval = getCSR();
  return (csr.bits.RSTBSY == 1); 
}

/*==============================================================*/
void CADC2530::clearFullnessFlags() {
#ifndef HAVE_VME_MAPPING
  my_pModule->pokew(0x0,ShortOffset(ADCregisters_t,FullnessFlag));
#else
  ((volatile ADCregisters_t*)my_pModule)->FullnessFlag = 0x0;
#endif
}

/*==============================================================*/
unsigned short CADC2530::getFullnessFlags() {
  unsigned short flags = 0;
#ifndef HAVE_VME_MAPPING
  flags = my_pModule->peekw(ShortOffset(ADCregisters_t,FullnessFlag));
#else
  flags = ((volatile ADCregisters_t*)my_pModule)->FullnessFlag;
#endif
  return flags;
}

/*==============================================================*/
bool CADC2530::isChannelFull(unsigned short aChan) {
  if ((aChan < 1)||(aChan > 8)) {
    char buffer[256];
    sprintf(buffer, "CADC2530::isChannelFull(): When checking channel fullness, the channel specified must be in the range [1-8] (channel == %d).\n",aChan);
    throw string(buffer);
  }

  ADCfullnessflag_t fflags;
  fflags.flags = getFullnessFlags();
  unsigned char mask = 0x1;
  mask = (mask << (aChan - 1));
  return ((fflags.bytes.FULL & mask) > 0);
}

/*==============================================================*/
bool CADC2530::channelHasData(unsigned short aChan) {
  if ((aChan < 1)||(aChan > 8)) {
    char buffer[256];
    sprintf(buffer, "CADC2530::channelHasData(): When checking channel fullness, the channel specified must be in the range [1-8] (channel == %d).\n",aChan);
    throw string(buffer);
  }

  ADCfullnessflag_t fflags;
  fflags.flags = getFullnessFlags();
  unsigned char mask = 0x1;
  mask = (mask << (aChan - 1));
  return ((fflags.bytes.HALFFULL & mask) > 0);
}

/*==============================================================*/
bool CADC2530::isListFull() { 
  ADCfullnessflag_t fflags;
  fflags.flags = getFullnessFlags();
  unsigned char mask = 0x1;
  return ((fflags.bytes.FULL & mask) > 0);
}

/*==============================================================*/
bool CADC2530::isListHalfFull() { 
  ADCfullnessflag_t fflags;
  fflags.flags = getFullnessFlags();
  unsigned char mask = 0x1;
  return ((fflags.bytes.HALFFULL & mask) > 0);
}

/*==============================================================*/
void CADC2530::setSSTR(unsigned short sstrval) {
  unsigned short val = (sstrval&0x3FFC);
#ifndef HAVE_VME_MAPPING
  my_pModule->pokew(val,ShortOffset(ADCregisters_t,SlidingScaleTest));
#else
  ((volatile ADCregisters_t*)my_pModule)->SlidingScaleTest= val;
#endif
}

/*==============================================================*/
unsigned short CADC2530::getSSTR() {
  unsigned short sstrval = 0;
#ifndef HAVE_VME_MAPPING
  sstrval = my_pModule->peekw(ShortOffset(ADCregisters_t,SlidingScaleTest));
#else
  sstrval = ((volatile ADCregisters_t*)my_pModule)->SlidingScaleTest;
#endif
  return sstrval;
}

/*==============================================================*/
bool CADC2530::hasInterrupt() {
  ADCcsr_t csr;
  csr.csrval = getCSR();
  return (csr.bits.IS == 1); 
}

/*==============================================================*/
bool CADC2530::dataReady() {
  ADCcsr_t csr;
  csr.csrval = getCSR();
  return (csr.bits.DR == 1); 
}

/*==============================================================*/
void CADC2530::resetCSR() {
  ADCcsr_t csr;
  csr.csrval = getCSR();
  csr.bits.RSTBSY = 1;
  setCSR(csr.csrval);
  setCSR((unsigned short)0x0);
  my_eventmode = false;
}

/*==============================================================*/
void CADC2530::resetCTR() {
  setCTR((unsigned short)0x0);
}

/*==============================================================*/
void CADC2530::fastClear() {
  ADCcsr_t csr;
  csr.csrval = getCSR();
  csr.bits.FFCLR = 1;
  setCSR(csr.csrval);
}

/*==============================================================*/
void CADC2530::setIPL(unsigned short iplval) {
  ADCcsr_t csr;
  ADCcsr_t mask;

  csr.csrval = 0;
  csr.bits.IPL = (iplval & 0x07);

  mask.csrval = 0;
  mask.bits.IPL = 0x7;

  setCSRbits(csr.csrval,mask.csrval);
}

/*==============================================================*/
unsigned short CADC2530::getIPL() {
  ADCcsr_t csr;
  csr.csrval = getCSR();
  unsigned short iplval = csr.bits.IPL;
  return iplval;
}

/*==============================================================*/
void CADC2530::setLLD(unsigned short lldval) {
#ifndef HAVE_VME_MAPPING
  my_pModule->pokew(lldval,ShortOffset(ADCregisters_t,LowerLevelDisc));
#else
  ((volatile ADCregisters_t*)my_pModule)->LowerLevelDisc = lldval;
#endif
}

/*==============================================================*/
unsigned short CADC2530::getLLD() {
  unsigned short lldval = 0;
#ifndef HAVE_VME_MAPPING
  lldval = my_pModule->peekw(ShortOffset(ADCregisters_t,LowerLevelDisc));
#else
  lldval = ((volatile ADCregisters_t*)my_pModule)->LowerLevelDisc;
#endif
  return lldval;
}

/*==============================================================*/
void CADC2530::setULD(unsigned short uldval) {
#ifndef HAVE_VME_MAPPING
  my_pModule->pokew(uldval,ShortOffset(ADCregisters_t,UpperLevelDisc));
#else
  ((volatile ADCregisters_t*)my_pModule)->UpperLevelDisc = uldval;
#endif
}

/*==============================================================*/
unsigned short CADC2530::getULD() {
  unsigned short uldval = 0;
#ifndef HAVE_VME_MAPPING
  uldval = my_pModule->peekw(ShortOffset(ADCregisters_t,UpperLevelDisc));
#else
  uldval = ((volatile ADCregisters_t*)my_pModule)->UpperLevelDisc;
#endif
  return uldval;
}

/*==============================================================*/
void CADC2530::setInterruptVector(unsigned short ivect) {
#ifndef HAVE_VME_MAPPING
  my_pModule->pokew(ivect,ShortOffset(ADCregisters_t,InterruptVector));
#else
  ((volatile ADCregisters_t*)my_pModule)->InterruptVector = ivect;
#endif
}

/*==============================================================*/
unsigned short CADC2530::getInterruptVector() {
  unsigned short ivect = 0;
#ifndef HAVE_VME_MAPPING
  ivect = my_pModule->peekw(ShortOffset(ADCregisters_t,InterruptVector));
#else
  ivect = ((volatile ADCregisters_t*)my_pModule)->InterruptVector;
#endif
  return ivect;
}

/*==============================================================*/
void CADC2530::setInterruptMask(unsigned short imask) {
#ifndef HAVE_VME_MAPPING
  my_pModule->pokew(imask,ShortOffset(ADCregisters_t,InterruptMask));
#else
  ((volatile ADCregisters_t*)my_pModule)->InterruptMask = imask;
#endif
}

/*==============================================================*/
unsigned short CADC2530::getInterruptMask() {
  unsigned short imask = 0;
#ifndef HAVE_VME_MAPPING
  imask = my_pModule->peekw(ShortOffset(ADCregisters_t,InterruptMask));
#else
  imask = ((volatile ADCregisters_t*)my_pModule)->InterruptMask;
#endif
  return imask;
}

/*==============================================================*/
void CADC2530::setCTRchannel(unsigned short chanval) {
  if ((chanval < 1)||(chanval > 8)) {
    char buffer[256];
    sprintf(buffer, "CADC2530::setCTRchannel(): The specified channel value must be in the range [1-8]\n");
    throw string(buffer);
  }
  
  ADCctr_t ctr;
  ADCctr_t mask;

  ctr.ctrval = 0;
  ctr.bits.M012 = ((chanval-1) & 0x07);

  mask.ctrval = 0;
  mask.bits.M012 = 0x7;

  setCTRbits(ctr.ctrval,mask.ctrval);
}

/*==============================================================*/
unsigned short CADC2530::getCTRchannel() {
  ADCctr_t ctr;
  ctr.ctrval = getCTR();
  unsigned short chanval = ctr.bits.M012;
  return (chanval+1);
}

/*==============================================================*/
void CADC2530::enableAutoFastClear() {
  ADCctr_t ctr;
  ctr.ctrval = 0;
  ctr.bits.DEAC = 1;
  resetCTRbits(ctr.ctrval);
}

/*==============================================================*/
void CADC2530::disableAutoFastClear() {
  ADCctr_t ctr;
  ctr.ctrval = 0;
  ctr.bits.DEAC = 1;
  setCTRbits(ctr.ctrval,ctr.ctrval);
}

/*==============================================================*/
void CADC2530::enableCompensation() {
  ADCctr_t ctr;
  ctr.ctrval = 0;
  ctr.bits.DISC = 1;
  resetCTRbits(ctr.ctrval);
}

/*==============================================================*/
void CADC2530::disableCompensation() {
  ADCctr_t ctr;
  ctr.ctrval = 0;
  ctr.bits.DISC = 1;
  setCTRbits(ctr.ctrval,ctr.ctrval);
}

/*==============================================================*/
void CADC2530::enableMUXswitch() {
  ADCctr_t ctr;
  ctr.ctrval = 0;
  ctr.bits.MEN = 1;
  setCTRbits(ctr.ctrval,ctr.ctrval);
}

/*==============================================================*/
void CADC2530::disableMUXswitch() {
  ADCctr_t ctr;
  ctr.ctrval = 0;
  ctr.bits.MEN = 1;
  resetCTRbits(ctr.ctrval);
}

/*==============================================================*/
unsigned short CADC2530::getCSR() {
  unsigned short csrval = 0;
#ifndef HAVE_VME_MAPPING
  csrval = my_pModule->peekw(ShortOffset(ADCregisters_t,CSR));
#else
  csrval = ((volatile ADCregisters_t*)my_pModule)->CSR;
#endif
  return csrval;
}

/*==============================================================*/
void CADC2530::setCSR(unsigned short csrval) {
  ADCcsr_t csr;
  csr.csrval = csrval;
  if (csr.bits.DR) my_eventmode = true;
  else my_eventmode = false;

#ifndef HAVE_VME_MAPPING
  my_pModule->pokew(csrval,ShortOffset(ADCregisters_t,CSR));
#else
  ((volatile ADCregisters_t*)my_pModule)->CSR = csrval;
#endif
}

/*==============================================================*/
void CADC2530::setCSRbits(unsigned short nBits,unsigned short nMask) {
  ADCcsr_t csr;
  csr.csrval = getCSR();
  csr.csrval = (csr.csrval & CADC2530_CSRMASK);
  if (my_eventmode) csr.bits.DR = 1;
  csr.csrval = (csr.csrval & (~nMask));
  csr.csrval = (csr.csrval | nBits);

#ifndef HAVE_VME_MAPPING
  my_pModule->pokew(csr.csrval,ShortOffset(ADCregisters_t,CSR));
#else
  ((volatile ADCregisters_t*)my_pModule)->CSR = csr.csrval;
#endif
}

/*==============================================================*/
void CADC2530::resetCSRbits(unsigned short nBits) {
  ADCcsr_t csr;
  csr.csrval = getCSR();
  csr.csrval = (csr.csrval & CADC2530_CSRMASK);
  if (my_eventmode) csr.bits.DR = 1;
  csr.csrval = (csr.csrval & (~nBits));

#ifndef HAVE_VME_MAPPING
  my_pModule->pokew(csr.csrval,ShortOffset(ADCregisters_t,CSR));
#else
  ((volatile ADCregisters_t*)my_pModule)->CSR = csr.csrval;
#endif
}

/*==============================================================*/
unsigned short CADC2530::getCTR() {
  unsigned short ctrval = 0;
#ifndef HAVE_VME_MAPPING
  ctrval = my_pModule->peekw(ShortOffset(ADCregisters_t,CTR));
#else
  ctrval = ((volatile ADCregisters_t*)my_pModule)->CTR;
#endif
  return ctrval;
}

/*==============================================================*/
void CADC2530::setCTR(unsigned short ctrval) {
#ifndef HAVE_VME_MAPPING
  my_pModule->pokew(ctrval,ShortOffset(ADCregisters_t,CTR));
#else
  ((volatile ADCregisters_t*)my_pModule)->CTR = ctrval;
#endif
}

/*==============================================================*/
void CADC2530::setCTRbits(unsigned short nBits,unsigned short nMask) {
  unsigned short ctrval = getCTR();
  ctrval = (ctrval & CADC2530_CTRMASK);
  ctrval = (ctrval & (~nMask));
  ctrval = (ctrval | nBits);

#ifndef HAVE_VME_MAPPING
  my_pModule->pokew(ctrval,ShortOffset(ADCregisters_t,CTR));
#else
  ((volatile ADCregisters_t*)my_pModule)->CTR = ctrval;
#endif
}

/*==============================================================*/
void CADC2530::resetCTRbits(unsigned short nBits) {
  unsigned short ctrval = getCTR();
  ctrval = (ctrval & CADC2530_CTRMASK);
  ctrval = (ctrval & (~nBits));

#ifndef HAVE_VME_MAPPING
  my_pModule->pokew(ctrval,ShortOffset(ADCregisters_t,CTR));
#else
  ((volatile ADCregisters_t*)my_pModule)->CTR = ctrval;
#endif
}

---