CCAENV1x90.cpp

Go to the documentation of this file.

/*
  Implementation of the CCAENV1x90 class.
  For more information about this class, see the associated header:
  CCAENV1x90.h
*/

// Headers etc.

#include <config.h>

#include "CCAENV1x90.h"
#include "CCAENV1x90Registers.h"
#include "CCAENV1x90Data.h"
#include "CCAENV1x90Opcodes.h"

#include <stdio.h>
#include <string.h>
#include <unistd.h>

#include <string>
#include <vector>



// Namespace imports:

#ifdef HAVE_STD_NAMESPACE
using namespace std;
#endif
using namespace DesignByContract;
using namespace CCAENV1x90Registers;
using namespace CCAENV1x90Data;

// Static class level data.  This data is present in order
// To allow us to wrap some bit definitions into a name-space
// like scope via class inclusion.  These definitions are not
// suitable for the registers nor the data namespaces.
//

// Chip error bits:

const unsigned short CCAENV1x90::ERR_VERNIER    (0x0001);
const unsigned short CCAENV1x90::ERR_COARSE     (0x0002);
const unsigned short CCAENV1x90::ERR_SELECT     (0x0004);
const unsigned short CCAENV1x90::ERR_L1PARITY   (0x0008);
const unsigned short CCAENV1x90::ERR_TFIFOPARITY(0x0010);
const unsigned short CCAENV1x90::ERR_MATCHERROR (0x0020);
const unsigned short CCAENV1x90::ERR_RFIFOPARITY(0x0040);
const unsigned short CCAENV1x90::ERR_RDOSTATE   (0x0080);
const unsigned short CCAENV1x90::ERR_SUPPARITY  (0x0100);
const unsigned short CCAENV1x90::ERR_CTLPARITY  (0x0200);
const unsigned short CCAENV1x90::ERR_JTAGPARITY (0x0400);

// Tap contact bits (used in calibrate delay line).
// These bits are shifted into position appropriately
// to control fine adjustments of the RC delay line.

const unsigned short CCAENV1x90::TAP_CONTACT1(4);
const unsigned short CCAENV1x90::TAP_CONTACT2(2);
const unsigned short CCAENV1x90::TAP_CONTACT3(1);

//  Below are constants that are not worth member status
//  but also should not be used as 'magic numbers'.

static const unsigned int MINMATCHWIDTH(1);
static const unsigned int MAXMATCHWIDTH(0xfff);
static const unsigned int MATCHMASK(0xfff);

static const int          MINWINDOWOFFSET(-2048);
static const int          MAXWINDOWOFFSET(40);
static const int          WINDOWOFFSETMASK(0xfff);

static const unsigned int MINEXTRAMARGIN(0);
static const unsigned int MAXEXTRAMARGIN(2047);
static const unsigned int EXTRAMARGINMASK(0xfff);

static const unsigned int MINREJECTMARGIN(0);
static const unsigned int MAXREJECTMARGIN(2047);
static const unsigned int REJECTMARGINMASK(0xfff);

static const unsigned int EDGEDETECTIONMASK(3);

static const unsigned int EDGERESOLUTIONMASK(3);
static const unsigned int LERESOLUTIONMASK(7);

static const unsigned int PWRESOLUTIONRSHIFT(8);
static const unsigned int PWRESOLUTIONMASK(0xff00);

static const unsigned int TRUEBIT(1); // TRUE for bools from sequencer.

static const unsigned int COARSEMAX(0x7ff);
static const unsigned int COARSEMASK(0x7ff);

static const unsigned int VERNIERMAX(0x1f);
static const unsigned int VERNIERMASK(0x1f);

static const unsigned int CHANOFFSETMAX(0xff);
static const unsigned int CHANOFFSETMASK(0xff);

static const unsigned int TAPCONTACTMASK(0x7);
static const unsigned int TAPCONTACTRSHIFT(3);

static const unsigned int  MAXTESTVALUE(0x7fffff);

static const unsigned int MAXGEO(0x1f);
static const unsigned int GEOMASK(0x1f);

static const unsigned long RESET_DELAY(1000);

// Utility inline functions:


static inline unsigned long OffsetW(unsigned long nByteOffset) 
{
  return nByteOffset/sizeof(short);
}

static inline unsigned long OffsetL(unsigned long nByteOffset)
{
  return nByteOffset/sizeof(long);
}

//   string:

template <class T>
static inline string FormatValue(const char* pFormatString, T value)
{
  int nformatsize = strlen(pFormatString);
  char*  message = new char[nformatsize+100];
  sprintf(message, pFormatString, value);
  string m(message);
  delete []message;
  return m;

}


static unsigned short 
inline HI(unsigned int nValue) 
{
  return static_cast<unsigned short>((nValue >> 16) & 0xffff);
}


static unsigned short
inline LO(unsigned int nValue)
{
  return static_cast<unsigned short>(nValue & 0xffff);
}



CCAENV1x90::CCAENV1x90(unsigned int nSlot,
                       unsigned int nCrate,
                       unsigned long nBase) :
  m_nBase(nBase),
  m_nCrate(nCrate),
  m_nSlot(nSlot),
  m_pRegisters(CVmeModule::a32d32, nBase, RegisterSize, nCrate)
{
  // Check preconditions:

  REQUIRE(((nSlot  >= 1)  && (nSlot <=20)), "Slot out of range");
  REQUIRE(((nCrate >= 0)  && (nCrate <= 7)), "Crate out of range");

  // Initializers create the module object for the 
  // control registers and data buffer.
  // we need to make one for the config prom so that we can
  // validate the module.

  CVmeModule pRom(CVmeModule::a32d32, 
                  m_nBase+ConfigRom, 
                  ConfigRomSize,
                  m_nCrate);

  // The configuration PROM can tell us if this is a valid board:

  ENSURE(ValidBoard(pRom), 
         "Board is not a valid CAEN V1x90 module");

  // Since the board is valid, set up the member variables
  // from the board properties as described in the config rom
  // and the various board registers:

  BoardProperties(pRom);


  // Check postconditions for model etc.:

  ENSURE(((m_nModel == 1190) || (m_nModel == 1290)),
         "Model number is incorrect on postcondition check");
  ENSURE(((m_cVersion == 'A') || (m_cVersion == 'B') || 
          (m_cVersion == 'N')),
         "Version is not A,B, or N in postcondition check");


  // Everything is good. Set slot,  turn on the FIFO:

  Reset();
  
}

CCAENV1x90::~CCAENV1x90()
{}


bool 
CCAENV1x90::isSetCR(unsigned short bit)
{
  return ((ReadCR() & (1 << bit)) != 0);
}
void
CCAENV1x90::Terminate()
{
  BitSetCR(ControlRegister::NTERM_SW); // Enable software termination.
  BitSetCR(ControlRegister::NTERM); // And request termination.
}
void
CCAENV1x90::Unterminate()
{
  BitSetCR(ControlRegister::NTERM_SW); // Enable software termination ctl
  BitClearCR(ControlRegister::NTERM); // Request unterminated.
}
void 
CCAENV1x90::TerminateWithSwitch()
{
  BitClearCR(ControlRegister::NTERM_SW); // Turn off software termination ctl.
}
void
CCAENV1x90::EnableTriggerTagTime()
{
  BitSetCR(ControlRegister::NTRIGGER_TAG_ENABLE);
}
void
CCAENV1x90::DisableTriggerTagTime()
{
  BitClearCR(ControlRegister::NTRIGGER_TAG_ENABLE);
}
bool
CCAENV1x90::DataReady()
{
  return isSetSR(StatusRegister::NDATA_READY);
}
bool
CCAENV1x90::AlmostFull()
{
  return isSetSR(StatusRegister::NALM_FULL);
}

bool
CCAENV1x90::isFull()
{
  return isSetSR(StatusRegister::NFULL);
}

bool
CCAENV1x90::isTriggerMatching()
{
  return isSetSR(StatusRegister::NTRG_MATCH);
}
bool
CCAENV1x90::isHeaderEnabled()
{
  return isSetSR(StatusRegister::NHEADER_EN);
}

bool
CCAENV1x90::isTerminated()
{
  return isSetSR(StatusRegister::NTERM_ON);
}
bool
CCAENV1x90::HadError(unsigned int nChip)
{
  // Check preconditions.

  REQUIRE(nChip < m_nChipCount, "Illegal chip number for device");
  
  // Compute the chip bit.  There's a huge assumption
  // here that the chip error bits are contiguous.
  // The debug code below will check this:

  ENSURE(((1 << StatusRegister::NCHIP0_ERROR)     |
          (1 << (StatusRegister::NCHIP0_ERROR+1)) |
          (1 << (StatusRegister::NCHIP0_ERROR+2)) |
          (1 << (StatusRegister::NCHIP0_ERROR+3))) == 
                                      ((StatusRegister::CHIP0_ERROR) |
                                       (StatusRegister::CHIP1_ERROR) |
                                       (StatusRegister::CHIP2_ERROR) |
                                       (StatusRegister::CHIP3_ERROR)),
         "Chip error bits are not continguous in the register");
  unsigned int nChipBit = 1 << (StatusRegister::NCHIP0_ERROR + nChip);

  // Return true if the associated error bit is set:

  return isSetSR(nChipBit);

}
int
CCAENV1x90::ReadResolution()
{
  int Resmask = SR() & StatusRegister::RESOLUTIONMASK;

  if(Resmask == StatusRegister::RES_800ps) {
    return 800;
  }
  else if (Resmask == StatusRegister::RES_200ps) {
    return 200;
  }
  else if (Resmask == StatusRegister::RES_100ps) {
    return 100;
  }
  else if(Resmask ==  StatusRegister::RES_25ps) {
    m_fIsHiResMode = true;      // module in hi res mode.
    return 25;
  } 
  else {
    CHECK(0, "Unrecognized resolution code");
  }
}

bool
CCAENV1x90::isPairMode()
{
  // I'm going to do a bit more work than I probably need to
  // by not assuming the pair bit is meaningful when the
  // 1290 is in pair mode:

  if((m_nModel == 1290) && (ReadResolution() == 25)) {
    return false;               // 1290 in hi res.
  }
  return isSetSR(StatusRegister::NPAIR);
}
bool
CCAENV1x90::WereTriggersLost()
{
  return isSetSR(StatusRegister::NTRIGGERLOST);
}
void 
CCAENV1x90::SetGeographicalID(unsigned short nSlot)
{
  // Check preconditions:


  REQUIRE(nSlot <= MAXGEO, "Slot number too big.");

  // Program the geo register:

  m_pRegisters.pokew(nSlot, OffsetW(WVirtualSlot));
  
  // Ensure it stayed programmed:

  if (GetGeographicalID() != nSlot) {
    throw 
      string ("Attempt to set geo register of geo-recognizing module");
  }

}

unsigned short
CCAENV1x90::GetGeographicalID()
{
  unsigned short g = m_pRegisters.peekw(OffsetW(WVirtualSlot));
  g &= GEOMASK;
  return g;

}
void
CCAENV1x90::Reset()
{
  m_pRegisters.pokew(0, OffsetW(WReset));
  m_fTriggerMatching = isTriggerMatching();
  WaitMicroWrite();


  // Re-asssert the slot and fifo enable.

  SetGeographicalID(m_nSlot);
  BitSetCR(ControlRegister::NEVENT_FIFO_ENABLE);


}
void 
CCAENV1x90::Clear()
{
  m_pRegisters.pokew(0, OffsetW(WClear));
  m_fTriggerMatching = isTriggerMatching();
}

void
CCAENV1x90::EventReset()
{
  m_pRegisters.pokew(0, OffsetW(WEventReset));
  m_fTriggerMatching = isTriggerMatching();
}

void
CCAENV1x90::Trigger()
{
  m_pRegisters.pokew(0, OffsetW(WSWTrigger));
}

unsigned long
CCAENV1x90::TriggerCount()
{
  return m_pRegisters.peekl(OffsetL(LEventCounter));
}

unsigned short
CCAENV1x90::EventCount()
{
  return m_pRegisters.peekw(OffsetW(WEventStored));
}

void
CCAENV1x90::SetAlmostFullLevel(unsigned int nWords)
{
  // Ensure preconditions are met:

  REQUIRE(nWords > 0, "Number of words is too small");
  REQUIRE(nWords <= 32735, "Number of words too big");

    // program the register.

  m_pRegisters.pokew(static_cast<unsigned short>(nWords), 
                     OffsetW(WAlmostFullLevel));

}

unsigned short
CCAENV1x90::GetAlmostFullLevel()
{
  return m_pRegisters.peekw(OffsetW(WAlmostFullLevel));
}

void
CCAENV1x90::DefineECLOutput(CCAENV1x90::ECLOutputSelect Signal)
{
  // Verify the precondition:

  REQUIRE(((Signal == DATA_READY)   ||
         (Signal == FULL)         ||
         (Signal == ALMOST_FULL)  ||
         (Signal == ERROR)),
        "Signal parameter is invalid.");


  // Convert our enum to register bits.

  unsigned short value;

  switch (Signal) {
  case DATA_READY:
    value = OutputControl::DATA_READY;
    break;
  case FULL:
    value = OutputControl::FULL;
    break;
  case ALMOST_FULL:
    value = OutputControl::ALM_FULL;
    break;
  case ERROR:
    value = OutputControl::ERROR;
    break;
    
    // Default case is prevented by precondition.
  }

  m_pRegisters.pokew(value, OffsetW(WOutputControl));

}
CCAENV1x90::ECLOutputSelect
CCAENV1x90::GetECLOutputDefinition()
{
  unsigned short 
    value = m_pRegisters.peekw(OffsetW(WOutputControl)) &
                                           OutputControl::MASK;

  // Convert the register value to the enum... the default
  // of the case below is illegal:

  if(value == OutputControl::DATA_READY) {
    return DATA_READY;
  } 
  else if (value == OutputControl::FULL) {
    return FULL;
  } 
  else if (value == OutputControl::ALM_FULL) {
    return ALMOST_FULL;
  }
  else if (value ==  OutputControl::ERROR) {
    return ERROR;
  }
  else {
    ENSURE(0, "Illegal value from output control register");
  }

}
unsigned short
CCAENV1x90::EventFIFOCount()
{
  return m_pRegisters.peekw(OffsetW(WEventFIFOStored)) & 
                         EventFIFO::FIFOCOUNT_MASK;
}
unsigned short
CCAENV1x90::FIFOEventNumber(unsigned long fifoentry)
{
  return (fifoentry & EventFIFO::EVENTCOUNT_MASK) >>
                      EventFIFO::EVENTCOUNT_RSHIFT;
}

unsigned short
CCAENV1x90::FIFOWordCount(unsigned long fifoentry)
{
  return (fifoentry & EventFIFO::WORDCOUNT_MASK) >>
                      EventFIFO::WORDCOUNT_RSHIFT;
}

unsigned long
CCAENV1x90::ReadEventFIFO()
{
  // check preconditions.

  REQUIRE(isEventFIFOReady(), "Attempting to read empty FIFO");

  return m_pRegisters.peekl(OffsetL(LEventFIFO));
}

bool
CCAENV1x90::isEventFIFOReady()
{
  
  return ((m_pRegisters.peekw(OffsetW(WEventFIFOStatus)) &
           FIFOStatus::EVFIFODATA_READY) != 0);
}

bool
CCAENV1x90::isEventFIFOFull()
{
  return ((m_pRegisters.peekw(OffsetW(WEventFIFOStatus)) &
           FIFOStatus::EVFIFO_FULL) != 0);
}



void 
CCAENV1x90::TriggerMatchMode()
{
  m_fTriggerMatching = true;
  WriteMicro(CCAENV1x90Opcodes::TRG_MATCH);
  WaitMicroWrite();
}

void
CCAENV1x90::ContinuousStorageMode()
{
  m_fTriggerMatching = false;
  WriteMicro(CCAENV1x90Opcodes::CONT_STOR);
  WaitMicroWrite();

}
void
CCAENV1x90::TransferUntilDone()
{
  WriteMicro(CCAENV1x90Opcodes::SET_KEEP_TOKEN);
  WaitMicroWrite();

}
void
CCAENV1x90::TransferOneAtATime()
{
  WriteMicro(CCAENV1x90Opcodes::CLEAR_KEEP_TOKEN);
  WaitMicroWrite();
  
}

void
CCAENV1x90::LoadDefaultConfig()
{
  WriteMicro(CCAENV1x90Opcodes::LOAD_DEF_CONFIG);
  WaitMicroWrite();

}
void
CCAENV1x90::SaveUserConfig()
{
  WriteMicro(CCAENV1x90Opcodes::SAVE_USER_CONFIG);
  WaitMicroWrite();
  usleep(10000);                // Carlo says wait 10ms after this opcode.
}
void
CCAENV1x90::LoadUserConfig()
{
  WriteMicro(CCAENV1x90Opcodes::LOAD_USER_CONFIG);
  WaitMicroWrite();
}
void
CCAENV1x90::AutoLoadUserConfig()
{
  WriteMicro(CCAENV1x90Opcodes::AUTOLOAD_USER_CONFIG);
  WaitMicroWrite();
  usleep(10000);                // Carlo says wait 10ms after this opcode.

}
void
CCAENV1x90::AutoLoadDefaultConfig()
{
  WriteMicro(CCAENV1x90Opcodes::AUTOLOAD_DEF_CONFIG);
  WaitMicroWrite();
  usleep(10000);                // Carlo says wait 10ms after this opcode.

}
void
CCAENV1x90::SetWindowWidth(unsigned int nWidth)
{
  REQUIRE(nWidth >= MINMATCHWIDTH, 
          FormatValue("Window width must be > %x",
                                    MINMATCHWIDTH).c_str());
  REQUIRE(nWidth <= MAXMATCHWIDTH, 
          FormatValue(" Window width must be <= 0x%x",
                                    MAXMATCHWIDTH).c_str());

  WriteMicro(CCAENV1x90Opcodes::SET_WIN_WIDTH);
  WriteMicro(nWidth);
  WaitMicroWrite();

}
void
CCAENV1x90::SetWindowOffset(int nOffset)
{
  REQUIRE(nOffset >= MINWINDOWOFFSET, 
          FormatValue("Window offset must be at least %d",
                           MINWINDOWOFFSET).c_str());
  REQUIRE(nOffset <= MAXWINDOWOFFSET,    
          FormatValue("Window offset must be no greater than %d",
                           MAXWINDOWOFFSET).c_str());
  WriteMicro(CCAENV1x90Opcodes::SET_WIN_OFFS);
  WriteMicro(nOffset);
  WaitMicroWrite();

}

void
CCAENV1x90::SetExtraSearchMargin(unsigned int nMargin)
{
  REQUIRE(nMargin >= 0, 
          FormatValue(" nMargin must be >=%d",
                                     MINEXTRAMARGIN).c_str());
  REQUIRE(nMargin <= 2047, 
          FormatValue("nMargin must be <= %d",
                                     MAXEXTRAMARGIN).c_str());

  WriteMicro(CCAENV1x90Opcodes::SET_SW_MARGIN);
  WriteMicro(nMargin);
  WaitMicroWrite();


}
void
CCAENV1x90::SetRejectMargin(unsigned int nMargin)
{
  REQUIRE(nMargin >= 0, 
          FormatValue("nMargin must be >= %d",
                                    MINREJECTMARGIN).c_str());
  REQUIRE(nMargin <= 2047, 
          FormatValue("nMargin must be <= %d",
                                    MAXREJECTMARGIN).c_str());

  WriteMicro(CCAENV1x90Opcodes::SET_REJ_MARGIN);
  WriteMicro(nMargin);
  WaitMicroWrite();
}
void
CCAENV1x90::EnableTriggerTimeSubtraction()
{
  WriteMicro(CCAENV1x90Opcodes::EN_SUB_TRG);
  WaitMicroWrite();
}
void 
CCAENV1x90::DisableTriggerTimeSubtraction()
{
  WriteMicro(CCAENV1x90Opcodes::DIS_SUB_TRG);
  WaitMicroWrite();

}

CCAENV1x90::TriggerConfiguration
CCAENV1x90::GetTriggerConfiguration()
{
  
  TriggerConfiguration config;
  MicroTransaction(CCAENV1x90Opcodes::READ_TRG_CONF,
                   &config, sizeof(config)/sizeof(short));
  return config;
}
unsigned int
CCAENV1x90::GetMatchWindow(TriggerConfiguration Config)
{
  return (Config.s_MatchWidth & MATCHMASK);
}
int 
CCAENV1x90::GetWindowOffset(TriggerConfiguration Config)
{
  int nOffset = (Config.s_MatchOffset & WINDOWOFFSETMASK);

  // nOffset is a signed 12 bit number... if necessary extend the  
  // sign; a & ~(a >> 1) is the highest set bit in a, if a is a mask
  // of contiguous 1's.


  if(nOffset & (WINDOWOFFSETMASK & ~(WINDOWOFFSETMASK >> 1))) {
    nOffset |= ~(WINDOWOFFSETMASK);
  }
  return nOffset;
}
unsigned int
CCAENV1x90::GetExtraSearchMargin(TriggerConfiguration Config)
{
  return Config.s_MatchExtra & EXTRAMARGINMASK;
}

unsigned int
CCAENV1x90::GetRejectMargin(TriggerConfiguration Config)
{
  return Config.s_RejectMargin & REJECTMARGINMASK;
}
bool
CCAENV1x90::isTriggerTimeSubtracted(TriggerConfiguration Config)
{
  return ((Config.s_Subtracting & TRUEBIT) != 0);
}
void
CCAENV1x90::SetIndividualLSB(Resolution nResolution)
{

  // Check the preconditions:

  REQUIRE(((nResolution == Res_25ps)     ||
           (nResolution == Res_100ps)    ||
           (nResolution == Res_200ps)    ||
           (nResolution == Res_800ps)), 
          "Resolution is not a legal value");
  if(nResolution == Res_25ps) {
    REQUIRE(m_fCanHiRes, "Only 1290 can be put in 25ps resolution");
  }

  WriteMicro(CCAENV1x90Opcodes::SET_TR_LEAD_LSB);
  WriteMicro(nResolution);
  WaitMicroWrite();

  // Only the 1290 can have 25ps resolution.. the flag variable
  // m_fIsHiResMode is used to keep track of this as there are things
  // you give up to get that resolution (most notably pair mode).

  if(nResolution == Res_25ps) {
    m_fIsHiResMode = true;
  } else {
    m_fIsHiResMode = false;
  }

}


void
CCAENV1x90::SetEdgeDetectMode(EdgeMode nEdgeMode)
{
  // Check preconditions.

  REQUIRE( ((nEdgeMode == EdgeMode_Pair)           ||
          (nEdgeMode == EdgeMode_Trailing)         ||
          (nEdgeMode == EdgeMode_Leading)          ||
          (nEdgeMode == EdgeMode_Both)),
         "Invalid edge mode");
  if(m_fCanHiRes & m_fIsHiResMode) {
    REQUIRE(nEdgeMode != EdgeMode_Pair,
          "Pair mode is not available in High resolution mode");
  }

  // Set the mode.

  WriteMicro(CCAENV1x90Opcodes::SET_DETECTION);
  WriteMicro(nEdgeMode);
  WaitMicroWrite();
}

CCAENV1x90::EdgeMode
CCAENV1x90::GetEdgeDetectMode()
{
  WriteMicro(CCAENV1x90Opcodes::READ_DETECTION);
  unsigned short n = ReadMicro();
  n   &= EDGEDETECTIONMASK;                     //  Only the bottom two bits have meaning
  return static_cast<EdgeMode>(n);

}
void
CCAENV1x90::SetPairResolutions(LEResolution nLEResolution,
                               PWResolution nPWResolution)
{
  // Check preconditions.

  REQUIRE((GetEdgeDetectMode() == EdgeMode_Pair),
        "Edge detection mode is not pair");
  REQUIRE( ((nLEResolution   == LE_100ps)     ||
          (nLEResolution   == LE_200ps)     ||
          (nLEResolution   == LE_400ps)     ||
          (nLEResolution   == LE_800ps)     ||
          (nLEResolution   == LE_1600ps)    ||
          (nLEResolution   == LE_3120ps)    ||
          (nLEResolution   == LE_6250ps)    ||
          (nLEResolution   == LE_12500ps)),
         "Leading edge resolution invalid");

  REQUIRE( ((nPWResolution  == PW_100ps)      ||
          (nPWResolution  == PW_200ps)      ||
          (nPWResolution  == PW_400ps)      ||
          (nPWResolution  == PW_800ps)      ||
          (nPWResolution  == PW_1600ps)     ||
          (nPWResolution  == PW_3200ps)     ||
          (nPWResolution  == PW_6250ps)     ||
          (nPWResolution  == PW_12500ps)    ||
          (nPWResolution  == PW_25ns)       ||
          (nPWResolution  == PW_50ns)       ||
          (nPWResolution  == PW_100ns)      ||
          (nPWResolution  == PW_200ns)      ||
          (nPWResolution  == PW_400ns)      ||
          (nPWResolution  == PW_800ns)),
         "Pair width resolution is invalid.");

  // Construct the settings word.

  unsigned short settings = nLEResolution | 
                            (nPWResolution << PWRESOLUTIONRSHIFT);


  // set the pair resolutions.
  WriteMicro(CCAENV1x90Opcodes::SET_PAIR_RES);
  WriteMicro(settings);
  WaitMicroWrite();

}
unsigned short
CCAENV1x90::GetResolution()
{
  WriteMicro(CCAENV1x90Opcodes::READ_RES);
  return ReadMicro();

}
CCAENV1x90::Resolution
CCAENV1x90::InterpretEdgeResolution(unsigned short nResolution)
{
  // Check preconditions:

  REQUIRE(GetEdgeDetectMode() != EdgeMode_Pair,
        "Edge resolution asked for when module in pair mode");

  //
  
  unsigned short nMask = nResolution & 
                         EDGERESOLUTIONMASK; // Mask off resolution and
  return static_cast<Resolution>(nMask); // Return as resolution 
}
CCAENV1x90::LEResolution
CCAENV1x90::InterpretLEResolution(unsigned short nResolution)
{
  // Check preconditions:

  REQUIRE(GetEdgeDetectMode() == EdgeMode_Pair,
        "LE resolution requested with module not in pair mode"); 

  // 

  unsigned short nMask = nResolution & LERESOLUTIONMASK;
  return static_cast<LEResolution>(nMask);
    
}
CCAENV1x90::PWResolution
CCAENV1x90::InterpretWidthResolution(unsigned short nResolution)
{
  // Check the precondition:

  REQUIRE(GetEdgeDetectMode() == EdgeMode_Pair,
        "PW resolution requested when not in pair mode");

  //
  unsigned short nMask = (nResolution & PWRESOLUTIONMASK) >> 
                          PWRESOLUTIONRSHIFT;
  return static_cast<PWResolution>(nMask);
}
void
CCAENV1x90::SetDoubleHitResolution(DeadTime nDeadTime) 
{ 
  // Check the preconditions

  REQUIRE((nDeadTime == DT_5ns)         ||
        (nDeadTime == DT_10ns)        ||
        (nDeadTime == DT_30ns)        ||
        (nDeadTime == DT_100ns),
        "Invalid dead time value");
  //
  WriteMicro(CCAENV1x90Opcodes::SET_DEAD_TIME);
  WriteMicro(nDeadTime);
  WaitMicroWrite();

}
CCAENV1x90::DeadTime
CCAENV1x90::GetDoubleHitResolution()
{
  WriteMicro(CCAENV1x90Opcodes::READ_DEAD_TIME);
  unsigned short nMask = ReadMicro();
  nMask &= 3;
  return static_cast<DeadTime>(nMask);

}
void
CCAENV1x90::EnableTDCEncapsulation()
{
  WriteMicro(CCAENV1x90Opcodes::EN_HEADER_TRAILER);
  WaitMicroWrite();
}

void
CCAENV1x90::DisableTDCEncapsulation()
{
  WriteMicro(CCAENV1x90Opcodes::DIS_HEADER_TRAILER);
  WaitMicroWrite();
}
bool
CCAENV1x90::isTDCEncapsulationOn()
{
  WriteMicro(CCAENV1x90Opcodes::READ_HEADER_TRAILER);
  return (ReadMicro() & TRUEBIT) != 0;

}
void
CCAENV1x90::SetMaxHitsPerEvent(HitMax nHits)
{
  // Check validity of nHits parameter (precondition)

  REQUIRE((nHits == HITS_0)              ||
        (nHits == HITS_1)              ||
        (nHits == HITS_2)              ||
        (nHits == HITS_4)              ||
        (nHits == HITS_8)              ||
        (nHits == HITS_16)             ||
        (nHits == HITS_32)             ||
        (nHits == HITS_64)             ||
        (nHits == HITS_128)            ||
        (nHits == HITS_UNLIMITED),
        "Invalid nHits parameter value");

  //  Set the device:

  WriteMicro(CCAENV1x90Opcodes::SET_EVENT_SIZE);
  WriteMicro(static_cast<unsigned short>(nHits));
  WaitMicroWrite();
}
CCAENV1x90::HitMax
CCAENV1x90::GetMaxHitsPerEvent()
{
  WriteMicro(CCAENV1x90Opcodes::READ_EVENT_SIZE);
  unsigned short nMask = ReadMicro();
  return static_cast<HitMax>(nMask);
}

void
CCAENV1x90::EnableErrorMark()
{
  WriteMicro(CCAENV1x90Opcodes::EN_ERROR_MARK);
  WaitMicroWrite();
}
void
CCAENV1x90::DisableErrorMark()
{
  WriteMicro(CCAENV1x90Opcodes::DIS_ERROR_MARK);
  WaitMicroWrite();
}
void
CCAENV1x90::EnableBypassOnError()
{
  WriteMicro(CCAENV1x90Opcodes::EN_ERROR_BYPASS);
  WaitMicroWrite();
}
void
CCAENV1x90::DisableBypassOnError()
{
  WriteMicro(CCAENV1x90Opcodes::DIS_ERROR_BYPASS);
  WaitMicroWrite();
}
void
CCAENV1x90::SetErrorEnables(unsigned short nErrors)
{
  // Check the preconditions..

  REQUIRE((nErrors & ~( ERR_VERNIER         &
                      ERR_SELECT          &
                      ERR_L1PARITY        &
                      ERR_TFIFOPARITY     &
                      ERR_MATCHERROR      &
                      ERR_RFIFOPARITY     &
                      ERR_RDOSTATE        &
                      ERR_SUPPARITY       &
                      ERR_CTLPARITY       &
                      ERR_JTAGPARITY)),
        "Error mask contains extra set bits.");

  // Set the device.

  WriteMicro(CCAENV1x90Opcodes::SET_ERROR_TYPES);
  WriteMicro(nErrors);
  WaitMicroWrite();
}

unsigned short
CCAENV1x90::GetErrorEnables()
{
  WriteMicro(CCAENV1x90Opcodes::READ_ERROR_TYPES);
  return ReadMicro();
}


void
CCAENV1x90::SetL1Size(L1Size nL1Size)
{
  // Check precondition:

  REQUIRE((nL1Size   == L1_2wds)       ||
        (nL1Size   == L1_4wds)       ||
        (nL1Size   == L1_8wds)       ||
        (nL1Size   == L1_16wds)      ||
        (nL1Size   == L1_32wds)      ||
        (nL1Size   == L1_64wds)      ||
        (nL1Size   == L1_128wds)     ||
        (nL1Size   == L1_256wds),
        "L1 size selector is invalid");

  //
  
  WriteMicro(CCAENV1x90Opcodes::SET_FIFO_SIZE);
  WriteMicro(nL1Size);
  WaitMicroWrite();
  

}
CCAENV1x90::L1Size
CCAENV1x90::GetL1Size()
{
  WriteMicro(CCAENV1x90Opcodes::READ_FIFO_SIZE);
  return static_cast<L1Size>(ReadMicro());
}

void
CCAENV1x90::EnableChannel(unsigned short nChannel)
{
  REQUIRE(nChannel < m_nChannels, "Channel number out of range");

  //
  WriteMicro(CCAENV1x90Opcodes::EN_CHANNEL | nChannel);
  WaitMicroWrite();
}
void
CCAENV1x90::DisableChannel(unsigned short nChannel)
{
  REQUIRE(nChannel < m_nChannels, "Channel Number out of range");

  //

  WriteMicro(CCAENV1x90Opcodes::DIS_CHANNEL | nChannel);
  WaitMicroWrite();

}

void
CCAENV1x90::EnableAllChannels()
{
  WriteMicro(CCAENV1x90Opcodes::EN_ALL_CH);
  WaitMicroWrite();
}
void
CCAENV1x90::DisableAllChannels()
{
  WriteMicro(CCAENV1x90Opcodes::DIS_ALL_CH);
  WaitMicroWrite();
}
void
CCAENV1x90::SetChannelEnables(vector<unsigned short> nMask)
{
  // Check the mask is the proper size:

  REQUIRE(nMask.size() == m_nChannels/(sizeof(short)*8),
        "Enables mask is not the right size.");

  // Marshall the vector into an array so we can call WriteMicroBlock

  unsigned short* pWords = new unsigned short[nMask.size() + 1];

  pWords[0] = CCAENV1x90Opcodes::WRITE_EN_PATTERN;
  for(int i =0; i < nMask.size(); i++) {
    pWords[i+1] = nMask[i];
  }

  WriteMicroBlock(pWords, nMask.size()+1);
  WaitMicroWrite();

  delete []pWords;

}
void
CCAENV1x90::GetChannelEnables(vector<unsigned short>& masks)
{
  unsigned int nMasks = m_nChannels/(sizeof(short)*8);

  unsigned short* localMasks = new unsigned short[nMasks];

  MicroTransaction(CCAENV1x90Opcodes::READ_EN_PATTERN,
                   localMasks, nMasks);

  for(int i =0; i < nMasks; i++) {
    masks.push_back(localMasks[i]);
  }
  delete []localMasks;

}

void
CCAENV1x90::SetChipEnables(unsigned short nChip,
                           unsigned int nMask)
{
  // Check the preconditions:

  REQUIRE(nChip < m_nChipCount,
        "Chip number is not valid for this model");
  
  //  Issue the opcode.  Note that nMask must be busted
  //  apart into a low and high word that get written to the
  //  micro.
  
  unsigned short wordMask;

  WriteMicro(CCAENV1x90Opcodes::WRITE_EN_PATTERN32 | nChip);

  wordMask = LO(nMask);
  WriteMicro(wordMask);

  wordMask = HI(nMask);
  WriteMicro(wordMask);
  WaitMicroWrite();

}

unsigned int
CCAENV1x90::GetChipEnables(unsigned short nChip)
{
  // Check preconditions:

  REQUIRE(nChip < m_nChipCount,
          FormatValue("Invalid chip number %d",
                                    nChip).c_str());

  // Fetch the mask out in two chunks.  The first
  // word has the low order channels, the second, the high:

  unsigned int mask;

  WriteMicro(CCAENV1x90Opcodes::READ_EN_PATTERN32 | nChip);

  mask = (static_cast<unsigned int>(ReadMicro())) & 0xffff;
  unsigned int top = ReadMicro();
  mask |= (top << 16);


  return mask;

}
void
CCAENV1x90::SetGlobalOffset(unsigned short nCoarse,
                            unsigned short nVernier)
{
  // Check the preconditions:

  REQUIRE(nCoarse <= COARSEMAX, 
          FormatValue("Global offset coarse value %d",
                                    nCoarse).c_str());
  REQUIRE(nVernier <= VERNIERMAX,
          FormatValue("Vernier offset is invalid: %d",
                                    nVernier).c_str());

  // Set the values:

  WriteMicro(CCAENV1x90Opcodes::SET_GLOB_OFFS);
  WriteMicro(nCoarse);
  WriteMicro(nVernier);
  WaitMicroWrite();

}

void
CCAENV1x90::ReadGlobalOffset(unsigned short& nCoarse,
                             unsigned short& nVernier)
{
  WriteMicro(CCAENV1x90Opcodes::READ_GLOB_OFFS);
  nCoarse = (ReadMicro()  & COARSEMASK);
  nVernier= (ReadMicro()  & VERNIERMASK);

}

void 
CCAENV1x90::SetChannelOffset(unsigned short nChannel,
                             unsigned short nOffset)
{
  // Check the preconditions:

  REQUIRE(nChannel < m_nChannels,
        " Channel number out of range");
  REQUIRE(nOffset  <= CHANOFFSETMAX,
          FormatValue("Offset value out of range: %d",
                                    nOffset).c_str());

  // Set the micro:

  WriteMicro(CCAENV1x90Opcodes::SET_ADJUST_CH | nChannel);
  WriteMicro(nOffset);
  WaitMicroWrite();
}
unsigned short
CCAENV1x90::GetChannelOffset(unsigned int nChannel)
{
  // check the preconditions:

  REQUIRE(nChannel < m_nChannels,
        "Channel number out of range");

  // Get and return the value:

  WriteMicro(CCAENV1x90Opcodes::READ_ADJUST_CH | nChannel);
  return (ReadMicro() & CHANOFFSETMASK);
}
void
CCAENV1x90::CalibrateDelayLine(unsigned short nChip,
                               unsigned short Tap1Contact,
                               unsigned short Tap2Contact,
                               unsigned short Tap3Contact,
                               unsigned short Tap4Contact)
{
  // check the preconditions:

  REQUIRE(nChip < m_nChipCount,
        "Chip number is not in range");

  REQUIRE((Tap1Contact & ~(TAP_CONTACT1 | TAP_CONTACT2 | TAP_CONTACT3)) == 0,
        " Tap 1 contact has extra bits"); 
  REQUIRE((Tap2Contact & ~(TAP_CONTACT1 | TAP_CONTACT2 | TAP_CONTACT3)) == 0,
        " Tap 1 contact has extra bits");
  REQUIRE((Tap3Contact & ~(TAP_CONTACT1 | TAP_CONTACT2 | TAP_CONTACT3)) == 0,
        " Tap 1 contact has extra bits");
  REQUIRE((Tap4Contact & ~(TAP_CONTACT1 | TAP_CONTACT2 | TAP_CONTACT3)) == 0,
        " Tap 1 contact has extra bits");

  // Set the delay line calibration.
  
  unsigned short TapMask = (Tap1Contact) |
                           (Tap2Contact << 3) |
                           (Tap3Contact << 6) |
                           (Tap4Contact << 9);


  WriteMicro(CCAENV1x90Opcodes::SET_RC_ADJ | nChip);
  WriteMicro(TapMask);
  WaitMicroWrite();
}
void
CCAENV1x90::GetDelayLineCalibration(unsigned short  nChip,
                                    unsigned short& Tap1Contact,
                                    unsigned short& Tap2Contact,
                                    unsigned short& Tap3Contact,
                                    unsigned short& Tap4Contact)
{
  WriteMicro(CCAENV1x90Opcodes::READ_RC_ADJ | nChip);
  unsigned short TapMask = ReadMicro();

  Tap1Contact = (TapMask & TAPCONTACTMASK);
  Tap2Contact = (TapMask >> TAPCONTACTRSHIFT) & TAPCONTACTMASK;
  Tap3Contact = (TapMask >> (2*TAPCONTACTRSHIFT)) & TAPCONTACTMASK;
  Tap4Contact = (TapMask >> (3*TAPCONTACTRSHIFT)) & TAPCONTACTMASK;

}
void
CCAENV1x90::SaveDelayLineCalibrations()
{
  WriteMicro(CCAENV1x90Opcodes::SAVE_RC_ADJ);
  WaitMicroWrite();

}
unsigned int
CCAENV1x90::GetChipId(unsigned short nChip)
{
  REQUIRE(nChip < m_nChipCount,
        "Chip number invalid for this board");


  WriteMicro(CCAENV1x90Opcodes::READ_TDC_ID | nChip);

  // 16 Is not a magic number.. It's the number of bits in a word.
  
  unsigned int nId = ReadMicro();
  nId             |= (static_cast<unsigned int>(ReadMicro())) << 16;
  return nId;
}


void
CCAENV1x90::GetuCFirmwareInfo(unsigned short& nRevision,
                              unsigned short& nDay,
                              unsigned short& nMonth,
                              unsigned short& nYear)
{
  WriteMicro(CCAENV1x90Opcodes::REV_DATE_MICRO_FW);
  nRevision = ReadMicro();
  nDay      = ReadMicro();
  nMonth    = ReadMicro();
  nYear     = ReadMicro();
}

unsigned short
CCAENV1x90::GetChipErrors(unsigned short nChip)
{
  REQUIRE(nChip < m_nChipCount,
        "Chip number is out of range for this module");

  WriteMicro(CCAENV1x90Opcodes::READ_ERROR_STATUS | nChip);

  unsigned short nErrors = ReadMicro();

  nErrors &= ~(ERR_VERNIER     |
               ERR_COARSE      |
               ERR_SELECT      |
               ERR_L1PARITY    |
               ERR_TFIFOPARITY |
               ERR_MATCHERROR  |
               ERR_RFIFOPARITY |
               ERR_RDOSTATE    |
               ERR_SUPPARITY   |
               ERR_CTLPARITY   |
               ERR_JTAGPARITY);
  return nErrors;
}
void
CCAENV1x90::EnableTestMode(unsigned int  nValue)
{
  // Validate preconditions:

  REQUIRE((nValue & ~(MAXTESTVALUE)) == 0,
        "The data value has extraneous bits");

  // Break up thed data longword into hi lo words:
  //  0xffff is just a word with all bits set., 16 the # bits in a word

  unsigned short nLow   = LO(nValue);
  unsigned short nHigh  = HI(nValue);

  WriteMicro(CCAENV1x90Opcodes::ENABLE_TEST_MODE);
  WriteMicro(nLow);
  WriteMicro(nHigh);
  WaitMicroWrite();

}

void
CCAENV1x90::DisableTestMode()
{
  WriteMicro(CCAENV1x90Opcodes::DISABLE_TEST_MODE);
  WaitMicroWrite();
}


unsigned int
CCAENV1x90::ReadData(void* pBuffer,
                     unsigned int nMaxLongs)
{
  if(m_fTriggerMatching) {
    return ReadPacket(pBuffer, nMaxLongs);
  } else {
    return ReadValid(pBuffer, nMaxLongs);
  }
}
unsigned int
CCAENV1x90::ReadPacket(void* pBuffer,
                       unsigned int nMaxLongs)
{
  unsigned long* pPacket = (unsigned long*)pBuffer;
  unsigned int   nRead   = 0;

  // Loop over the read until we get a data word that has
  // either the TDC_TRAILER or FILLER_LONG type  mask value.
  // Note that if we run out of user buffer we just stop incrementing
  // the counter/pointer.

  bool done(false);
  while(!done) {
    unsigned long datum = m_pRegisters.peekl(OffsetL(OutputBuffer));
    *pPacket            = datum;
    if(isGlobalTrailer(datum) || isFiller(datum)) {
      done = true;              // Last read.
    }
    if(nRead < nMaxLongs) {     // overwrite last word if output full.
      pPacket++;
      nRead++;
    }
  }
  
  return nRead;
}
unsigned int 
CCAENV1x90::ReadValid(void* pBuffer, unsigned int nMaxLongs)
{
  unsigned long* pLongs = (unsigned long*)pBuffer;
  unsigned int   nRead  = 0;
  bool           done   = false;

  while(!done) {
    unsigned long datum = m_pRegisters.peekl(OffsetL(OutputBuffer));
    *pLongs++          = datum;
    nRead++;

    if(isGlobalTrailer(datum) ||
       isFiller(datum)    ||
       (nRead == nMaxLongs)) {
      done = true;
    }
  }

  return nRead;
}


bool
CCAENV1x90::ValidBoard(CVmeModule& pRom)
{
  // Check the manufacturer's code (OUI):
  
  unsigned long oui = ReadPromLong(pRom, WOUI2); // Read oui from prom.
  if(oui != 0x0040e6) {
    return false;
  }

  // Check the board version:

  unsigned long nModel = ReadPromLong(pRom, WModelNumber2);
  if((nModel != 1190) && (nModel != 1290)) {
    return false;
  }

  // 1190's can be either type a or b, 1290's must be a or n

  unsigned char nType = 
    pRom.peekw(OffsetW(WBoardVersion)) & 0xff;

  if(nModel == 1190) {
    if((nType != ModuleVersion::A) && 
       (nType != ModuleVersion::B)) {
      return false;
    }
  }
  else {                        // Already know from above it's a 1290
    if((nType != ModuleVersion::A) && 
       (nType != ModuleVersion::N)) {
      return false;
    }
  }
  // Ok board.

  return true;
}

void
CCAENV1x90::BoardProperties(CVmeModule& pROM)
{
  m_nModel = ReadPromLong(pROM,WModelNumber2);

  // Sub module gets encoded as a letter:

  unsigned short ntype= 
    pROM.peekw(OffsetW(WBoardVersion)) & 0xff;
  if(ntype == ModuleVersion::A) {
    m_cVersion = 'A';
   }
  else if (ntype == ModuleVersion::B) {
    m_cVersion = 'B';
  }
  else if (ntype ==  ModuleVersion::N) {
    m_cVersion = 'N';
  }
  else {                        // Not allowed.
    throw string("Unrecognized module subtype, not A,B, nor N");
  }

  // Serial number is a prom word:

  m_nSerialNumber = 
    (pROM.peekw(OffsetW(WSerialNumber1)) & 0xff) << 8;
  m_nSerialNumber |=
    (pROM.peekw(OffsetW(WSerialNumber0)) & 0xff);

  // Board revision is 4 bytes (a true long word).
  // this will be built up by trickery from a 3 byte long:

  m_nBoardRevision = ReadPromLong(pROM, WRevision3); // top 24 bits
  m_nBoardRevision = (m_nBoardRevision << 8) |
    (pROM.peekw(OffsetW(WRevision0)) & 0xff); // bottom 8.

  // Module specific info is as follows:
  //           chans   chips  CanHires
  //   1190 A:  128      4     no
  //   1190 B:   64      2     no
  //   1290 A:   32      4     yes
  //   1290 N:   16      2     yes

  if(m_nModel == 1190) {
    m_fCanHiRes  = false;
    if(m_cVersion == 'A') {
      m_nChannels = 128;
      m_nChipCount=   4;
    } 
    else {
      m_nChannels =  64;
      m_nChipCount=   2;
    }
  } 
  else {                        // 1290
    m_fCanHiRes = true;
    if(m_cVersion == 'A') {
      m_nChannels  = 32;
      m_nChipCount =  4;
    } 
    else {
      m_nChannels  = 16;
      m_nChipCount =  2;
    }
  }

  // Now use the SR to figure out if the module is in trigger
  // match mode.  We don't need to conditionalize the
  // resolution check for hires as the hi-res mode is not
  // an allowed resolution combination for the 1190:
  
  unsigned short sr = SR();
  m_fTriggerMatching = (sr & StatusRegister::TRG_MATCH) == 
                                        StatusRegister::TRG_MATCH;
  m_fIsHiResMode      = (sr & StatusRegister::RESOLUTIONMASK) ==
                                        StatusRegister::RES_25ps;

}

unsigned short
CCAENV1x90::SR()
{
  return m_pRegisters.peekw(OffsetW(WStatusRegister));
}

bool
CCAENV1x90::isSetSR(unsigned short bitnum)
{
  return (SR() & (1 << bitnum)) != 0;
}

void
CCAENV1x90::WriteCR(unsigned short mask)
{
  m_pRegisters.pokew(mask, OffsetW(WControlRegister));
}

unsigned short
CCAENV1x90::ReadCR()
{
  return m_pRegisters.peekw(OffsetW(WControlRegister));
}
void 
CCAENV1x90::BitSetCR(unsigned short bit)
{
  unsigned short cr = ReadCR();
  cr |= (1 << bit);
  WriteCR(cr);
}

void
CCAENV1x90::BitClearCR(unsigned short bit)
{
  unsigned short cr = ReadCR();
  cr &= ~(1 << bit);
  WriteCR(cr);
}


unsigned long
CCAENV1x90::ReadPromLong(CVmeModule& prombase,
                         unsigned long ByteOffset)
{
  unsigned long n;              // Result long.
  unsigned long WordOffset = OffsetW(ByteOffset);

  n  = (prombase.peekw(WordOffset)   & 0xff) << 16;
  n |= (prombase.peekw(WordOffset+2) & 0xff) <<  8;
  n |= (prombase.peekw(WordOffset+4) & 0xff);

  return n;

}
void
CCAENV1x90::WaitMicroWrite()
{

  while((m_pRegisters.peekw(OffsetW(WMicroHandshake)) & 
         MicroHandshake::WRITE_OK)  == 0) 
    ;                           // Spin on the register...

}
  
void 
CCAENV1x90::WriteMicro(unsigned short nWord)
{
  // Wait for the micro to be writable...

  WaitMicroWrite();

  // Write the word.
  
  m_pRegisters.pokew(nWord, OffsetW(WMicroData));

}
unsigned short
CCAENV1x90::ReadMicro()
{
  // Wait for data to be presented:

  while((m_pRegisters.peekw(OffsetW(WMicroHandshake)) & 
         MicroHandshake::READ_OK)  == 0)
    ;                           // Spin on the bit.

  // Return the data:

  return m_pRegisters.peekw(OffsetW(WMicroData));
}
void 
CCAENV1x90::WriteMicroBlock(void* pWords,
                            unsigned int nWords)
{
  unsigned short* pW = (unsigned short*) pWords;

  for(int i = 0; i < nWords; i++) {
    WriteMicro(*pW++);
  }
}
void
CCAENV1x90::ReadMicroBlock(void* pWords, 
                           unsigned int nWords)
{
  unsigned short* pW = (unsigned short*) pWords;

  for(int i =0; i < nWords; i++) {
    *pW++ = ReadMicro();
  }
}
void 
CCAENV1x90::MicroTransaction(unsigned short opcode,
                             void*          pWords,
                             unsigned int   nWords)
{
  WriteMicro(opcode);
  ReadMicroBlock(pWords, nWords);
}

---